diff --git a/browser-build.js b/browser-build.js
index 2aae67bc9..5a2b914fb 100644
--- a/browser-build.js
+++ b/browser-build.js
@@ -28,6 +28,7 @@ function build(options, callback) {
   };
   browserify(brOpts).add('./browser.js')
     .transform(babelify, {
+        "global": true,
         "presets": ["es2015"],
         "plugins": ["transform-runtime"]
     }).transform(aliasify, {
diff --git a/dist/aliyun-oss-sdk.js b/dist/aliyun-oss-sdk.js
index e69de29bb..903bdbf71 100644
--- a/dist/aliyun-oss-sdk.js
+++ b/dist/aliyun-oss-sdk.js
@@ -0,0 +1,31475 @@
+// Aliyun OSS SDK for JavaScript v4.6.0
+// Copyright Aliyun.com, Inc. or its affiliates. All Rights Reserved.
+// License at https://github.com/ali-sdk/ali-oss/blob/master/LICENSE
+(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.OSS = 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){
+'use strict';
+
+/*
+ * Export `OSS` as standalone lib which can be used in browser
+ */
+
+var OSS = require('.');
+OSS.Buffer = require('buffer').Buffer;
+OSS.co = require('co');
+OSS.urllib = require('urllib');
+
+module.exports = OSS;
+
+},{".":3,"buffer":45,"co":51,"urllib":379}],2:[function(require,module,exports){
+'use strict';
+
+var _regenerator = require('babel-runtime/regenerator');
+
+var _regenerator2 = _interopRequireDefault(_regenerator);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var proto = exports;
+
+/**
+ * Bucket opertaions
+ */
+
+proto.listBuckets = _regenerator2.default.mark(function listBuckets(query, options) {
+  var result, data, buckets;
+  return _regenerator2.default.wrap(function listBuckets$(_context) {
+    while (1) {
+      switch (_context.prev = _context.next) {
+        case 0:
+          _context.next = 2;
+          return this.request({
+            method: 'GET',
+            query: query,
+            timeout: options && options.timeout,
+            ctx: options && options.ctx
+          });
+
+        case 2:
+          result = _context.sent;
+
+          if (!(result.status === 200)) {
+            _context.next = 10;
+            break;
+          }
+
+          _context.next = 6;
+          return this.parseXML(result.data);
+
+        case 6:
+          data = _context.sent;
+          buckets = data.Buckets || null;
+
+          if (buckets) {
+            if (buckets.Bucket) {
+              buckets = buckets.Bucket;
+            }
+            if (!Array.isArray(buckets)) {
+              buckets = [buckets];
+            }
+            buckets = buckets.map(function (item) {
+              return {
+                name: item.Name,
+                region: item.Location,
+                creationDate: item.CreationDate
+              };
+            });
+          }
+          return _context.abrupt('return', {
+            buckets: buckets,
+            owner: {
+              id: data.Owner.ID,
+              displayName: data.Owner.DisplayName
+            },
+            isTruncated: data.IsTruncated === 'true',
+            nextMarker: data.NextMarker || null,
+            res: result.res
+          });
+
+        case 10:
+          _context.next = 12;
+          return this.requestError(result);
+
+        case 12:
+          throw _context.sent;
+
+        case 13:
+        case 'end':
+          return _context.stop();
+      }
+    }
+  }, listBuckets, this);
+});
+
+proto.useBucket = function useBucket(name, region) {
+  this.options.bucket = name;
+  return this;
+};
+
+proto.putBucket = _regenerator2.default.mark(function putBucket(name, region, options) {
+  var params, result;
+  return _regenerator2.default.wrap(function putBucket$(_context2) {
+    while (1) {
+      switch (_context2.prev = _context2.next) {
+        case 0:
+          params = this._bucketRequestParams('PUT', name, '', options);
+
+          if (region) {
+            params.mime = 'xml';
+            params.content = '<?xml version="1.0" encoding="UTF-8"?>\n' + '<CreateBucketConfiguration><LocationConstraint>' + region + '</LocationConstraint></CreateBucketConfiguration>';
+          }
+          params.successStatuses = [200];
+          _context2.next = 5;
+          return this.request(params);
+
+        case 5:
+          result = _context2.sent;
+          return _context2.abrupt('return', {
+            bucket: result.headers.location && result.headers.location.substring(1) || null,
+            res: result.res
+          });
+
+        case 7:
+        case 'end':
+          return _context2.stop();
+      }
+    }
+  }, putBucket, this);
+});
+
+proto.deleteBucket = _regenerator2.default.mark(function deleteBucket(name, region, options) {
+  var params, result;
+  return _regenerator2.default.wrap(function deleteBucket$(_context3) {
+    while (1) {
+      switch (_context3.prev = _context3.next) {
+        case 0:
+          params = this._bucketRequestParams('DELETE', name, '', options);
+          _context3.next = 3;
+          return this.request(params);
+
+        case 3:
+          result = _context3.sent;
+
+          if (!(result.status === 200 || result.status === 204)) {
+            _context3.next = 6;
+            break;
+          }
+
+          return _context3.abrupt('return', {
+            res: result.res
+          });
+
+        case 6:
+          _context3.next = 8;
+          return this.requestError(result);
+
+        case 8:
+          throw _context3.sent;
+
+        case 9:
+        case 'end':
+          return _context3.stop();
+      }
+    }
+  }, deleteBucket, this);
+});
+
+// acl
+
+proto.putBucketACL = _regenerator2.default.mark(function putBucketACL(name, region, acl, options) {
+  var params, result;
+  return _regenerator2.default.wrap(function putBucketACL$(_context4) {
+    while (1) {
+      switch (_context4.prev = _context4.next) {
+        case 0:
+          params = this._bucketRequestParams('PUT', name, 'acl', options);
+
+          params.headers = {
+            'x-oss-acl': acl
+          };
+          params.successStatuses = [200];
+          _context4.next = 5;
+          return this.request(params);
+
+        case 5:
+          result = _context4.sent;
+          return _context4.abrupt('return', {
+            bucket: result.headers.location && result.headers.location.substring(1) || null,
+            res: result.res
+          });
+
+        case 7:
+        case 'end':
+          return _context4.stop();
+      }
+    }
+  }, putBucketACL, this);
+});
+
+proto.getBucketACL = _regenerator2.default.mark(function getBucketACL(name, region, options) {
+  var params, result;
+  return _regenerator2.default.wrap(function getBucketACL$(_context5) {
+    while (1) {
+      switch (_context5.prev = _context5.next) {
+        case 0:
+          params = this._bucketRequestParams('GET', name, 'acl', options);
+
+          params.successStatuses = [200];
+          params.xmlResponse = true;
+          _context5.next = 5;
+          return this.request(params);
+
+        case 5:
+          result = _context5.sent;
+          return _context5.abrupt('return', {
+            acl: result.data.AccessControlList.Grant,
+            owner: {
+              id: result.data.Owner.ID,
+              displayName: result.data.Owner.DisplayName
+            },
+            res: result.res
+          });
+
+        case 7:
+        case 'end':
+          return _context5.stop();
+      }
+    }
+  }, getBucketACL, this);
+});
+
+// logging
+
+proto.putBucketLogging = _regenerator2.default.mark(function putBucketLogging(name, region, prefix, options) {
+  var params, xml, result;
+  return _regenerator2.default.wrap(function putBucketLogging$(_context6) {
+    while (1) {
+      switch (_context6.prev = _context6.next) {
+        case 0:
+          params = this._bucketRequestParams('PUT', name, 'logging', options);
+          xml = '<?xml version="1.0" encoding="UTF-8"?>\n<BucketLoggingStatus>\n' + '<LoggingEnabled>\n<TargetBucket>' + name + '</TargetBucket>\n';
+
+          if (prefix) {
+            xml += '<TargetPrefix>' + prefix + '</TargetPrefix>\n';
+          }
+          xml += '</LoggingEnabled>\n</BucketLoggingStatus>';
+          params.content = xml;
+          params.mime = 'xml';
+          params.successStatuses = [200];
+          _context6.next = 9;
+          return this.request(params);
+
+        case 9:
+          result = _context6.sent;
+          return _context6.abrupt('return', {
+            res: result.res
+          });
+
+        case 11:
+        case 'end':
+          return _context6.stop();
+      }
+    }
+  }, putBucketLogging, this);
+});
+
+proto.getBucketLogging = _regenerator2.default.mark(function getBucketLogging(name, region, options) {
+  var params, result, enable;
+  return _regenerator2.default.wrap(function getBucketLogging$(_context7) {
+    while (1) {
+      switch (_context7.prev = _context7.next) {
+        case 0:
+          params = this._bucketRequestParams('GET', name, 'logging', options);
+
+          params.successStatuses = [200];
+          params.xmlResponse = true;
+          _context7.next = 5;
+          return this.request(params);
+
+        case 5:
+          result = _context7.sent;
+          enable = result.data.LoggingEnabled;
+          return _context7.abrupt('return', {
+            enable: !!enable,
+            prefix: enable && enable.TargetPrefix || null,
+            res: result.res
+          });
+
+        case 8:
+        case 'end':
+          return _context7.stop();
+      }
+    }
+  }, getBucketLogging, this);
+});
+
+proto.deleteBucketLogging = _regenerator2.default.mark(function deleteBucketLogging(name, region, options) {
+  var params, result;
+  return _regenerator2.default.wrap(function deleteBucketLogging$(_context8) {
+    while (1) {
+      switch (_context8.prev = _context8.next) {
+        case 0:
+          params = this._bucketRequestParams('DELETE', name, 'logging', options);
+
+          params.successStatuses = [204, 200];
+          _context8.next = 4;
+          return this.request(params);
+
+        case 4:
+          result = _context8.sent;
+          return _context8.abrupt('return', {
+            res: result.res
+          });
+
+        case 6:
+        case 'end':
+          return _context8.stop();
+      }
+    }
+  }, deleteBucketLogging, this);
+});
+
+// website
+
+proto.putBucketWebsite = _regenerator2.default.mark(function putBucketWebsite(name, region, config, options) {
+  var params, xml, result;
+  return _regenerator2.default.wrap(function putBucketWebsite$(_context9) {
+    while (1) {
+      switch (_context9.prev = _context9.next) {
+        case 0:
+          // config: index, [error]
+          params = this._bucketRequestParams('PUT', name, 'website', options);
+
+          config = config || {};
+          config.index = config.index || 'index.html';
+          xml = '<?xml version="1.0" encoding="UTF-8"?>\n<WebsiteConfiguration>\n' + ' <IndexDocument><Suffix>' + config.index + '</Suffix></IndexDocument>\n';
+
+          if (config.error) {
+            xml += '<ErrorDocument><Key>' + config.error + '</Key></ErrorDocument>\n';
+          }
+          xml += '</WebsiteConfiguration>';
+          params.content = xml;
+          params.mime = 'xml';
+          params.successStatuses = [200];
+          return _context9.delegateYield(this.request(params), 't0', 10);
+
+        case 10:
+          result = _context9.t0;
+          return _context9.abrupt('return', {
+            res: result.res
+          });
+
+        case 12:
+        case 'end':
+          return _context9.stop();
+      }
+    }
+  }, putBucketWebsite, this);
+});
+
+proto.getBucketWebsite = _regenerator2.default.mark(function getBucketWebsite(name, region, options) {
+  var params, result;
+  return _regenerator2.default.wrap(function getBucketWebsite$(_context10) {
+    while (1) {
+      switch (_context10.prev = _context10.next) {
+        case 0:
+          params = this._bucketRequestParams('GET', name, 'website', options);
+
+          params.successStatuses = [200];
+          params.xmlResponse = true;
+          _context10.next = 5;
+          return this.request(params);
+
+        case 5:
+          result = _context10.sent;
+          return _context10.abrupt('return', {
+            index: result.data.IndexDocument.Suffix,
+            error: result.data.ErrorDocument && result.data.ErrorDocument.Key || null,
+            res: result.res
+          });
+
+        case 7:
+        case 'end':
+          return _context10.stop();
+      }
+    }
+  }, getBucketWebsite, this);
+});
+
+proto.deleteBucketWebsite = _regenerator2.default.mark(function deleteBucketWebsite(name, region, options) {
+  var params, result;
+  return _regenerator2.default.wrap(function deleteBucketWebsite$(_context11) {
+    while (1) {
+      switch (_context11.prev = _context11.next) {
+        case 0:
+          params = this._bucketRequestParams('DELETE', name, 'website', options);
+
+          params.successStatuses = [204];
+          _context11.next = 4;
+          return this.request(params);
+
+        case 4:
+          result = _context11.sent;
+          return _context11.abrupt('return', {
+            res: result.res
+          });
+
+        case 6:
+        case 'end':
+          return _context11.stop();
+      }
+    }
+  }, deleteBucketWebsite, this);
+});
+
+// lifecycle
+
+proto.putBucketLifecycle = _regenerator2.default.mark(function putBucketLifecycle(name, region, rules, options) {
+  var params, xml, i, rule, expiration, id, result;
+  return _regenerator2.default.wrap(function putBucketLifecycle$(_context12) {
+    while (1) {
+      switch (_context12.prev = _context12.next) {
+        case 0:
+          // rules: [rule, ...]
+          // rule: [id], prefix, status, expiration, [days or date]
+          // status: 'Enabled' or 'Disabled'
+          params = this._bucketRequestParams('PUT', name, 'lifecycle', options);
+          xml = '<?xml version="1.0" encoding="UTF-8"?>\n<LifecycleConfiguration>\n';
+
+          for (i = 0; i < rules.length; i++) {
+            rule = rules[i];
+            expiration = rule.days ? '<Days>' + rule.days + '</Days>' : '<Date>' + rule.date + '</Date>';
+            id = rule.id ? '<ID>' + rule.id + '</ID>\n' : '';
+
+            xml += '  <Rule>\n' + id + '    <Prefix>' + rule.prefix + '</Prefix>\n' + '    <Status>' + rule.status + '</Status>\n' + '    <Expiration>' + expiration + '</Expiration>\n' + '  </Rule>\n';
+          }
+          xml += '</LifecycleConfiguration>';
+          params.content = xml;
+          params.mime = 'xml';
+          params.successStatuses = [200];
+          _context12.next = 9;
+          return this.request(params);
+
+        case 9:
+          result = _context12.sent;
+          return _context12.abrupt('return', {
+            res: result.res
+          });
+
+        case 11:
+        case 'end':
+          return _context12.stop();
+      }
+    }
+  }, putBucketLifecycle, this);
+});
+
+proto.getBucketLifecycle = _regenerator2.default.mark(function getBucketLifecycle(name, region, options) {
+  var params, result, rules;
+  return _regenerator2.default.wrap(function getBucketLifecycle$(_context13) {
+    while (1) {
+      switch (_context13.prev = _context13.next) {
+        case 0:
+          params = this._bucketRequestParams('GET', name, 'lifecycle', options);
+
+          params.successStatuses = [200];
+          params.xmlResponse = true;
+          _context13.next = 5;
+          return this.request(params);
+
+        case 5:
+          result = _context13.sent;
+          rules = result.data.Rule || null;
+
+          if (rules) {
+            if (!Array.isArray(rules)) {
+              rules = [rules];
+            }
+            rules = rules.map(function (rule) {
+              var item = {
+                id: rule.ID,
+                prefix: rule.Prefix,
+                status: rule.Status
+              };
+              if (rule.Expiration.Days) {
+                item.days = rule.Expiration.Days;
+              } else {
+                item.date = rule.Expiration.Date;
+              }
+              return item;
+            });
+          }
+          return _context13.abrupt('return', {
+            rules: rules,
+            res: result.res
+          });
+
+        case 9:
+        case 'end':
+          return _context13.stop();
+      }
+    }
+  }, getBucketLifecycle, this);
+});
+
+proto.deleteBucketLifecycle = _regenerator2.default.mark(function deleteBucketLifecycle(name, region, options) {
+  var params, result;
+  return _regenerator2.default.wrap(function deleteBucketLifecycle$(_context14) {
+    while (1) {
+      switch (_context14.prev = _context14.next) {
+        case 0:
+          params = this._bucketRequestParams('DELETE', name, 'lifecycle', options);
+
+          params.successStatuses = [204];
+          _context14.next = 4;
+          return this.request(params);
+
+        case 4:
+          result = _context14.sent;
+          return _context14.abrupt('return', {
+            res: result.res
+          });
+
+        case 6:
+        case 'end':
+          return _context14.stop();
+      }
+    }
+  }, deleteBucketLifecycle, this);
+});
+
+// referer
+
+proto.putBucketReferer = _regenerator2.default.mark(function putBucketReferer(name, region, allowEmpty, referers, options) {
+  var params, xml, i, result;
+  return _regenerator2.default.wrap(function putBucketReferer$(_context15) {
+    while (1) {
+      switch (_context15.prev = _context15.next) {
+        case 0:
+          params = this._bucketRequestParams('PUT', name, 'referer', options);
+          xml = '<?xml version="1.0" encoding="UTF-8"?>\n<RefererConfiguration>\n';
+
+          xml += '  <AllowEmptyReferer>' + (allowEmpty ? 'true' : 'false') + '</AllowEmptyReferer>\n';
+          if (referers && referers.length > 0) {
+            xml += '  <RefererList>\n';
+            for (i = 0; i < referers.length; i++) {
+              xml += '    <Referer>' + referers[i] + '</Referer>\n';
+            }
+            xml += '  </RefererList>\n';
+          } else {
+            xml += '  <RefererList />\n';
+          }
+          xml += '</RefererConfiguration>';
+          params.content = xml;
+          params.mime = 'xml';
+          params.successStatuses = [200];
+          _context15.next = 10;
+          return this.request(params);
+
+        case 10:
+          result = _context15.sent;
+          return _context15.abrupt('return', {
+            res: result.res
+          });
+
+        case 12:
+        case 'end':
+          return _context15.stop();
+      }
+    }
+  }, putBucketReferer, this);
+});
+
+proto.getBucketReferer = _regenerator2.default.mark(function getBucketReferer(name, region, options) {
+  var params, result, referers;
+  return _regenerator2.default.wrap(function getBucketReferer$(_context16) {
+    while (1) {
+      switch (_context16.prev = _context16.next) {
+        case 0:
+          params = this._bucketRequestParams('GET', name, 'referer', options);
+
+          params.successStatuses = [200];
+          params.xmlResponse = true;
+          _context16.next = 5;
+          return this.request(params);
+
+        case 5:
+          result = _context16.sent;
+          referers = result.data.RefererList.Referer || null;
+
+          if (referers) {
+            if (!Array.isArray(referers)) {
+              referers = [referers];
+            }
+          }
+          return _context16.abrupt('return', {
+            allowEmpty: result.data.AllowEmptyReferer === 'true',
+            referers: referers,
+            res: result.res
+          });
+
+        case 9:
+        case 'end':
+          return _context16.stop();
+      }
+    }
+  }, getBucketReferer, this);
+});
+
+proto.deleteBucketReferer = _regenerator2.default.mark(function deleteBucketReferer(name, region, options) {
+  return _regenerator2.default.wrap(function deleteBucketReferer$(_context17) {
+    while (1) {
+      switch (_context17.prev = _context17.next) {
+        case 0:
+          _context17.next = 2;
+          return this.putBucketReferer(name, region, true, null, options);
+
+        case 2:
+          return _context17.abrupt('return', _context17.sent);
+
+        case 3:
+        case 'end':
+          return _context17.stop();
+      }
+    }
+  }, deleteBucketReferer, this);
+});
+
+// private apis
+
+proto._bucketRequestParams = function _bucketRequestParams(method, bucket, subres, options) {
+  return {
+    method: method,
+    bucket: bucket,
+    subres: subres,
+    timeout: options && options.timeout,
+    ctx: options && options.ctx
+  };
+};
+
+},{"babel-runtime/regenerator":40}],3:[function(require,module,exports){
+(function (process,Buffer){
+'use strict';
+
+var _regenerator = require('babel-runtime/regenerator');
+
+var _regenerator2 = _interopRequireDefault(_regenerator);
+
+var _keys = require('babel-runtime/core-js/object/keys');
+
+var _keys2 = _interopRequireDefault(_keys);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var debug = require('debug')('ali-oss');
+var crypto = require('./../shims/crypto.js');
+var path = require('path');
+var querystring = require('querystring');
+var copy = require('copy-to');
+var mime = require('mime');
+var xml = require('xml2js');
+var ms = require('humanize-ms');
+var AgentKeepalive = require('agentkeepalive');
+var merge = require('merge-descriptors');
+var urlutil = require('url');
+var is = require('is-type-of');
+var platform = require('platform');
+var utility = require('utility');
+var urllib = require('urllib');
+var pkg = require('../package.json');
+var dateFormat = require('dateformat');
+
+var globalHttpAgent = new AgentKeepalive();
+
+/**
+ * Expose `Client`
+ */
+
+module.exports = Client;
+
+function Client(options, ctx) {
+  if (!(this instanceof Client)) {
+    return new Client(options, ctx);
+  }
+
+  if (options && options.inited) {
+    this.options = options;
+  } else {
+    this.options = Client.initOptions(options);
+  }
+
+  // support custom agent and urllib client
+  if (this.options.urllib) {
+    this.urllib = this.options.urllib;
+  } else {
+    this.urllib = urllib;
+    this.agent = this.options.agent || globalHttpAgent;
+  }
+  this.ctx = ctx;
+}
+
+Client.initOptions = function initOptions(options) {
+  if (!options || !options.accessKeyId || !options.accessKeySecret) {
+    throw new Error('require accessKeyId, accessKeySecret');
+  }
+
+  var opts = {
+    region: 'oss-cn-hangzhou',
+    internal: false,
+    secure: false,
+    timeout: 60000, // 60s
+    bucket: null,
+    endpoint: null,
+    cname: false
+  };
+
+  for (var key in options) {
+    if (options[key] === undefined) continue;
+    opts[key] = options[key];
+  }
+  opts.accessKeyId = opts.accessKeyId.trim();
+  opts.accessKeySecret = opts.accessKeySecret.trim();
+
+  opts.timeout = ms(opts.timeout);
+
+  if (opts.endpoint) {
+    opts.endpoint = setEndpoint(opts.endpoint);
+  } else if (opts.region) {
+    opts.endpoint = setRegion(opts.region, opts.internal, opts.secure);
+  } else {
+    throw new Error('require options.endpoint or options.region');
+  }
+
+  opts.inited = true;
+  return opts;
+};
+
+/**
+ * prototype
+ */
+
+var proto = Client.prototype;
+
+/**
+ * Object operations
+ */
+merge(proto, require('./object'));
+/**
+ * Bucket operations
+ */
+merge(proto, require('./bucket'));
+/**
+ * Multipart operations
+ */
+merge(proto, require('./multipart'));
+
+/**
+ * ImageClient class
+ */
+Client.ImageClient = require('./image')(Client);
+/**
+ * Cluster Client class
+ */
+Client.ClusterClient = require('./cluster')(Client);
+
+/**
+ * STS Client class
+ */
+Client.STS = require('./sts');
+
+/**
+ * Aysnc wrapper
+ */
+Client.Wrapper = require('./wrapper');
+
+/**
+ * get OSS signature
+ * @param {String} stringToSign
+ * @return {String} the signature
+ */
+proto.signature = function signature(stringToSign) {
+  debug('authorization stringToSign: %s', stringToSign);
+
+  var signature = crypto.createHmac('sha1', this.options.accessKeySecret);
+  signature = signature.update(new Buffer(stringToSign, 'utf8')).digest('base64');
+
+  return signature;
+};
+
+/**
+ * get author header
+ *
+ * "Authorization: OSS " + Access Key Id + ":" + Signature
+ *
+ * Signature = base64(hmac-sha1(Access Key Secret + "\n"
+ *  + VERB + "\n"
+ *  + CONTENT-MD5 + "\n"
+ *  + CONTENT-TYPE + "\n"
+ *  + DATE + "\n"
+ *  + CanonicalizedOSSHeaders
+ *  + CanonicalizedResource))
+ *
+ * @param {String} method
+ * @param {String} resource
+ * @param {Object} header
+ * @return {String}
+ *
+ * @api private
+ */
+
+proto.authorization = function authorization(method, resource, subres, headers) {
+  var params = [method.toUpperCase(), headers['Content-Md5'] || '', getHeader(headers, 'Content-Type'), headers['x-oss-date']];
+
+  var ossHeaders = {};
+  for (var key in headers) {
+    var lkey = key.toLowerCase().trim();
+    if (lkey.indexOf('x-oss-') === 0) {
+      ossHeaders[lkey] = ossHeaders[lkey] || [];
+      ossHeaders[lkey].push(String(headers[key]).trim());
+    }
+  }
+
+  var ossHeadersList = [];
+  (0, _keys2.default)(ossHeaders).sort().forEach(function (key) {
+    ossHeadersList.push(key + ':' + ossHeaders[key].join(','));
+  });
+
+  params = params.concat(ossHeadersList);
+
+  var resourceStr = '';
+  resourceStr += resource;
+
+  var subresList = [];
+  if (subres) {
+    if (is.string(subres)) {
+      subresList.push(subres);
+    } else if (is.array(subres)) {
+      subresList = subresList.concat(subres);
+    } else {
+      for (var k in subres) {
+        var item = subres[k] ? k + '=' + subres[k] : k;
+        subresList.push(item);
+      }
+    }
+  }
+
+  if (subresList.length > 0) {
+    resourceStr += '?' + subresList.join('&');
+  }
+  params.push(resourceStr);
+  var stringToSign = params.join('\n');
+
+  var auth = 'OSS ' + this.options.accessKeyId + ':';
+  return auth + this.signature(stringToSign);
+};
+
+/**
+ * create request params
+ * See `request`
+ * @api private
+ */
+
+proto.createRequest = function createRequest(params) {
+  var userAgent = this._userAgent();
+
+  var headers = {
+    'x-oss-date': dateFormat(new Date(), 'UTC:ddd, dd mmm yyyy HH:MM:ss \'GMT\''),
+    'x-oss-user-agent': userAgent,
+    'User-Agent': userAgent
+  };
+
+  if (this.options.stsToken) {
+    headers['x-oss-security-token'] = this.options.stsToken;
+  }
+
+  copy(params.headers).to(headers);
+
+  if (!getHeader(headers, 'Content-Type')) {
+    if (params.mime === mime.default_type) {
+      params.mime = '';
+    }
+
+    if (params.mime && params.mime.indexOf('/') > 0) {
+      headers['Content-Type'] = params.mime;
+    } else {
+      headers['Content-Type'] = mime.lookup(params.mime || path.extname(params.object || ''));
+    }
+  }
+
+  if (params.content) {
+    headers['Content-Md5'] = crypto.createHash('md5').update(new Buffer(params.content, 'utf8')).digest('base64');
+    if (!headers['Content-Length']) {
+      headers['Content-Length'] = params.content.length;
+    }
+  }
+
+  var authResource = this._getResource(params);
+  headers.authorization = this.authorization(params.method, authResource, params.subres, headers);
+
+  var url = this._getReqUrl(params);
+  debug('request %s %s, with headers %j, !!stream: %s', params.method, url, headers, !!params.stream);
+  var timeout = params.timeout || this.options.timeout;
+  var reqParams = {
+    agent: this.agent,
+    method: params.method,
+    content: params.content,
+    stream: params.stream,
+    headers: headers,
+    timeout: timeout,
+    writeStream: params.writeStream,
+    customResponse: params.customResponse,
+    ctx: params.ctx || this.ctx
+  };
+
+  return {
+    url: url,
+    params: reqParams
+  };
+};
+
+/**
+ * request oss server
+ * @param {Object} params
+ *   - {String} object
+ *   - {String} bucket
+ *   - {Object} [headers]
+ *   - {Object} [query]
+ *   - {Buffer} [content]
+ *   - {Stream} [stream]
+ *   - {Stream} [writeStream]
+ *   - {String} [mime]
+ *   - {Boolean} [xmlResponse]
+ *   - {Boolean} [customResponse]
+ *   - {Number} [timeout]
+ *   - {Object} [ctx] request context, default is `this.ctx`
+ *
+ * @api private
+ */
+
+proto.request = _regenerator2.default.mark(function request(params) {
+  var reqParams, result, err;
+  return _regenerator2.default.wrap(function request$(_context) {
+    while (1) {
+      switch (_context.prev = _context.next) {
+        case 0:
+          reqParams = this.createRequest(params);
+          _context.next = 3;
+          return this.urllib.request(reqParams.url, reqParams.params);
+
+        case 3:
+          result = _context.sent;
+
+          debug('response %s %s, got %s, headers: %j', params.method, reqParams.url, result.status, result.headers);
+
+          if (!(params.successStatuses && params.successStatuses.indexOf(result.status) === -1)) {
+            _context.next = 10;
+            break;
+          }
+
+          return _context.delegateYield(this.requestError(result), 't0', 7);
+
+        case 7:
+          err = _context.t0;
+
+          err.params = params;
+          throw err;
+
+        case 10:
+          if (!params.xmlResponse) {
+            _context.next = 14;
+            break;
+          }
+
+          _context.next = 13;
+          return this.parseXML(result.data);
+
+        case 13:
+          result.data = _context.sent;
+
+        case 14:
+          return _context.abrupt('return', result);
+
+        case 15:
+        case 'end':
+          return _context.stop();
+      }
+    }
+  }, request, this);
+});
+
+proto._getResource = function _getResource(params) {
+  var resource = '/';
+  if (params.bucket) resource += params.bucket + '/';
+  if (params.object) resource += params.object;
+
+  return resource;
+};
+
+proto._isIP = function _isIP(host) {
+  var ipv4Regex = /^(\d{1,3}\.){3,3}\d{1,3}$/;
+  return ipv4Regex.test(host);
+};
+
+proto._escape = function _escape(name) {
+  return utility.encodeURIComponent(name).replace(/%2F/g, '/');
+};
+
+proto._getReqUrl = function _getReqUrl(params) {
+  var ep = {};
+  copy(this.options.endpoint).to(ep);
+  var isIP = this._isIP(ep.hostname);
+  var isCname = this.options.cname;
+  if (params.bucket && !isCname && !isIP) {
+    ep.host = params.bucket + '.' + ep.host;
+  }
+
+  var path = '/';
+  if (params.bucket && isIP) {
+    path += params.bucket + '/';
+  }
+
+  if (params.object) {
+    // Preserve '/' in result url
+    path += this._escape(params.object);
+  }
+  ep.pathname = path;
+
+  var query = {};
+  if (params.query) {
+    merge(query, params.query);
+  }
+
+  if (params.subres) {
+    var subresAsQuery = {};
+    if (is.string(params.subres)) {
+      subresAsQuery[params.subres] = '';
+    } else if (is.array(params.subres)) {
+      params.subres.forEach(function (k) {
+        subresAsQuery[k] = '';
+      });
+    } else {
+      subresAsQuery = params.subres;
+    }
+    merge(query, subresAsQuery);
+  }
+
+  ep.query = query;
+
+  // As '%20' is not recognized by OSS server, we must convert it to '+'.
+  return urlutil.format(ep).replace(/%20/g, '+');
+};
+
+/*
+ * Get User-Agent for browser & node.js
+ * @example
+ *   aliyun-sdk-nodejs/4.1.2 Node.js 5.3.0 on Darwin 64-bit
+ *   aliyun-sdk-js/4.1.2 Safari 9.0 on Apple iPhone(iOS 9.2.1)
+ *   aliyun-sdk-js/4.1.2 Chrome 43.0.2357.134 32-bit on Windows Server 2008 R2 / 7 64-bit
+ */
+
+proto._userAgent = function _userAgent() {
+  var agent = process && process.browser ? 'js' : 'nodejs';
+  var sdk = 'aliyun-sdk-' + agent + '/' + pkg.version;
+  var plat = platform.description;
+
+  return sdk + ' ' + plat;
+};
+
+/**
+ * thunkify xml.parseString
+ * @param {String|Buffer} str
+ *
+ * @api private
+ */
+
+proto.parseXML = function parseXMLThunk(str) {
+  return function parseXML(done) {
+    if (Buffer.isBuffer(str)) {
+      str = str.toString();
+    }
+    xml.parseString(str, {
+      explicitRoot: false,
+      explicitArray: false
+    }, done);
+  };
+};
+
+/**
+ * generater a request error with request response
+ * @param {Object} result
+ *
+ * @api private
+ */
+
+proto.requestError = _regenerator2.default.mark(function requestError(result) {
+  var err, message, info;
+  return _regenerator2.default.wrap(function requestError$(_context2) {
+    while (1) {
+      switch (_context2.prev = _context2.next) {
+        case 0:
+          if (!(!result.data || !result.data.length)) {
+            _context2.next = 6;
+            break;
+          }
+
+          // HEAD not exists resource
+          if (result.status === 404) {
+            err = new Error('Object not exists');
+            err.name = 'NoSuchKeyError';
+            err.status = 404;
+            err.code = 'NoSuchKey';
+          } else if (result.status === 412) {
+            err = new Error('Pre condition failed');
+            err.name = 'PreconditionFailedError';
+            err.status = 412;
+            err.code = 'PreconditionFailed';
+          } else {
+            err = new Error('Unknow error, status: ' + result.status);
+            err.name = 'UnknowError';
+            err.status = result.status;
+          }
+          err.requestId = result.headers['x-oss-request-id'];
+          err.host = '';
+          _context2.next = 29;
+          break;
+
+        case 6:
+          message = String(result.data);
+
+          debug('request response error data: %s', message);
+
+          _context2.prev = 8;
+          _context2.next = 11;
+          return this.parseXML(message) || {};
+
+        case 11:
+          info = _context2.sent;
+          _context2.next = 21;
+          break;
+
+        case 14:
+          _context2.prev = 14;
+          _context2.t0 = _context2['catch'](8);
+
+          debug(message);
+          _context2.t0.message += '\nraw xml: ' + message;
+          _context2.t0.status = result.status;
+          _context2.t0.requestId = result.headers['x-oss-request-id'];
+          return _context2.abrupt('return', _context2.t0);
+
+        case 21:
+          message = info.Message || 'unknow request error, status: ' + result.status;
+
+          if (info.Condition) {
+            message += ' (condition: ' + info.Condition + ')';
+          }
+          err = new Error(message);
+
+          err.name = info.Code ? info.Code + 'Error' : 'UnknowError';
+          err.status = result.status;
+          err.code = info.Code;
+          err.requestId = info.RequestId;
+          err.hostId = info.HostId;
+
+        case 29:
+
+          debug('generate error %j', err);
+          return _context2.abrupt('return', err);
+
+        case 31:
+        case 'end':
+          return _context2.stop();
+      }
+    }
+  }, requestError, this, [[8, 14]]);
+});
+
+function getHeader(headers, name) {
+  return headers[name] || headers[name.toLowerCase()];
+}
+
+function setEndpoint(endpoint) {
+  var url = urlutil.parse(endpoint);
+
+  if (!url.protocol) {
+    url = urlutil.parse('http://' + endpoint);
+  }
+
+  if (url.protocol != 'http:' && url.protocol != 'https:') {
+    throw new Error('Endpoint protocol must be http or https.');
+  }
+
+  return url;
+}
+
+function setRegion(region, internal, secure) {
+  var protocol = secure ? 'https://' : 'http://';
+  var suffix = internal ? '-internal.aliyuncs.com' : '.aliyuncs.com';
+
+  return urlutil.parse(protocol + region + suffix);
+}
+
+}).call(this,require('_process'),require("buffer").Buffer)
+},{"../package.json":419,"./../shims/crypto.js":420,"./bucket":2,"./cluster":4,"./image":5,"./multipart":6,"./object":7,"./sts":8,"./wrapper":9,"_process":345,"agentkeepalive":11,"babel-runtime/core-js/object/keys":30,"babel-runtime/regenerator":40,"buffer":45,"copy-to":54,"dateformat":183,"debug":184,"humanize-ms":196,"is-type-of":201,"merge-descriptors":335,"mime":336,"path":342,"platform":343,"querystring":349,"url":377,"urllib":379,"utility":395,"xml2js":400}],4:[function(require,module,exports){
+(function (Buffer){
+'use strict';
+
+var _regenerator = require('babel-runtime/regenerator');
+
+var _regenerator2 = _interopRequireDefault(_regenerator);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var co = require('co');
+var defer = require('co-defer');
+var Base = require('sdk-base');
+var util = require('util');
+var utility = require('utility');
+var ready = require('get-ready');
+var copy = require('copy-to');
+var currentIP = require('address').ip();
+
+var RR = 'roundRobin';
+var MS = 'masterSlave';
+
+module.exports = function (OssClient) {
+  function Client(options) {
+    if (!(this instanceof Client)) {
+      return new Client(options);
+    }
+
+    if (!options || !Array.isArray(options.cluster)) {
+      throw new Error('require options.cluster to be an array');
+    }
+
+    Base.call(this);
+
+    this.clients = [];
+    this.availables = {};
+
+    for (var i = 0; i < options.cluster.length; i++) {
+      var opt = options.cluster[i];
+      copy(options).pick('timeout', 'agent', 'urllib').to(opt);
+      this.clients.push(new OssClient(opt));
+      this.availables[i] = true;
+    }
+
+    this.schedule = options.schedule || RR;
+    this.index = 0;
+
+    var heartbeatInterval = options.heartbeatInterval || 10000;
+    this._checkAvailableLock = false;
+    this._timerId = defer.setInterval(this._checkAvailable.bind(this, true), heartbeatInterval);
+    this._ignoreStatusFile = options.ignoreStatusFile || false;
+    this._init();
+  }
+
+  util.inherits(Client, Base);
+  var proto = Client.prototype;
+  ready.mixin(proto);
+
+  var GET_METHODS = ['head', 'get', 'getStream', 'list'];
+
+  var PUT_METHODS = ['put', 'putStream', 'delete', 'deleteMulti', 'copy', 'putMeta'];
+
+  GET_METHODS.forEach(function (method) {
+    proto[method] = _regenerator2.default.mark(function _callee() {
+      var args,
+          client,
+          lastError,
+          i,
+          c,
+          _args = arguments;
+      return _regenerator2.default.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              args = utility.argumentsToArray(_args);
+              client = this.chooseAvailable();
+              _context.prev = 2;
+              _context.next = 5;
+              return client[method].apply(client, args);
+
+            case 5:
+              return _context.abrupt('return', _context.sent);
+
+            case 8:
+              _context.prev = 8;
+              _context.t0 = _context['catch'](2);
+
+              if (!(_context.t0.status && _context.t0.status >= 200 && _context.t0.status < 500)) {
+                _context.next = 12;
+                break;
+              }
+
+              throw _context.t0;
+
+            case 12:
+              // < 200 || >= 500 need to retry from other cluser node
+              lastError = _context.t0;
+
+            case 13:
+              i = 0;
+
+            case 14:
+              if (!(i < this.clients.length)) {
+                _context.next = 32;
+                break;
+              }
+
+              c = this.clients[i];
+
+              if (!(c === client)) {
+                _context.next = 18;
+                break;
+              }
+
+              return _context.abrupt('continue', 29);
+
+            case 18:
+              _context.prev = 18;
+              _context.next = 21;
+              return c[method].apply(client, args);
+
+            case 21:
+              return _context.abrupt('return', _context.sent);
+
+            case 24:
+              _context.prev = 24;
+              _context.t1 = _context['catch'](18);
+
+              if (!(_context.t1.status && _context.t1.status >= 200 && _context.t1.status < 500)) {
+                _context.next = 28;
+                break;
+              }
+
+              throw _context.t1;
+
+            case 28:
+              // < 200 || >= 500 need to retry from other cluser node
+              lastError = _context.t1;
+
+            case 29:
+              i++;
+              _context.next = 14;
+              break;
+
+            case 32:
+
+              lastError.message += ' (all clients are down)';
+              throw lastError;
+
+            case 34:
+            case 'end':
+              return _context.stop();
+          }
+        }
+      }, _callee, this, [[2, 8], [18, 24]]);
+    });
+  });
+
+  // must cluster node write success
+  PUT_METHODS.forEach(function (method) {
+    proto[method] = _regenerator2.default.mark(function _callee2() {
+      var args,
+          res,
+          _args2 = arguments;
+      return _regenerator2.default.wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              args = utility.argumentsToArray(_args2);
+              _context2.next = 3;
+              return this.clients.map(function (client) {
+                return client[method].apply(client, args);
+              });
+
+            case 3:
+              res = _context2.sent;
+              return _context2.abrupt('return', res[0]);
+
+            case 5:
+            case 'end':
+              return _context2.stop();
+          }
+        }
+      }, _callee2, this);
+    });
+  });
+
+  proto.signatureUrl = function signatureUrl() /* name */{
+    var args = utility.argumentsToArray(arguments);
+    var client = this.chooseAvailable();
+    return client.signatureUrl.apply(client, args);
+  };
+
+  proto.getObjectUrl = function getObjectUrl() /* name, baseUrl */{
+    var args = utility.argumentsToArray(arguments);
+    var client = this.chooseAvailable();
+    return client.getObjectUrl.apply(client, args);
+  };
+
+  proto._init = function _init() {
+    var that = this;
+    co(_regenerator2.default.mark(function _callee3() {
+      return _regenerator2.default.wrap(function _callee3$(_context3) {
+        while (1) {
+          switch (_context3.prev = _context3.next) {
+            case 0:
+              _context3.next = 2;
+              return that._checkAvailable(that._ignoreStatusFile);
+
+            case 2:
+              that.ready(true);
+
+            case 3:
+            case 'end':
+              return _context3.stop();
+          }
+        }
+      }, _callee3, this);
+    })).catch(function (err) {
+      that.emit('error', err);
+    });
+  };
+
+  proto._checkAvailable = _regenerator2.default.mark(function _checkAvailable(ignoreStatusFile) {
+    var name, downStatusFiles, i, client, available, err;
+    return _regenerator2.default.wrap(function _checkAvailable$(_context4) {
+      while (1) {
+        switch (_context4.prev = _context4.next) {
+          case 0:
+            name = '._ali-oss/check.status.' + currentIP + '.txt';
+
+            if (ignoreStatusFile) {
+              _context4.next = 4;
+              break;
+            }
+
+            _context4.next = 4;
+            return this.put(name, new Buffer('check available started at ' + Date()));
+
+          case 4:
+            if (!this._checkAvailableLock) {
+              _context4.next = 6;
+              break;
+            }
+
+            return _context4.abrupt('return');
+
+          case 6:
+            this._checkAvailableLock = true;
+            downStatusFiles = [];
+            i = 0;
+
+          case 9:
+            if (!(i < this.clients.length)) {
+              _context4.next = 27;
+              break;
+            }
+
+            client = this.clients[i];
+            // check 3 times
+
+            _context4.next = 13;
+            return this._checkStatus(client, name);
+
+          case 13:
+            available = _context4.sent;
+
+            if (available) {
+              _context4.next = 18;
+              break;
+            }
+
+            _context4.next = 17;
+            return this._checkStatus(client, name);
+
+          case 17:
+            available = _context4.sent;
+
+          case 18:
+            if (available) {
+              _context4.next = 23;
+              break;
+            }
+
+            _context4.next = 21;
+            return this._checkStatus(client, name);
+
+          case 21:
+            available = _context4.sent;
+
+            if (!available) {
+              downStatusFiles.push(client._objectUrl(name));
+            }
+
+          case 23:
+            this.availables[i] = available;
+
+          case 24:
+            i++;
+            _context4.next = 9;
+            break;
+
+          case 27:
+            this._checkAvailableLock = false;
+
+            if (downStatusFiles.length > 0) {
+              err = new Error(downStatusFiles.length + ' data node down, please check status file: ' + downStatusFiles.join(', '));
+
+              err.name = 'CheckAvailableError';
+              this.emit('error', err);
+            }
+
+          case 29:
+          case 'end':
+            return _context4.stop();
+        }
+      }
+    }, _checkAvailable, this);
+  });
+
+  proto._checkStatus = _regenerator2.default.mark(function _checkStatus(client, name) {
+    var available;
+    return _regenerator2.default.wrap(function _checkStatus$(_context5) {
+      while (1) {
+        switch (_context5.prev = _context5.next) {
+          case 0:
+            available = true;
+            _context5.prev = 1;
+            _context5.next = 4;
+            return client.head(name);
+
+          case 4:
+            _context5.next = 9;
+            break;
+
+          case 6:
+            _context5.prev = 6;
+            _context5.t0 = _context5['catch'](1);
+
+            // 404 will be available too
+            if (!_context5.t0.status || _context5.t0.status >= 500 || _context5.t0.status < 200) {
+              available = false;
+            }
+
+          case 9:
+            return _context5.abrupt('return', available);
+
+          case 10:
+          case 'end':
+            return _context5.stop();
+        }
+      }
+    }, _checkStatus, this, [[1, 6]]);
+  });
+
+  proto.chooseAvailable = function chooseAvailable() {
+    if (this.schedule === MS) {
+      for (var i = 0; i < this.clients.length; i++) {
+        if (this.availables[i]) {
+          return this.clients[i];
+        }
+      }
+      // all down, try to use this first one
+      return this.clients[0];
+    }
+
+    // RR
+    var n = this.clients.length;
+    while (n > 0) {
+      var i = this._nextRRIndex();
+      if (this.availables[i]) {
+        return this.clients[i];
+      }
+      n--;
+    }
+    // all down, try to use this first one
+    return this.clients[0];
+  };
+
+  proto._nextRRIndex = function _nextRRIndex() {
+    var index = this.index++;
+    if (this.index >= this.clients.length) {
+      this.index = 0;
+    }
+    return index;
+  };
+
+  proto.close = function close() {
+    clearInterval(this._timerId);
+    this._timerId = null;
+  };
+
+  return Client;
+};
+
+}).call(this,require("buffer").Buffer)
+},{"address":10,"babel-runtime/regenerator":40,"buffer":45,"co":51,"co-defer":48,"copy-to":54,"get-ready":194,"sdk-base":365,"util":384,"utility":395}],5:[function(require,module,exports){
+'use strict';
+
+/* istanbul ignore next */
+
+var _regenerator = require('babel-runtime/regenerator');
+
+var _regenerator2 = _interopRequireDefault(_regenerator);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+module.exports = function (OssClient) {
+
+  function ImageClient(options) {
+    if (!(this instanceof ImageClient)) {
+      return new ImageClient(options);
+    }
+    if (!options.bucket) {
+      throw new Error('require bucket for image service instance');
+    }
+    if (!options.imageHost) {
+      throw new Error('require imageHost for image service instance');
+    }
+
+    this.ossClient = new OssClient(options);
+    this.ossClient.options.imageHost = options.imageHost;
+    this.ossClient._objectRequestParams = objectRequestParams;
+  }
+
+  /**
+   * Image operations
+   */
+
+  ImageClient.prototype.get = _regenerator2.default.mark(function get(name, file, options) {
+    return _regenerator2.default.wrap(function get$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return this.ossClient.get(name, file, options);
+
+          case 2:
+            return _context.abrupt('return', _context.sent);
+
+          case 3:
+          case 'end':
+            return _context.stop();
+        }
+      }
+    }, get, this);
+  });
+
+  ImageClient.prototype.getStream = _regenerator2.default.mark(function getStream(name, options) {
+    return _regenerator2.default.wrap(function getStream$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            _context2.next = 2;
+            return this.ossClient.getStream(name, options);
+
+          case 2:
+            return _context2.abrupt('return', _context2.sent);
+
+          case 3:
+          case 'end':
+            return _context2.stop();
+        }
+      }
+    }, getStream, this);
+  });
+
+  ImageClient.prototype.getExif = _regenerator2.default.mark(function getExif(name, options) {
+    var params, result;
+    return _regenerator2.default.wrap(function getExif$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            params = this.ossClient._objectRequestParams('GET', name + '@exif', options);
+
+            params.successStatuses = [200];
+
+            _context3.next = 4;
+            return this.ossClient.request(params);
+
+          case 4:
+            result = _context3.sent;
+            _context3.next = 7;
+            return this._parseResponse(result);
+
+          case 7:
+            result = _context3.sent;
+            return _context3.abrupt('return', {
+              res: result.res,
+              data: result.data
+            });
+
+          case 9:
+          case 'end':
+            return _context3.stop();
+        }
+      }
+    }, getExif, this);
+  });
+
+  ImageClient.prototype.getInfo = _regenerator2.default.mark(function getInfo(name, options) {
+    var params, result;
+    return _regenerator2.default.wrap(function getInfo$(_context4) {
+      while (1) {
+        switch (_context4.prev = _context4.next) {
+          case 0:
+            params = this.ossClient._objectRequestParams('GET', name + '@infoexif', options);
+
+            params.successStatuses = [200];
+
+            _context4.next = 4;
+            return this.ossClient.request(params);
+
+          case 4:
+            result = _context4.sent;
+            _context4.next = 7;
+            return this._parseResponse(result);
+
+          case 7:
+            result = _context4.sent;
+            return _context4.abrupt('return', {
+              res: result.res,
+              data: result.data
+            });
+
+          case 9:
+          case 'end':
+            return _context4.stop();
+        }
+      }
+    }, getInfo, this);
+  });
+
+  ImageClient.prototype.putStyle = _regenerator2.default.mark(function putStyle(styleName, style, options) {
+    var params, result;
+    return _regenerator2.default.wrap(function putStyle$(_context5) {
+      while (1) {
+        switch (_context5.prev = _context5.next) {
+          case 0:
+            params = this.ossClient._objectRequestParams('PUT', '/?style&styleName=' + styleName, options);
+
+            params.successStatuses = [200];
+            params.content = '<?xml version="1.0" encoding="UTF-8"?>\n' + '<Style><Content>' + style + '</Content></Style>';
+
+            _context5.next = 5;
+            return this.ossClient.request(params);
+
+          case 5:
+            result = _context5.sent;
+            _context5.next = 8;
+            return this._parseResponse(result);
+
+          case 8:
+            result = _context5.sent;
+            return _context5.abrupt('return', {
+              res: result.res,
+              data: result.data
+            });
+
+          case 10:
+          case 'end':
+            return _context5.stop();
+        }
+      }
+    }, putStyle, this);
+  });
+
+  ImageClient.prototype.getStyle = _regenerator2.default.mark(function getStyle(styleName, options) {
+    var params, result;
+    return _regenerator2.default.wrap(function getStyle$(_context6) {
+      while (1) {
+        switch (_context6.prev = _context6.next) {
+          case 0:
+            params = this.ossClient._objectRequestParams('GET', '/?style&styleName=' + styleName, options);
+
+            params.successStatuses = [200];
+
+            _context6.next = 4;
+            return this.ossClient.request(params);
+
+          case 4:
+            result = _context6.sent;
+            _context6.next = 7;
+            return this._parseResponse(result);
+
+          case 7:
+            result = _context6.sent;
+            return _context6.abrupt('return', {
+              res: result.res,
+              data: result.data
+            });
+
+          case 9:
+          case 'end':
+            return _context6.stop();
+        }
+      }
+    }, getStyle, this);
+  });
+
+  ImageClient.prototype.listStyle = _regenerator2.default.mark(function listStyle(options) {
+    var params, result;
+    return _regenerator2.default.wrap(function listStyle$(_context7) {
+      while (1) {
+        switch (_context7.prev = _context7.next) {
+          case 0:
+            params = this.ossClient._objectRequestParams('GET', '/?style', options);
+
+            params.successStatuses = [200];
+
+            _context7.next = 4;
+            return this.ossClient.request(params);
+
+          case 4:
+            result = _context7.sent;
+            _context7.next = 7;
+            return this._parseResponse(result);
+
+          case 7:
+            result = _context7.sent;
+            return _context7.abrupt('return', {
+              res: result.res,
+              data: result.data.Style
+            });
+
+          case 9:
+          case 'end':
+            return _context7.stop();
+        }
+      }
+    }, listStyle, this);
+  });
+
+  ImageClient.prototype.deleteStyle = _regenerator2.default.mark(function deleteStyle(styleName, options) {
+    var params, result;
+    return _regenerator2.default.wrap(function deleteStyle$(_context8) {
+      while (1) {
+        switch (_context8.prev = _context8.next) {
+          case 0:
+            params = this.ossClient._objectRequestParams('DELETE', '/?style&styleName=' + styleName, options);
+
+            params.successStatuses = [204];
+
+            _context8.next = 4;
+            return this.ossClient.request(params);
+
+          case 4:
+            result = _context8.sent;
+            return _context8.abrupt('return', {
+              res: result.res
+            });
+
+          case 6:
+          case 'end':
+            return _context8.stop();
+        }
+      }
+    }, deleteStyle, this);
+  });
+
+  ImageClient.prototype.signatureUrl = function signatureUrl(name) {
+    return this.ossClient.signatureUrl(name, this.ossClient.options.imageHost);
+  };
+
+  ImageClient.prototype._parseResponse = _regenerator2.default.mark(function _parseResponse(result) {
+    var str, type, data, key;
+    return _regenerator2.default.wrap(function _parseResponse$(_context9) {
+      while (1) {
+        switch (_context9.prev = _context9.next) {
+          case 0:
+            str = result.data.toString();
+            type = result.res.headers['content-type'];
+
+            if (!(type === 'application/json')) {
+              _context9.next = 8;
+              break;
+            }
+
+            data = JSON.parse(str);
+
+            result.data = {};
+            for (key in data) {
+              result.data[key] = parseFloat(data[key].value, 10) || data[key].value;
+            }
+            _context9.next = 12;
+            break;
+
+          case 8:
+            if (!(type === 'application/xml')) {
+              _context9.next = 12;
+              break;
+            }
+
+            _context9.next = 11;
+            return this.ossClient.parseXML(str);
+
+          case 11:
+            result.data = _context9.sent;
+
+          case 12:
+            return _context9.abrupt('return', result);
+
+          case 13:
+          case 'end':
+            return _context9.stop();
+        }
+      }
+    }, _parseResponse, this);
+  });
+
+  return ImageClient;
+};
+
+/* istanbul ignore next */
+function objectRequestParams(method, name, options) {
+  options = options || {};
+  name = this._objectName(name);
+  var authResource = '/' + this.options.bucket + '/' + name;
+  var params = {
+    name: name,
+    method: method,
+    host: this.options.imageHost,
+    resource: '/' + name,
+    timeout: options.timeout,
+    authResource: authResource,
+    ctx: options.ctx
+  };
+
+  if (options.headers) {
+    params.headers = options.headers;
+  }
+  return params;
+}
+
+},{"babel-runtime/regenerator":40}],6:[function(require,module,exports){
+(function (Buffer){
+'use strict';
+
+var _from = require('babel-runtime/core-js/array/from');
+
+var _from2 = _interopRequireDefault(_from);
+
+var _regenerator = require('babel-runtime/regenerator');
+
+var _regenerator2 = _interopRequireDefault(_regenerator);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var debug = require('debug')('ali-oss:multipart');
+var fs = require('fs');
+var is = require('is-type-of');
+var destroy = require('destroy');
+var eoe = require('end-or-error');
+var util = require('util');
+var path = require('path');
+var mime = require('mime');
+var gather = require('co-gather');
+
+var proto = exports;
+
+/**
+ * Multipart operations
+ */
+
+/**
+ * Upload an file to OSS using multipart uploads
+ * @param {String} name
+ * @param {String|File} file
+ * @param {Object} options
+ */
+proto.multipartUpload = _regenerator2.default.mark(function multipartUpload(name, file, options) {
+  var minPartSize, filename, fileSize, stream, ret, result, uploadId, partSize, checkpoint;
+  return _regenerator2.default.wrap(function multipartUpload$(_context) {
+    while (1) {
+      switch (_context.prev = _context.next) {
+        case 0:
+          options = options || {};
+
+          if (!(options.checkpoint && options.checkpoint.uploadId)) {
+            _context.next = 5;
+            break;
+          }
+
+          _context.next = 4;
+          return this._resumeMultipart(options.checkpoint, options);
+
+        case 4:
+          return _context.abrupt('return', _context.sent);
+
+        case 5:
+          minPartSize = 100 * 1024;
+          filename = is.file(file) ? file.name : file;
+
+          options.mime = options.mime || mime.lookup(path.extname(filename));
+          options.headers = options.headers || {};
+          this._convertMetaToHeaders(options.meta, options.headers);
+
+          _context.next = 12;
+          return this._getFileSize(file);
+
+        case 12:
+          fileSize = _context.sent;
+
+          if (!(fileSize < minPartSize)) {
+            _context.next = 23;
+            break;
+          }
+
+          stream = this._createStream(file, 0, fileSize);
+
+          options.contentLength = fileSize;
+
+          _context.next = 18;
+          return this.putStream(name, stream, options);
+
+        case 18:
+          ret = _context.sent;
+
+          if (!(options && options.progress)) {
+            _context.next = 22;
+            break;
+          }
+
+          _context.next = 22;
+          return options.progress(1);
+
+        case 22:
+          return _context.abrupt('return', ret);
+
+        case 23:
+          if (!(options.partSize && options.partSize < minPartSize)) {
+            _context.next = 25;
+            break;
+          }
+
+          throw new Error('partSize must not be smaller than ' + minPartSize);
+
+        case 25:
+          _context.next = 27;
+          return this._initMultipartUpload(name, options);
+
+        case 27:
+          result = _context.sent;
+          uploadId = result.uploadId;
+          partSize = this._getPartSize(fileSize, options.partSize);
+          checkpoint = {
+            file: file,
+            name: name,
+            fileSize: fileSize,
+            partSize: partSize,
+            uploadId: uploadId,
+            doneParts: []
+          };
+          _context.next = 33;
+          return this._resumeMultipart(checkpoint, options);
+
+        case 33:
+          return _context.abrupt('return', _context.sent);
+
+        case 34:
+        case 'end':
+          return _context.stop();
+      }
+    }
+  }, multipartUpload, this);
+});
+
+/*
+ * Resume multipart upload from checkpoint. The checkpoint will be
+ * updated after each successful part upload.
+ * @param {Object} checkpoint the checkpoint
+ * @param {Object} options
+ */
+proto._resumeMultipart = _regenerator2.default.mark(function _resumeMultipart(checkpoint, options) {
+  var file, fileSize, partSize, uploadId, doneParts, name, partOffs, numParts, uploadPartJob, all, done, todo, jobs, i, defaultParallel, parallel, results;
+  return _regenerator2.default.wrap(function _resumeMultipart$(_context3) {
+    while (1) {
+      switch (_context3.prev = _context3.next) {
+        case 0:
+          file = checkpoint.file;
+          fileSize = checkpoint.fileSize;
+          partSize = checkpoint.partSize;
+          uploadId = checkpoint.uploadId;
+          doneParts = checkpoint.doneParts;
+          name = checkpoint.name;
+          partOffs = this._divideParts(fileSize, partSize);
+          numParts = partOffs.length;
+          uploadPartJob = _regenerator2.default.mark(function uploadPartJob(self, partNo) {
+            var pi, data, result;
+            return _regenerator2.default.wrap(function uploadPartJob$(_context2) {
+              while (1) {
+                switch (_context2.prev = _context2.next) {
+                  case 0:
+                    pi = partOffs[partNo - 1];
+                    data = {
+                      stream: self._createStream(file, pi.start, pi.end),
+                      size: pi.end - pi.start
+                    };
+                    _context2.next = 4;
+                    return self._uploadPart(name, uploadId, partNo, data);
+
+                  case 4:
+                    result = _context2.sent;
+
+
+                    doneParts.push({
+                      number: partNo,
+                      etag: result.res.headers.etag
+                    });
+                    checkpoint.doneParts = doneParts;
+
+                    if (!(options && options.progress)) {
+                      _context2.next = 10;
+                      break;
+                    }
+
+                    _context2.next = 10;
+                    return options.progress(doneParts.length / numParts, checkpoint);
+
+                  case 10:
+                  case 'end':
+                    return _context2.stop();
+                }
+              }
+            }, uploadPartJob, this);
+          });
+          all = (0, _from2.default)(new Array(numParts), function (x, i) {
+            return i + 1;
+          });
+          done = doneParts.map(function (p) {
+            return p.number;
+          });
+          todo = all.filter(function (p) {
+            return done.indexOf(p) < 0;
+          });
+          jobs = [];
+
+          for (i = 0; i < todo.length; i++) {
+            jobs.push(uploadPartJob(this, todo[i]));
+          }
+
+          defaultParallel = 5;
+          parallel = options.parallel || defaultParallel;
+
+          // yield in parallel
+
+          _context3.next = 18;
+          return gather(jobs, parallel);
+
+        case 18:
+          results = _context3.sent;
+          i = 0;
+
+        case 20:
+          if (!(i < results.length)) {
+            _context3.next = 26;
+            break;
+          }
+
+          if (!results[i].isError) {
+            _context3.next = 23;
+            break;
+          }
+
+          throw new Error('Failed to upload some parts with error: ' + results[i].error.toString());
+
+        case 23:
+          i++;
+          _context3.next = 20;
+          break;
+
+        case 26:
+          _context3.next = 28;
+          return this._completeMultipartUpload(name, uploadId, doneParts, options);
+
+        case 28:
+          return _context3.abrupt('return', _context3.sent);
+
+        case 29:
+        case 'end':
+          return _context3.stop();
+      }
+    }
+  }, _resumeMultipart, this);
+});
+
+/**
+ * List the on-going multipart uploads
+ * @param {Object} options
+ * @return {Array} the multipart uploads
+ */
+proto.listUploads = _regenerator2.default.mark(function listUploads(query, options) {
+  var params, result, uploads;
+  return _regenerator2.default.wrap(function listUploads$(_context4) {
+    while (1) {
+      switch (_context4.prev = _context4.next) {
+        case 0:
+          options = options || {};
+          options.subres = 'uploads';
+          params = this._objectRequestParams('GET', '', options);
+
+          params.query = query;
+          params.xmlResponse = true;
+          params.successStatuses = [200];
+
+          _context4.next = 8;
+          return this.request(params);
+
+        case 8:
+          result = _context4.sent;
+          uploads = result.data.Upload || [];
+
+          if (!Array.isArray(uploads)) {
+            uploads = [uploads];
+          }
+          uploads = uploads.map(function (up) {
+            return {
+              name: up.Key,
+              uploadId: up.UploadId,
+              initiated: up.Initiated
+            };
+          });
+
+          return _context4.abrupt('return', {
+            res: result.res,
+            uploads: uploads,
+            bucket: result.data.Bucket,
+            nextKeyMarker: result.data.NextKeyMarker,
+            nextUploadIdMarker: result.data.NextUploadIdMarker,
+            isTruncated: result.data.IsTruncated === 'true'
+          });
+
+        case 13:
+        case 'end':
+          return _context4.stop();
+      }
+    }
+  }, listUploads, this);
+});
+
+/**
+ * Abort a multipart upload transaction
+ * @param {String} name the object name
+ * @param {String} uploadId the upload id
+ * @param {Object} options
+ */
+proto.abortMultipartUpload = _regenerator2.default.mark(function abortMultipartUpload(name, uploadId, options) {
+  var params, result;
+  return _regenerator2.default.wrap(function abortMultipartUpload$(_context5) {
+    while (1) {
+      switch (_context5.prev = _context5.next) {
+        case 0:
+          options = options || {};
+          options.subres = { uploadId: uploadId };
+          params = this._objectRequestParams('DELETE', name, options);
+
+          params.successStatuses = [204];
+
+          _context5.next = 6;
+          return this.request(params);
+
+        case 6:
+          result = _context5.sent;
+          return _context5.abrupt('return', {
+            res: result.res
+          });
+
+        case 8:
+        case 'end':
+          return _context5.stop();
+      }
+    }
+  }, abortMultipartUpload, this);
+});
+
+/**
+ * Initiate a multipart upload transaction
+ * @param {String} name the object name
+ * @param {Object} options
+ * @return {String} upload id
+ */
+proto._initMultipartUpload = _regenerator2.default.mark(function _initMultipartUpload(name, options) {
+  var params, result;
+  return _regenerator2.default.wrap(function _initMultipartUpload$(_context6) {
+    while (1) {
+      switch (_context6.prev = _context6.next) {
+        case 0:
+          options = options || {};
+          options.headers = options.headers || {};
+          this._convertMetaToHeaders(options.meta, options.headers);
+
+          options.subres = 'uploads';
+          params = this._objectRequestParams('POST', name, options);
+
+          params.mime = options.mime;
+          params.xmlResponse = true;
+          params.successStatuses = [200];
+
+          _context6.next = 10;
+          return this.request(params);
+
+        case 10:
+          result = _context6.sent;
+          return _context6.abrupt('return', {
+            res: result.res,
+            bucket: result.data.Bucket,
+            name: result.data.Key,
+            uploadId: result.data.UploadId
+          });
+
+        case 12:
+        case 'end':
+          return _context6.stop();
+      }
+    }
+  }, _initMultipartUpload, this);
+});
+
+/**
+ * Upload a part in a multipart upload transaction
+ * @param {String} name the object name
+ * @param {String} uploadId the upload id
+ * @param {Integer} partNo the part number
+ * @param {Object} data the body data
+ * @param {Object} options
+ */
+proto._uploadPart = _regenerator2.default.mark(function _uploadPart(name, uploadId, partNo, data, options) {
+  var params, result;
+  return _regenerator2.default.wrap(function _uploadPart$(_context7) {
+    while (1) {
+      switch (_context7.prev = _context7.next) {
+        case 0:
+          options = options || {};
+          options.headers = {
+            'Content-Length': data.size
+          };
+
+          options.subres = {
+            partNumber: partNo,
+            uploadId: uploadId
+          };
+          params = this._objectRequestParams('PUT', name, options);
+
+          params.mime = options.mime;
+          params.stream = data.stream;
+          params.successStatuses = [200];
+
+          _context7.next = 9;
+          return this.request(params);
+
+        case 9:
+          result = _context7.sent;
+          return _context7.abrupt('return', {
+            name: name,
+            etag: result.res.headers.etag,
+            res: result.res
+          });
+
+        case 11:
+        case 'end':
+          return _context7.stop();
+      }
+    }
+  }, _uploadPart, this);
+});
+
+/**
+ * Complete a multipart upload transaction
+ * @param {String} name the object name
+ * @param {String} uploadId the upload id
+ * @param {Array} parts the uploaded parts
+ * @param {Object} options
+ */
+proto._completeMultipartUpload = _regenerator2.default.mark(function _completeMultipartUpload(name, uploadId, parts, options) {
+  var xml, i, p, params, result, ret;
+  return _regenerator2.default.wrap(function _completeMultipartUpload$(_context8) {
+    while (1) {
+      switch (_context8.prev = _context8.next) {
+        case 0:
+          parts.sort(function (a, b) {
+            return a.number - b.number;
+          });
+          xml = '<?xml version="1.0" encoding="UTF-8"?>\n<CompleteMultipartUpload>\n';
+
+          for (i = 0; i < parts.length; i++) {
+            p = parts[i];
+
+            xml += '<Part>\n';
+            xml += '<PartNumber>' + p.number + '</PartNumber>\n';
+            xml += '<ETag>' + p.etag + '</ETag>\n';
+            xml += '</Part>\n';
+          }
+          xml += '</CompleteMultipartUpload>';
+
+          options = options || {};
+          options.subres = { uploadId: uploadId };
+          params = this._objectRequestParams('POST', name, options);
+
+          params.mime = 'xml';
+          params.content = xml;
+          if (!(options.headers && options.headers['x-oss-callback'])) {
+            params.xmlResponse = true;
+          }
+          params.successStatuses = [200];
+          _context8.next = 13;
+          return this.request(params);
+
+        case 13:
+          result = _context8.sent;
+          ret = {
+            res: result.res,
+            bucket: params.bucket,
+            name: name,
+            etag: result.res.headers['etag']
+          };
+
+
+          if (options.headers && options.headers['x-oss-callback']) {
+            ret.data = JSON.parse(result.data.toString());
+          }
+
+          return _context8.abrupt('return', ret);
+
+        case 17:
+        case 'end':
+          return _context8.stop();
+      }
+    }
+  }, _completeMultipartUpload, this);
+});
+
+is.file = function (file) {
+  return typeof File !== 'undefined' && file instanceof File;
+};
+
+/**
+ * Get file size
+ */
+proto._getFileSize = _regenerator2.default.mark(function _getFileSize(file) {
+  var stat;
+  return _regenerator2.default.wrap(function _getFileSize$(_context9) {
+    while (1) {
+      switch (_context9.prev = _context9.next) {
+        case 0:
+          if (!is.buffer(file)) {
+            _context9.next = 4;
+            break;
+          }
+
+          return _context9.abrupt('return', file.length);
+
+        case 4:
+          if (!is.file(file)) {
+            _context9.next = 6;
+            break;
+          }
+
+          return _context9.abrupt('return', file.size);
+
+        case 6:
+          if (!is.string(file)) {
+            _context9.next = 11;
+            break;
+          }
+
+          _context9.next = 9;
+          return this._statFile(file);
+
+        case 9:
+          stat = _context9.sent;
+          return _context9.abrupt('return', stat.size);
+
+        case 11:
+          throw new Error('_getFileSize requires Buffer/File/String.');
+
+        case 12:
+        case 'end':
+          return _context9.stop();
+      }
+    }
+  }, _getFileSize, this);
+});
+
+/*
+ * Readable stream for Web File
+ */
+var Readable = require('stream').Readable;
+
+function WebFileReadStream(file, options) {
+  if (!(this instanceof WebFileReadStream)) {
+    return new WebFileReadStream(file, options);
+  }
+
+  Readable.call(this, options);
+
+  this.file = file;
+  this.reader = null;
+};
+util.inherits(WebFileReadStream, Readable);
+
+WebFileReadStream.prototype._read = function _read() {
+  if (!this.reader) {
+    var that = this;
+    that.reader = new FileReader();
+    that.reader.onload = function (e) {
+      that.push(new Buffer(new Uint8Array(e.target.result)));
+      that.push(null);
+    };
+    that.reader.readAsArrayBuffer(that.file);
+  }
+};
+
+proto._createStream = function _createStream(file, start, end) {
+  if (is.file(file)) {
+    return new WebFileReadStream(file.slice(start, end));
+  } else if (is.string(file)) {
+    return fs.createReadStream(file, {
+      start: start,
+      end: end - 1
+    });
+  } else {
+    throw new Error('_createStream requires File/String.');
+  }
+};
+
+proto._getPartSize = function _getPartSize(fileSize, partSize) {
+  var maxNumParts = 10 * 1000;
+  var defaultPartSize = 1 * 1024 * 1024;
+
+  if (!partSize) {
+    return defaultPartSize;
+  }
+
+  return Math.max(Math.ceil(fileSize / maxNumParts), partSize);
+};
+
+proto._divideParts = function _divideParts(fileSize, partSize) {
+  var numParts = Math.ceil(fileSize / partSize);
+
+  var partOffs = [];
+  for (var i = 0; i < numParts; i++) {
+    var start = partSize * i;
+    var end = Math.min(start + partSize, fileSize);
+
+    partOffs.push({
+      start: start,
+      end: end
+    });
+  }
+
+  return partOffs;
+};
+
+}).call(this,require("buffer").Buffer)
+},{"babel-runtime/core-js/array/from":15,"babel-runtime/regenerator":40,"buffer":45,"co-gather":49,"debug":184,"destroy":187,"end-or-error":191,"fs":43,"is-type-of":201,"mime":336,"path":342,"stream":369,"util":384}],7:[function(require,module,exports){
+'use strict';
+
+var _regenerator = require('babel-runtime/regenerator');
+
+var _regenerator2 = _interopRequireDefault(_regenerator);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var debug = require('debug')('ali-oss:object');
+var utility = require('utility');
+var crypto = require('./../shims/crypto.js');
+var fs = require('fs');
+var is = require('is-type-of');
+var destroy = require('destroy');
+var eoe = require('end-or-error');
+var urlutil = require('url');
+var copy = require('copy-to');
+var querystring = require('querystring');
+var path = require('path');
+var mime = require('mime');
+
+var proto = exports;
+
+/**
+ * Object operations
+ */
+
+/**
+ * put an object from String(file path)/Buffer/ReadableStream
+ * @param {String} name the object key
+ * @param {Mixed} file String(file path)/Buffer/ReadableStream
+ * @param {Object} options
+ * @return {Object}
+ */
+proto.put = _regenerator2.default.mark(function put(name, file, options) {
+  var content, stream, params, result, ret;
+  return _regenerator2.default.wrap(function put$(_context) {
+    while (1) {
+      switch (_context.prev = _context.next) {
+        case 0:
+
+          options = options || {};
+
+          if (!is.buffer(file)) {
+            _context.next = 5;
+            break;
+          }
+
+          content = file;
+          _context.next = 23;
+          break;
+
+        case 5:
+          if (!is.string(file)) {
+            _context.next = 16;
+            break;
+          }
+
+          options.mime = options.mime || mime.lookup(path.extname(file));
+          stream = fs.createReadStream(file);
+          _context.next = 10;
+          return this._getFileSize(file);
+
+        case 10:
+          options.contentLength = _context.sent;
+          _context.next = 13;
+          return this.putStream(name, stream, options);
+
+        case 13:
+          return _context.abrupt('return', _context.sent);
+
+        case 16:
+          if (!is.readableStream(file)) {
+            _context.next = 22;
+            break;
+          }
+
+          _context.next = 19;
+          return this.putStream(name, file, options);
+
+        case 19:
+          return _context.abrupt('return', _context.sent);
+
+        case 22:
+          throw new TypeError('Must provide String/Buffer/ReadableStream for put.');
+
+        case 23:
+
+          options.headers = options.headers || {};
+          this._convertMetaToHeaders(options.meta, options.headers);
+
+          params = this._objectRequestParams('PUT', name, options);
+
+          params.mime = options.mime;
+          params.content = content;
+          params.successStatuses = [200];
+
+          _context.next = 31;
+          return this.request(params);
+
+        case 31:
+          result = _context.sent;
+          ret = {
+            name: name,
+            url: this._objectUrl(name),
+            res: result.res
+          };
+
+
+          if (options.headers && options.headers['x-oss-callback']) {
+            ret.data = JSON.parse(result.data.toString());
+          }
+
+          return _context.abrupt('return', ret);
+
+        case 35:
+        case 'end':
+          return _context.stop();
+      }
+    }
+  }, put, this);
+});
+
+/**
+ * put an object from ReadableStream. If `options.contentLength` is
+ * not provided, chunked encoding is used.
+ * @param {String} name the object key
+ * @param {Readable} stream the ReadableStream
+ * @param {Object} options
+ * @return {Object}
+ */
+proto.putStream = _regenerator2.default.mark(function putStream(name, stream, options) {
+  var params, result, ret;
+  return _regenerator2.default.wrap(function putStream$(_context2) {
+    while (1) {
+      switch (_context2.prev = _context2.next) {
+        case 0:
+          options = options || {};
+          options.headers = options.headers || {};
+          if (options.contentLength) {
+            options.headers['Content-Length'] = options.contentLength;
+          } else {
+            options.headers['Transfer-Encoding'] = 'chunked';
+          }
+          this._convertMetaToHeaders(options.meta, options.headers);
+          params = this._objectRequestParams('PUT', name, options);
+
+
+          params.mime = options.mime;
+          params.stream = stream;
+          params.successStatuses = [200];
+
+          _context2.next = 10;
+          return this.request(params);
+
+        case 10:
+          result = _context2.sent;
+          ret = {
+            name: name,
+            url: this._objectUrl(name),
+            res: result.res
+          };
+
+
+          if (options.headers && options.headers['x-oss-callback']) {
+            ret.data = JSON.parse(result.data.toString());
+          }
+
+          return _context2.abrupt('return', ret);
+
+        case 14:
+        case 'end':
+          return _context2.stop();
+      }
+    }
+  }, putStream, this);
+});
+
+proto.head = _regenerator2.default.mark(function head(name, options) {
+  var params, result, data, k;
+  return _regenerator2.default.wrap(function head$(_context3) {
+    while (1) {
+      switch (_context3.prev = _context3.next) {
+        case 0:
+          params = this._objectRequestParams('HEAD', name, options);
+
+          params.successStatuses = [200, 304];
+
+          _context3.next = 4;
+          return this.request(params);
+
+        case 4:
+          result = _context3.sent;
+          data = {
+            meta: null,
+            res: result.res,
+            status: result.status
+          };
+
+
+          if (result.status === 200) {
+            for (k in result.headers) {
+              if (k.indexOf('x-oss-meta-') === 0) {
+                if (!data.meta) {
+                  data.meta = {};
+                }
+                data.meta[k.substring(11)] = result.headers[k];
+              }
+            }
+          }
+          return _context3.abrupt('return', data);
+
+        case 8:
+        case 'end':
+          return _context3.stop();
+      }
+    }
+  }, head, this);
+});
+
+proto.get = _regenerator2.default.mark(function get(name, file, options) {
+  var writeStream, needDestroy, result, params;
+  return _regenerator2.default.wrap(function get$(_context4) {
+    while (1) {
+      switch (_context4.prev = _context4.next) {
+        case 0:
+          writeStream = null;
+          needDestroy = false;
+
+
+          if (is.writableStream(file)) {
+            writeStream = file;
+          } else if (is.string(file)) {
+            writeStream = fs.createWriteStream(file);
+            needDestroy = true;
+          } else {
+            // get(name, options)
+            options = file;
+          }
+
+          options = options || {};
+          _context4.prev = 4;
+          params = this._objectRequestParams('GET', name, options);
+
+          params.writeStream = writeStream;
+          params.successStatuses = [200, 206, 304];
+
+          _context4.next = 10;
+          return this.request(params);
+
+        case 10:
+          result = _context4.sent;
+
+
+          if (needDestroy) {
+            writeStream.destroy();
+          }
+          _context4.next = 22;
+          break;
+
+        case 14:
+          _context4.prev = 14;
+          _context4.t0 = _context4['catch'](4);
+
+          if (!needDestroy) {
+            _context4.next = 21;
+            break;
+          }
+
+          writeStream.destroy();
+          // should delete the exists file before throw error
+          debug('get error: %s, delete the exists file %s', _context4.t0, file);
+          _context4.next = 21;
+          return this._deleteFileSafe(file);
+
+        case 21:
+          throw _context4.t0;
+
+        case 22:
+          return _context4.abrupt('return', {
+            res: result.res,
+            content: result.data
+          });
+
+        case 23:
+        case 'end':
+          return _context4.stop();
+      }
+    }
+  }, get, this, [[4, 14]]);
+});
+
+proto.getStream = _regenerator2.default.mark(function getStream(name, options) {
+  var params, result;
+  return _regenerator2.default.wrap(function getStream$(_context5) {
+    while (1) {
+      switch (_context5.prev = _context5.next) {
+        case 0:
+          options = options || {};
+          params = this._objectRequestParams('GET', name, options);
+
+          params.customResponse = true;
+          params.successStatuses = [200, 206, 304];
+
+          _context5.next = 6;
+          return this.request(params);
+
+        case 6:
+          result = _context5.sent;
+          return _context5.abrupt('return', {
+            stream: result.res,
+            res: {
+              status: result.status,
+              headers: result.headers
+            }
+          });
+
+        case 8:
+        case 'end':
+          return _context5.stop();
+      }
+    }
+  }, getStream, this);
+});
+
+proto.delete = _regenerator2.default.mark(function _delete(name, options) {
+  var params, result;
+  return _regenerator2.default.wrap(function _delete$(_context6) {
+    while (1) {
+      switch (_context6.prev = _context6.next) {
+        case 0:
+          params = this._objectRequestParams('DELETE', name, options);
+
+          params.successStatuses = [204];
+
+          _context6.next = 4;
+          return this.request(params);
+
+        case 4:
+          result = _context6.sent;
+          return _context6.abrupt('return', {
+            res: result.res
+          });
+
+        case 6:
+        case 'end':
+          return _context6.stop();
+      }
+    }
+  }, _delete, this);
+});
+
+proto.deleteMulti = _regenerator2.default.mark(function deleteMulti(names, options) {
+  var xml, i, params, result, r, deleted;
+  return _regenerator2.default.wrap(function deleteMulti$(_context7) {
+    while (1) {
+      switch (_context7.prev = _context7.next) {
+        case 0:
+          options = options || {};
+          xml = '<?xml version="1.0" encoding="UTF-8"?>\n<Delete>\n';
+
+          if (options.quiet) {
+            xml += '  <Quiet>true</Quiet>\n';
+          } else {
+            xml += '  <Quiet>false</Quiet>\n';
+          }
+          for (i = 0; i < names.length; i++) {
+            xml += '  <Object><Key>' + utility.escape(this._objectName(names[i])) + '</Key></Object>\n';
+          }
+          xml += '</Delete>';
+          debug('delete multi objects: %s', xml);
+
+          options.subres = 'delete';
+          params = this._objectRequestParams('POST', '', options);
+
+          params.mime = 'xml';
+          params.content = xml;
+          params.xmlResponse = true;
+          params.successStatuses = [200];
+          _context7.next = 14;
+          return this.request(params);
+
+        case 14:
+          result = _context7.sent;
+          r = result.data;
+          deleted = r && r.Deleted || null;
+
+          if (deleted) {
+            if (!Array.isArray(deleted)) {
+              deleted = [deleted];
+            }
+            deleted = deleted.map(function (item) {
+              return item.Key;
+            });
+          }
+          return _context7.abrupt('return', {
+            res: result.res,
+            deleted: deleted
+          });
+
+        case 19:
+        case 'end':
+          return _context7.stop();
+      }
+    }
+  }, deleteMulti, this);
+});
+
+proto.copy = _regenerator2.default.mark(function copy(name, sourceName, options) {
+  var k, params, result, data;
+  return _regenerator2.default.wrap(function copy$(_context8) {
+    while (1) {
+      switch (_context8.prev = _context8.next) {
+        case 0:
+          options = options || {};
+          options.headers = options.headers || {};
+          for (k in options.headers) {
+            options.headers['x-oss-copy-source-' + k.toLowerCase()] = options.headers[k];
+          }
+
+          if (options.meta) {
+            options.headers['x-oss-metadata-directive'] = 'REPLACE';
+          }
+          this._convertMetaToHeaders(options.meta, options.headers);
+
+          if (sourceName[0] !== '/') {
+            // copy same bucket object
+            sourceName = '/' + this.options.bucket + '/' + sourceName;
+          }
+          options.headers['x-oss-copy-source'] = sourceName;
+
+          params = this._objectRequestParams('PUT', name, options);
+
+          params.xmlResponse = true;
+          params.successStatuses = [200, 304];
+
+          _context8.next = 12;
+          return this.request(params);
+
+        case 12:
+          result = _context8.sent;
+          data = result.data;
+
+          if (data) {
+            data = {
+              etag: data.ETag,
+              lastModified: data.LastModified
+            };
+          }
+
+          return _context8.abrupt('return', {
+            data: data,
+            res: result.res
+          });
+
+        case 16:
+        case 'end':
+          return _context8.stop();
+      }
+    }
+  }, copy, this);
+});
+
+proto.putMeta = _regenerator2.default.mark(function putMeta(name, meta, options) {
+  return _regenerator2.default.wrap(function putMeta$(_context9) {
+    while (1) {
+      switch (_context9.prev = _context9.next) {
+        case 0:
+          _context9.next = 2;
+          return this.copy(name, name, {
+            meta: meta || {},
+            timeout: options && options.timeout,
+            ctx: options && options.ctx
+          });
+
+        case 2:
+          return _context9.abrupt('return', _context9.sent);
+
+        case 3:
+        case 'end':
+          return _context9.stop();
+      }
+    }
+  }, putMeta, this);
+});
+
+proto.list = _regenerator2.default.mark(function list(query, options) {
+  var params, result, objects, that, prefixes;
+  return _regenerator2.default.wrap(function list$(_context10) {
+    while (1) {
+      switch (_context10.prev = _context10.next) {
+        case 0:
+          // prefix, marker, max-keys, delimiter
+
+          params = this._objectRequestParams('GET', '', options);
+
+          params.query = query;
+          params.xmlResponse = true;
+          params.successStatuses = [200];
+
+          _context10.next = 6;
+          return this.request(params);
+
+        case 6:
+          result = _context10.sent;
+          objects = result.data.Contents;
+          that = this;
+
+          if (objects) {
+            if (!Array.isArray(objects)) {
+              objects = [objects];
+            }
+            objects = objects.map(function (obj) {
+              return {
+                name: obj.Key,
+                url: that._objectUrl(obj.Key),
+                lastModified: obj.LastModified,
+                etag: obj.ETag,
+                type: obj.Type,
+                size: Number(obj.Size),
+                storageClass: obj.StorageClass,
+                owner: {
+                  id: obj.Owner.ID,
+                  displayName: obj.Owner.DisplayName
+                }
+              };
+            });
+          }
+          prefixes = result.data.CommonPrefixes || null;
+
+          if (prefixes) {
+            if (!Array.isArray(prefixes)) {
+              prefixes = [prefixes];
+            }
+            prefixes = prefixes.map(function (item) {
+              return item.Prefix;
+            });
+          }
+          return _context10.abrupt('return', {
+            res: result.res,
+            objects: objects,
+            prefixes: prefixes,
+            nextMarker: result.data.NextMarker || null,
+            isTruncated: result.data.IsTruncated === 'true'
+          });
+
+        case 13:
+        case 'end':
+          return _context10.stop();
+      }
+    }
+  }, list, this);
+});
+
+/*
+ * Set object's ACL
+ * @param {String} name the object key
+ * @param {String} acl the object ACL
+ * @param {Object} options
+ */
+proto.putACL = _regenerator2.default.mark(function putACL(name, acl, options) {
+  var params, result;
+  return _regenerator2.default.wrap(function putACL$(_context11) {
+    while (1) {
+      switch (_context11.prev = _context11.next) {
+        case 0:
+          options = options || {};
+          options.subres = 'acl';
+          options.headers = options.headers || {};
+          options.headers['x-oss-object-acl'] = acl;
+          name = this._objectName(name);
+
+          params = this._objectRequestParams('PUT', name, options);
+
+          params.successStatuses = [200];
+
+          _context11.next = 9;
+          return this.request(params);
+
+        case 9:
+          result = _context11.sent;
+          return _context11.abrupt('return', {
+            res: result.res
+          });
+
+        case 11:
+        case 'end':
+          return _context11.stop();
+      }
+    }
+  }, putACL, this);
+});
+
+/*
+ * Get object's ACL
+ * @param {String} name the object key
+ * @param {Object} options
+ * @return {Object}
+ */
+proto.getACL = _regenerator2.default.mark(function getACL(name, options) {
+  var params, result;
+  return _regenerator2.default.wrap(function getACL$(_context12) {
+    while (1) {
+      switch (_context12.prev = _context12.next) {
+        case 0:
+          options = options || {};
+          options.subres = 'acl';
+          name = this._objectName(name);
+
+          params = this._objectRequestParams('GET', name, options);
+
+          params.successStatuses = [200];
+          params.xmlResponse = true;
+
+          _context12.next = 8;
+          return this.request(params);
+
+        case 8:
+          result = _context12.sent;
+          return _context12.abrupt('return', {
+            acl: result.data.AccessControlList.Grant,
+            owner: {
+              id: result.data.Owner.ID,
+              displayName: result.data.Owner.DisplayName
+            },
+            res: result.res
+          });
+
+        case 10:
+        case 'end':
+          return _context12.stop();
+      }
+    }
+  }, getACL, this);
+});
+
+proto.signatureUrl = function (name, options) {
+  name = this._objectName(name);
+  var params = {
+    bucket: this.options.bucket,
+    object: name
+  };
+  options = options || {};
+  var expires = utility.timestamp() + (options.expires || 1800);
+  var resource = this._getResource(params);
+
+  var query = {};
+  var signList = [];
+  for (var k in options.response) {
+    var key = 'response-' + k.toLowerCase();
+    query[key] = options.response[k];
+    signList.push(key + '=' + options.response[k]);
+  }
+  if (this.options.stsToken) {
+    query['security-token'] = this.options.stsToken;
+    signList.push('security-token=' + this.options.stsToken);
+  }
+  if (signList.length > 0) {
+    signList.sort();
+    resource += '?' + signList.join('&');
+  }
+
+  var stringToSign = [options.method || 'GET', options['content-md5'] || '', // Content-MD5
+  options['content-type'] || '', // Content-Type
+  expires, resource].join('\n');
+  var signature = this.signature(stringToSign);
+
+  var url = urlutil.parse(this._getReqUrl(params));
+  url.query = {
+    OSSAccessKeyId: this.options.accessKeyId,
+    Expires: expires,
+    Signature: signature
+  };
+  copy(query).to(url.query);
+
+  return url.format();
+};
+
+/**
+ * Get Object url by name
+ * @param {String} name - object name
+ * @param {String} [baseUrl] - If provide `baseUrl`, will use `baseUrl` instead the default `endpoint`.
+ * @return {String} object url
+ */
+proto.getObjectUrl = function (name, baseUrl) {
+  if (!baseUrl) {
+    baseUrl = this.options.endpoint.format();
+  } else if (baseUrl[baseUrl.length - 1] !== '/') {
+    baseUrl += '/';
+  }
+  return baseUrl + this._escape(this._objectName(name));
+};
+
+proto._objectUrl = function (name) {
+  return this._getReqUrl({ bucket: this.options.bucket, object: name });
+};
+
+/**
+ * generator request params
+ * @return {Object} params
+ *
+ * @api private
+ */
+
+proto._objectRequestParams = function (method, name, options) {
+  if (!this.options.bucket) {
+    throw new Error('Please create a bucket first');
+  }
+
+  options = options || {};
+  name = this._objectName(name);
+  var params = {
+    object: name,
+    bucket: this.options.bucket,
+    method: method,
+    subres: options && options.subres,
+    timeout: options && options.timeout,
+    ctx: options && options.ctx
+  };
+
+  if (options.headers) {
+    params.headers = options.headers;
+  }
+  return params;
+};
+
+proto._objectName = function (name) {
+  return name.replace(/^\/+/, '');
+};
+
+proto._statFile = function (filepath) {
+  return function (callback) {
+    fs.stat(filepath, callback);
+  };
+};
+
+proto._convertMetaToHeaders = function (meta, headers) {
+  if (!meta) {
+    return;
+  }
+
+  for (var k in meta) {
+    headers['x-oss-meta-' + k] = meta[k];
+  }
+};
+
+proto._deleteFileSafe = function (filepath) {
+  return function (callback) {
+    fs.exists(filepath, function (exists) {
+      if (!exists) {
+        return callback();
+      }
+      fs.unlink(filepath, function (err) {
+        if (err) {
+          debug('unlink %j error: %s', filepath, err);
+        }
+        callback();
+      });
+    });
+  };
+};
+
+},{"./../shims/crypto.js":420,"babel-runtime/regenerator":40,"copy-to":54,"debug":184,"destroy":187,"end-or-error":191,"fs":43,"is-type-of":201,"mime":336,"path":342,"querystring":349,"url":377,"utility":395}],8:[function(require,module,exports){
+'use strict';
+
+var _keys = require('babel-runtime/core-js/object/keys');
+
+var _keys2 = _interopRequireDefault(_keys);
+
+var _regenerator = require('babel-runtime/regenerator');
+
+var _regenerator2 = _interopRequireDefault(_regenerator);
+
+var _stringify = require('babel-runtime/core-js/json/stringify');
+
+var _stringify2 = _interopRequireDefault(_stringify);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var debug = require('debug')('ali-oss:sts');
+var crypto = require('./../shims/crypto.js');
+var querystring = require('querystring');
+var copy = require('copy-to');
+var AgentKeepalive = require('agentkeepalive');
+var is = require('is-type-of');
+var ms = require('humanize-ms');
+var urllib = require('urllib');
+
+var globalHttpAgent = new AgentKeepalive();
+
+module.exports = STS;
+
+function STS(options) {
+  if (!(this instanceof STS)) {
+    return new STS(options);
+  }
+
+  if (!options || !options.accessKeyId || !options.accessKeySecret) {
+    throw new Error('require accessKeyId, accessKeySecret');
+  }
+
+  this.options = {
+    endpoint: options.endpoint || 'https://sts.aliyuncs.com',
+    format: 'JSON',
+    apiVersion: '2015-04-01',
+    sigMethod: 'HMAC-SHA1',
+    sigVersion: '1.0',
+    timeout: '60s'
+  };
+  copy(options).to(this.options);
+
+  // support custom agent and urllib client
+  if (this.options.urllib) {
+    this.urllib = this.options.urllib;
+  } else {
+    this.urllib = urllib;
+    this.agent = this.options.agent || globalHttpAgent;
+  }
+};
+
+var proto = STS.prototype;
+
+/**
+ * STS opertaions
+ */
+
+proto.assumeRole = _regenerator2.default.mark(function assumeRole(role, policy, expiration, session, options) {
+  var opts, params, policyStr, signature, reqUrl, reqParams, result, err;
+  return _regenerator2.default.wrap(function assumeRole$(_context) {
+    while (1) {
+      switch (_context.prev = _context.next) {
+        case 0:
+          opts = this.options;
+          params = {
+            'Action': 'AssumeRole',
+            'RoleArn': role,
+            'RoleSessionName': session || 'app',
+            'DurationSeconds': expiration || 3600,
+
+            'Format': opts.format,
+            'Version': opts.apiVersion,
+            'AccessKeyId': opts.accessKeyId,
+            'SignatureMethod': opts.sigMethod,
+            'SignatureVersion': opts.sigVersion,
+            'SignatureNonce': Math.random(),
+            'Timestamp': new Date().toISOString()
+          };
+
+          if (!policy) {
+            _context.next = 15;
+            break;
+          }
+
+          if (!is.string(policy)) {
+            _context.next = 13;
+            break;
+          }
+
+          _context.prev = 4;
+
+          policyStr = (0, _stringify2.default)(JSON.parse(policy));
+          _context.next = 11;
+          break;
+
+        case 8:
+          _context.prev = 8;
+          _context.t0 = _context['catch'](4);
+          throw new Error('Policy string is not a valid JSON: ' + _context.t0.message);
+
+        case 11:
+          _context.next = 14;
+          break;
+
+        case 13:
+          policyStr = (0, _stringify2.default)(policy);
+
+        case 14:
+          params.Policy = policyStr;
+
+        case 15:
+          signature = this._getSignature('POST', params, opts.accessKeySecret);
+
+          params.Signature = signature;
+
+          reqUrl = opts.endpoint;
+          reqParams = {
+            agent: this.agent,
+            timeout: ms(options && options.timeout || opts.timeout),
+            method: 'POST',
+            content: querystring.stringify(params),
+            headers: {
+              'Content-Type': 'application/x-www-form-urlencoded'
+            },
+            ctx: options && options.ctx
+          };
+          _context.next = 21;
+          return this.urllib.request(reqUrl, reqParams);
+
+        case 21:
+          result = _context.sent;
+
+          debug('response %s %s, got %s, headers: %j', reqParams.method, reqUrl, result.status, result.headers);
+
+          if (!(Math.floor(result.status / 100) !== 2)) {
+            _context.next = 29;
+            break;
+          }
+
+          _context.next = 26;
+          return this._requestError(result);
+
+        case 26:
+          err = _context.sent;
+
+          err.params = reqParams;
+          throw err;
+
+        case 29:
+          result.data = JSON.parse(result.data);
+
+          return _context.abrupt('return', {
+            res: result.res,
+            credentials: result.data.Credentials
+          });
+
+        case 31:
+        case 'end':
+          return _context.stop();
+      }
+    }
+  }, assumeRole, this, [[4, 8]]);
+});
+
+proto._requestError = _regenerator2.default.mark(function _requestError(result) {
+  var err, resp;
+  return _regenerator2.default.wrap(function _requestError$(_context2) {
+    while (1) {
+      switch (_context2.prev = _context2.next) {
+        case 0:
+          err = new Error();
+
+          err.status = result.status;
+
+          _context2.prev = 2;
+          _context2.next = 5;
+          return JSON.parse(result.data) || {};
+
+        case 5:
+          resp = _context2.sent;
+
+          err.code = resp.Code;
+          err.message = resp.Code + ': ' + resp.Message;
+          err.requestId = resp.RequestId;
+          _context2.next = 14;
+          break;
+
+        case 11:
+          _context2.prev = 11;
+          _context2.t0 = _context2['catch'](2);
+
+          err.message = 'UnknownError: ' + String(result.data);
+
+        case 14:
+          return _context2.abrupt('return', err);
+
+        case 15:
+        case 'end':
+          return _context2.stop();
+      }
+    }
+  }, _requestError, this, [[2, 11]]);
+});
+
+proto._getSignature = function _getSignature(method, params, key) {
+  var that = this;
+  var canoQuery = (0, _keys2.default)(params).sort().map(function (key) {
+    return that._escape(key) + '=' + that._escape(params[key]);
+  }).join('&');
+
+  var stringToSign = method.toUpperCase() + '&' + this._escape('/') + '&' + this._escape(canoQuery);
+
+  debug('string to sign: %s', stringToSign);
+
+  var signature = crypto.createHmac('sha1', key + '&');
+  signature = signature.update(stringToSign).digest('base64');
+
+  debug('signature: %s', signature);
+
+  return signature;
+};
+
+/**
+ * Since `encodeURIComponent` doesn't encode '*', which causes
+ * 'SignatureDoesNotMatch'. We need do it ourselves.
+ */
+proto._escape = function _escape(str) {
+  return encodeURIComponent(str).replace(/\*/g, '%2A');
+};
+
+},{"./../shims/crypto.js":420,"agentkeepalive":11,"babel-runtime/core-js/json/stringify":18,"babel-runtime/core-js/object/keys":30,"babel-runtime/regenerator":40,"copy-to":54,"debug":184,"humanize-ms":196,"is-type-of":201,"querystring":349,"urllib":379}],9:[function(require,module,exports){
+'use strict';
+
+var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of');
+
+var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);
+
+var _keys = require('babel-runtime/core-js/object/keys');
+
+var _keys2 = _interopRequireDefault(_keys);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var co = require('co');
+var OssClient = require('..');
+
+module.exports = Client;
+
+function isGenerator(obj) {
+  return obj && 'function' == typeof obj.next && 'function' == typeof obj.throw;
+}
+
+function isGeneratorFunction(obj) {
+  if (!obj) return false;
+
+  var constructor = obj.constructor;
+  if (!constructor) return false;
+  if ('GeneratorFunction' === constructor.name || 'GeneratorFunction' === constructor.displayName) return true;
+  return isGenerator(constructor.prototype) || isGenerator(obj.prototype);
+}
+
+function wrap(ObjectClass, options) {
+  var client = new ObjectClass(options);
+  var props = (0, _keys2.default)(client);
+  var protoProps = (0, _keys2.default)((0, _getPrototypeOf2.default)(client));
+
+  props.concat(protoProps).forEach(function (key) {
+    if (isGeneratorFunction(client[key])) {
+      this[key] = co.wrap(client[key]).bind(client);
+    } else {
+      this[key] = client[key];
+    }
+  }, this);
+}
+
+function Client(options) {
+  if (!(this instanceof Client)) {
+    return new Client(options);
+  }
+
+  wrap.call(this, OssClient, options);
+}
+
+Client.STS = function STSClient(options) {
+  if (!(this instanceof STSClient)) {
+    return new STSClient(options);
+  }
+
+  wrap.call(this, OssClient.STS, options);
+};
+
+},{"..":3,"babel-runtime/core-js/object/get-prototype-of":28,"babel-runtime/core-js/object/keys":30,"co":51}],10:[function(require,module,exports){
+'use strict';
+
+var os = require('os');
+var fs = require('fs');
+var child = require('child_process');
+
+var DEFAULT_RESOLV_FILE = '/etc/resolv.conf';
+var DEFAULT_INTERFACE = 'eth';
+var IFCONFIG_CMD = '/sbin/ifconfig';
+
+var platform = os.platform();
+if (platform === 'darwin') {
+  DEFAULT_INTERFACE = 'en';
+} else if (platform === 'win32') {
+  IFCONFIG_CMD = 'ipconfig';
+}
+
+/**
+ * Get all addresses.
+ *
+ * @param {String} [interfaceName] interface name, default is 'eth' on linux, 'en' on mac os.
+ * @param {Function(err, addr)} callback
+ *  - {Object} addr {
+ *    - {String} ip
+ *    - {String} ipv6
+ *    - {String} mac
+ *  }
+ */
+function address(interfaceName, callback) {
+  if (typeof interfaceName === 'function') {
+    callback = interfaceName;
+    interfaceName = null;
+  }
+
+  var addr = {
+    ip: address.ip(interfaceName),
+    ipv6: address.ipv6(interfaceName),
+    mac: null
+  };
+  address.mac(interfaceName, function (err, mac) {
+    if (mac) {
+      addr.mac = mac;
+    }
+    callback(err, addr);
+  });
+}
+
+address.interface = function (family, name) {
+  var interfaces = os.networkInterfaces();
+  var noName = !name;
+  name = name || DEFAULT_INTERFACE;
+  family = family || 'IPv4';
+  var networks;
+  for (var i = -1; i < 8; i++) {
+    var interfaceName = name + (i >= 0 ? i : ''); // support 'lo' and 'lo0'
+    var items = interfaces[interfaceName];
+    if (items) {
+      for (var j = 0; j < items.length; j++) {
+        var item = items[j];
+        if (item.family === family) {
+          return item;
+        }
+      }
+    }
+  }
+
+  if (noName) {
+    // filter 127.0.0.1, get the first ip
+    for (var k in interfaces) {
+      var items = interfaces[k];
+      for (var i = 0; i < items.length; i++) {
+        var item = items[i];
+        if (item.family === family && item.address !== '127.0.0.1') {
+          return item;
+        }
+      }
+    }
+  }
+  return;
+};
+
+/**
+ * Get current machine IPv4
+ *
+ * @param {String} [interfaceName] interface name, default is 'eth' on linux, 'en' on mac os.
+ * @return {String} IP address
+ */
+address.ip = function (interfaceName) {
+  var item = address.interface('IPv4', interfaceName);
+  return item && item.address;
+};
+
+/**
+ * Get current machine IPv6
+ *
+ * @param {String} [interfaceName] interface name, default is 'eth' on linux, 'en' on mac os.
+ * @return {String} IP address
+ */
+address.ipv6 = function (interfaceName) {
+  var item = address.interface('IPv6', interfaceName);
+  return item && item.address;
+};
+
+// osx start line 'en0: flags=8863<UP,BROADCAST,SMART,RUNNING,SIMPLEX,MULTICAST> mtu 1500'
+// linux start line 'eth0      Link encap:Ethernet  HWaddr 00:16:3E:00:0A:29  '
+var MAC_OSX_START_LINE = /^(\w+)\:\s+flags=/;
+var MAC_LINUX_START_LINE = /^(\w+)\s{2,}link encap:\w+/i;
+
+// ether 78:ca:39:b0:e6:7d
+// HWaddr 00:16:3E:00:0A:29
+var MAC_RE = address.MAC_RE = /(?:ether|HWaddr)\s+((?:[a-z0-9]{2}\:){5}[a-z0-9]{2})/i;
+
+// osx: inet 192.168.2.104 netmask 0xffffff00 broadcast 192.168.2.255
+// linux: inet addr:10.125.5.202  Bcast:10.125.15.255  Mask:255.255.240.0
+var MAC_IP_RE = address.MAC_IP_RE = /inet\s(?:addr\:)?(\d+\.\d+\.\d+\.\d+)/;
+
+function getMAC(content, interfaceName, matchIP) {
+  var lines = content.split('\n');
+  for (var i = 0; i < lines.length; i++) {
+    var line = lines[i].trimRight();
+    var m = MAC_OSX_START_LINE.exec(line) || MAC_LINUX_START_LINE.exec(line);
+    if (!m) {
+      continue;
+    }
+
+    // check interface name
+    var name = m[1];
+    if (name.indexOf(interfaceName) !== 0) {
+      continue;
+    }
+
+    var ip = null;
+    var mac = null;
+    var match = MAC_RE.exec(line);
+    if (match) {
+      mac = match[1];
+    }
+
+    i++;
+    while (true) {
+      line = lines[i];
+      if (!line || MAC_OSX_START_LINE.exec(line) || MAC_LINUX_START_LINE.exec(line)) {
+        i--;
+        break; // hit next interface, handle next interface
+      }
+      if (!mac) {
+        match = MAC_RE.exec(line);
+        if (match) {
+          mac = match[1];
+        }
+      }
+
+      if (!ip) {
+        match = MAC_IP_RE.exec(line);
+        if (match) {
+          ip = match[1];
+        }
+      }
+
+      i++;
+    }
+
+    if (ip === matchIP) {
+      return mac;
+    }
+  }
+}
+
+/**
+ * Get current machine MAC address
+ *
+ * @param {String} [interfaceName] interface name, default is 'eth' on linux, 'en' on mac os.
+ * @param {Function(err, address)} callback
+ */
+address.mac = function (interfaceName, callback) {
+  if (typeof interfaceName === 'function') {
+    callback = interfaceName;
+    interfaceName = null;
+  }
+
+  interfaceName = interfaceName || DEFAULT_INTERFACE;
+
+  var item = address.interface('IPv4', interfaceName);
+  if (!item) {
+    return callback();
+  }
+
+  if (item.mac) {
+    return callback(null, item.mac);
+  }
+
+  child.exec(IFCONFIG_CMD, { timeout: 5000 }, function (err, stdout, stderr) {
+    if (err || !stdout) {
+      return callback(err);
+    }
+
+    var mac = getMAC(stdout || '', interfaceName, item.address);
+    callback(null, mac);
+  });
+};
+
+// nameserver 172.24.102.254
+var DNS_SERVER_RE = /^nameserver\s+(\d+\.\d+\.\d+\.\d+)$/i;
+
+/**
+ * Get DNS servers.
+ *
+ * @param {String} [filepath] resolv config file path. default is '/etc/resolv.conf'.
+ * @param {Function(err, servers)} callback
+ */
+address.dns = function (filepath, callback) {
+  if (typeof filepath === 'function') {
+    callback = filepath;
+    filepath = null;
+  }
+  filepath = filepath || DEFAULT_RESOLV_FILE;
+  fs.readFile(filepath, 'utf8', function (err, content) {
+    if (err) {
+      return callback(err);
+    }
+    var servers = [];
+    content = content || '';
+    var lines = content.split('\n');
+    for (var i = 0; i < lines.length; i++) {
+      var line = lines[i].trim();
+      var m = DNS_SERVER_RE.exec(line);
+      if (m) {
+        servers.push(m[1]);
+      }
+    }
+
+    callback(null, servers);
+  });
+};
+
+module.exports = address;
+
+},{"child_process":43,"fs":43,"os":339}],11:[function(require,module,exports){
+"use strict";
+
+module.exports = noop;
+module.exports.HttpsAgent = noop;
+
+// Noop function for browser since native api's don't use agents.
+function noop() {}
+
+},{}],12:[function(require,module,exports){
+'use strict';
+
+module.exports = require('./register')().Promise;
+
+},{"./register":14}],13:[function(require,module,exports){
+"use strict";
+// global key for user preferred registration
+
+var REGISTRATION_KEY = '@@any-promise/REGISTRATION',
+
+// Prior registration (preferred or detected)
+registered = null;
+
+/**
+ * Registers the given implementation.  An implementation must
+ * be registered prior to any call to `require("any-promise")`,
+ * typically on application load.
+ *
+ * If called with no arguments, will return registration in
+ * following priority:
+ *
+ * For Node.js:
+ *
+ * 1. Previous registration
+ * 2. global.Promise if node.js version >= 0.12
+ * 3. Auto detected promise based on first sucessful require of
+ *    known promise libraries. Note this is a last resort, as the
+ *    loaded library is non-deterministic. node.js >= 0.12 will
+ *    always use global.Promise over this priority list.
+ * 4. Throws error.
+ *
+ * For Browser:
+ *
+ * 1. Previous registration
+ * 2. window.Promise
+ * 3. Throws error.
+ *
+ * Options:
+ *
+ * Promise: Desired Promise constructor
+ * global: Boolean - Should the registration be cached in a global variable to
+ * allow cross dependency/bundle registration?  (default true)
+ */
+module.exports = function (root, loadImplementation) {
+  return function register(implementation, opts) {
+    implementation = implementation || null;
+    opts = opts || {};
+    // global registration unless explicitly  {global: false} in options (default true)
+    var registerGlobal = opts.global !== false;
+
+    // load any previous global registration
+    if (registered === null && registerGlobal) {
+      registered = root[REGISTRATION_KEY] || null;
+    }
+
+    if (registered !== null && implementation !== null && registered.implementation !== implementation) {
+      // Throw error if attempting to redefine implementation
+      throw new Error('any-promise already defined as "' + registered.implementation + '".  You can only register an implementation before the first ' + ' call to require("any-promise") and an implementation cannot be changed');
+    }
+
+    if (registered === null) {
+      // use provided implementation
+      if (implementation !== null && typeof opts.Promise !== 'undefined') {
+        registered = {
+          Promise: opts.Promise,
+          implementation: implementation
+        };
+      } else {
+        // require implementation if implementation is specified but not provided
+        registered = loadImplementation(implementation);
+      }
+
+      if (registerGlobal) {
+        // register preference globally in case multiple installations
+        root[REGISTRATION_KEY] = registered;
+      }
+    }
+
+    return registered;
+  };
+};
+
+},{}],14:[function(require,module,exports){
+"use strict";
+
+module.exports = require('./loader')(window, loadImplementation);
+
+/**
+ * Browser specific loadImplementation.  Always uses `window.Promise`
+ *
+ * To register a custom implementation, must register with `Promise` option.
+ */
+function loadImplementation() {
+  if (typeof window.Promise === 'undefined') {
+    throw new Error("any-promise browser requires a polyfill or explicit registration" + " e.g: require('any-promise/register/bluebird')");
+  }
+  return {
+    Promise: window.Promise,
+    implementation: 'window.Promise'
+  };
+}
+
+},{"./loader":13}],15:[function(require,module,exports){
+"use strict";
+
+module.exports = { "default": require("core-js/library/fn/array/from"), __esModule: true };
+
+},{"core-js/library/fn/array/from":55}],16:[function(require,module,exports){
+"use strict";
+
+module.exports = { "default": require("core-js/library/fn/clear-immediate"), __esModule: true };
+
+},{"core-js/library/fn/clear-immediate":56}],17:[function(require,module,exports){
+"use strict";
+
+module.exports = { "default": require("core-js/library/fn/get-iterator"), __esModule: true };
+
+},{"core-js/library/fn/get-iterator":57}],18:[function(require,module,exports){
+"use strict";
+
+module.exports = { "default": require("core-js/library/fn/json/stringify"), __esModule: true };
+
+},{"core-js/library/fn/json/stringify":58}],19:[function(require,module,exports){
+"use strict";
+
+module.exports = { "default": require("core-js/library/fn/number/is-finite"), __esModule: true };
+
+},{"core-js/library/fn/number/is-finite":59}],20:[function(require,module,exports){
+"use strict";
+
+module.exports = { "default": require("core-js/library/fn/number/is-nan"), __esModule: true };
+
+},{"core-js/library/fn/number/is-nan":60}],21:[function(require,module,exports){
+"use strict";
+
+module.exports = { "default": require("core-js/library/fn/number/max-safe-integer"), __esModule: true };
+
+},{"core-js/library/fn/number/max-safe-integer":61}],22:[function(require,module,exports){
+"use strict";
+
+module.exports = { "default": require("core-js/library/fn/object/create"), __esModule: true };
+
+},{"core-js/library/fn/object/create":62}],23:[function(require,module,exports){
+"use strict";
+
+module.exports = { "default": require("core-js/library/fn/object/define-properties"), __esModule: true };
+
+},{"core-js/library/fn/object/define-properties":63}],24:[function(require,module,exports){
+"use strict";
+
+module.exports = { "default": require("core-js/library/fn/object/define-property"), __esModule: true };
+
+},{"core-js/library/fn/object/define-property":64}],25:[function(require,module,exports){
+"use strict";
+
+module.exports = { "default": require("core-js/library/fn/object/get-own-property-descriptor"), __esModule: true };
+
+},{"core-js/library/fn/object/get-own-property-descriptor":65}],26:[function(require,module,exports){
+"use strict";
+
+module.exports = { "default": require("core-js/library/fn/object/get-own-property-names"), __esModule: true };
+
+},{"core-js/library/fn/object/get-own-property-names":66}],27:[function(require,module,exports){
+"use strict";
+
+module.exports = { "default": require("core-js/library/fn/object/get-own-property-symbols"), __esModule: true };
+
+},{"core-js/library/fn/object/get-own-property-symbols":67}],28:[function(require,module,exports){
+"use strict";
+
+module.exports = { "default": require("core-js/library/fn/object/get-prototype-of"), __esModule: true };
+
+},{"core-js/library/fn/object/get-prototype-of":68}],29:[function(require,module,exports){
+"use strict";
+
+module.exports = { "default": require("core-js/library/fn/object/is-extensible"), __esModule: true };
+
+},{"core-js/library/fn/object/is-extensible":69}],30:[function(require,module,exports){
+"use strict";
+
+module.exports = { "default": require("core-js/library/fn/object/keys"), __esModule: true };
+
+},{"core-js/library/fn/object/keys":70}],31:[function(require,module,exports){
+"use strict";
+
+module.exports = { "default": require("core-js/library/fn/object/prevent-extensions"), __esModule: true };
+
+},{"core-js/library/fn/object/prevent-extensions":71}],32:[function(require,module,exports){
+"use strict";
+
+module.exports = { "default": require("core-js/library/fn/object/set-prototype-of"), __esModule: true };
+
+},{"core-js/library/fn/object/set-prototype-of":72}],33:[function(require,module,exports){
+"use strict";
+
+module.exports = { "default": require("core-js/library/fn/promise"), __esModule: true };
+
+},{"core-js/library/fn/promise":73}],34:[function(require,module,exports){
+"use strict";
+
+module.exports = { "default": require("core-js/library/fn/set-immediate"), __esModule: true };
+
+},{"core-js/library/fn/set-immediate":74}],35:[function(require,module,exports){
+"use strict";
+
+module.exports = { "default": require("core-js/library/fn/string/from-code-point"), __esModule: true };
+
+},{"core-js/library/fn/string/from-code-point":75}],36:[function(require,module,exports){
+"use strict";
+
+module.exports = { "default": require("core-js/library/fn/symbol"), __esModule: true };
+
+},{"core-js/library/fn/symbol":76}],37:[function(require,module,exports){
+"use strict";
+
+module.exports = { "default": require("core-js/library/fn/symbol/iterator"), __esModule: true };
+
+},{"core-js/library/fn/symbol/iterator":77}],38:[function(require,module,exports){
+"use strict";
+
+module.exports = { "default": require("core-js/library/fn/symbol/species"), __esModule: true };
+
+},{"core-js/library/fn/symbol/species":78}],39:[function(require,module,exports){
+"use strict";
+
+var _typeof3 = require("babel-runtime/helpers/typeof");
+
+var _typeof4 = _interopRequireDefault2(_typeof3);
+
+function _interopRequireDefault2(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.__esModule = true;
+
+var _iterator = require("../core-js/symbol/iterator");
+
+var _iterator2 = _interopRequireDefault(_iterator);
+
+var _symbol = require("../core-js/symbol");
+
+var _symbol2 = _interopRequireDefault(_symbol);
+
+var _typeof = typeof _symbol2.default === "function" && (0, _typeof4.default)(_iterator2.default) === "symbol" ? function (obj) {
+  return typeof obj === "undefined" ? "undefined" : (0, _typeof4.default)(obj);
+} : function (obj) {
+  return obj && typeof _symbol2.default === "function" && obj.constructor === _symbol2.default && obj !== _symbol2.default.prototype ? "symbol" : typeof obj === "undefined" ? "undefined" : (0, _typeof4.default)(obj);
+};
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
+
+exports.default = typeof _symbol2.default === "function" && _typeof(_iterator2.default) === "symbol" ? function (obj) {
+  return typeof obj === "undefined" ? "undefined" : _typeof(obj);
+} : function (obj) {
+  return obj && typeof _symbol2.default === "function" && obj.constructor === _symbol2.default && obj !== _symbol2.default.prototype ? "symbol" : typeof obj === "undefined" ? "undefined" : _typeof(obj);
+};
+
+},{"../core-js/symbol":36,"../core-js/symbol/iterator":37,"babel-runtime/helpers/typeof":39}],40:[function(require,module,exports){
+"use strict";
+
+module.exports = require("regenerator-runtime");
+
+},{"regenerator-runtime":362}],41:[function(require,module,exports){
+'use strict';
+
+exports.byteLength = byteLength;
+exports.toByteArray = toByteArray;
+exports.fromByteArray = fromByteArray;
+
+var lookup = [];
+var revLookup = [];
+var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array;
+
+var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+for (var i = 0, len = code.length; i < len; ++i) {
+  lookup[i] = code[i];
+  revLookup[code.charCodeAt(i)] = i;
+}
+
+revLookup['-'.charCodeAt(0)] = 62;
+revLookup['_'.charCodeAt(0)] = 63;
+
+function placeHoldersCount(b64) {
+  var len = b64.length;
+  if (len % 4 > 0) {
+    throw new Error('Invalid string. Length must be a multiple of 4');
+  }
+
+  // the number of equal signs (place holders)
+  // if there are two placeholders, than the two characters before it
+  // represent one byte
+  // if there is only one, then the three characters before it represent 2 bytes
+  // this is just a cheap hack to not do indexOf twice
+  return b64[len - 2] === '=' ? 2 : b64[len - 1] === '=' ? 1 : 0;
+}
+
+function byteLength(b64) {
+  // base64 is 4/3 + up to two characters of the original data
+  return b64.length * 3 / 4 - placeHoldersCount(b64);
+}
+
+function toByteArray(b64) {
+  var i, j, l, tmp, placeHolders, arr;
+  var len = b64.length;
+  placeHolders = placeHoldersCount(b64);
+
+  arr = new Arr(len * 3 / 4 - placeHolders);
+
+  // if there are placeholders, only get up to the last complete 4 chars
+  l = placeHolders > 0 ? len - 4 : len;
+
+  var L = 0;
+
+  for (i = 0, j = 0; i < l; i += 4, j += 3) {
+    tmp = revLookup[b64.charCodeAt(i)] << 18 | revLookup[b64.charCodeAt(i + 1)] << 12 | revLookup[b64.charCodeAt(i + 2)] << 6 | revLookup[b64.charCodeAt(i + 3)];
+    arr[L++] = tmp >> 16 & 0xFF;
+    arr[L++] = tmp >> 8 & 0xFF;
+    arr[L++] = tmp & 0xFF;
+  }
+
+  if (placeHolders === 2) {
+    tmp = revLookup[b64.charCodeAt(i)] << 2 | revLookup[b64.charCodeAt(i + 1)] >> 4;
+    arr[L++] = tmp & 0xFF;
+  } else if (placeHolders === 1) {
+    tmp = revLookup[b64.charCodeAt(i)] << 10 | revLookup[b64.charCodeAt(i + 1)] << 4 | revLookup[b64.charCodeAt(i + 2)] >> 2;
+    arr[L++] = tmp >> 8 & 0xFF;
+    arr[L++] = tmp & 0xFF;
+  }
+
+  return arr;
+}
+
+function tripletToBase64(num) {
+  return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F];
+}
+
+function encodeChunk(uint8, start, end) {
+  var tmp;
+  var output = [];
+  for (var i = start; i < end; i += 3) {
+    tmp = (uint8[i] << 16) + (uint8[i + 1] << 8) + uint8[i + 2];
+    output.push(tripletToBase64(tmp));
+  }
+  return output.join('');
+}
+
+function fromByteArray(uint8) {
+  var tmp;
+  var len = uint8.length;
+  var extraBytes = len % 3; // if we have 1 byte left, pad 2 bytes
+  var output = '';
+  var parts = [];
+  var maxChunkLength = 16383; // must be multiple of 3
+
+  // go through the array every three bytes, we'll deal with trailing stuff later
+  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
+    parts.push(encodeChunk(uint8, i, i + maxChunkLength > len2 ? len2 : i + maxChunkLength));
+  }
+
+  // pad the end with zeros, but make sure to not forget the extra bytes
+  if (extraBytes === 1) {
+    tmp = uint8[len - 1];
+    output += lookup[tmp >> 2];
+    output += lookup[tmp << 4 & 0x3F];
+    output += '==';
+  } else if (extraBytes === 2) {
+    tmp = (uint8[len - 2] << 8) + uint8[len - 1];
+    output += lookup[tmp >> 10];
+    output += lookup[tmp >> 4 & 0x3F];
+    output += lookup[tmp << 2 & 0x3F];
+    output += '=';
+  }
+
+  parts.push(output);
+
+  return parts.join('');
+}
+
+},{}],42:[function(require,module,exports){
+"use strict";
+
+},{}],43:[function(require,module,exports){
+"use strict";
+
+},{}],44:[function(require,module,exports){
+(function (global){
+'use strict';
+
+var buffer = require('buffer');
+var Buffer = buffer.Buffer;
+var SlowBuffer = buffer.SlowBuffer;
+var MAX_LEN = buffer.kMaxLength || 2147483647;
+exports.alloc = function alloc(size, fill, encoding) {
+  if (typeof Buffer.alloc === 'function') {
+    return Buffer.alloc(size, fill, encoding);
+  }
+  if (typeof encoding === 'number') {
+    throw new TypeError('encoding must not be number');
+  }
+  if (typeof size !== 'number') {
+    throw new TypeError('size must be a number');
+  }
+  if (size > MAX_LEN) {
+    throw new RangeError('size is too large');
+  }
+  var enc = encoding;
+  var _fill = fill;
+  if (_fill === undefined) {
+    enc = undefined;
+    _fill = 0;
+  }
+  var buf = new Buffer(size);
+  if (typeof _fill === 'string') {
+    var fillBuf = new Buffer(_fill, enc);
+    var flen = fillBuf.length;
+    var i = -1;
+    while (++i < size) {
+      buf[i] = fillBuf[i % flen];
+    }
+  } else {
+    buf.fill(_fill);
+  }
+  return buf;
+};
+exports.allocUnsafe = function allocUnsafe(size) {
+  if (typeof Buffer.allocUnsafe === 'function') {
+    return Buffer.allocUnsafe(size);
+  }
+  if (typeof size !== 'number') {
+    throw new TypeError('size must be a number');
+  }
+  if (size > MAX_LEN) {
+    throw new RangeError('size is too large');
+  }
+  return new Buffer(size);
+};
+exports.from = function from(value, encodingOrOffset, length) {
+  if (typeof Buffer.from === 'function' && (!global.Uint8Array || Uint8Array.from !== Buffer.from)) {
+    return Buffer.from(value, encodingOrOffset, length);
+  }
+  if (typeof value === 'number') {
+    throw new TypeError('"value" argument must not be a number');
+  }
+  if (typeof value === 'string') {
+    return new Buffer(value, encodingOrOffset);
+  }
+  if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {
+    var offset = encodingOrOffset;
+    if (arguments.length === 1) {
+      return new Buffer(value);
+    }
+    if (typeof offset === 'undefined') {
+      offset = 0;
+    }
+    var len = length;
+    if (typeof len === 'undefined') {
+      len = value.byteLength - offset;
+    }
+    if (offset >= value.byteLength) {
+      throw new RangeError('\'offset\' is out of bounds');
+    }
+    if (len > value.byteLength - offset) {
+      throw new RangeError('\'length\' is out of bounds');
+    }
+    return new Buffer(value.slice(offset, offset + len));
+  }
+  if (Buffer.isBuffer(value)) {
+    var out = new Buffer(value.length);
+    value.copy(out, 0, 0, value.length);
+    return out;
+  }
+  if (value) {
+    if (Array.isArray(value) || typeof ArrayBuffer !== 'undefined' && value.buffer instanceof ArrayBuffer || 'length' in value) {
+      return new Buffer(value);
+    }
+    if (value.type === 'Buffer' && Array.isArray(value.data)) {
+      return new Buffer(value.data);
+    }
+  }
+
+  throw new TypeError('First argument must be a string, Buffer, ' + 'ArrayBuffer, Array, or array-like object.');
+};
+exports.allocUnsafeSlow = function allocUnsafeSlow(size) {
+  if (typeof Buffer.allocUnsafeSlow === 'function') {
+    return Buffer.allocUnsafeSlow(size);
+  }
+  if (typeof size !== 'number') {
+    throw new TypeError('size must be a number');
+  }
+  if (size >= MAX_LEN) {
+    throw new RangeError('size is too large');
+  }
+  return new SlowBuffer(size);
+};
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"buffer":45}],45:[function(require,module,exports){
+(function (global){
+/*!
+ * The buffer module from node.js, for the browser.
+ *
+ * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
+ * @license  MIT
+ */
+/* eslint-disable no-proto */
+
+'use strict';
+
+var _defineProperty = require('babel-runtime/core-js/object/define-property');
+
+var _defineProperty2 = _interopRequireDefault(_defineProperty);
+
+var _species = require('babel-runtime/core-js/symbol/species');
+
+var _species2 = _interopRequireDefault(_species);
+
+var _symbol = require('babel-runtime/core-js/symbol');
+
+var _symbol2 = _interopRequireDefault(_symbol);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var base64 = require('base64-js');
+var ieee754 = require('ieee754');
+var isArray = require('isarray');
+
+exports.Buffer = Buffer;
+exports.SlowBuffer = SlowBuffer;
+exports.INSPECT_MAX_BYTES = 50;
+
+/**
+ * If `Buffer.TYPED_ARRAY_SUPPORT`:
+ *   === true    Use Uint8Array implementation (fastest)
+ *   === false   Use Object implementation (most compatible, even IE6)
+ *
+ * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
+ * Opera 11.6+, iOS 4.2+.
+ *
+ * Due to various browser bugs, sometimes the Object implementation will be used even
+ * when the browser supports typed arrays.
+ *
+ * Note:
+ *
+ *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,
+ *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.
+ *
+ *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.
+ *
+ *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of
+ *     incorrect length in some situations.
+
+ * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they
+ * get the Object implementation, which is slower but behaves correctly.
+ */
+Buffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined ? global.TYPED_ARRAY_SUPPORT : typedArraySupport();
+
+/*
+ * Export kMaxLength after typed array support is determined.
+ */
+exports.kMaxLength = kMaxLength();
+
+function typedArraySupport() {
+  try {
+    var arr = new Uint8Array(1);
+    arr.__proto__ = { __proto__: Uint8Array.prototype, foo: function foo() {
+        return 42;
+      } };
+    return arr.foo() === 42 && // typed array instances can be augmented
+    typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`
+    arr.subarray(1, 1).byteLength === 0; // ie10 has broken `subarray`
+  } catch (e) {
+    return false;
+  }
+}
+
+function kMaxLength() {
+  return Buffer.TYPED_ARRAY_SUPPORT ? 0x7fffffff : 0x3fffffff;
+}
+
+function createBuffer(that, length) {
+  if (kMaxLength() < length) {
+    throw new RangeError('Invalid typed array length');
+  }
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
+    // Return an augmented `Uint8Array` instance, for best performance
+    that = new Uint8Array(length);
+    that.__proto__ = Buffer.prototype;
+  } else {
+    // Fallback: Return an object instance of the Buffer class
+    if (that === null) {
+      that = new Buffer(length);
+    }
+    that.length = length;
+  }
+
+  return that;
+}
+
+/**
+ * The Buffer constructor returns instances of `Uint8Array` that have their
+ * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
+ * `Uint8Array`, so the returned instances will have all the node `Buffer` methods
+ * and the `Uint8Array` methods. Square bracket notation works as expected -- it
+ * returns a single octet.
+ *
+ * The `Uint8Array` prototype remains unmodified.
+ */
+
+function Buffer(arg, encodingOrOffset, length) {
+  if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {
+    return new Buffer(arg, encodingOrOffset, length);
+  }
+
+  // Common case.
+  if (typeof arg === 'number') {
+    if (typeof encodingOrOffset === 'string') {
+      throw new Error('If encoding is specified then the first argument must be a string');
+    }
+    return allocUnsafe(this, arg);
+  }
+  return from(this, arg, encodingOrOffset, length);
+}
+
+Buffer.poolSize = 8192; // not used by this implementation
+
+// TODO: Legacy, not needed anymore. Remove in next major version.
+Buffer._augment = function (arr) {
+  arr.__proto__ = Buffer.prototype;
+  return arr;
+};
+
+function from(that, value, encodingOrOffset, length) {
+  if (typeof value === 'number') {
+    throw new TypeError('"value" argument must not be a number');
+  }
+
+  if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {
+    return fromArrayBuffer(that, value, encodingOrOffset, length);
+  }
+
+  if (typeof value === 'string') {
+    return fromString(that, value, encodingOrOffset);
+  }
+
+  return fromObject(that, value);
+}
+
+/**
+ * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
+ * if value is a number.
+ * Buffer.from(str[, encoding])
+ * Buffer.from(array)
+ * Buffer.from(buffer)
+ * Buffer.from(arrayBuffer[, byteOffset[, length]])
+ **/
+Buffer.from = function (value, encodingOrOffset, length) {
+  return from(null, value, encodingOrOffset, length);
+};
+
+if (Buffer.TYPED_ARRAY_SUPPORT) {
+  Buffer.prototype.__proto__ = Uint8Array.prototype;
+  Buffer.__proto__ = Uint8Array;
+  if (typeof _symbol2.default !== 'undefined' && _species2.default && Buffer[_species2.default] === Buffer) {
+    // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97
+    (0, _defineProperty2.default)(Buffer, _species2.default, {
+      value: null,
+      configurable: true
+    });
+  }
+}
+
+function assertSize(size) {
+  if (typeof size !== 'number') {
+    throw new TypeError('"size" argument must be a number');
+  } else if (size < 0) {
+    throw new RangeError('"size" argument must not be negative');
+  }
+}
+
+function alloc(that, size, fill, encoding) {
+  assertSize(size);
+  if (size <= 0) {
+    return createBuffer(that, size);
+  }
+  if (fill !== undefined) {
+    // Only pay attention to encoding if it's a string. This
+    // prevents accidentally sending in a number that would
+    // be interpretted as a start offset.
+    return typeof encoding === 'string' ? createBuffer(that, size).fill(fill, encoding) : createBuffer(that, size).fill(fill);
+  }
+  return createBuffer(that, size);
+}
+
+/**
+ * Creates a new filled Buffer instance.
+ * alloc(size[, fill[, encoding]])
+ **/
+Buffer.alloc = function (size, fill, encoding) {
+  return alloc(null, size, fill, encoding);
+};
+
+function allocUnsafe(that, size) {
+  assertSize(size);
+  that = createBuffer(that, size < 0 ? 0 : checked(size) | 0);
+  if (!Buffer.TYPED_ARRAY_SUPPORT) {
+    for (var i = 0; i < size; ++i) {
+      that[i] = 0;
+    }
+  }
+  return that;
+}
+
+/**
+ * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
+ * */
+Buffer.allocUnsafe = function (size) {
+  return allocUnsafe(null, size);
+};
+/**
+ * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
+ */
+Buffer.allocUnsafeSlow = function (size) {
+  return allocUnsafe(null, size);
+};
+
+function fromString(that, string, encoding) {
+  if (typeof encoding !== 'string' || encoding === '') {
+    encoding = 'utf8';
+  }
+
+  if (!Buffer.isEncoding(encoding)) {
+    throw new TypeError('"encoding" must be a valid string encoding');
+  }
+
+  var length = byteLength(string, encoding) | 0;
+  that = createBuffer(that, length);
+
+  var actual = that.write(string, encoding);
+
+  if (actual !== length) {
+    // Writing a hex string, for example, that contains invalid characters will
+    // cause everything after the first invalid character to be ignored. (e.g.
+    // 'abxxcd' will be treated as 'ab')
+    that = that.slice(0, actual);
+  }
+
+  return that;
+}
+
+function fromArrayLike(that, array) {
+  var length = array.length < 0 ? 0 : checked(array.length) | 0;
+  that = createBuffer(that, length);
+  for (var i = 0; i < length; i += 1) {
+    that[i] = array[i] & 255;
+  }
+  return that;
+}
+
+function fromArrayBuffer(that, array, byteOffset, length) {
+  array.byteLength; // this throws if `array` is not a valid ArrayBuffer
+
+  if (byteOffset < 0 || array.byteLength < byteOffset) {
+    throw new RangeError('\'offset\' is out of bounds');
+  }
+
+  if (array.byteLength < byteOffset + (length || 0)) {
+    throw new RangeError('\'length\' is out of bounds');
+  }
+
+  if (byteOffset === undefined && length === undefined) {
+    array = new Uint8Array(array);
+  } else if (length === undefined) {
+    array = new Uint8Array(array, byteOffset);
+  } else {
+    array = new Uint8Array(array, byteOffset, length);
+  }
+
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
+    // Return an augmented `Uint8Array` instance, for best performance
+    that = array;
+    that.__proto__ = Buffer.prototype;
+  } else {
+    // Fallback: Return an object instance of the Buffer class
+    that = fromArrayLike(that, array);
+  }
+  return that;
+}
+
+function fromObject(that, obj) {
+  if (Buffer.isBuffer(obj)) {
+    var len = checked(obj.length) | 0;
+    that = createBuffer(that, len);
+
+    if (that.length === 0) {
+      return that;
+    }
+
+    obj.copy(that, 0, 0, len);
+    return that;
+  }
+
+  if (obj) {
+    if (typeof ArrayBuffer !== 'undefined' && obj.buffer instanceof ArrayBuffer || 'length' in obj) {
+      if (typeof obj.length !== 'number' || isnan(obj.length)) {
+        return createBuffer(that, 0);
+      }
+      return fromArrayLike(that, obj);
+    }
+
+    if (obj.type === 'Buffer' && isArray(obj.data)) {
+      return fromArrayLike(that, obj.data);
+    }
+  }
+
+  throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.');
+}
+
+function checked(length) {
+  // Note: cannot use `length < kMaxLength()` here because that fails when
+  // length is NaN (which is otherwise coerced to zero.)
+  if (length >= kMaxLength()) {
+    throw new RangeError('Attempt to allocate Buffer larger than maximum ' + 'size: 0x' + kMaxLength().toString(16) + ' bytes');
+  }
+  return length | 0;
+}
+
+function SlowBuffer(length) {
+  if (+length != length) {
+    // eslint-disable-line eqeqeq
+    length = 0;
+  }
+  return Buffer.alloc(+length);
+}
+
+Buffer.isBuffer = function isBuffer(b) {
+  return !!(b != null && b._isBuffer);
+};
+
+Buffer.compare = function compare(a, b) {
+  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
+    throw new TypeError('Arguments must be Buffers');
+  }
+
+  if (a === b) return 0;
+
+  var x = a.length;
+  var y = b.length;
+
+  for (var i = 0, len = Math.min(x, y); i < len; ++i) {
+    if (a[i] !== b[i]) {
+      x = a[i];
+      y = b[i];
+      break;
+    }
+  }
+
+  if (x < y) return -1;
+  if (y < x) return 1;
+  return 0;
+};
+
+Buffer.isEncoding = function isEncoding(encoding) {
+  switch (String(encoding).toLowerCase()) {
+    case 'hex':
+    case 'utf8':
+    case 'utf-8':
+    case 'ascii':
+    case 'latin1':
+    case 'binary':
+    case 'base64':
+    case 'ucs2':
+    case 'ucs-2':
+    case 'utf16le':
+    case 'utf-16le':
+      return true;
+    default:
+      return false;
+  }
+};
+
+Buffer.concat = function concat(list, length) {
+  if (!isArray(list)) {
+    throw new TypeError('"list" argument must be an Array of Buffers');
+  }
+
+  if (list.length === 0) {
+    return Buffer.alloc(0);
+  }
+
+  var i;
+  if (length === undefined) {
+    length = 0;
+    for (i = 0; i < list.length; ++i) {
+      length += list[i].length;
+    }
+  }
+
+  var buffer = Buffer.allocUnsafe(length);
+  var pos = 0;
+  for (i = 0; i < list.length; ++i) {
+    var buf = list[i];
+    if (!Buffer.isBuffer(buf)) {
+      throw new TypeError('"list" argument must be an Array of Buffers');
+    }
+    buf.copy(buffer, pos);
+    pos += buf.length;
+  }
+  return buffer;
+};
+
+function byteLength(string, encoding) {
+  if (Buffer.isBuffer(string)) {
+    return string.length;
+  }
+  if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' && (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {
+    return string.byteLength;
+  }
+  if (typeof string !== 'string') {
+    string = '' + string;
+  }
+
+  var len = string.length;
+  if (len === 0) return 0;
+
+  // Use a for loop to avoid recursion
+  var loweredCase = false;
+  for (;;) {
+    switch (encoding) {
+      case 'ascii':
+      case 'latin1':
+      case 'binary':
+        return len;
+      case 'utf8':
+      case 'utf-8':
+      case undefined:
+        return utf8ToBytes(string).length;
+      case 'ucs2':
+      case 'ucs-2':
+      case 'utf16le':
+      case 'utf-16le':
+        return len * 2;
+      case 'hex':
+        return len >>> 1;
+      case 'base64':
+        return base64ToBytes(string).length;
+      default:
+        if (loweredCase) return utf8ToBytes(string).length; // assume utf8
+        encoding = ('' + encoding).toLowerCase();
+        loweredCase = true;
+    }
+  }
+}
+Buffer.byteLength = byteLength;
+
+function slowToString(encoding, start, end) {
+  var loweredCase = false;
+
+  // No need to verify that "this.length <= MAX_UINT32" since it's a read-only
+  // property of a typed array.
+
+  // This behaves neither like String nor Uint8Array in that we set start/end
+  // to their upper/lower bounds if the value passed is out of range.
+  // undefined is handled specially as per ECMA-262 6th Edition,
+  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.
+  if (start === undefined || start < 0) {
+    start = 0;
+  }
+  // Return early if start > this.length. Done here to prevent potential uint32
+  // coercion fail below.
+  if (start > this.length) {
+    return '';
+  }
+
+  if (end === undefined || end > this.length) {
+    end = this.length;
+  }
+
+  if (end <= 0) {
+    return '';
+  }
+
+  // Force coersion to uint32. This will also coerce falsey/NaN values to 0.
+  end >>>= 0;
+  start >>>= 0;
+
+  if (end <= start) {
+    return '';
+  }
+
+  if (!encoding) encoding = 'utf8';
+
+  while (true) {
+    switch (encoding) {
+      case 'hex':
+        return hexSlice(this, start, end);
+
+      case 'utf8':
+      case 'utf-8':
+        return utf8Slice(this, start, end);
+
+      case 'ascii':
+        return asciiSlice(this, start, end);
+
+      case 'latin1':
+      case 'binary':
+        return latin1Slice(this, start, end);
+
+      case 'base64':
+        return base64Slice(this, start, end);
+
+      case 'ucs2':
+      case 'ucs-2':
+      case 'utf16le':
+      case 'utf-16le':
+        return utf16leSlice(this, start, end);
+
+      default:
+        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding);
+        encoding = (encoding + '').toLowerCase();
+        loweredCase = true;
+    }
+  }
+}
+
+// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect
+// Buffer instances.
+Buffer.prototype._isBuffer = true;
+
+function swap(b, n, m) {
+  var i = b[n];
+  b[n] = b[m];
+  b[m] = i;
+}
+
+Buffer.prototype.swap16 = function swap16() {
+  var len = this.length;
+  if (len % 2 !== 0) {
+    throw new RangeError('Buffer size must be a multiple of 16-bits');
+  }
+  for (var i = 0; i < len; i += 2) {
+    swap(this, i, i + 1);
+  }
+  return this;
+};
+
+Buffer.prototype.swap32 = function swap32() {
+  var len = this.length;
+  if (len % 4 !== 0) {
+    throw new RangeError('Buffer size must be a multiple of 32-bits');
+  }
+  for (var i = 0; i < len; i += 4) {
+    swap(this, i, i + 3);
+    swap(this, i + 1, i + 2);
+  }
+  return this;
+};
+
+Buffer.prototype.swap64 = function swap64() {
+  var len = this.length;
+  if (len % 8 !== 0) {
+    throw new RangeError('Buffer size must be a multiple of 64-bits');
+  }
+  for (var i = 0; i < len; i += 8) {
+    swap(this, i, i + 7);
+    swap(this, i + 1, i + 6);
+    swap(this, i + 2, i + 5);
+    swap(this, i + 3, i + 4);
+  }
+  return this;
+};
+
+Buffer.prototype.toString = function toString() {
+  var length = this.length | 0;
+  if (length === 0) return '';
+  if (arguments.length === 0) return utf8Slice(this, 0, length);
+  return slowToString.apply(this, arguments);
+};
+
+Buffer.prototype.equals = function equals(b) {
+  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer');
+  if (this === b) return true;
+  return Buffer.compare(this, b) === 0;
+};
+
+Buffer.prototype.inspect = function inspect() {
+  var str = '';
+  var max = exports.INSPECT_MAX_BYTES;
+  if (this.length > 0) {
+    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ');
+    if (this.length > max) str += ' ... ';
+  }
+  return '<Buffer ' + str + '>';
+};
+
+Buffer.prototype.compare = function compare(target, start, end, thisStart, thisEnd) {
+  if (!Buffer.isBuffer(target)) {
+    throw new TypeError('Argument must be a Buffer');
+  }
+
+  if (start === undefined) {
+    start = 0;
+  }
+  if (end === undefined) {
+    end = target ? target.length : 0;
+  }
+  if (thisStart === undefined) {
+    thisStart = 0;
+  }
+  if (thisEnd === undefined) {
+    thisEnd = this.length;
+  }
+
+  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
+    throw new RangeError('out of range index');
+  }
+
+  if (thisStart >= thisEnd && start >= end) {
+    return 0;
+  }
+  if (thisStart >= thisEnd) {
+    return -1;
+  }
+  if (start >= end) {
+    return 1;
+  }
+
+  start >>>= 0;
+  end >>>= 0;
+  thisStart >>>= 0;
+  thisEnd >>>= 0;
+
+  if (this === target) return 0;
+
+  var x = thisEnd - thisStart;
+  var y = end - start;
+  var len = Math.min(x, y);
+
+  var thisCopy = this.slice(thisStart, thisEnd);
+  var targetCopy = target.slice(start, end);
+
+  for (var i = 0; i < len; ++i) {
+    if (thisCopy[i] !== targetCopy[i]) {
+      x = thisCopy[i];
+      y = targetCopy[i];
+      break;
+    }
+  }
+
+  if (x < y) return -1;
+  if (y < x) return 1;
+  return 0;
+};
+
+// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,
+// OR the last index of `val` in `buffer` at offset <= `byteOffset`.
+//
+// Arguments:
+// - buffer - a Buffer to search
+// - val - a string, Buffer, or number
+// - byteOffset - an index into `buffer`; will be clamped to an int32
+// - encoding - an optional encoding, relevant is val is a string
+// - dir - true for indexOf, false for lastIndexOf
+function bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {
+  // Empty buffer means no match
+  if (buffer.length === 0) return -1;
+
+  // Normalize byteOffset
+  if (typeof byteOffset === 'string') {
+    encoding = byteOffset;
+    byteOffset = 0;
+  } else if (byteOffset > 0x7fffffff) {
+    byteOffset = 0x7fffffff;
+  } else if (byteOffset < -0x80000000) {
+    byteOffset = -0x80000000;
+  }
+  byteOffset = +byteOffset; // Coerce to Number.
+  if (isNaN(byteOffset)) {
+    // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer
+    byteOffset = dir ? 0 : buffer.length - 1;
+  }
+
+  // Normalize byteOffset: negative offsets start from the end of the buffer
+  if (byteOffset < 0) byteOffset = buffer.length + byteOffset;
+  if (byteOffset >= buffer.length) {
+    if (dir) return -1;else byteOffset = buffer.length - 1;
+  } else if (byteOffset < 0) {
+    if (dir) byteOffset = 0;else return -1;
+  }
+
+  // Normalize val
+  if (typeof val === 'string') {
+    val = Buffer.from(val, encoding);
+  }
+
+  // Finally, search either indexOf (if dir is true) or lastIndexOf
+  if (Buffer.isBuffer(val)) {
+    // Special case: looking for empty string/buffer always fails
+    if (val.length === 0) {
+      return -1;
+    }
+    return arrayIndexOf(buffer, val, byteOffset, encoding, dir);
+  } else if (typeof val === 'number') {
+    val = val & 0xFF; // Search for a byte value [0-255]
+    if (Buffer.TYPED_ARRAY_SUPPORT && typeof Uint8Array.prototype.indexOf === 'function') {
+      if (dir) {
+        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset);
+      } else {
+        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset);
+      }
+    }
+    return arrayIndexOf(buffer, [val], byteOffset, encoding, dir);
+  }
+
+  throw new TypeError('val must be string, number or Buffer');
+}
+
+function arrayIndexOf(arr, val, byteOffset, encoding, dir) {
+  var indexSize = 1;
+  var arrLength = arr.length;
+  var valLength = val.length;
+
+  if (encoding !== undefined) {
+    encoding = String(encoding).toLowerCase();
+    if (encoding === 'ucs2' || encoding === 'ucs-2' || encoding === 'utf16le' || encoding === 'utf-16le') {
+      if (arr.length < 2 || val.length < 2) {
+        return -1;
+      }
+      indexSize = 2;
+      arrLength /= 2;
+      valLength /= 2;
+      byteOffset /= 2;
+    }
+  }
+
+  function read(buf, i) {
+    if (indexSize === 1) {
+      return buf[i];
+    } else {
+      return buf.readUInt16BE(i * indexSize);
+    }
+  }
+
+  var i;
+  if (dir) {
+    var foundIndex = -1;
+    for (i = byteOffset; i < arrLength; i++) {
+      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
+        if (foundIndex === -1) foundIndex = i;
+        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize;
+      } else {
+        if (foundIndex !== -1) i -= i - foundIndex;
+        foundIndex = -1;
+      }
+    }
+  } else {
+    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength;
+    for (i = byteOffset; i >= 0; i--) {
+      var found = true;
+      for (var j = 0; j < valLength; j++) {
+        if (read(arr, i + j) !== read(val, j)) {
+          found = false;
+          break;
+        }
+      }
+      if (found) return i;
+    }
+  }
+
+  return -1;
+}
+
+Buffer.prototype.includes = function includes(val, byteOffset, encoding) {
+  return this.indexOf(val, byteOffset, encoding) !== -1;
+};
+
+Buffer.prototype.indexOf = function indexOf(val, byteOffset, encoding) {
+  return bidirectionalIndexOf(this, val, byteOffset, encoding, true);
+};
+
+Buffer.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) {
+  return bidirectionalIndexOf(this, val, byteOffset, encoding, false);
+};
+
+function hexWrite(buf, string, offset, length) {
+  offset = Number(offset) || 0;
+  var remaining = buf.length - offset;
+  if (!length) {
+    length = remaining;
+  } else {
+    length = Number(length);
+    if (length > remaining) {
+      length = remaining;
+    }
+  }
+
+  // must be an even number of digits
+  var strLen = string.length;
+  if (strLen % 2 !== 0) throw new TypeError('Invalid hex string');
+
+  if (length > strLen / 2) {
+    length = strLen / 2;
+  }
+  for (var i = 0; i < length; ++i) {
+    var parsed = parseInt(string.substr(i * 2, 2), 16);
+    if (isNaN(parsed)) return i;
+    buf[offset + i] = parsed;
+  }
+  return i;
+}
+
+function utf8Write(buf, string, offset, length) {
+  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length);
+}
+
+function asciiWrite(buf, string, offset, length) {
+  return blitBuffer(asciiToBytes(string), buf, offset, length);
+}
+
+function latin1Write(buf, string, offset, length) {
+  return asciiWrite(buf, string, offset, length);
+}
+
+function base64Write(buf, string, offset, length) {
+  return blitBuffer(base64ToBytes(string), buf, offset, length);
+}
+
+function ucs2Write(buf, string, offset, length) {
+  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length);
+}
+
+Buffer.prototype.write = function write(string, offset, length, encoding) {
+  // Buffer#write(string)
+  if (offset === undefined) {
+    encoding = 'utf8';
+    length = this.length;
+    offset = 0;
+    // Buffer#write(string, encoding)
+  } else if (length === undefined && typeof offset === 'string') {
+    encoding = offset;
+    length = this.length;
+    offset = 0;
+    // Buffer#write(string, offset[, length][, encoding])
+  } else if (isFinite(offset)) {
+    offset = offset | 0;
+    if (isFinite(length)) {
+      length = length | 0;
+      if (encoding === undefined) encoding = 'utf8';
+    } else {
+      encoding = length;
+      length = undefined;
+    }
+    // legacy write(string, encoding, offset, length) - remove in v0.13
+  } else {
+    throw new Error('Buffer.write(string, encoding, offset[, length]) is no longer supported');
+  }
+
+  var remaining = this.length - offset;
+  if (length === undefined || length > remaining) length = remaining;
+
+  if (string.length > 0 && (length < 0 || offset < 0) || offset > this.length) {
+    throw new RangeError('Attempt to write outside buffer bounds');
+  }
+
+  if (!encoding) encoding = 'utf8';
+
+  var loweredCase = false;
+  for (;;) {
+    switch (encoding) {
+      case 'hex':
+        return hexWrite(this, string, offset, length);
+
+      case 'utf8':
+      case 'utf-8':
+        return utf8Write(this, string, offset, length);
+
+      case 'ascii':
+        return asciiWrite(this, string, offset, length);
+
+      case 'latin1':
+      case 'binary':
+        return latin1Write(this, string, offset, length);
+
+      case 'base64':
+        // Warning: maxLength not taken into account in base64Write
+        return base64Write(this, string, offset, length);
+
+      case 'ucs2':
+      case 'ucs-2':
+      case 'utf16le':
+      case 'utf-16le':
+        return ucs2Write(this, string, offset, length);
+
+      default:
+        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding);
+        encoding = ('' + encoding).toLowerCase();
+        loweredCase = true;
+    }
+  }
+};
+
+Buffer.prototype.toJSON = function toJSON() {
+  return {
+    type: 'Buffer',
+    data: Array.prototype.slice.call(this._arr || this, 0)
+  };
+};
+
+function base64Slice(buf, start, end) {
+  if (start === 0 && end === buf.length) {
+    return base64.fromByteArray(buf);
+  } else {
+    return base64.fromByteArray(buf.slice(start, end));
+  }
+}
+
+function utf8Slice(buf, start, end) {
+  end = Math.min(buf.length, end);
+  var res = [];
+
+  var i = start;
+  while (i < end) {
+    var firstByte = buf[i];
+    var codePoint = null;
+    var bytesPerSequence = firstByte > 0xEF ? 4 : firstByte > 0xDF ? 3 : firstByte > 0xBF ? 2 : 1;
+
+    if (i + bytesPerSequence <= end) {
+      var secondByte, thirdByte, fourthByte, tempCodePoint;
+
+      switch (bytesPerSequence) {
+        case 1:
+          if (firstByte < 0x80) {
+            codePoint = firstByte;
+          }
+          break;
+        case 2:
+          secondByte = buf[i + 1];
+          if ((secondByte & 0xC0) === 0x80) {
+            tempCodePoint = (firstByte & 0x1F) << 0x6 | secondByte & 0x3F;
+            if (tempCodePoint > 0x7F) {
+              codePoint = tempCodePoint;
+            }
+          }
+          break;
+        case 3:
+          secondByte = buf[i + 1];
+          thirdByte = buf[i + 2];
+          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
+            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | thirdByte & 0x3F;
+            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
+              codePoint = tempCodePoint;
+            }
+          }
+          break;
+        case 4:
+          secondByte = buf[i + 1];
+          thirdByte = buf[i + 2];
+          fourthByte = buf[i + 3];
+          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
+            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | fourthByte & 0x3F;
+            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
+              codePoint = tempCodePoint;
+            }
+          }
+      }
+    }
+
+    if (codePoint === null) {
+      // we did not generate a valid codePoint so insert a
+      // replacement char (U+FFFD) and advance only 1 byte
+      codePoint = 0xFFFD;
+      bytesPerSequence = 1;
+    } else if (codePoint > 0xFFFF) {
+      // encode to utf16 (surrogate pair dance)
+      codePoint -= 0x10000;
+      res.push(codePoint >>> 10 & 0x3FF | 0xD800);
+      codePoint = 0xDC00 | codePoint & 0x3FF;
+    }
+
+    res.push(codePoint);
+    i += bytesPerSequence;
+  }
+
+  return decodeCodePointsArray(res);
+}
+
+// Based on http://stackoverflow.com/a/22747272/680742, the browser with
+// the lowest limit is Chrome, with 0x10000 args.
+// We go 1 magnitude less, for safety
+var MAX_ARGUMENTS_LENGTH = 0x1000;
+
+function decodeCodePointsArray(codePoints) {
+  var len = codePoints.length;
+  if (len <= MAX_ARGUMENTS_LENGTH) {
+    return String.fromCharCode.apply(String, codePoints); // avoid extra slice()
+  }
+
+  // Decode in chunks to avoid "call stack size exceeded".
+  var res = '';
+  var i = 0;
+  while (i < len) {
+    res += String.fromCharCode.apply(String, codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH));
+  }
+  return res;
+}
+
+function asciiSlice(buf, start, end) {
+  var ret = '';
+  end = Math.min(buf.length, end);
+
+  for (var i = start; i < end; ++i) {
+    ret += String.fromCharCode(buf[i] & 0x7F);
+  }
+  return ret;
+}
+
+function latin1Slice(buf, start, end) {
+  var ret = '';
+  end = Math.min(buf.length, end);
+
+  for (var i = start; i < end; ++i) {
+    ret += String.fromCharCode(buf[i]);
+  }
+  return ret;
+}
+
+function hexSlice(buf, start, end) {
+  var len = buf.length;
+
+  if (!start || start < 0) start = 0;
+  if (!end || end < 0 || end > len) end = len;
+
+  var out = '';
+  for (var i = start; i < end; ++i) {
+    out += toHex(buf[i]);
+  }
+  return out;
+}
+
+function utf16leSlice(buf, start, end) {
+  var bytes = buf.slice(start, end);
+  var res = '';
+  for (var i = 0; i < bytes.length; i += 2) {
+    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256);
+  }
+  return res;
+}
+
+Buffer.prototype.slice = function slice(start, end) {
+  var len = this.length;
+  start = ~~start;
+  end = end === undefined ? len : ~~end;
+
+  if (start < 0) {
+    start += len;
+    if (start < 0) start = 0;
+  } else if (start > len) {
+    start = len;
+  }
+
+  if (end < 0) {
+    end += len;
+    if (end < 0) end = 0;
+  } else if (end > len) {
+    end = len;
+  }
+
+  if (end < start) end = start;
+
+  var newBuf;
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
+    newBuf = this.subarray(start, end);
+    newBuf.__proto__ = Buffer.prototype;
+  } else {
+    var sliceLen = end - start;
+    newBuf = new Buffer(sliceLen, undefined);
+    for (var i = 0; i < sliceLen; ++i) {
+      newBuf[i] = this[i + start];
+    }
+  }
+
+  return newBuf;
+};
+
+/*
+ * Need to make sure that buffer isn't trying to write out of bounds.
+ */
+function checkOffset(offset, ext, length) {
+  if (offset % 1 !== 0 || offset < 0) throw new RangeError('offset is not uint');
+  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length');
+}
+
+Buffer.prototype.readUIntLE = function readUIntLE(offset, byteLength, noAssert) {
+  offset = offset | 0;
+  byteLength = byteLength | 0;
+  if (!noAssert) checkOffset(offset, byteLength, this.length);
+
+  var val = this[offset];
+  var mul = 1;
+  var i = 0;
+  while (++i < byteLength && (mul *= 0x100)) {
+    val += this[offset + i] * mul;
+  }
+
+  return val;
+};
+
+Buffer.prototype.readUIntBE = function readUIntBE(offset, byteLength, noAssert) {
+  offset = offset | 0;
+  byteLength = byteLength | 0;
+  if (!noAssert) {
+    checkOffset(offset, byteLength, this.length);
+  }
+
+  var val = this[offset + --byteLength];
+  var mul = 1;
+  while (byteLength > 0 && (mul *= 0x100)) {
+    val += this[offset + --byteLength] * mul;
+  }
+
+  return val;
+};
+
+Buffer.prototype.readUInt8 = function readUInt8(offset, noAssert) {
+  if (!noAssert) checkOffset(offset, 1, this.length);
+  return this[offset];
+};
+
+Buffer.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {
+  if (!noAssert) checkOffset(offset, 2, this.length);
+  return this[offset] | this[offset + 1] << 8;
+};
+
+Buffer.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {
+  if (!noAssert) checkOffset(offset, 2, this.length);
+  return this[offset] << 8 | this[offset + 1];
+};
+
+Buffer.prototype.readUInt32LE = function readUInt32LE(offset, noAssert) {
+  if (!noAssert) checkOffset(offset, 4, this.length);
+
+  return (this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16) + this[offset + 3] * 0x1000000;
+};
+
+Buffer.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) {
+  if (!noAssert) checkOffset(offset, 4, this.length);
+
+  return this[offset] * 0x1000000 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]);
+};
+
+Buffer.prototype.readIntLE = function readIntLE(offset, byteLength, noAssert) {
+  offset = offset | 0;
+  byteLength = byteLength | 0;
+  if (!noAssert) checkOffset(offset, byteLength, this.length);
+
+  var val = this[offset];
+  var mul = 1;
+  var i = 0;
+  while (++i < byteLength && (mul *= 0x100)) {
+    val += this[offset + i] * mul;
+  }
+  mul *= 0x80;
+
+  if (val >= mul) val -= Math.pow(2, 8 * byteLength);
+
+  return val;
+};
+
+Buffer.prototype.readIntBE = function readIntBE(offset, byteLength, noAssert) {
+  offset = offset | 0;
+  byteLength = byteLength | 0;
+  if (!noAssert) checkOffset(offset, byteLength, this.length);
+
+  var i = byteLength;
+  var mul = 1;
+  var val = this[offset + --i];
+  while (i > 0 && (mul *= 0x100)) {
+    val += this[offset + --i] * mul;
+  }
+  mul *= 0x80;
+
+  if (val >= mul) val -= Math.pow(2, 8 * byteLength);
+
+  return val;
+};
+
+Buffer.prototype.readInt8 = function readInt8(offset, noAssert) {
+  if (!noAssert) checkOffset(offset, 1, this.length);
+  if (!(this[offset] & 0x80)) return this[offset];
+  return (0xff - this[offset] + 1) * -1;
+};
+
+Buffer.prototype.readInt16LE = function readInt16LE(offset, noAssert) {
+  if (!noAssert) checkOffset(offset, 2, this.length);
+  var val = this[offset] | this[offset + 1] << 8;
+  return val & 0x8000 ? val | 0xFFFF0000 : val;
+};
+
+Buffer.prototype.readInt16BE = function readInt16BE(offset, noAssert) {
+  if (!noAssert) checkOffset(offset, 2, this.length);
+  var val = this[offset + 1] | this[offset] << 8;
+  return val & 0x8000 ? val | 0xFFFF0000 : val;
+};
+
+Buffer.prototype.readInt32LE = function readInt32LE(offset, noAssert) {
+  if (!noAssert) checkOffset(offset, 4, this.length);
+
+  return this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24;
+};
+
+Buffer.prototype.readInt32BE = function readInt32BE(offset, noAssert) {
+  if (!noAssert) checkOffset(offset, 4, this.length);
+
+  return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3];
+};
+
+Buffer.prototype.readFloatLE = function readFloatLE(offset, noAssert) {
+  if (!noAssert) checkOffset(offset, 4, this.length);
+  return ieee754.read(this, offset, true, 23, 4);
+};
+
+Buffer.prototype.readFloatBE = function readFloatBE(offset, noAssert) {
+  if (!noAssert) checkOffset(offset, 4, this.length);
+  return ieee754.read(this, offset, false, 23, 4);
+};
+
+Buffer.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) {
+  if (!noAssert) checkOffset(offset, 8, this.length);
+  return ieee754.read(this, offset, true, 52, 8);
+};
+
+Buffer.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) {
+  if (!noAssert) checkOffset(offset, 8, this.length);
+  return ieee754.read(this, offset, false, 52, 8);
+};
+
+function checkInt(buf, value, offset, ext, max, min) {
+  if (!Buffer.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance');
+  if (value > max || value < min) throw new RangeError('"value" argument is out of bounds');
+  if (offset + ext > buf.length) throw new RangeError('Index out of range');
+}
+
+Buffer.prototype.writeUIntLE = function writeUIntLE(value, offset, byteLength, noAssert) {
+  value = +value;
+  offset = offset | 0;
+  byteLength = byteLength | 0;
+  if (!noAssert) {
+    var maxBytes = Math.pow(2, 8 * byteLength) - 1;
+    checkInt(this, value, offset, byteLength, maxBytes, 0);
+  }
+
+  var mul = 1;
+  var i = 0;
+  this[offset] = value & 0xFF;
+  while (++i < byteLength && (mul *= 0x100)) {
+    this[offset + i] = value / mul & 0xFF;
+  }
+
+  return offset + byteLength;
+};
+
+Buffer.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength, noAssert) {
+  value = +value;
+  offset = offset | 0;
+  byteLength = byteLength | 0;
+  if (!noAssert) {
+    var maxBytes = Math.pow(2, 8 * byteLength) - 1;
+    checkInt(this, value, offset, byteLength, maxBytes, 0);
+  }
+
+  var i = byteLength - 1;
+  var mul = 1;
+  this[offset + i] = value & 0xFF;
+  while (--i >= 0 && (mul *= 0x100)) {
+    this[offset + i] = value / mul & 0xFF;
+  }
+
+  return offset + byteLength;
+};
+
+Buffer.prototype.writeUInt8 = function writeUInt8(value, offset, noAssert) {
+  value = +value;
+  offset = offset | 0;
+  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0);
+  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value);
+  this[offset] = value & 0xff;
+  return offset + 1;
+};
+
+function objectWriteUInt16(buf, value, offset, littleEndian) {
+  if (value < 0) value = 0xffff + value + 1;
+  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {
+    buf[offset + i] = (value & 0xff << 8 * (littleEndian ? i : 1 - i)) >>> (littleEndian ? i : 1 - i) * 8;
+  }
+}
+
+Buffer.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) {
+  value = +value;
+  offset = offset | 0;
+  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0);
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
+    this[offset] = value & 0xff;
+    this[offset + 1] = value >>> 8;
+  } else {
+    objectWriteUInt16(this, value, offset, true);
+  }
+  return offset + 2;
+};
+
+Buffer.prototype.writeUInt16BE = function writeUInt16BE(value, offset, noAssert) {
+  value = +value;
+  offset = offset | 0;
+  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0);
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
+    this[offset] = value >>> 8;
+    this[offset + 1] = value & 0xff;
+  } else {
+    objectWriteUInt16(this, value, offset, false);
+  }
+  return offset + 2;
+};
+
+function objectWriteUInt32(buf, value, offset, littleEndian) {
+  if (value < 0) value = 0xffffffff + value + 1;
+  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {
+    buf[offset + i] = value >>> (littleEndian ? i : 3 - i) * 8 & 0xff;
+  }
+}
+
+Buffer.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) {
+  value = +value;
+  offset = offset | 0;
+  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0);
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
+    this[offset + 3] = value >>> 24;
+    this[offset + 2] = value >>> 16;
+    this[offset + 1] = value >>> 8;
+    this[offset] = value & 0xff;
+  } else {
+    objectWriteUInt32(this, value, offset, true);
+  }
+  return offset + 4;
+};
+
+Buffer.prototype.writeUInt32BE = function writeUInt32BE(value, offset, noAssert) {
+  value = +value;
+  offset = offset | 0;
+  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0);
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
+    this[offset] = value >>> 24;
+    this[offset + 1] = value >>> 16;
+    this[offset + 2] = value >>> 8;
+    this[offset + 3] = value & 0xff;
+  } else {
+    objectWriteUInt32(this, value, offset, false);
+  }
+  return offset + 4;
+};
+
+Buffer.prototype.writeIntLE = function writeIntLE(value, offset, byteLength, noAssert) {
+  value = +value;
+  offset = offset | 0;
+  if (!noAssert) {
+    var limit = Math.pow(2, 8 * byteLength - 1);
+
+    checkInt(this, value, offset, byteLength, limit - 1, -limit);
+  }
+
+  var i = 0;
+  var mul = 1;
+  var sub = 0;
+  this[offset] = value & 0xFF;
+  while (++i < byteLength && (mul *= 0x100)) {
+    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
+      sub = 1;
+    }
+    this[offset + i] = (value / mul >> 0) - sub & 0xFF;
+  }
+
+  return offset + byteLength;
+};
+
+Buffer.prototype.writeIntBE = function writeIntBE(value, offset, byteLength, noAssert) {
+  value = +value;
+  offset = offset | 0;
+  if (!noAssert) {
+    var limit = Math.pow(2, 8 * byteLength - 1);
+
+    checkInt(this, value, offset, byteLength, limit - 1, -limit);
+  }
+
+  var i = byteLength - 1;
+  var mul = 1;
+  var sub = 0;
+  this[offset + i] = value & 0xFF;
+  while (--i >= 0 && (mul *= 0x100)) {
+    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
+      sub = 1;
+    }
+    this[offset + i] = (value / mul >> 0) - sub & 0xFF;
+  }
+
+  return offset + byteLength;
+};
+
+Buffer.prototype.writeInt8 = function writeInt8(value, offset, noAssert) {
+  value = +value;
+  offset = offset | 0;
+  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80);
+  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value);
+  if (value < 0) value = 0xff + value + 1;
+  this[offset] = value & 0xff;
+  return offset + 1;
+};
+
+Buffer.prototype.writeInt16LE = function writeInt16LE(value, offset, noAssert) {
+  value = +value;
+  offset = offset | 0;
+  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000);
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
+    this[offset] = value & 0xff;
+    this[offset + 1] = value >>> 8;
+  } else {
+    objectWriteUInt16(this, value, offset, true);
+  }
+  return offset + 2;
+};
+
+Buffer.prototype.writeInt16BE = function writeInt16BE(value, offset, noAssert) {
+  value = +value;
+  offset = offset | 0;
+  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000);
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
+    this[offset] = value >>> 8;
+    this[offset + 1] = value & 0xff;
+  } else {
+    objectWriteUInt16(this, value, offset, false);
+  }
+  return offset + 2;
+};
+
+Buffer.prototype.writeInt32LE = function writeInt32LE(value, offset, noAssert) {
+  value = +value;
+  offset = offset | 0;
+  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000);
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
+    this[offset] = value & 0xff;
+    this[offset + 1] = value >>> 8;
+    this[offset + 2] = value >>> 16;
+    this[offset + 3] = value >>> 24;
+  } else {
+    objectWriteUInt32(this, value, offset, true);
+  }
+  return offset + 4;
+};
+
+Buffer.prototype.writeInt32BE = function writeInt32BE(value, offset, noAssert) {
+  value = +value;
+  offset = offset | 0;
+  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000);
+  if (value < 0) value = 0xffffffff + value + 1;
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
+    this[offset] = value >>> 24;
+    this[offset + 1] = value >>> 16;
+    this[offset + 2] = value >>> 8;
+    this[offset + 3] = value & 0xff;
+  } else {
+    objectWriteUInt32(this, value, offset, false);
+  }
+  return offset + 4;
+};
+
+function checkIEEE754(buf, value, offset, ext, max, min) {
+  if (offset + ext > buf.length) throw new RangeError('Index out of range');
+  if (offset < 0) throw new RangeError('Index out of range');
+}
+
+function writeFloat(buf, value, offset, littleEndian, noAssert) {
+  if (!noAssert) {
+    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38);
+  }
+  ieee754.write(buf, value, offset, littleEndian, 23, 4);
+  return offset + 4;
+}
+
+Buffer.prototype.writeFloatLE = function writeFloatLE(value, offset, noAssert) {
+  return writeFloat(this, value, offset, true, noAssert);
+};
+
+Buffer.prototype.writeFloatBE = function writeFloatBE(value, offset, noAssert) {
+  return writeFloat(this, value, offset, false, noAssert);
+};
+
+function writeDouble(buf, value, offset, littleEndian, noAssert) {
+  if (!noAssert) {
+    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308);
+  }
+  ieee754.write(buf, value, offset, littleEndian, 52, 8);
+  return offset + 8;
+}
+
+Buffer.prototype.writeDoubleLE = function writeDoubleLE(value, offset, noAssert) {
+  return writeDouble(this, value, offset, true, noAssert);
+};
+
+Buffer.prototype.writeDoubleBE = function writeDoubleBE(value, offset, noAssert) {
+  return writeDouble(this, value, offset, false, noAssert);
+};
+
+// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
+Buffer.prototype.copy = function copy(target, targetStart, start, end) {
+  if (!start) start = 0;
+  if (!end && end !== 0) end = this.length;
+  if (targetStart >= target.length) targetStart = target.length;
+  if (!targetStart) targetStart = 0;
+  if (end > 0 && end < start) end = start;
+
+  // Copy 0 bytes; we're done
+  if (end === start) return 0;
+  if (target.length === 0 || this.length === 0) return 0;
+
+  // Fatal error conditions
+  if (targetStart < 0) {
+    throw new RangeError('targetStart out of bounds');
+  }
+  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds');
+  if (end < 0) throw new RangeError('sourceEnd out of bounds');
+
+  // Are we oob?
+  if (end > this.length) end = this.length;
+  if (target.length - targetStart < end - start) {
+    end = target.length - targetStart + start;
+  }
+
+  var len = end - start;
+  var i;
+
+  if (this === target && start < targetStart && targetStart < end) {
+    // descending copy from end
+    for (i = len - 1; i >= 0; --i) {
+      target[i + targetStart] = this[i + start];
+    }
+  } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {
+    // ascending copy from start
+    for (i = 0; i < len; ++i) {
+      target[i + targetStart] = this[i + start];
+    }
+  } else {
+    Uint8Array.prototype.set.call(target, this.subarray(start, start + len), targetStart);
+  }
+
+  return len;
+};
+
+// Usage:
+//    buffer.fill(number[, offset[, end]])
+//    buffer.fill(buffer[, offset[, end]])
+//    buffer.fill(string[, offset[, end]][, encoding])
+Buffer.prototype.fill = function fill(val, start, end, encoding) {
+  // Handle string cases:
+  if (typeof val === 'string') {
+    if (typeof start === 'string') {
+      encoding = start;
+      start = 0;
+      end = this.length;
+    } else if (typeof end === 'string') {
+      encoding = end;
+      end = this.length;
+    }
+    if (val.length === 1) {
+      var code = val.charCodeAt(0);
+      if (code < 256) {
+        val = code;
+      }
+    }
+    if (encoding !== undefined && typeof encoding !== 'string') {
+      throw new TypeError('encoding must be a string');
+    }
+    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {
+      throw new TypeError('Unknown encoding: ' + encoding);
+    }
+  } else if (typeof val === 'number') {
+    val = val & 255;
+  }
+
+  // Invalid ranges are not set to a default, so can range check early.
+  if (start < 0 || this.length < start || this.length < end) {
+    throw new RangeError('Out of range index');
+  }
+
+  if (end <= start) {
+    return this;
+  }
+
+  start = start >>> 0;
+  end = end === undefined ? this.length : end >>> 0;
+
+  if (!val) val = 0;
+
+  var i;
+  if (typeof val === 'number') {
+    for (i = start; i < end; ++i) {
+      this[i] = val;
+    }
+  } else {
+    var bytes = Buffer.isBuffer(val) ? val : utf8ToBytes(new Buffer(val, encoding).toString());
+    var len = bytes.length;
+    for (i = 0; i < end - start; ++i) {
+      this[i + start] = bytes[i % len];
+    }
+  }
+
+  return this;
+};
+
+// HELPER FUNCTIONS
+// ================
+
+var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g;
+
+function base64clean(str) {
+  // Node strips out invalid characters like \n and \t from the string, base64-js does not
+  str = stringtrim(str).replace(INVALID_BASE64_RE, '');
+  // Node converts strings with length < 2 to ''
+  if (str.length < 2) return '';
+  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
+  while (str.length % 4 !== 0) {
+    str = str + '=';
+  }
+  return str;
+}
+
+function stringtrim(str) {
+  if (str.trim) return str.trim();
+  return str.replace(/^\s+|\s+$/g, '');
+}
+
+function toHex(n) {
+  if (n < 16) return '0' + n.toString(16);
+  return n.toString(16);
+}
+
+function utf8ToBytes(string, units) {
+  units = units || Infinity;
+  var codePoint;
+  var length = string.length;
+  var leadSurrogate = null;
+  var bytes = [];
+
+  for (var i = 0; i < length; ++i) {
+    codePoint = string.charCodeAt(i);
+
+    // is surrogate component
+    if (codePoint > 0xD7FF && codePoint < 0xE000) {
+      // last char was a lead
+      if (!leadSurrogate) {
+        // no lead yet
+        if (codePoint > 0xDBFF) {
+          // unexpected trail
+          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);
+          continue;
+        } else if (i + 1 === length) {
+          // unpaired lead
+          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);
+          continue;
+        }
+
+        // valid lead
+        leadSurrogate = codePoint;
+
+        continue;
+      }
+
+      // 2 leads in a row
+      if (codePoint < 0xDC00) {
+        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);
+        leadSurrogate = codePoint;
+        continue;
+      }
+
+      // valid surrogate pair
+      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000;
+    } else if (leadSurrogate) {
+      // valid bmp char, but last char was a lead
+      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);
+    }
+
+    leadSurrogate = null;
+
+    // encode utf8
+    if (codePoint < 0x80) {
+      if ((units -= 1) < 0) break;
+      bytes.push(codePoint);
+    } else if (codePoint < 0x800) {
+      if ((units -= 2) < 0) break;
+      bytes.push(codePoint >> 0x6 | 0xC0, codePoint & 0x3F | 0x80);
+    } else if (codePoint < 0x10000) {
+      if ((units -= 3) < 0) break;
+      bytes.push(codePoint >> 0xC | 0xE0, codePoint >> 0x6 & 0x3F | 0x80, codePoint & 0x3F | 0x80);
+    } else if (codePoint < 0x110000) {
+      if ((units -= 4) < 0) break;
+      bytes.push(codePoint >> 0x12 | 0xF0, codePoint >> 0xC & 0x3F | 0x80, codePoint >> 0x6 & 0x3F | 0x80, codePoint & 0x3F | 0x80);
+    } else {
+      throw new Error('Invalid code point');
+    }
+  }
+
+  return bytes;
+}
+
+function asciiToBytes(str) {
+  var byteArray = [];
+  for (var i = 0; i < str.length; ++i) {
+    // Node's code seems to be doing this and not & 0x7F..
+    byteArray.push(str.charCodeAt(i) & 0xFF);
+  }
+  return byteArray;
+}
+
+function utf16leToBytes(str, units) {
+  var c, hi, lo;
+  var byteArray = [];
+  for (var i = 0; i < str.length; ++i) {
+    if ((units -= 2) < 0) break;
+
+    c = str.charCodeAt(i);
+    hi = c >> 8;
+    lo = c % 256;
+    byteArray.push(lo);
+    byteArray.push(hi);
+  }
+
+  return byteArray;
+}
+
+function base64ToBytes(str) {
+  return base64.toByteArray(base64clean(str));
+}
+
+function blitBuffer(src, dst, offset, length) {
+  for (var i = 0; i < length; ++i) {
+    if (i + offset >= dst.length || i >= src.length) break;
+    dst[i + offset] = src[i];
+  }
+  return i;
+}
+
+function isnan(val) {
+  return val !== val; // eslint-disable-line no-self-compare
+}
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"babel-runtime/core-js/object/define-property":24,"babel-runtime/core-js/symbol":36,"babel-runtime/core-js/symbol/species":38,"base64-js":41,"ieee754":197,"isarray":46}],46:[function(require,module,exports){
+'use strict';
+
+var toString = {}.toString;
+
+module.exports = Array.isArray || function (arr) {
+  return toString.call(arr) == '[object Array]';
+};
+
+},{}],47:[function(require,module,exports){
+"use strict";
+
+module.exports = {
+  "100": "Continue",
+  "101": "Switching Protocols",
+  "102": "Processing",
+  "200": "OK",
+  "201": "Created",
+  "202": "Accepted",
+  "203": "Non-Authoritative Information",
+  "204": "No Content",
+  "205": "Reset Content",
+  "206": "Partial Content",
+  "207": "Multi-Status",
+  "208": "Already Reported",
+  "226": "IM Used",
+  "300": "Multiple Choices",
+  "301": "Moved Permanently",
+  "302": "Found",
+  "303": "See Other",
+  "304": "Not Modified",
+  "305": "Use Proxy",
+  "307": "Temporary Redirect",
+  "308": "Permanent Redirect",
+  "400": "Bad Request",
+  "401": "Unauthorized",
+  "402": "Payment Required",
+  "403": "Forbidden",
+  "404": "Not Found",
+  "405": "Method Not Allowed",
+  "406": "Not Acceptable",
+  "407": "Proxy Authentication Required",
+  "408": "Request Timeout",
+  "409": "Conflict",
+  "410": "Gone",
+  "411": "Length Required",
+  "412": "Precondition Failed",
+  "413": "Payload Too Large",
+  "414": "URI Too Long",
+  "415": "Unsupported Media Type",
+  "416": "Range Not Satisfiable",
+  "417": "Expectation Failed",
+  "418": "I'm a teapot",
+  "421": "Misdirected Request",
+  "422": "Unprocessable Entity",
+  "423": "Locked",
+  "424": "Failed Dependency",
+  "425": "Unordered Collection",
+  "426": "Upgrade Required",
+  "428": "Precondition Required",
+  "429": "Too Many Requests",
+  "431": "Request Header Fields Too Large",
+  "500": "Internal Server Error",
+  "501": "Not Implemented",
+  "502": "Bad Gateway",
+  "503": "Service Unavailable",
+  "504": "Gateway Timeout",
+  "505": "HTTP Version Not Supported",
+  "506": "Variant Also Negotiates",
+  "507": "Insufficient Storage",
+  "508": "Loop Detected",
+  "509": "Bandwidth Limit Exceeded",
+  "510": "Not Extended",
+  "511": "Network Authentication Required"
+};
+
+},{}],48:[function(require,module,exports){
+(function (process){
+'use strict';
+
+var _setImmediate2 = require('babel-runtime/core-js/set-immediate');
+
+var _setImmediate3 = _interopRequireDefault(_setImmediate2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var co = require('co');
+
+exports = module.exports = deferImmediate;
+exports.defer = exports.immediate = exports.setImmediate = deferImmediate;
+
+function createCallback(ctx, gen, cb) {
+  return function () {
+    cb = cb || error;
+    co.call(ctx, gen).then(function () {
+      cb();
+    }, cb);
+  };
+}
+
+function deferImmediate(gen, cb) {
+  return (0, _setImmediate3.default)(createCallback(this, gen, cb));
+}
+
+exports.nextTick = function deferNextTick(gen, cb) {
+  return process.nextTick(createCallback(this, gen, cb));
+};
+
+exports.timeout = exports.setTimeout = function deferTimeout(gen, timeout, cb) {
+  return setTimeout(createCallback(this, gen, cb), timeout);
+};
+
+exports.interval = exports.setInterval = function deferInterval(gen, timeout, cb) {
+  return setInterval(createCallback(this, gen, cb), timeout);
+};
+
+function error(err) {
+  if (err) throw err;
+}
+
+}).call(this,require('_process'))
+},{"_process":345,"babel-runtime/core-js/set-immediate":34,"co":51}],49:[function(require,module,exports){
+/*!
+ * co-gather - index.js
+ * Copyright(c) 2014 dead_horse <dead_horse@qq.com>
+ * MIT Licensed
+ */
+
+'use strict';
+
+/**
+ * Module dependencies.
+ */
+
+var _regenerator = require('babel-runtime/regenerator');
+
+var _regenerator2 = _interopRequireDefault(_regenerator);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var thread = require('co-thread');
+
+module.exports = _regenerator2.default.mark(function gather(thunks, n) {
+  var _marked, ret, index, next;
+
+  return _regenerator2.default.wrap(function gather$(_context2) {
+    while (1) {
+      switch (_context2.prev = _context2.next) {
+        case 0:
+          next = function next() {
+            var i;
+            return _regenerator2.default.wrap(function next$(_context) {
+              while (1) {
+                switch (_context.prev = _context.next) {
+                  case 0:
+                    i = index++;
+
+                    ret[i] = { isError: false };
+                    _context.prev = 2;
+                    _context.next = 5;
+                    return thunks[i];
+
+                  case 5:
+                    ret[i].value = _context.sent;
+                    _context.next = 12;
+                    break;
+
+                  case 8:
+                    _context.prev = 8;
+                    _context.t0 = _context['catch'](2);
+
+                    ret[i].error = _context.t0;
+                    ret[i].isError = true;
+
+                  case 12:
+                    if (!(index < thunks.length)) {
+                      _context.next = 15;
+                      break;
+                    }
+
+                    _context.next = 15;
+                    return next;
+
+                  case 15:
+                  case 'end':
+                    return _context.stop();
+                }
+              }
+            }, _marked[0], this, [[2, 8]]);
+          };
+
+          _marked = [next].map(_regenerator2.default.mark);
+
+          n = Math.min(n || 5, thunks.length);
+          ret = [];
+          index = 0;
+          _context2.next = 7;
+          return thread(next, n);
+
+        case 7:
+          return _context2.abrupt('return', ret);
+
+        case 8:
+        case 'end':
+          return _context2.stop();
+      }
+    }
+  }, gather, this);
+});
+
+},{"babel-runtime/regenerator":40,"co-thread":50}],50:[function(require,module,exports){
+"use strict";
+
+/**
+ * Expose `thread`.
+ */
+
+module.exports = thread;
+
+/**
+ * Run `fn` `n` times in parallel.
+ *
+ * @param {Function} fn
+ * @param {Number} n
+ * @return {Array}
+ * @api public
+ */
+
+function thread(fn, n) {
+  var gens = [];
+  while (n--) {
+    gens.push(fn);
+  }return gens;
+}
+
+},{}],51:[function(require,module,exports){
+'use strict';
+
+var _keys = require('babel-runtime/core-js/object/keys');
+
+var _keys2 = _interopRequireDefault(_keys);
+
+var _promise = require('babel-runtime/core-js/promise');
+
+var _promise2 = _interopRequireDefault(_promise);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * slice() reference.
+ */
+
+var slice = Array.prototype.slice;
+
+/**
+ * Expose `co`.
+ */
+
+module.exports = co['default'] = co.co = co;
+
+/**
+ * Wrap the given generator `fn` into a
+ * function that returns a promise.
+ * This is a separate function so that
+ * every `co()` call doesn't create a new,
+ * unnecessary closure.
+ *
+ * @param {GeneratorFunction} fn
+ * @return {Function}
+ * @api public
+ */
+
+co.wrap = function (fn) {
+  createPromise.__generatorFunction__ = fn;
+  return createPromise;
+  function createPromise() {
+    return co.call(this, fn.apply(this, arguments));
+  }
+};
+
+/**
+ * Execute the generator function or a generator
+ * and return a promise.
+ *
+ * @param {Function} fn
+ * @return {Promise}
+ * @api public
+ */
+
+function co(gen) {
+  var ctx = this;
+  var args = slice.call(arguments, 1);
+
+  // we wrap everything in a promise to avoid promise chaining,
+  // which leads to memory leak errors.
+  // see https://github.com/tj/co/issues/180
+  return new _promise2.default(function (resolve, reject) {
+    if (typeof gen === 'function') gen = gen.apply(ctx, args);
+    if (!gen || typeof gen.next !== 'function') return resolve(gen);
+
+    onFulfilled();
+
+    /**
+     * @param {Mixed} res
+     * @return {Promise}
+     * @api private
+     */
+
+    function onFulfilled(res) {
+      var ret;
+      try {
+        ret = gen.next(res);
+      } catch (e) {
+        return reject(e);
+      }
+      next(ret);
+    }
+
+    /**
+     * @param {Error} err
+     * @return {Promise}
+     * @api private
+     */
+
+    function onRejected(err) {
+      var ret;
+      try {
+        ret = gen.throw(err);
+      } catch (e) {
+        return reject(e);
+      }
+      next(ret);
+    }
+
+    /**
+     * Get the next value in the generator,
+     * return a promise.
+     *
+     * @param {Object} ret
+     * @return {Promise}
+     * @api private
+     */
+
+    function next(ret) {
+      if (ret.done) return resolve(ret.value);
+      var value = toPromise.call(ctx, ret.value);
+      if (value && isPromise(value)) return value.then(onFulfilled, onRejected);
+      return onRejected(new TypeError('You may only yield a function, promise, generator, array, or object, ' + 'but the following object was passed: "' + String(ret.value) + '"'));
+    }
+  });
+}
+
+/**
+ * Convert a `yield`ed value into a promise.
+ *
+ * @param {Mixed} obj
+ * @return {Promise}
+ * @api private
+ */
+
+function toPromise(obj) {
+  if (!obj) return obj;
+  if (isPromise(obj)) return obj;
+  if (isGeneratorFunction(obj) || isGenerator(obj)) return co.call(this, obj);
+  if ('function' == typeof obj) return thunkToPromise.call(this, obj);
+  if (Array.isArray(obj)) return arrayToPromise.call(this, obj);
+  if (isObject(obj)) return objectToPromise.call(this, obj);
+  return obj;
+}
+
+/**
+ * Convert a thunk to a promise.
+ *
+ * @param {Function}
+ * @return {Promise}
+ * @api private
+ */
+
+function thunkToPromise(fn) {
+  var ctx = this;
+  return new _promise2.default(function (resolve, reject) {
+    fn.call(ctx, function (err, res) {
+      if (err) return reject(err);
+      if (arguments.length > 2) res = slice.call(arguments, 1);
+      resolve(res);
+    });
+  });
+}
+
+/**
+ * Convert an array of "yieldables" to a promise.
+ * Uses `Promise.all()` internally.
+ *
+ * @param {Array} obj
+ * @return {Promise}
+ * @api private
+ */
+
+function arrayToPromise(obj) {
+  return _promise2.default.all(obj.map(toPromise, this));
+}
+
+/**
+ * Convert an object of "yieldables" to a promise.
+ * Uses `Promise.all()` internally.
+ *
+ * @param {Object} obj
+ * @return {Promise}
+ * @api private
+ */
+
+function objectToPromise(obj) {
+  var results = new obj.constructor();
+  var keys = (0, _keys2.default)(obj);
+  var promises = [];
+  for (var i = 0; i < keys.length; i++) {
+    var key = keys[i];
+    var promise = toPromise.call(this, obj[key]);
+    if (promise && isPromise(promise)) defer(promise, key);else results[key] = obj[key];
+  }
+  return _promise2.default.all(promises).then(function () {
+    return results;
+  });
+
+  function defer(promise, key) {
+    // predefine the key in the result
+    results[key] = undefined;
+    promises.push(promise.then(function (res) {
+      results[key] = res;
+    }));
+  }
+}
+
+/**
+ * Check if `obj` is a promise.
+ *
+ * @param {Object} obj
+ * @return {Boolean}
+ * @api private
+ */
+
+function isPromise(obj) {
+  return 'function' == typeof obj.then;
+}
+
+/**
+ * Check if `obj` is a generator.
+ *
+ * @param {Mixed} obj
+ * @return {Boolean}
+ * @api private
+ */
+
+function isGenerator(obj) {
+  return 'function' == typeof obj.next && 'function' == typeof obj.throw;
+}
+
+/**
+ * Check if `obj` is a generator function.
+ *
+ * @param {Mixed} obj
+ * @return {Boolean}
+ * @api private
+ */
+function isGeneratorFunction(obj) {
+  var constructor = obj.constructor;
+  if (!constructor) return false;
+  if ('GeneratorFunction' === constructor.name || 'GeneratorFunction' === constructor.displayName) return true;
+  return isGenerator(constructor.prototype);
+}
+
+/**
+ * Check for plain object.
+ *
+ * @param {Mixed} val
+ * @return {Boolean}
+ * @api private
+ */
+
+function isObject(val) {
+  return Object == val.constructor;
+}
+
+},{"babel-runtime/core-js/object/keys":30,"babel-runtime/core-js/promise":33}],52:[function(require,module,exports){
+module.exports={
+  "O_RDONLY": 0,
+  "O_WRONLY": 1,
+  "O_RDWR": 2,
+  "S_IFMT": 61440,
+  "S_IFREG": 32768,
+  "S_IFDIR": 16384,
+  "S_IFCHR": 8192,
+  "S_IFBLK": 24576,
+  "S_IFIFO": 4096,
+  "S_IFLNK": 40960,
+  "S_IFSOCK": 49152,
+  "O_CREAT": 512,
+  "O_EXCL": 2048,
+  "O_NOCTTY": 131072,
+  "O_TRUNC": 1024,
+  "O_APPEND": 8,
+  "O_DIRECTORY": 1048576,
+  "O_NOFOLLOW": 256,
+  "O_SYNC": 128,
+  "O_SYMLINK": 2097152,
+  "O_NONBLOCK": 4,
+  "S_IRWXU": 448,
+  "S_IRUSR": 256,
+  "S_IWUSR": 128,
+  "S_IXUSR": 64,
+  "S_IRWXG": 56,
+  "S_IRGRP": 32,
+  "S_IWGRP": 16,
+  "S_IXGRP": 8,
+  "S_IRWXO": 7,
+  "S_IROTH": 4,
+  "S_IWOTH": 2,
+  "S_IXOTH": 1,
+  "E2BIG": 7,
+  "EACCES": 13,
+  "EADDRINUSE": 48,
+  "EADDRNOTAVAIL": 49,
+  "EAFNOSUPPORT": 47,
+  "EAGAIN": 35,
+  "EALREADY": 37,
+  "EBADF": 9,
+  "EBADMSG": 94,
+  "EBUSY": 16,
+  "ECANCELED": 89,
+  "ECHILD": 10,
+  "ECONNABORTED": 53,
+  "ECONNREFUSED": 61,
+  "ECONNRESET": 54,
+  "EDEADLK": 11,
+  "EDESTADDRREQ": 39,
+  "EDOM": 33,
+  "EDQUOT": 69,
+  "EEXIST": 17,
+  "EFAULT": 14,
+  "EFBIG": 27,
+  "EHOSTUNREACH": 65,
+  "EIDRM": 90,
+  "EILSEQ": 92,
+  "EINPROGRESS": 36,
+  "EINTR": 4,
+  "EINVAL": 22,
+  "EIO": 5,
+  "EISCONN": 56,
+  "EISDIR": 21,
+  "ELOOP": 62,
+  "EMFILE": 24,
+  "EMLINK": 31,
+  "EMSGSIZE": 40,
+  "EMULTIHOP": 95,
+  "ENAMETOOLONG": 63,
+  "ENETDOWN": 50,
+  "ENETRESET": 52,
+  "ENETUNREACH": 51,
+  "ENFILE": 23,
+  "ENOBUFS": 55,
+  "ENODATA": 96,
+  "ENODEV": 19,
+  "ENOENT": 2,
+  "ENOEXEC": 8,
+  "ENOLCK": 77,
+  "ENOLINK": 97,
+  "ENOMEM": 12,
+  "ENOMSG": 91,
+  "ENOPROTOOPT": 42,
+  "ENOSPC": 28,
+  "ENOSR": 98,
+  "ENOSTR": 99,
+  "ENOSYS": 78,
+  "ENOTCONN": 57,
+  "ENOTDIR": 20,
+  "ENOTEMPTY": 66,
+  "ENOTSOCK": 38,
+  "ENOTSUP": 45,
+  "ENOTTY": 25,
+  "ENXIO": 6,
+  "EOPNOTSUPP": 102,
+  "EOVERFLOW": 84,
+  "EPERM": 1,
+  "EPIPE": 32,
+  "EPROTO": 100,
+  "EPROTONOSUPPORT": 43,
+  "EPROTOTYPE": 41,
+  "ERANGE": 34,
+  "EROFS": 30,
+  "ESPIPE": 29,
+  "ESRCH": 3,
+  "ESTALE": 70,
+  "ETIME": 101,
+  "ETIMEDOUT": 60,
+  "ETXTBSY": 26,
+  "EWOULDBLOCK": 35,
+  "EXDEV": 18,
+  "SIGHUP": 1,
+  "SIGINT": 2,
+  "SIGQUIT": 3,
+  "SIGILL": 4,
+  "SIGTRAP": 5,
+  "SIGABRT": 6,
+  "SIGIOT": 6,
+  "SIGBUS": 10,
+  "SIGFPE": 8,
+  "SIGKILL": 9,
+  "SIGUSR1": 30,
+  "SIGSEGV": 11,
+  "SIGUSR2": 31,
+  "SIGPIPE": 13,
+  "SIGALRM": 14,
+  "SIGTERM": 15,
+  "SIGCHLD": 20,
+  "SIGCONT": 19,
+  "SIGSTOP": 17,
+  "SIGTSTP": 18,
+  "SIGTTIN": 21,
+  "SIGTTOU": 22,
+  "SIGURG": 16,
+  "SIGXCPU": 24,
+  "SIGXFSZ": 25,
+  "SIGVTALRM": 26,
+  "SIGPROF": 27,
+  "SIGWINCH": 28,
+  "SIGIO": 23,
+  "SIGSYS": 12,
+  "SSL_OP_ALL": 2147486719,
+  "SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION": 262144,
+  "SSL_OP_CIPHER_SERVER_PREFERENCE": 4194304,
+  "SSL_OP_CISCO_ANYCONNECT": 32768,
+  "SSL_OP_COOKIE_EXCHANGE": 8192,
+  "SSL_OP_CRYPTOPRO_TLSEXT_BUG": 2147483648,
+  "SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS": 2048,
+  "SSL_OP_EPHEMERAL_RSA": 0,
+  "SSL_OP_LEGACY_SERVER_CONNECT": 4,
+  "SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER": 32,
+  "SSL_OP_MICROSOFT_SESS_ID_BUG": 1,
+  "SSL_OP_MSIE_SSLV2_RSA_PADDING": 0,
+  "SSL_OP_NETSCAPE_CA_DN_BUG": 536870912,
+  "SSL_OP_NETSCAPE_CHALLENGE_BUG": 2,
+  "SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG": 1073741824,
+  "SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG": 8,
+  "SSL_OP_NO_COMPRESSION": 131072,
+  "SSL_OP_NO_QUERY_MTU": 4096,
+  "SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION": 65536,
+  "SSL_OP_NO_SSLv2": 16777216,
+  "SSL_OP_NO_SSLv3": 33554432,
+  "SSL_OP_NO_TICKET": 16384,
+  "SSL_OP_NO_TLSv1": 67108864,
+  "SSL_OP_NO_TLSv1_1": 268435456,
+  "SSL_OP_NO_TLSv1_2": 134217728,
+  "SSL_OP_PKCS1_CHECK_1": 0,
+  "SSL_OP_PKCS1_CHECK_2": 0,
+  "SSL_OP_SINGLE_DH_USE": 1048576,
+  "SSL_OP_SINGLE_ECDH_USE": 524288,
+  "SSL_OP_SSLEAY_080_CLIENT_DH_BUG": 128,
+  "SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG": 0,
+  "SSL_OP_TLS_BLOCK_PADDING_BUG": 512,
+  "SSL_OP_TLS_D5_BUG": 256,
+  "SSL_OP_TLS_ROLLBACK_BUG": 8388608,
+  "ENGINE_METHOD_DSA": 2,
+  "ENGINE_METHOD_DH": 4,
+  "ENGINE_METHOD_RAND": 8,
+  "ENGINE_METHOD_ECDH": 16,
+  "ENGINE_METHOD_ECDSA": 32,
+  "ENGINE_METHOD_CIPHERS": 64,
+  "ENGINE_METHOD_DIGESTS": 128,
+  "ENGINE_METHOD_STORE": 256,
+  "ENGINE_METHOD_PKEY_METHS": 512,
+  "ENGINE_METHOD_PKEY_ASN1_METHS": 1024,
+  "ENGINE_METHOD_ALL": 65535,
+  "ENGINE_METHOD_NONE": 0,
+  "DH_CHECK_P_NOT_SAFE_PRIME": 2,
+  "DH_CHECK_P_NOT_PRIME": 1,
+  "DH_UNABLE_TO_CHECK_GENERATOR": 4,
+  "DH_NOT_SUITABLE_GENERATOR": 8,
+  "NPN_ENABLED": 1,
+  "RSA_PKCS1_PADDING": 1,
+  "RSA_SSLV23_PADDING": 2,
+  "RSA_NO_PADDING": 3,
+  "RSA_PKCS1_OAEP_PADDING": 4,
+  "RSA_X931_PADDING": 5,
+  "RSA_PKCS1_PSS_PADDING": 6,
+  "POINT_CONVERSION_COMPRESSED": 2,
+  "POINT_CONVERSION_UNCOMPRESSED": 4,
+  "POINT_CONVERSION_HYBRID": 6,
+  "F_OK": 0,
+  "R_OK": 4,
+  "W_OK": 2,
+  "X_OK": 1,
+  "UV_UDP_REUSEADDR": 4
+}
+
+},{}],53:[function(require,module,exports){
+/*!
+ * content-type
+ * Copyright(c) 2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+'use strict';
+
+/**
+ * RegExp to match *( ";" parameter ) in RFC 7231 sec 3.1.1.1
+ *
+ * parameter     = token "=" ( token / quoted-string )
+ * token         = 1*tchar
+ * tchar         = "!" / "#" / "$" / "%" / "&" / "'" / "*"
+ *               / "+" / "-" / "." / "^" / "_" / "`" / "|" / "~"
+ *               / DIGIT / ALPHA
+ *               ; any VCHAR, except delimiters
+ * quoted-string = DQUOTE *( qdtext / quoted-pair ) DQUOTE
+ * qdtext        = HTAB / SP / %x21 / %x23-5B / %x5D-7E / obs-text
+ * obs-text      = %x80-FF
+ * quoted-pair   = "\" ( HTAB / SP / VCHAR / obs-text )
+ */
+
+var _create = require('babel-runtime/core-js/object/create');
+
+var _create2 = _interopRequireDefault(_create);
+
+var _keys = require('babel-runtime/core-js/object/keys');
+
+var _keys2 = _interopRequireDefault(_keys);
+
+var _typeof2 = require('babel-runtime/helpers/typeof');
+
+var _typeof3 = _interopRequireDefault(_typeof2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var paramRegExp = /; *([!#$%&'\*\+\-\.\^_`\|~0-9A-Za-z]+) *= *("(?:[\u000b\u0020\u0021\u0023-\u005b\u005d-\u007e\u0080-\u00ff]|\\[\u000b\u0020-\u00ff])*"|[!#$%&'\*\+\-\.\^_`\|~0-9A-Za-z]+) */g;
+var textRegExp = /^[\u000b\u0020-\u007e\u0080-\u00ff]+$/;
+var tokenRegExp = /^[!#$%&'\*\+\-\.\^_`\|~0-9A-Za-z]+$/;
+
+/**
+ * RegExp to match quoted-pair in RFC 7230 sec 3.2.6
+ *
+ * quoted-pair = "\" ( HTAB / SP / VCHAR / obs-text )
+ * obs-text    = %x80-FF
+ */
+var qescRegExp = /\\([\u000b\u0020-\u00ff])/g;
+
+/**
+ * RegExp to match chars that must be quoted-pair in RFC 7230 sec 3.2.6
+ */
+var quoteRegExp = /([\\"])/g;
+
+/**
+ * RegExp to match type in RFC 6838
+ *
+ * media-type = type "/" subtype
+ * type       = token
+ * subtype    = token
+ */
+var typeRegExp = /^[!#$%&'\*\+\-\.\^_`\|~0-9A-Za-z]+\/[!#$%&'\*\+\-\.\^_`\|~0-9A-Za-z]+$/;
+
+/**
+ * Module exports.
+ * @public
+ */
+
+exports.format = format;
+exports.parse = parse;
+
+/**
+ * Format object to media type.
+ *
+ * @param {object} obj
+ * @return {string}
+ * @public
+ */
+
+function format(obj) {
+  if (!obj || (typeof obj === 'undefined' ? 'undefined' : (0, _typeof3.default)(obj)) !== 'object') {
+    throw new TypeError('argument obj is required');
+  }
+
+  var parameters = obj.parameters;
+  var type = obj.type;
+
+  if (!type || !typeRegExp.test(type)) {
+    throw new TypeError('invalid type');
+  }
+
+  var string = type;
+
+  // append parameters
+  if (parameters && (typeof parameters === 'undefined' ? 'undefined' : (0, _typeof3.default)(parameters)) === 'object') {
+    var param;
+    var params = (0, _keys2.default)(parameters).sort();
+
+    for (var i = 0; i < params.length; i++) {
+      param = params[i];
+
+      if (!tokenRegExp.test(param)) {
+        throw new TypeError('invalid parameter name');
+      }
+
+      string += '; ' + param + '=' + qstring(parameters[param]);
+    }
+  }
+
+  return string;
+}
+
+/**
+ * Parse media type to object.
+ *
+ * @param {string|object} string
+ * @return {Object}
+ * @public
+ */
+
+function parse(string) {
+  if (!string) {
+    throw new TypeError('argument string is required');
+  }
+
+  if ((typeof string === 'undefined' ? 'undefined' : (0, _typeof3.default)(string)) === 'object') {
+    // support req/res-like objects as argument
+    string = getcontenttype(string);
+
+    if (typeof string !== 'string') {
+      throw new TypeError('content-type header is missing from object');
+    }
+  }
+
+  if (typeof string !== 'string') {
+    throw new TypeError('argument string is required to be a string');
+  }
+
+  var index = string.indexOf(';');
+  var type = index !== -1 ? string.substr(0, index).trim() : string.trim();
+
+  if (!typeRegExp.test(type)) {
+    throw new TypeError('invalid media type');
+  }
+
+  var key;
+  var match;
+  var obj = new ContentType(type.toLowerCase());
+  var value;
+
+  paramRegExp.lastIndex = index;
+
+  while (match = paramRegExp.exec(string)) {
+    if (match.index !== index) {
+      throw new TypeError('invalid parameter format');
+    }
+
+    index += match[0].length;
+    key = match[1].toLowerCase();
+    value = match[2];
+
+    if (value[0] === '"') {
+      // remove quotes and escapes
+      value = value.substr(1, value.length - 2).replace(qescRegExp, '$1');
+    }
+
+    obj.parameters[key] = value;
+  }
+
+  if (index !== -1 && index !== string.length) {
+    throw new TypeError('invalid parameter format');
+  }
+
+  return obj;
+}
+
+/**
+ * Get content-type from req/res objects.
+ *
+ * @param {object}
+ * @return {Object}
+ * @private
+ */
+
+function getcontenttype(obj) {
+  if (typeof obj.getHeader === 'function') {
+    // res-like
+    return obj.getHeader('content-type');
+  }
+
+  if ((0, _typeof3.default)(obj.headers) === 'object') {
+    // req-like
+    return obj.headers && obj.headers['content-type'];
+  }
+}
+
+/**
+ * Quote a string if necessary.
+ *
+ * @param {string} val
+ * @return {string}
+ * @private
+ */
+
+function qstring(val) {
+  var str = String(val);
+
+  // no need to quote tokens
+  if (tokenRegExp.test(str)) {
+    return str;
+  }
+
+  if (str.length > 0 && !textRegExp.test(str)) {
+    throw new TypeError('invalid parameter value');
+  }
+
+  return '"' + str.replace(quoteRegExp, '\\$1') + '"';
+}
+
+/**
+ * Class to represent a content type.
+ * @private
+ */
+function ContentType(type) {
+  this.parameters = (0, _create2.default)(null);
+  this.type = type;
+}
+
+},{"babel-runtime/core-js/object/create":22,"babel-runtime/core-js/object/keys":30,"babel-runtime/helpers/typeof":39}],54:[function(require,module,exports){
+/*!
+ * copy-to - index.js
+ * Copyright(c) 2014 dead_horse <dead_horse@qq.com>
+ * MIT Licensed
+ */
+
+'use strict';
+
+/**
+ * slice() reference.
+ */
+
+var _keys = require('babel-runtime/core-js/object/keys');
+
+var _keys2 = _interopRequireDefault(_keys);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var slice = Array.prototype.slice;
+
+/**
+ * Expose copy
+ *
+ * ```
+ * copy({foo: 'nar', hello: 'copy'}).to({hello: 'world'});
+ * copy({foo: 'nar', hello: 'copy'}).toCover({hello: 'world'});
+ * ```
+ *
+ * @param {Object} src
+ * @return {Copy}
+ */
+
+module.exports = Copy;
+
+/**
+ * Copy
+ * @param {Object} src
+ * @param {Boolean} withAccess
+ */
+
+function Copy(src, withAccess) {
+  if (!(this instanceof Copy)) return new Copy(src, withAccess);
+  this.src = src;
+  this._withAccess = withAccess;
+}
+
+/**
+ * copy properties include getter and setter
+ * @param {[type]} val [description]
+ * @return {[type]} [description]
+ */
+
+Copy.prototype.withAccess = function (w) {
+  this._withAccess = w !== false;
+  return this;
+};
+
+/**
+ * pick keys in src
+ *
+ * @api: public
+ */
+
+Copy.prototype.pick = function (keys) {
+  if (!Array.isArray(keys)) {
+    keys = slice.call(arguments);
+  }
+  if (keys.length) {
+    this.keys = keys;
+  }
+  return this;
+};
+
+/**
+ * copy src to target,
+ * do not cover any property target has
+ * @param {Object} to
+ *
+ * @api: public
+ */
+
+Copy.prototype.to = function (to) {
+  to = to || {};
+
+  if (!this.src) return to;
+  var keys = this.keys || (0, _keys2.default)(this.src);
+
+  if (!this._withAccess) {
+    for (var i = 0; i < keys.length; i++) {
+      key = keys[i];
+      if (to[key] !== undefined) continue;
+      to[key] = this.src[key];
+    }
+    return to;
+  }
+
+  for (var i = 0; i < keys.length; i++) {
+    var key = keys[i];
+    if (!notDefined(to, key)) continue;
+    var getter = this.src.__lookupGetter__(key);
+    var setter = this.src.__lookupSetter__(key);
+    if (getter) to.__defineGetter__(key, getter);
+    if (setter) to.__defineSetter__(key, setter);
+
+    if (!getter && !setter) {
+      to[key] = this.src[key];
+    }
+  }
+  return to;
+};
+
+/**
+ * copy src to target,
+ * override any property target has
+ * @param {Object} to
+ *
+ * @api: public
+ */
+
+Copy.prototype.toCover = function (to) {
+  var keys = this.keys || (0, _keys2.default)(this.src);
+
+  for (var i = 0; i < keys.length; i++) {
+    var key = keys[i];
+    delete to[key];
+    var getter = this.src.__lookupGetter__(key);
+    var setter = this.src.__lookupSetter__(key);
+    if (getter) to.__defineGetter__(key, getter);
+    if (setter) to.__defineSetter__(key, setter);
+
+    if (!getter && !setter) {
+      to[key] = this.src[key];
+    }
+  }
+};
+
+Copy.prototype.override = Copy.prototype.toCover;
+
+/**
+ * append another object to src
+ * @param {Obj} obj
+ * @return {Copy}
+ */
+
+Copy.prototype.and = function (obj) {
+  var src = {};
+  this.to(src);
+  this.src = obj;
+  this.to(src);
+  this.src = src;
+
+  return this;
+};
+
+/**
+ * check obj[key] if not defiend
+ * @param {Object} obj
+ * @param {String} key
+ * @return {Boolean}
+ */
+
+function notDefined(obj, key) {
+  return obj[key] === undefined && obj.__lookupGetter__(key) === undefined && obj.__lookupSetter__(key) === undefined;
+}
+
+},{"babel-runtime/core-js/object/keys":30}],55:[function(require,module,exports){
+'use strict';
+
+require('../../modules/es6.string.iterator');
+require('../../modules/es6.array.from');
+module.exports = require('../../modules/_core').Array.from;
+
+},{"../../modules/_core":86,"../../modules/es6.array.from":152,"../../modules/es6.string.iterator":170}],56:[function(require,module,exports){
+'use strict';
+
+require('../modules/web.immediate');
+module.exports = require('../modules/_core').clearImmediate;
+
+},{"../modules/_core":86,"../modules/web.immediate":175}],57:[function(require,module,exports){
+'use strict';
+
+require('../modules/web.dom.iterable');
+require('../modules/es6.string.iterator');
+module.exports = require('../modules/core.get-iterator');
+
+},{"../modules/core.get-iterator":151,"../modules/es6.string.iterator":170,"../modules/web.dom.iterable":174}],58:[function(require,module,exports){
+'use strict';
+
+var _stringify = require('babel-runtime/core-js/json/stringify');
+
+var _stringify2 = _interopRequireDefault(_stringify);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var core = require('../../modules/_core'),
+    $JSON = core.JSON || (core.JSON = { stringify: _stringify2.default });
+module.exports = function stringify(it) {
+  // eslint-disable-line no-unused-vars
+  return $JSON.stringify.apply($JSON, arguments);
+};
+
+},{"../../modules/_core":86,"babel-runtime/core-js/json/stringify":18}],59:[function(require,module,exports){
+'use strict';
+
+require('../../modules/es6.number.is-finite');
+module.exports = require('../../modules/_core').Number.isFinite;
+
+},{"../../modules/_core":86,"../../modules/es6.number.is-finite":154}],60:[function(require,module,exports){
+'use strict';
+
+require('../../modules/es6.number.is-nan');
+module.exports = require('../../modules/_core').Number.isNaN;
+
+},{"../../modules/_core":86,"../../modules/es6.number.is-nan":155}],61:[function(require,module,exports){
+'use strict';
+
+require('../../modules/es6.number.max-safe-integer');
+module.exports = 0x1fffffffffffff;
+
+},{"../../modules/es6.number.max-safe-integer":156}],62:[function(require,module,exports){
+'use strict';
+
+require('../../modules/es6.object.create');
+var $Object = require('../../modules/_core').Object;
+module.exports = function create(P, D) {
+  return $Object.create(P, D);
+};
+
+},{"../../modules/_core":86,"../../modules/es6.object.create":157}],63:[function(require,module,exports){
+'use strict';
+
+require('../../modules/es6.object.define-properties');
+var $Object = require('../../modules/_core').Object;
+module.exports = function defineProperties(T, D) {
+  return $Object.defineProperties(T, D);
+};
+
+},{"../../modules/_core":86,"../../modules/es6.object.define-properties":158}],64:[function(require,module,exports){
+'use strict';
+
+require('../../modules/es6.object.define-property');
+var $Object = require('../../modules/_core').Object;
+module.exports = function defineProperty(it, key, desc) {
+  return $Object.defineProperty(it, key, desc);
+};
+
+},{"../../modules/_core":86,"../../modules/es6.object.define-property":159}],65:[function(require,module,exports){
+'use strict';
+
+require('../../modules/es6.object.get-own-property-descriptor');
+var $Object = require('../../modules/_core').Object;
+module.exports = function getOwnPropertyDescriptor(it, key) {
+  return $Object.getOwnPropertyDescriptor(it, key);
+};
+
+},{"../../modules/_core":86,"../../modules/es6.object.get-own-property-descriptor":160}],66:[function(require,module,exports){
+'use strict';
+
+require('../../modules/es6.object.get-own-property-names');
+var $Object = require('../../modules/_core').Object;
+module.exports = function getOwnPropertyNames(it) {
+  return $Object.getOwnPropertyNames(it);
+};
+
+},{"../../modules/_core":86,"../../modules/es6.object.get-own-property-names":161}],67:[function(require,module,exports){
+'use strict';
+
+require('../../modules/es6.symbol');
+module.exports = require('../../modules/_core').Object.getOwnPropertySymbols;
+
+},{"../../modules/_core":86,"../../modules/es6.symbol":171}],68:[function(require,module,exports){
+'use strict';
+
+require('../../modules/es6.object.get-prototype-of');
+module.exports = require('../../modules/_core').Object.getPrototypeOf;
+
+},{"../../modules/_core":86,"../../modules/es6.object.get-prototype-of":162}],69:[function(require,module,exports){
+'use strict';
+
+require('../../modules/es6.object.is-extensible');
+module.exports = require('../../modules/_core').Object.isExtensible;
+
+},{"../../modules/_core":86,"../../modules/es6.object.is-extensible":163}],70:[function(require,module,exports){
+'use strict';
+
+require('../../modules/es6.object.keys');
+module.exports = require('../../modules/_core').Object.keys;
+
+},{"../../modules/_core":86,"../../modules/es6.object.keys":164}],71:[function(require,module,exports){
+'use strict';
+
+require('../../modules/es6.object.prevent-extensions');
+module.exports = require('../../modules/_core').Object.preventExtensions;
+
+},{"../../modules/_core":86,"../../modules/es6.object.prevent-extensions":165}],72:[function(require,module,exports){
+'use strict';
+
+require('../../modules/es6.object.set-prototype-of');
+module.exports = require('../../modules/_core').Object.setPrototypeOf;
+
+},{"../../modules/_core":86,"../../modules/es6.object.set-prototype-of":166}],73:[function(require,module,exports){
+'use strict';
+
+require('../modules/es6.object.to-string');
+require('../modules/es6.string.iterator');
+require('../modules/web.dom.iterable');
+require('../modules/es6.promise');
+module.exports = require('../modules/_core').Promise;
+
+},{"../modules/_core":86,"../modules/es6.object.to-string":167,"../modules/es6.promise":168,"../modules/es6.string.iterator":170,"../modules/web.dom.iterable":174}],74:[function(require,module,exports){
+'use strict';
+
+require('../modules/web.immediate');
+module.exports = require('../modules/_core').setImmediate;
+
+},{"../modules/_core":86,"../modules/web.immediate":175}],75:[function(require,module,exports){
+'use strict';
+
+require('../../modules/es6.string.from-code-point');
+module.exports = require('../../modules/_core').String.fromCodePoint;
+
+},{"../../modules/_core":86,"../../modules/es6.string.from-code-point":169}],76:[function(require,module,exports){
+'use strict';
+
+require('../../modules/es6.symbol');
+require('../../modules/es6.object.to-string');
+require('../../modules/es7.symbol.async-iterator');
+require('../../modules/es7.symbol.observable');
+module.exports = require('../../modules/_core').Symbol;
+
+},{"../../modules/_core":86,"../../modules/es6.object.to-string":167,"../../modules/es6.symbol":171,"../../modules/es7.symbol.async-iterator":172,"../../modules/es7.symbol.observable":173}],77:[function(require,module,exports){
+'use strict';
+
+require('../../modules/es6.string.iterator');
+require('../../modules/web.dom.iterable');
+module.exports = require('../../modules/_wks-ext').f('iterator');
+
+},{"../../modules/_wks-ext":148,"../../modules/es6.string.iterator":170,"../../modules/web.dom.iterable":174}],78:[function(require,module,exports){
+'use strict';
+
+module.exports = require('../../modules/_wks-ext').f('species');
+
+},{"../../modules/_wks-ext":148}],79:[function(require,module,exports){
+'use strict';
+
+module.exports = function (it) {
+  if (typeof it != 'function') throw TypeError(it + ' is not a function!');
+  return it;
+};
+
+},{}],80:[function(require,module,exports){
+"use strict";
+
+module.exports = function () {/* empty */};
+
+},{}],81:[function(require,module,exports){
+'use strict';
+
+module.exports = function (it, Constructor, name, forbiddenField) {
+  if (!(it instanceof Constructor) || forbiddenField !== undefined && forbiddenField in it) {
+    throw TypeError(name + ': incorrect invocation!');
+  }return it;
+};
+
+},{}],82:[function(require,module,exports){
+'use strict';
+
+var isObject = require('./_is-object');
+module.exports = function (it) {
+  if (!isObject(it)) throw TypeError(it + ' is not an object!');
+  return it;
+};
+
+},{"./_is-object":106}],83:[function(require,module,exports){
+'use strict';
+
+// false -> Array#indexOf
+// true  -> Array#includes
+var toIObject = require('./_to-iobject'),
+    toLength = require('./_to-length'),
+    toIndex = require('./_to-index');
+module.exports = function (IS_INCLUDES) {
+  return function ($this, el, fromIndex) {
+    var O = toIObject($this),
+        length = toLength(O.length),
+        index = toIndex(fromIndex, length),
+        value;
+    // Array#includes uses SameValueZero equality algorithm
+    if (IS_INCLUDES && el != el) while (length > index) {
+      value = O[index++];
+      if (value != value) return true;
+      // Array#toIndex ignores holes, Array#includes - not
+    } else for (; length > index; index++) {
+      if (IS_INCLUDES || index in O) {
+        if (O[index] === el) return IS_INCLUDES || index || 0;
+      }
+    }return !IS_INCLUDES && -1;
+  };
+};
+
+},{"./_to-index":140,"./_to-iobject":142,"./_to-length":143}],84:[function(require,module,exports){
+'use strict';
+
+// getting tag from 19.1.3.6 Object.prototype.toString()
+var cof = require('./_cof'),
+    TAG = require('./_wks')('toStringTag')
+// ES3 wrong here
+,
+    ARG = cof(function () {
+  return arguments;
+}()) == 'Arguments';
+
+// fallback for IE11 Script Access Denied error
+var tryGet = function tryGet(it, key) {
+  try {
+    return it[key];
+  } catch (e) {/* empty */}
+};
+
+module.exports = function (it) {
+  var O, T, B;
+  return it === undefined ? 'Undefined' : it === null ? 'Null'
+  // @@toStringTag case
+  : typeof (T = tryGet(O = Object(it), TAG)) == 'string' ? T
+  // builtinTag case
+  : ARG ? cof(O)
+  // ES3 arguments fallback
+  : (B = cof(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B;
+};
+
+},{"./_cof":85,"./_wks":149}],85:[function(require,module,exports){
+"use strict";
+
+var toString = {}.toString;
+
+module.exports = function (it) {
+  return toString.call(it).slice(8, -1);
+};
+
+},{}],86:[function(require,module,exports){
+'use strict';
+
+var core = module.exports = { version: '2.4.0' };
+if (typeof __e == 'number') __e = core; // eslint-disable-line no-undef
+
+},{}],87:[function(require,module,exports){
+'use strict';
+
+var $defineProperty = require('./_object-dp'),
+    createDesc = require('./_property-desc');
+
+module.exports = function (object, index, value) {
+  if (index in object) $defineProperty.f(object, index, createDesc(0, value));else object[index] = value;
+};
+
+},{"./_object-dp":118,"./_property-desc":129}],88:[function(require,module,exports){
+'use strict';
+
+// optional / simple context binding
+var aFunction = require('./_a-function');
+module.exports = function (fn, that, length) {
+  aFunction(fn);
+  if (that === undefined) return fn;
+  switch (length) {
+    case 1:
+      return function (a) {
+        return fn.call(that, a);
+      };
+    case 2:
+      return function (a, b) {
+        return fn.call(that, a, b);
+      };
+    case 3:
+      return function (a, b, c) {
+        return fn.call(that, a, b, c);
+      };
+  }
+  return function () /* ...args */{
+    return fn.apply(that, arguments);
+  };
+};
+
+},{"./_a-function":79}],89:[function(require,module,exports){
+"use strict";
+
+// 7.2.1 RequireObjectCoercible(argument)
+module.exports = function (it) {
+  if (it == undefined) throw TypeError("Can't call method on  " + it);
+  return it;
+};
+
+},{}],90:[function(require,module,exports){
+'use strict';
+
+// Thank's IE8 for his funny defineProperty
+module.exports = !require('./_fails')(function () {
+  return Object.defineProperty({}, 'a', { get: function get() {
+      return 7;
+    } }).a != 7;
+});
+
+},{"./_fails":95}],91:[function(require,module,exports){
+'use strict';
+
+var isObject = require('./_is-object'),
+    document = require('./_global').document
+// in old IE typeof document.createElement is 'object'
+,
+    is = isObject(document) && isObject(document.createElement);
+module.exports = function (it) {
+  return is ? document.createElement(it) : {};
+};
+
+},{"./_global":97,"./_is-object":106}],92:[function(require,module,exports){
+'use strict';
+
+// IE 8- don't enum bug keys
+module.exports = 'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf'.split(',');
+
+},{}],93:[function(require,module,exports){
+'use strict';
+
+// all enumerable object keys, includes symbols
+var getKeys = require('./_object-keys'),
+    gOPS = require('./_object-gops'),
+    pIE = require('./_object-pie');
+module.exports = function (it) {
+  var result = getKeys(it),
+      getSymbols = gOPS.f;
+  if (getSymbols) {
+    var symbols = getSymbols(it),
+        isEnum = pIE.f,
+        i = 0,
+        key;
+    while (symbols.length > i) {
+      if (isEnum.call(it, key = symbols[i++])) result.push(key);
+    }
+  }return result;
+};
+
+},{"./_object-gops":123,"./_object-keys":126,"./_object-pie":127}],94:[function(require,module,exports){
+'use strict';
+
+var global = require('./_global'),
+    core = require('./_core'),
+    ctx = require('./_ctx'),
+    hide = require('./_hide'),
+    PROTOTYPE = 'prototype';
+
+var $export = function $export(type, name, source) {
+  var IS_FORCED = type & $export.F,
+      IS_GLOBAL = type & $export.G,
+      IS_STATIC = type & $export.S,
+      IS_PROTO = type & $export.P,
+      IS_BIND = type & $export.B,
+      IS_WRAP = type & $export.W,
+      exports = IS_GLOBAL ? core : core[name] || (core[name] = {}),
+      expProto = exports[PROTOTYPE],
+      target = IS_GLOBAL ? global : IS_STATIC ? global[name] : (global[name] || {})[PROTOTYPE],
+      key,
+      own,
+      out;
+  if (IS_GLOBAL) source = name;
+  for (key in source) {
+    // contains in native
+    own = !IS_FORCED && target && target[key] !== undefined;
+    if (own && key in exports) continue;
+    // export native or passed
+    out = own ? target[key] : source[key];
+    // prevent global pollution for namespaces
+    exports[key] = IS_GLOBAL && typeof target[key] != 'function' ? source[key]
+    // bind timers to global for call from export context
+    : IS_BIND && own ? ctx(out, global)
+    // wrap global constructors for prevent change them in library
+    : IS_WRAP && target[key] == out ? function (C) {
+      var F = function F(a, b, c) {
+        if (this instanceof C) {
+          switch (arguments.length) {
+            case 0:
+              return new C();
+            case 1:
+              return new C(a);
+            case 2:
+              return new C(a, b);
+          }return new C(a, b, c);
+        }return C.apply(this, arguments);
+      };
+      F[PROTOTYPE] = C[PROTOTYPE];
+      return F;
+      // make static versions for prototype methods
+    }(out) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;
+    // export proto methods to core.%CONSTRUCTOR%.methods.%NAME%
+    if (IS_PROTO) {
+      (exports.virtual || (exports.virtual = {}))[key] = out;
+      // export proto methods to core.%CONSTRUCTOR%.prototype.%NAME%
+      if (type & $export.R && expProto && !expProto[key]) hide(expProto, key, out);
+    }
+  }
+};
+// type bitmap
+$export.F = 1; // forced
+$export.G = 2; // global
+$export.S = 4; // static
+$export.P = 8; // proto
+$export.B = 16; // bind
+$export.W = 32; // wrap
+$export.U = 64; // safe
+$export.R = 128; // real proto method for `library` 
+module.exports = $export;
+
+},{"./_core":86,"./_ctx":88,"./_global":97,"./_hide":99}],95:[function(require,module,exports){
+"use strict";
+
+module.exports = function (exec) {
+  try {
+    return !!exec();
+  } catch (e) {
+    return true;
+  }
+};
+
+},{}],96:[function(require,module,exports){
+'use strict';
+
+var ctx = require('./_ctx'),
+    call = require('./_iter-call'),
+    isArrayIter = require('./_is-array-iter'),
+    anObject = require('./_an-object'),
+    toLength = require('./_to-length'),
+    getIterFn = require('./core.get-iterator-method'),
+    BREAK = {},
+    RETURN = {};
+var _exports = module.exports = function (iterable, entries, fn, that, ITERATOR) {
+  var iterFn = ITERATOR ? function () {
+    return iterable;
+  } : getIterFn(iterable),
+      f = ctx(fn, that, entries ? 2 : 1),
+      index = 0,
+      length,
+      step,
+      iterator,
+      result;
+  if (typeof iterFn != 'function') throw TypeError(iterable + ' is not iterable!');
+  // fast case for arrays with default iterator
+  if (isArrayIter(iterFn)) for (length = toLength(iterable.length); length > index; index++) {
+    result = entries ? f(anObject(step = iterable[index])[0], step[1]) : f(iterable[index]);
+    if (result === BREAK || result === RETURN) return result;
+  } else for (iterator = iterFn.call(iterable); !(step = iterator.next()).done;) {
+    result = call(iterator, f, step.value, entries);
+    if (result === BREAK || result === RETURN) return result;
+  }
+};
+_exports.BREAK = BREAK;
+_exports.RETURN = RETURN;
+
+},{"./_an-object":82,"./_ctx":88,"./_is-array-iter":104,"./_iter-call":107,"./_to-length":143,"./core.get-iterator-method":150}],97:[function(require,module,exports){
+'use strict';
+
+// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
+var global = module.exports = typeof window != 'undefined' && window.Math == Math ? window : typeof self != 'undefined' && self.Math == Math ? self : Function('return this')();
+if (typeof __g == 'number') __g = global; // eslint-disable-line no-undef
+
+},{}],98:[function(require,module,exports){
+"use strict";
+
+var hasOwnProperty = {}.hasOwnProperty;
+module.exports = function (it, key) {
+  return hasOwnProperty.call(it, key);
+};
+
+},{}],99:[function(require,module,exports){
+'use strict';
+
+var dP = require('./_object-dp'),
+    createDesc = require('./_property-desc');
+module.exports = require('./_descriptors') ? function (object, key, value) {
+  return dP.f(object, key, createDesc(1, value));
+} : function (object, key, value) {
+  object[key] = value;
+  return object;
+};
+
+},{"./_descriptors":90,"./_object-dp":118,"./_property-desc":129}],100:[function(require,module,exports){
+'use strict';
+
+module.exports = require('./_global').document && document.documentElement;
+
+},{"./_global":97}],101:[function(require,module,exports){
+'use strict';
+
+module.exports = !require('./_descriptors') && !require('./_fails')(function () {
+  return Object.defineProperty(require('./_dom-create')('div'), 'a', { get: function get() {
+      return 7;
+    } }).a != 7;
+});
+
+},{"./_descriptors":90,"./_dom-create":91,"./_fails":95}],102:[function(require,module,exports){
+"use strict";
+
+// fast apply, http://jsperf.lnkit.com/fast-apply/5
+module.exports = function (fn, args, that) {
+                  var un = that === undefined;
+                  switch (args.length) {
+                                    case 0:
+                                                      return un ? fn() : fn.call(that);
+                                    case 1:
+                                                      return un ? fn(args[0]) : fn.call(that, args[0]);
+                                    case 2:
+                                                      return un ? fn(args[0], args[1]) : fn.call(that, args[0], args[1]);
+                                    case 3:
+                                                      return un ? fn(args[0], args[1], args[2]) : fn.call(that, args[0], args[1], args[2]);
+                                    case 4:
+                                                      return un ? fn(args[0], args[1], args[2], args[3]) : fn.call(that, args[0], args[1], args[2], args[3]);
+                  }return fn.apply(that, args);
+};
+
+},{}],103:[function(require,module,exports){
+'use strict';
+
+// fallback for non-array-like ES3 and non-enumerable old V8 strings
+var cof = require('./_cof');
+module.exports = Object('z').propertyIsEnumerable(0) ? Object : function (it) {
+  return cof(it) == 'String' ? it.split('') : Object(it);
+};
+
+},{"./_cof":85}],104:[function(require,module,exports){
+'use strict';
+
+// check on default Array iterator
+var Iterators = require('./_iterators'),
+    ITERATOR = require('./_wks')('iterator'),
+    ArrayProto = Array.prototype;
+
+module.exports = function (it) {
+  return it !== undefined && (Iterators.Array === it || ArrayProto[ITERATOR] === it);
+};
+
+},{"./_iterators":112,"./_wks":149}],105:[function(require,module,exports){
+'use strict';
+
+// 7.2.2 IsArray(argument)
+var cof = require('./_cof');
+module.exports = Array.isArray || function isArray(arg) {
+  return cof(arg) == 'Array';
+};
+
+},{"./_cof":85}],106:[function(require,module,exports){
+'use strict';
+
+var _typeof2 = require('babel-runtime/helpers/typeof');
+
+var _typeof3 = _interopRequireDefault(_typeof2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+module.exports = function (it) {
+  return (typeof it === 'undefined' ? 'undefined' : (0, _typeof3.default)(it)) === 'object' ? it !== null : typeof it === 'function';
+};
+
+},{"babel-runtime/helpers/typeof":39}],107:[function(require,module,exports){
+'use strict';
+
+// call something on iterator step with safe closing on error
+var anObject = require('./_an-object');
+module.exports = function (iterator, fn, value, entries) {
+  try {
+    return entries ? fn(anObject(value)[0], value[1]) : fn(value);
+    // 7.4.6 IteratorClose(iterator, completion)
+  } catch (e) {
+    var ret = iterator['return'];
+    if (ret !== undefined) anObject(ret.call(iterator));
+    throw e;
+  }
+};
+
+},{"./_an-object":82}],108:[function(require,module,exports){
+'use strict';
+
+var create = require('./_object-create'),
+    descriptor = require('./_property-desc'),
+    setToStringTag = require('./_set-to-string-tag'),
+    IteratorPrototype = {};
+
+// 25.1.2.1.1 %IteratorPrototype%[@@iterator]()
+require('./_hide')(IteratorPrototype, require('./_wks')('iterator'), function () {
+  return this;
+});
+
+module.exports = function (Constructor, NAME, next) {
+  Constructor.prototype = create(IteratorPrototype, { next: descriptor(1, next) });
+  setToStringTag(Constructor, NAME + ' Iterator');
+};
+
+},{"./_hide":99,"./_object-create":117,"./_property-desc":129,"./_set-to-string-tag":134,"./_wks":149}],109:[function(require,module,exports){
+'use strict';
+
+var LIBRARY = require('./_library'),
+    $export = require('./_export'),
+    redefine = require('./_redefine'),
+    hide = require('./_hide'),
+    has = require('./_has'),
+    Iterators = require('./_iterators'),
+    $iterCreate = require('./_iter-create'),
+    setToStringTag = require('./_set-to-string-tag'),
+    getPrototypeOf = require('./_object-gpo'),
+    ITERATOR = require('./_wks')('iterator'),
+    BUGGY = !([].keys && 'next' in [].keys()) // Safari has buggy iterators w/o `next`
+,
+    FF_ITERATOR = '@@iterator',
+    KEYS = 'keys',
+    VALUES = 'values';
+
+var returnThis = function returnThis() {
+  return this;
+};
+
+module.exports = function (Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCED) {
+  $iterCreate(Constructor, NAME, next);
+  var getMethod = function getMethod(kind) {
+    if (!BUGGY && kind in proto) return proto[kind];
+    switch (kind) {
+      case KEYS:
+        return function keys() {
+          return new Constructor(this, kind);
+        };
+      case VALUES:
+        return function values() {
+          return new Constructor(this, kind);
+        };
+    }return function entries() {
+      return new Constructor(this, kind);
+    };
+  };
+  var TAG = NAME + ' Iterator',
+      DEF_VALUES = DEFAULT == VALUES,
+      VALUES_BUG = false,
+      proto = Base.prototype,
+      $native = proto[ITERATOR] || proto[FF_ITERATOR] || DEFAULT && proto[DEFAULT],
+      $default = $native || getMethod(DEFAULT),
+      $entries = DEFAULT ? !DEF_VALUES ? $default : getMethod('entries') : undefined,
+      $anyNative = NAME == 'Array' ? proto.entries || $native : $native,
+      methods,
+      key,
+      IteratorPrototype;
+  // Fix native
+  if ($anyNative) {
+    IteratorPrototype = getPrototypeOf($anyNative.call(new Base()));
+    if (IteratorPrototype !== Object.prototype) {
+      // Set @@toStringTag to native iterators
+      setToStringTag(IteratorPrototype, TAG, true);
+      // fix for some old engines
+      if (!LIBRARY && !has(IteratorPrototype, ITERATOR)) hide(IteratorPrototype, ITERATOR, returnThis);
+    }
+  }
+  // fix Array#{values, @@iterator}.name in V8 / FF
+  if (DEF_VALUES && $native && $native.name !== VALUES) {
+    VALUES_BUG = true;
+    $default = function values() {
+      return $native.call(this);
+    };
+  }
+  // Define iterator
+  if ((!LIBRARY || FORCED) && (BUGGY || VALUES_BUG || !proto[ITERATOR])) {
+    hide(proto, ITERATOR, $default);
+  }
+  // Plug for library
+  Iterators[NAME] = $default;
+  Iterators[TAG] = returnThis;
+  if (DEFAULT) {
+    methods = {
+      values: DEF_VALUES ? $default : getMethod(VALUES),
+      keys: IS_SET ? $default : getMethod(KEYS),
+      entries: $entries
+    };
+    if (FORCED) for (key in methods) {
+      if (!(key in proto)) redefine(proto, key, methods[key]);
+    } else $export($export.P + $export.F * (BUGGY || VALUES_BUG), NAME, methods);
+  }
+  return methods;
+};
+
+},{"./_export":94,"./_has":98,"./_hide":99,"./_iter-create":108,"./_iterators":112,"./_library":114,"./_object-gpo":124,"./_redefine":131,"./_set-to-string-tag":134,"./_wks":149}],110:[function(require,module,exports){
+'use strict';
+
+var _from = require('babel-runtime/core-js/array/from');
+
+var _from2 = _interopRequireDefault(_from);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var ITERATOR = require('./_wks')('iterator'),
+    SAFE_CLOSING = false;
+
+try {
+  var riter = [7][ITERATOR]();
+  riter['return'] = function () {
+    SAFE_CLOSING = true;
+  };
+  (0, _from2.default)(riter, function () {
+    throw 2;
+  });
+} catch (e) {/* empty */}
+
+module.exports = function (exec, skipClosing) {
+  if (!skipClosing && !SAFE_CLOSING) return false;
+  var safe = false;
+  try {
+    var arr = [7],
+        iter = arr[ITERATOR]();
+    iter.next = function () {
+      return { done: safe = true };
+    };
+    arr[ITERATOR] = function () {
+      return iter;
+    };
+    exec(arr);
+  } catch (e) {/* empty */}
+  return safe;
+};
+
+},{"./_wks":149,"babel-runtime/core-js/array/from":15}],111:[function(require,module,exports){
+"use strict";
+
+module.exports = function (done, value) {
+  return { value: value, done: !!done };
+};
+
+},{}],112:[function(require,module,exports){
+"use strict";
+
+module.exports = {};
+
+},{}],113:[function(require,module,exports){
+'use strict';
+
+var getKeys = require('./_object-keys'),
+    toIObject = require('./_to-iobject');
+module.exports = function (object, el) {
+  var O = toIObject(object),
+      keys = getKeys(O),
+      length = keys.length,
+      index = 0,
+      key;
+  while (length > index) {
+    if (O[key = keys[index++]] === el) return key;
+  }
+};
+
+},{"./_object-keys":126,"./_to-iobject":142}],114:[function(require,module,exports){
+"use strict";
+
+module.exports = true;
+
+},{}],115:[function(require,module,exports){
+'use strict';
+
+var _typeof2 = require('babel-runtime/helpers/typeof');
+
+var _typeof3 = _interopRequireDefault(_typeof2);
+
+var _preventExtensions = require('babel-runtime/core-js/object/prevent-extensions');
+
+var _preventExtensions2 = _interopRequireDefault(_preventExtensions);
+
+var _isExtensible = require('babel-runtime/core-js/object/is-extensible');
+
+var _isExtensible2 = _interopRequireDefault(_isExtensible);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var META = require('./_uid')('meta'),
+    isObject = require('./_is-object'),
+    has = require('./_has'),
+    setDesc = require('./_object-dp').f,
+    id = 0;
+var isExtensible = _isExtensible2.default || function () {
+  return true;
+};
+var FREEZE = !require('./_fails')(function () {
+  return isExtensible((0, _preventExtensions2.default)({}));
+});
+var setMeta = function setMeta(it) {
+  setDesc(it, META, { value: {
+      i: 'O' + ++id, // object ID
+      w: {} // weak collections IDs
+    } });
+};
+var fastKey = function fastKey(it, create) {
+  // return primitive with prefix
+  if (!isObject(it)) return (typeof it === 'undefined' ? 'undefined' : (0, _typeof3.default)(it)) == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it;
+  if (!has(it, META)) {
+    // can't set metadata to uncaught frozen object
+    if (!isExtensible(it)) return 'F';
+    // not necessary to add metadata
+    if (!create) return 'E';
+    // add missing metadata
+    setMeta(it);
+    // return object ID
+  }return it[META].i;
+};
+var getWeak = function getWeak(it, create) {
+  if (!has(it, META)) {
+    // can't set metadata to uncaught frozen object
+    if (!isExtensible(it)) return true;
+    // not necessary to add metadata
+    if (!create) return false;
+    // add missing metadata
+    setMeta(it);
+    // return hash weak collections IDs
+  }return it[META].w;
+};
+// add metadata on freeze-family methods calling
+var onFreeze = function onFreeze(it) {
+  if (FREEZE && meta.NEED && isExtensible(it) && !has(it, META)) setMeta(it);
+  return it;
+};
+var meta = module.exports = {
+  KEY: META,
+  NEED: false,
+  fastKey: fastKey,
+  getWeak: getWeak,
+  onFreeze: onFreeze
+};
+
+},{"./_fails":95,"./_has":98,"./_is-object":106,"./_object-dp":118,"./_uid":146,"babel-runtime/core-js/object/is-extensible":29,"babel-runtime/core-js/object/prevent-extensions":31,"babel-runtime/helpers/typeof":39}],116:[function(require,module,exports){
+'use strict';
+
+var global = require('./_global'),
+    macrotask = require('./_task').set,
+    Observer = global.MutationObserver || global.WebKitMutationObserver,
+    process = global.process,
+    Promise = global.Promise,
+    isNode = require('./_cof')(process) == 'process';
+
+module.exports = function () {
+  var head, last, notify;
+
+  var flush = function flush() {
+    var parent, fn;
+    if (isNode && (parent = process.domain)) parent.exit();
+    while (head) {
+      fn = head.fn;
+      head = head.next;
+      try {
+        fn();
+      } catch (e) {
+        if (head) notify();else last = undefined;
+        throw e;
+      }
+    }last = undefined;
+    if (parent) parent.enter();
+  };
+
+  // Node.js
+  if (isNode) {
+    notify = function notify() {
+      process.nextTick(flush);
+    };
+    // browsers with MutationObserver
+  } else if (Observer) {
+    var toggle = true,
+        node = document.createTextNode('');
+    new Observer(flush).observe(node, { characterData: true }); // eslint-disable-line no-new
+    notify = function notify() {
+      node.data = toggle = !toggle;
+    };
+    // environments with maybe non-completely correct, but existent Promise
+  } else if (Promise && Promise.resolve) {
+    var promise = Promise.resolve();
+    notify = function notify() {
+      promise.then(flush);
+    };
+    // for other environments - macrotask based on:
+    // - setImmediate
+    // - MessageChannel
+    // - window.postMessag
+    // - onreadystatechange
+    // - setTimeout
+  } else {
+    notify = function notify() {
+      // strange IE + webpack dev server bug - use .call(global)
+      macrotask.call(global, flush);
+    };
+  }
+
+  return function (fn) {
+    var task = { fn: fn, next: undefined };
+    if (last) last.next = task;
+    if (!head) {
+      head = task;
+      notify();
+    }last = task;
+  };
+};
+
+},{"./_cof":85,"./_global":97,"./_task":139}],117:[function(require,module,exports){
+'use strict';
+
+var _create = require('babel-runtime/core-js/object/create');
+
+var _create2 = _interopRequireDefault(_create);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])
+var anObject = require('./_an-object'),
+    dPs = require('./_object-dps'),
+    enumBugKeys = require('./_enum-bug-keys'),
+    IE_PROTO = require('./_shared-key')('IE_PROTO'),
+    Empty = function Empty() {/* empty */},
+    PROTOTYPE = 'prototype';
+
+// Create object with fake `null` prototype: use iframe Object with cleared prototype
+var _createDict = function createDict() {
+  // Thrash, waste and sodomy: IE GC bug
+  var iframe = require('./_dom-create')('iframe'),
+      i = enumBugKeys.length,
+      lt = '<',
+      gt = '>',
+      iframeDocument;
+  iframe.style.display = 'none';
+  require('./_html').appendChild(iframe);
+  iframe.src = 'javascript:'; // eslint-disable-line no-script-url
+  // createDict = iframe.contentWindow.Object;
+  // html.removeChild(iframe);
+  iframeDocument = iframe.contentWindow.document;
+  iframeDocument.open();
+  iframeDocument.write(lt + 'script' + gt + 'document.F=Object' + lt + '/script' + gt);
+  iframeDocument.close();
+  _createDict = iframeDocument.F;
+  while (i--) {
+    delete _createDict[PROTOTYPE][enumBugKeys[i]];
+  }return _createDict();
+};
+
+module.exports = _create2.default || function create(O, Properties) {
+  var result;
+  if (O !== null) {
+    Empty[PROTOTYPE] = anObject(O);
+    result = new Empty();
+    Empty[PROTOTYPE] = null;
+    // add "__proto__" for Object.getPrototypeOf polyfill
+    result[IE_PROTO] = O;
+  } else result = _createDict();
+  return Properties === undefined ? result : dPs(result, Properties);
+};
+
+},{"./_an-object":82,"./_dom-create":91,"./_enum-bug-keys":92,"./_html":100,"./_object-dps":119,"./_shared-key":135,"babel-runtime/core-js/object/create":22}],118:[function(require,module,exports){
+'use strict';
+
+var _defineProperty = require('babel-runtime/core-js/object/define-property');
+
+var _defineProperty2 = _interopRequireDefault(_defineProperty);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var anObject = require('./_an-object'),
+    IE8_DOM_DEFINE = require('./_ie8-dom-define'),
+    toPrimitive = require('./_to-primitive'),
+    dP = _defineProperty2.default;
+
+exports.f = require('./_descriptors') ? _defineProperty2.default : function defineProperty(O, P, Attributes) {
+  anObject(O);
+  P = toPrimitive(P, true);
+  anObject(Attributes);
+  if (IE8_DOM_DEFINE) try {
+    return dP(O, P, Attributes);
+  } catch (e) {/* empty */}
+  if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported!');
+  if ('value' in Attributes) O[P] = Attributes.value;
+  return O;
+};
+
+},{"./_an-object":82,"./_descriptors":90,"./_ie8-dom-define":101,"./_to-primitive":145,"babel-runtime/core-js/object/define-property":24}],119:[function(require,module,exports){
+'use strict';
+
+var _defineProperties = require('babel-runtime/core-js/object/define-properties');
+
+var _defineProperties2 = _interopRequireDefault(_defineProperties);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var dP = require('./_object-dp'),
+    anObject = require('./_an-object'),
+    getKeys = require('./_object-keys');
+
+module.exports = require('./_descriptors') ? _defineProperties2.default : function defineProperties(O, Properties) {
+  anObject(O);
+  var keys = getKeys(Properties),
+      length = keys.length,
+      i = 0,
+      P;
+  while (length > i) {
+    dP.f(O, P = keys[i++], Properties[P]);
+  }return O;
+};
+
+},{"./_an-object":82,"./_descriptors":90,"./_object-dp":118,"./_object-keys":126,"babel-runtime/core-js/object/define-properties":23}],120:[function(require,module,exports){
+'use strict';
+
+var _getOwnPropertyDescriptor = require('babel-runtime/core-js/object/get-own-property-descriptor');
+
+var _getOwnPropertyDescriptor2 = _interopRequireDefault(_getOwnPropertyDescriptor);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var pIE = require('./_object-pie'),
+    createDesc = require('./_property-desc'),
+    toIObject = require('./_to-iobject'),
+    toPrimitive = require('./_to-primitive'),
+    has = require('./_has'),
+    IE8_DOM_DEFINE = require('./_ie8-dom-define'),
+    gOPD = _getOwnPropertyDescriptor2.default;
+
+exports.f = require('./_descriptors') ? gOPD : function getOwnPropertyDescriptor(O, P) {
+  O = toIObject(O);
+  P = toPrimitive(P, true);
+  if (IE8_DOM_DEFINE) try {
+    return gOPD(O, P);
+  } catch (e) {/* empty */}
+  if (has(O, P)) return createDesc(!pIE.f.call(O, P), O[P]);
+};
+
+},{"./_descriptors":90,"./_has":98,"./_ie8-dom-define":101,"./_object-pie":127,"./_property-desc":129,"./_to-iobject":142,"./_to-primitive":145,"babel-runtime/core-js/object/get-own-property-descriptor":25}],121:[function(require,module,exports){
+'use strict';
+
+var _getOwnPropertyNames = require('babel-runtime/core-js/object/get-own-property-names');
+
+var _getOwnPropertyNames2 = _interopRequireDefault(_getOwnPropertyNames);
+
+var _typeof2 = require('babel-runtime/helpers/typeof');
+
+var _typeof3 = _interopRequireDefault(_typeof2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window
+var toIObject = require('./_to-iobject'),
+    gOPN = require('./_object-gopn').f,
+    toString = {}.toString;
+
+var windowNames = (typeof window === 'undefined' ? 'undefined' : (0, _typeof3.default)(window)) == 'object' && window && _getOwnPropertyNames2.default ? (0, _getOwnPropertyNames2.default)(window) : [];
+
+var getWindowNames = function getWindowNames(it) {
+  try {
+    return gOPN(it);
+  } catch (e) {
+    return windowNames.slice();
+  }
+};
+
+module.exports.f = function getOwnPropertyNames(it) {
+  return windowNames && toString.call(it) == '[object Window]' ? getWindowNames(it) : gOPN(toIObject(it));
+};
+
+},{"./_object-gopn":122,"./_to-iobject":142,"babel-runtime/core-js/object/get-own-property-names":26,"babel-runtime/helpers/typeof":39}],122:[function(require,module,exports){
+'use strict';
+
+var _getOwnPropertyNames = require('babel-runtime/core-js/object/get-own-property-names');
+
+var _getOwnPropertyNames2 = _interopRequireDefault(_getOwnPropertyNames);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// 19.1.2.7 / 15.2.3.4 Object.getOwnPropertyNames(O)
+var $keys = require('./_object-keys-internal'),
+    hiddenKeys = require('./_enum-bug-keys').concat('length', 'prototype');
+
+exports.f = _getOwnPropertyNames2.default || function getOwnPropertyNames(O) {
+  return $keys(O, hiddenKeys);
+};
+
+},{"./_enum-bug-keys":92,"./_object-keys-internal":125,"babel-runtime/core-js/object/get-own-property-names":26}],123:[function(require,module,exports){
+"use strict";
+
+var _getOwnPropertySymbols = require("babel-runtime/core-js/object/get-own-property-symbols");
+
+var _getOwnPropertySymbols2 = _interopRequireDefault(_getOwnPropertySymbols);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.f = _getOwnPropertySymbols2.default;
+
+},{"babel-runtime/core-js/object/get-own-property-symbols":27}],124:[function(require,module,exports){
+'use strict';
+
+var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of');
+
+var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O)
+var has = require('./_has'),
+    toObject = require('./_to-object'),
+    IE_PROTO = require('./_shared-key')('IE_PROTO'),
+    ObjectProto = Object.prototype;
+
+module.exports = _getPrototypeOf2.default || function (O) {
+  O = toObject(O);
+  if (has(O, IE_PROTO)) return O[IE_PROTO];
+  if (typeof O.constructor == 'function' && O instanceof O.constructor) {
+    return O.constructor.prototype;
+  }return O instanceof Object ? ObjectProto : null;
+};
+
+},{"./_has":98,"./_shared-key":135,"./_to-object":144,"babel-runtime/core-js/object/get-prototype-of":28}],125:[function(require,module,exports){
+'use strict';
+
+var has = require('./_has'),
+    toIObject = require('./_to-iobject'),
+    arrayIndexOf = require('./_array-includes')(false),
+    IE_PROTO = require('./_shared-key')('IE_PROTO');
+
+module.exports = function (object, names) {
+  var O = toIObject(object),
+      i = 0,
+      result = [],
+      key;
+  for (key in O) {
+    if (key != IE_PROTO) has(O, key) && result.push(key);
+  } // Don't enum bug & hidden keys
+  while (names.length > i) {
+    if (has(O, key = names[i++])) {
+      ~arrayIndexOf(result, key) || result.push(key);
+    }
+  }return result;
+};
+
+},{"./_array-includes":83,"./_has":98,"./_shared-key":135,"./_to-iobject":142}],126:[function(require,module,exports){
+'use strict';
+
+var _keys = require('babel-runtime/core-js/object/keys');
+
+var _keys2 = _interopRequireDefault(_keys);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// 19.1.2.14 / 15.2.3.14 Object.keys(O)
+var $keys = require('./_object-keys-internal'),
+    enumBugKeys = require('./_enum-bug-keys');
+
+module.exports = _keys2.default || function keys(O) {
+  return $keys(O, enumBugKeys);
+};
+
+},{"./_enum-bug-keys":92,"./_object-keys-internal":125,"babel-runtime/core-js/object/keys":30}],127:[function(require,module,exports){
+"use strict";
+
+exports.f = {}.propertyIsEnumerable;
+
+},{}],128:[function(require,module,exports){
+'use strict';
+
+// most Object methods by ES6 should accept primitives
+var $export = require('./_export'),
+    core = require('./_core'),
+    fails = require('./_fails');
+module.exports = function (KEY, exec) {
+  var fn = (core.Object || {})[KEY] || Object[KEY],
+      exp = {};
+  exp[KEY] = exec(fn);
+  $export($export.S + $export.F * fails(function () {
+    fn(1);
+  }), 'Object', exp);
+};
+
+},{"./_core":86,"./_export":94,"./_fails":95}],129:[function(require,module,exports){
+"use strict";
+
+module.exports = function (bitmap, value) {
+  return {
+    enumerable: !(bitmap & 1),
+    configurable: !(bitmap & 2),
+    writable: !(bitmap & 4),
+    value: value
+  };
+};
+
+},{}],130:[function(require,module,exports){
+'use strict';
+
+var hide = require('./_hide');
+module.exports = function (target, src, safe) {
+  for (var key in src) {
+    if (safe && target[key]) target[key] = src[key];else hide(target, key, src[key]);
+  }return target;
+};
+
+},{"./_hide":99}],131:[function(require,module,exports){
+'use strict';
+
+module.exports = require('./_hide');
+
+},{"./_hide":99}],132:[function(require,module,exports){
+'use strict';
+
+var _setPrototypeOf = require('babel-runtime/core-js/object/set-prototype-of');
+
+var _setPrototypeOf2 = _interopRequireDefault(_setPrototypeOf);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// Works with __proto__ only. Old v8 can't work with null proto objects.
+/* eslint-disable no-proto */
+var isObject = require('./_is-object'),
+    anObject = require('./_an-object');
+var check = function check(O, proto) {
+  anObject(O);
+  if (!isObject(proto) && proto !== null) throw TypeError(proto + ": can't set as prototype!");
+};
+module.exports = {
+  set: _setPrototypeOf2.default || ('__proto__' in {} ? // eslint-disable-line
+  function (test, buggy, set) {
+    try {
+      set = require('./_ctx')(Function.call, require('./_object-gopd').f(Object.prototype, '__proto__').set, 2);
+      set(test, []);
+      buggy = !(test instanceof Array);
+    } catch (e) {
+      buggy = true;
+    }
+    return function setPrototypeOf(O, proto) {
+      check(O, proto);
+      if (buggy) O.__proto__ = proto;else set(O, proto);
+      return O;
+    };
+  }({}, false) : undefined),
+  check: check
+};
+
+},{"./_an-object":82,"./_ctx":88,"./_is-object":106,"./_object-gopd":120,"babel-runtime/core-js/object/set-prototype-of":32}],133:[function(require,module,exports){
+'use strict';
+
+var global = require('./_global'),
+    core = require('./_core'),
+    dP = require('./_object-dp'),
+    DESCRIPTORS = require('./_descriptors'),
+    SPECIES = require('./_wks')('species');
+
+module.exports = function (KEY) {
+  var C = typeof core[KEY] == 'function' ? core[KEY] : global[KEY];
+  if (DESCRIPTORS && C && !C[SPECIES]) dP.f(C, SPECIES, {
+    configurable: true,
+    get: function get() {
+      return this;
+    }
+  });
+};
+
+},{"./_core":86,"./_descriptors":90,"./_global":97,"./_object-dp":118,"./_wks":149}],134:[function(require,module,exports){
+'use strict';
+
+var def = require('./_object-dp').f,
+    has = require('./_has'),
+    TAG = require('./_wks')('toStringTag');
+
+module.exports = function (it, tag, stat) {
+  if (it && !has(it = stat ? it : it.prototype, TAG)) def(it, TAG, { configurable: true, value: tag });
+};
+
+},{"./_has":98,"./_object-dp":118,"./_wks":149}],135:[function(require,module,exports){
+'use strict';
+
+var shared = require('./_shared')('keys'),
+    uid = require('./_uid');
+module.exports = function (key) {
+  return shared[key] || (shared[key] = uid(key));
+};
+
+},{"./_shared":136,"./_uid":146}],136:[function(require,module,exports){
+'use strict';
+
+var global = require('./_global'),
+    SHARED = '__core-js_shared__',
+    store = global[SHARED] || (global[SHARED] = {});
+module.exports = function (key) {
+  return store[key] || (store[key] = {});
+};
+
+},{"./_global":97}],137:[function(require,module,exports){
+'use strict';
+
+// 7.3.20 SpeciesConstructor(O, defaultConstructor)
+var anObject = require('./_an-object'),
+    aFunction = require('./_a-function'),
+    SPECIES = require('./_wks')('species');
+module.exports = function (O, D) {
+  var C = anObject(O).constructor,
+      S;
+  return C === undefined || (S = anObject(C)[SPECIES]) == undefined ? D : aFunction(S);
+};
+
+},{"./_a-function":79,"./_an-object":82,"./_wks":149}],138:[function(require,module,exports){
+'use strict';
+
+var toInteger = require('./_to-integer'),
+    defined = require('./_defined');
+// true  -> String#at
+// false -> String#codePointAt
+module.exports = function (TO_STRING) {
+  return function (that, pos) {
+    var s = String(defined(that)),
+        i = toInteger(pos),
+        l = s.length,
+        a,
+        b;
+    if (i < 0 || i >= l) return TO_STRING ? '' : undefined;
+    a = s.charCodeAt(i);
+    return a < 0xd800 || a > 0xdbff || i + 1 === l || (b = s.charCodeAt(i + 1)) < 0xdc00 || b > 0xdfff ? TO_STRING ? s.charAt(i) : a : TO_STRING ? s.slice(i, i + 2) : (a - 0xd800 << 10) + (b - 0xdc00) + 0x10000;
+  };
+};
+
+},{"./_defined":89,"./_to-integer":141}],139:[function(require,module,exports){
+'use strict';
+
+var ctx = require('./_ctx'),
+    invoke = require('./_invoke'),
+    html = require('./_html'),
+    cel = require('./_dom-create'),
+    global = require('./_global'),
+    process = global.process,
+    setTask = global.setImmediate,
+    clearTask = global.clearImmediate,
+    MessageChannel = global.MessageChannel,
+    counter = 0,
+    queue = {},
+    ONREADYSTATECHANGE = 'onreadystatechange',
+    defer,
+    channel,
+    port;
+var run = function run() {
+  var id = +this;
+  if (queue.hasOwnProperty(id)) {
+    var fn = queue[id];
+    delete queue[id];
+    fn();
+  }
+};
+var listener = function listener(event) {
+  run.call(event.data);
+};
+// Node.js 0.9+ & IE10+ has setImmediate, otherwise:
+if (!setTask || !clearTask) {
+  setTask = function setImmediate(fn) {
+    var args = [],
+        i = 1;
+    while (arguments.length > i) {
+      args.push(arguments[i++]);
+    }queue[++counter] = function () {
+      invoke(typeof fn == 'function' ? fn : Function(fn), args);
+    };
+    defer(counter);
+    return counter;
+  };
+  clearTask = function clearImmediate(id) {
+    delete queue[id];
+  };
+  // Node.js 0.8-
+  if (require('./_cof')(process) == 'process') {
+    defer = function defer(id) {
+      process.nextTick(ctx(run, id, 1));
+    };
+    // Browsers with MessageChannel, includes WebWorkers
+  } else if (MessageChannel) {
+    channel = new MessageChannel();
+    port = channel.port2;
+    channel.port1.onmessage = listener;
+    defer = ctx(port.postMessage, port, 1);
+    // Browsers with postMessage, skip WebWorkers
+    // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'
+  } else if (global.addEventListener && typeof postMessage == 'function' && !global.importScripts) {
+    defer = function defer(id) {
+      global.postMessage(id + '', '*');
+    };
+    global.addEventListener('message', listener, false);
+    // IE8-
+  } else if (ONREADYSTATECHANGE in cel('script')) {
+    defer = function defer(id) {
+      html.appendChild(cel('script'))[ONREADYSTATECHANGE] = function () {
+        html.removeChild(this);
+        run.call(id);
+      };
+    };
+    // Rest old browsers
+  } else {
+    defer = function defer(id) {
+      setTimeout(ctx(run, id, 1), 0);
+    };
+  }
+}
+module.exports = {
+  set: setTask,
+  clear: clearTask
+};
+
+},{"./_cof":85,"./_ctx":88,"./_dom-create":91,"./_global":97,"./_html":100,"./_invoke":102}],140:[function(require,module,exports){
+'use strict';
+
+var toInteger = require('./_to-integer'),
+    max = Math.max,
+    min = Math.min;
+module.exports = function (index, length) {
+  index = toInteger(index);
+  return index < 0 ? max(index + length, 0) : min(index, length);
+};
+
+},{"./_to-integer":141}],141:[function(require,module,exports){
+"use strict";
+
+// 7.1.4 ToInteger
+var ceil = Math.ceil,
+    floor = Math.floor;
+module.exports = function (it) {
+  return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);
+};
+
+},{}],142:[function(require,module,exports){
+'use strict';
+
+// to indexed object, toObject with fallback for non-array-like ES3 strings
+var IObject = require('./_iobject'),
+    defined = require('./_defined');
+module.exports = function (it) {
+  return IObject(defined(it));
+};
+
+},{"./_defined":89,"./_iobject":103}],143:[function(require,module,exports){
+'use strict';
+
+// 7.1.15 ToLength
+var toInteger = require('./_to-integer'),
+    min = Math.min;
+module.exports = function (it) {
+  return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991
+};
+
+},{"./_to-integer":141}],144:[function(require,module,exports){
+'use strict';
+
+// 7.1.13 ToObject(argument)
+var defined = require('./_defined');
+module.exports = function (it) {
+  return Object(defined(it));
+};
+
+},{"./_defined":89}],145:[function(require,module,exports){
+'use strict';
+
+// 7.1.1 ToPrimitive(input [, PreferredType])
+var isObject = require('./_is-object');
+// instead of the ES6 spec version, we didn't implement @@toPrimitive case
+// and the second argument - flag - preferred type is a string
+module.exports = function (it, S) {
+  if (!isObject(it)) return it;
+  var fn, val;
+  if (S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val;
+  if (typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it))) return val;
+  if (!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val;
+  throw TypeError("Can't convert object to primitive value");
+};
+
+},{"./_is-object":106}],146:[function(require,module,exports){
+'use strict';
+
+var id = 0,
+    px = Math.random();
+module.exports = function (key) {
+  return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));
+};
+
+},{}],147:[function(require,module,exports){
+'use strict';
+
+var global = require('./_global'),
+    core = require('./_core'),
+    LIBRARY = require('./_library'),
+    wksExt = require('./_wks-ext'),
+    defineProperty = require('./_object-dp').f;
+module.exports = function (name) {
+  var $Symbol = core.Symbol || (core.Symbol = LIBRARY ? {} : global.Symbol || {});
+  if (name.charAt(0) != '_' && !(name in $Symbol)) defineProperty($Symbol, name, { value: wksExt.f(name) });
+};
+
+},{"./_core":86,"./_global":97,"./_library":114,"./_object-dp":118,"./_wks-ext":148}],148:[function(require,module,exports){
+'use strict';
+
+exports.f = require('./_wks');
+
+},{"./_wks":149}],149:[function(require,module,exports){
+'use strict';
+
+var store = require('./_shared')('wks'),
+    uid = require('./_uid'),
+    _Symbol = require('./_global').Symbol,
+    USE_SYMBOL = typeof _Symbol == 'function';
+
+var $exports = module.exports = function (name) {
+  return store[name] || (store[name] = USE_SYMBOL && _Symbol[name] || (USE_SYMBOL ? _Symbol : uid)('Symbol.' + name));
+};
+
+$exports.store = store;
+
+},{"./_global":97,"./_shared":136,"./_uid":146}],150:[function(require,module,exports){
+'use strict';
+
+var classof = require('./_classof'),
+    ITERATOR = require('./_wks')('iterator'),
+    Iterators = require('./_iterators');
+module.exports = require('./_core').getIteratorMethod = function (it) {
+  if (it != undefined) return it[ITERATOR] || it['@@iterator'] || Iterators[classof(it)];
+};
+
+},{"./_classof":84,"./_core":86,"./_iterators":112,"./_wks":149}],151:[function(require,module,exports){
+'use strict';
+
+var anObject = require('./_an-object'),
+    get = require('./core.get-iterator-method');
+module.exports = require('./_core').getIterator = function (it) {
+  var iterFn = get(it);
+  if (typeof iterFn != 'function') throw TypeError(it + ' is not iterable!');
+  return anObject(iterFn.call(it));
+};
+
+},{"./_an-object":82,"./_core":86,"./core.get-iterator-method":150}],152:[function(require,module,exports){
+'use strict';
+
+var _from = require('babel-runtime/core-js/array/from');
+
+var _from2 = _interopRequireDefault(_from);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var ctx = require('./_ctx'),
+    $export = require('./_export'),
+    toObject = require('./_to-object'),
+    call = require('./_iter-call'),
+    isArrayIter = require('./_is-array-iter'),
+    toLength = require('./_to-length'),
+    createProperty = require('./_create-property'),
+    getIterFn = require('./core.get-iterator-method');
+
+$export($export.S + $export.F * !require('./_iter-detect')(function (iter) {
+  (0, _from2.default)(iter);
+}), 'Array', {
+  // 22.1.2.1 Array.from(arrayLike, mapfn = undefined, thisArg = undefined)
+  from: function from(arrayLike /*, mapfn = undefined, thisArg = undefined*/) {
+    var O = toObject(arrayLike),
+        C = typeof this == 'function' ? this : Array,
+        aLen = arguments.length,
+        mapfn = aLen > 1 ? arguments[1] : undefined,
+        mapping = mapfn !== undefined,
+        index = 0,
+        iterFn = getIterFn(O),
+        length,
+        result,
+        step,
+        iterator;
+    if (mapping) mapfn = ctx(mapfn, aLen > 2 ? arguments[2] : undefined, 2);
+    // if object isn't iterable or it's array with default iterator - use simple case
+    if (iterFn != undefined && !(C == Array && isArrayIter(iterFn))) {
+      for (iterator = iterFn.call(O), result = new C(); !(step = iterator.next()).done; index++) {
+        createProperty(result, index, mapping ? call(iterator, mapfn, [step.value, index], true) : step.value);
+      }
+    } else {
+      length = toLength(O.length);
+      for (result = new C(length); length > index; index++) {
+        createProperty(result, index, mapping ? mapfn(O[index], index) : O[index]);
+      }
+    }
+    result.length = index;
+    return result;
+  }
+});
+
+},{"./_create-property":87,"./_ctx":88,"./_export":94,"./_is-array-iter":104,"./_iter-call":107,"./_iter-detect":110,"./_to-length":143,"./_to-object":144,"./core.get-iterator-method":150,"babel-runtime/core-js/array/from":15}],153:[function(require,module,exports){
+'use strict';
+
+var addToUnscopables = require('./_add-to-unscopables'),
+    step = require('./_iter-step'),
+    Iterators = require('./_iterators'),
+    toIObject = require('./_to-iobject');
+
+// 22.1.3.4 Array.prototype.entries()
+// 22.1.3.13 Array.prototype.keys()
+// 22.1.3.29 Array.prototype.values()
+// 22.1.3.30 Array.prototype[@@iterator]()
+module.exports = require('./_iter-define')(Array, 'Array', function (iterated, kind) {
+  this._t = toIObject(iterated); // target
+  this._i = 0; // next index
+  this._k = kind; // kind
+  // 22.1.5.2.1 %ArrayIteratorPrototype%.next()
+}, function () {
+  var O = this._t,
+      kind = this._k,
+      index = this._i++;
+  if (!O || index >= O.length) {
+    this._t = undefined;
+    return step(1);
+  }
+  if (kind == 'keys') return step(0, index);
+  if (kind == 'values') return step(0, O[index]);
+  return step(0, [index, O[index]]);
+}, 'values');
+
+// argumentsList[@@iterator] is %ArrayProto_values% (9.4.4.6, 9.4.4.7)
+Iterators.Arguments = Iterators.Array;
+
+addToUnscopables('keys');
+addToUnscopables('values');
+addToUnscopables('entries');
+
+},{"./_add-to-unscopables":80,"./_iter-define":109,"./_iter-step":111,"./_iterators":112,"./_to-iobject":142}],154:[function(require,module,exports){
+'use strict';
+
+// 20.1.2.2 Number.isFinite(number)
+var $export = require('./_export'),
+    _isFinite = require('./_global').isFinite;
+
+$export($export.S, 'Number', {
+  isFinite: function isFinite(it) {
+    return typeof it == 'number' && _isFinite(it);
+  }
+});
+
+},{"./_export":94,"./_global":97}],155:[function(require,module,exports){
+'use strict';
+
+// 20.1.2.4 Number.isNaN(number)
+var $export = require('./_export');
+
+$export($export.S, 'Number', {
+  isNaN: function isNaN(number) {
+    return number != number;
+  }
+});
+
+},{"./_export":94}],156:[function(require,module,exports){
+'use strict';
+
+// 20.1.2.6 Number.MAX_SAFE_INTEGER
+var $export = require('./_export');
+
+$export($export.S, 'Number', { MAX_SAFE_INTEGER: 0x1fffffffffffff });
+
+},{"./_export":94}],157:[function(require,module,exports){
+'use strict';
+
+var $export = require('./_export');
+// 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])
+$export($export.S, 'Object', { create: require('./_object-create') });
+
+},{"./_export":94,"./_object-create":117}],158:[function(require,module,exports){
+'use strict';
+
+var $export = require('./_export');
+// 19.1.2.3 / 15.2.3.7 Object.defineProperties(O, Properties)
+$export($export.S + $export.F * !require('./_descriptors'), 'Object', { defineProperties: require('./_object-dps') });
+
+},{"./_descriptors":90,"./_export":94,"./_object-dps":119}],159:[function(require,module,exports){
+'use strict';
+
+var $export = require('./_export');
+// 19.1.2.4 / 15.2.3.6 Object.defineProperty(O, P, Attributes)
+$export($export.S + $export.F * !require('./_descriptors'), 'Object', { defineProperty: require('./_object-dp').f });
+
+},{"./_descriptors":90,"./_export":94,"./_object-dp":118}],160:[function(require,module,exports){
+'use strict';
+
+// 19.1.2.6 Object.getOwnPropertyDescriptor(O, P)
+var toIObject = require('./_to-iobject'),
+    $getOwnPropertyDescriptor = require('./_object-gopd').f;
+
+require('./_object-sap')('getOwnPropertyDescriptor', function () {
+  return function getOwnPropertyDescriptor(it, key) {
+    return $getOwnPropertyDescriptor(toIObject(it), key);
+  };
+});
+
+},{"./_object-gopd":120,"./_object-sap":128,"./_to-iobject":142}],161:[function(require,module,exports){
+'use strict';
+
+// 19.1.2.7 Object.getOwnPropertyNames(O)
+require('./_object-sap')('getOwnPropertyNames', function () {
+  return require('./_object-gopn-ext').f;
+});
+
+},{"./_object-gopn-ext":121,"./_object-sap":128}],162:[function(require,module,exports){
+'use strict';
+
+// 19.1.2.9 Object.getPrototypeOf(O)
+var toObject = require('./_to-object'),
+    $getPrototypeOf = require('./_object-gpo');
+
+require('./_object-sap')('getPrototypeOf', function () {
+  return function getPrototypeOf(it) {
+    return $getPrototypeOf(toObject(it));
+  };
+});
+
+},{"./_object-gpo":124,"./_object-sap":128,"./_to-object":144}],163:[function(require,module,exports){
+'use strict';
+
+// 19.1.2.11 Object.isExtensible(O)
+var isObject = require('./_is-object');
+
+require('./_object-sap')('isExtensible', function ($isExtensible) {
+  return function isExtensible(it) {
+    return isObject(it) ? $isExtensible ? $isExtensible(it) : true : false;
+  };
+});
+
+},{"./_is-object":106,"./_object-sap":128}],164:[function(require,module,exports){
+'use strict';
+
+// 19.1.2.14 Object.keys(O)
+var toObject = require('./_to-object'),
+    $keys = require('./_object-keys');
+
+require('./_object-sap')('keys', function () {
+  return function keys(it) {
+    return $keys(toObject(it));
+  };
+});
+
+},{"./_object-keys":126,"./_object-sap":128,"./_to-object":144}],165:[function(require,module,exports){
+'use strict';
+
+// 19.1.2.15 Object.preventExtensions(O)
+var isObject = require('./_is-object'),
+    meta = require('./_meta').onFreeze;
+
+require('./_object-sap')('preventExtensions', function ($preventExtensions) {
+  return function preventExtensions(it) {
+    return $preventExtensions && isObject(it) ? $preventExtensions(meta(it)) : it;
+  };
+});
+
+},{"./_is-object":106,"./_meta":115,"./_object-sap":128}],166:[function(require,module,exports){
+'use strict';
+
+// 19.1.3.19 Object.setPrototypeOf(O, proto)
+var $export = require('./_export');
+$export($export.S, 'Object', { setPrototypeOf: require('./_set-proto').set });
+
+},{"./_export":94,"./_set-proto":132}],167:[function(require,module,exports){
+"use strict";
+
+},{}],168:[function(require,module,exports){
+'use strict';
+
+var LIBRARY = require('./_library'),
+    global = require('./_global'),
+    ctx = require('./_ctx'),
+    classof = require('./_classof'),
+    $export = require('./_export'),
+    isObject = require('./_is-object'),
+    aFunction = require('./_a-function'),
+    anInstance = require('./_an-instance'),
+    forOf = require('./_for-of'),
+    speciesConstructor = require('./_species-constructor'),
+    task = require('./_task').set,
+    microtask = require('./_microtask')(),
+    PROMISE = 'Promise',
+    TypeError = global.TypeError,
+    process = global.process,
+    $Promise = global[PROMISE],
+    process = global.process,
+    isNode = classof(process) == 'process',
+    empty = function empty() {/* empty */},
+    Internal,
+    GenericPromiseCapability,
+    Wrapper;
+
+var USE_NATIVE = !!function () {
+  try {
+    // correct subclassing with @@species support
+    var promise = $Promise.resolve(1),
+        FakePromise = (promise.constructor = {})[require('./_wks')('species')] = function (exec) {
+      exec(empty, empty);
+    };
+    // unhandled rejections tracking support, NodeJS Promise without it fails @@species test
+    return (isNode || typeof PromiseRejectionEvent == 'function') && promise.then(empty) instanceof FakePromise;
+  } catch (e) {/* empty */}
+}();
+
+// helpers
+var sameConstructor = function sameConstructor(a, b) {
+  // with library wrapper special case
+  return a === b || a === $Promise && b === Wrapper;
+};
+var isThenable = function isThenable(it) {
+  var then;
+  return isObject(it) && typeof (then = it.then) == 'function' ? then : false;
+};
+var newPromiseCapability = function newPromiseCapability(C) {
+  return sameConstructor($Promise, C) ? new PromiseCapability(C) : new GenericPromiseCapability(C);
+};
+var PromiseCapability = GenericPromiseCapability = function GenericPromiseCapability(C) {
+  var resolve, reject;
+  this.promise = new C(function ($$resolve, $$reject) {
+    if (resolve !== undefined || reject !== undefined) throw TypeError('Bad Promise constructor');
+    resolve = $$resolve;
+    reject = $$reject;
+  });
+  this.resolve = aFunction(resolve);
+  this.reject = aFunction(reject);
+};
+var perform = function perform(exec) {
+  try {
+    exec();
+  } catch (e) {
+    return { error: e };
+  }
+};
+var notify = function notify(promise, isReject) {
+  if (promise._n) return;
+  promise._n = true;
+  var chain = promise._c;
+  microtask(function () {
+    var value = promise._v,
+        ok = promise._s == 1,
+        i = 0;
+    var run = function run(reaction) {
+      var handler = ok ? reaction.ok : reaction.fail,
+          resolve = reaction.resolve,
+          reject = reaction.reject,
+          domain = reaction.domain,
+          result,
+          then;
+      try {
+        if (handler) {
+          if (!ok) {
+            if (promise._h == 2) onHandleUnhandled(promise);
+            promise._h = 1;
+          }
+          if (handler === true) result = value;else {
+            if (domain) domain.enter();
+            result = handler(value);
+            if (domain) domain.exit();
+          }
+          if (result === reaction.promise) {
+            reject(TypeError('Promise-chain cycle'));
+          } else if (then = isThenable(result)) {
+            then.call(result, resolve, reject);
+          } else resolve(result);
+        } else reject(value);
+      } catch (e) {
+        reject(e);
+      }
+    };
+    while (chain.length > i) {
+      run(chain[i++]);
+    } // variable length - can't use forEach
+    promise._c = [];
+    promise._n = false;
+    if (isReject && !promise._h) onUnhandled(promise);
+  });
+};
+var onUnhandled = function onUnhandled(promise) {
+  task.call(global, function () {
+    var value = promise._v,
+        abrupt,
+        handler,
+        console;
+    if (isUnhandled(promise)) {
+      abrupt = perform(function () {
+        if (isNode) {
+          process.emit('unhandledRejection', value, promise);
+        } else if (handler = global.onunhandledrejection) {
+          handler({ promise: promise, reason: value });
+        } else if ((console = global.console) && console.error) {
+          console.error('Unhandled promise rejection', value);
+        }
+      });
+      // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should
+      promise._h = isNode || isUnhandled(promise) ? 2 : 1;
+    }promise._a = undefined;
+    if (abrupt) throw abrupt.error;
+  });
+};
+var isUnhandled = function isUnhandled(promise) {
+  if (promise._h == 1) return false;
+  var chain = promise._a || promise._c,
+      i = 0,
+      reaction;
+  while (chain.length > i) {
+    reaction = chain[i++];
+    if (reaction.fail || !isUnhandled(reaction.promise)) return false;
+  }return true;
+};
+var onHandleUnhandled = function onHandleUnhandled(promise) {
+  task.call(global, function () {
+    var handler;
+    if (isNode) {
+      process.emit('rejectionHandled', promise);
+    } else if (handler = global.onrejectionhandled) {
+      handler({ promise: promise, reason: promise._v });
+    }
+  });
+};
+var $reject = function $reject(value) {
+  var promise = this;
+  if (promise._d) return;
+  promise._d = true;
+  promise = promise._w || promise; // unwrap
+  promise._v = value;
+  promise._s = 2;
+  if (!promise._a) promise._a = promise._c.slice();
+  notify(promise, true);
+};
+var $resolve = function $resolve(value) {
+  var promise = this,
+      then;
+  if (promise._d) return;
+  promise._d = true;
+  promise = promise._w || promise; // unwrap
+  try {
+    if (promise === value) throw TypeError("Promise can't be resolved itself");
+    if (then = isThenable(value)) {
+      microtask(function () {
+        var wrapper = { _w: promise, _d: false }; // wrap
+        try {
+          then.call(value, ctx($resolve, wrapper, 1), ctx($reject, wrapper, 1));
+        } catch (e) {
+          $reject.call(wrapper, e);
+        }
+      });
+    } else {
+      promise._v = value;
+      promise._s = 1;
+      notify(promise, false);
+    }
+  } catch (e) {
+    $reject.call({ _w: promise, _d: false }, e); // wrap
+  }
+};
+
+// constructor polyfill
+if (!USE_NATIVE) {
+  // 25.4.3.1 Promise(executor)
+  $Promise = function Promise(executor) {
+    anInstance(this, $Promise, PROMISE, '_h');
+    aFunction(executor);
+    Internal.call(this);
+    try {
+      executor(ctx($resolve, this, 1), ctx($reject, this, 1));
+    } catch (err) {
+      $reject.call(this, err);
+    }
+  };
+  Internal = function Promise(executor) {
+    this._c = []; // <- awaiting reactions
+    this._a = undefined; // <- checked in isUnhandled reactions
+    this._s = 0; // <- state
+    this._d = false; // <- done
+    this._v = undefined; // <- value
+    this._h = 0; // <- rejection state, 0 - default, 1 - handled, 2 - unhandled
+    this._n = false; // <- notify
+  };
+  Internal.prototype = require('./_redefine-all')($Promise.prototype, {
+    // 25.4.5.3 Promise.prototype.then(onFulfilled, onRejected)
+    then: function then(onFulfilled, onRejected) {
+      var reaction = newPromiseCapability(speciesConstructor(this, $Promise));
+      reaction.ok = typeof onFulfilled == 'function' ? onFulfilled : true;
+      reaction.fail = typeof onRejected == 'function' && onRejected;
+      reaction.domain = isNode ? process.domain : undefined;
+      this._c.push(reaction);
+      if (this._a) this._a.push(reaction);
+      if (this._s) notify(this, false);
+      return reaction.promise;
+    },
+    // 25.4.5.1 Promise.prototype.catch(onRejected)
+    'catch': function _catch(onRejected) {
+      return this.then(undefined, onRejected);
+    }
+  });
+  PromiseCapability = function PromiseCapability() {
+    var promise = new Internal();
+    this.promise = promise;
+    this.resolve = ctx($resolve, promise, 1);
+    this.reject = ctx($reject, promise, 1);
+  };
+}
+
+$export($export.G + $export.W + $export.F * !USE_NATIVE, { Promise: $Promise });
+require('./_set-to-string-tag')($Promise, PROMISE);
+require('./_set-species')(PROMISE);
+Wrapper = require('./_core')[PROMISE];
+
+// statics
+$export($export.S + $export.F * !USE_NATIVE, PROMISE, {
+  // 25.4.4.5 Promise.reject(r)
+  reject: function reject(r) {
+    var capability = newPromiseCapability(this),
+        $$reject = capability.reject;
+    $$reject(r);
+    return capability.promise;
+  }
+});
+$export($export.S + $export.F * (LIBRARY || !USE_NATIVE), PROMISE, {
+  // 25.4.4.6 Promise.resolve(x)
+  resolve: function resolve(x) {
+    // instanceof instead of internal slot check because we should fix it without replacement native Promise core
+    if (x instanceof $Promise && sameConstructor(x.constructor, this)) return x;
+    var capability = newPromiseCapability(this),
+        $$resolve = capability.resolve;
+    $$resolve(x);
+    return capability.promise;
+  }
+});
+$export($export.S + $export.F * !(USE_NATIVE && require('./_iter-detect')(function (iter) {
+  $Promise.all(iter)['catch'](empty);
+})), PROMISE, {
+  // 25.4.4.1 Promise.all(iterable)
+  all: function all(iterable) {
+    var C = this,
+        capability = newPromiseCapability(C),
+        resolve = capability.resolve,
+        reject = capability.reject;
+    var abrupt = perform(function () {
+      var values = [],
+          index = 0,
+          remaining = 1;
+      forOf(iterable, false, function (promise) {
+        var $index = index++,
+            alreadyCalled = false;
+        values.push(undefined);
+        remaining++;
+        C.resolve(promise).then(function (value) {
+          if (alreadyCalled) return;
+          alreadyCalled = true;
+          values[$index] = value;
+          --remaining || resolve(values);
+        }, reject);
+      });
+      --remaining || resolve(values);
+    });
+    if (abrupt) reject(abrupt.error);
+    return capability.promise;
+  },
+  // 25.4.4.4 Promise.race(iterable)
+  race: function race(iterable) {
+    var C = this,
+        capability = newPromiseCapability(C),
+        reject = capability.reject;
+    var abrupt = perform(function () {
+      forOf(iterable, false, function (promise) {
+        C.resolve(promise).then(capability.resolve, reject);
+      });
+    });
+    if (abrupt) reject(abrupt.error);
+    return capability.promise;
+  }
+});
+
+},{"./_a-function":79,"./_an-instance":81,"./_classof":84,"./_core":86,"./_ctx":88,"./_export":94,"./_for-of":96,"./_global":97,"./_is-object":106,"./_iter-detect":110,"./_library":114,"./_microtask":116,"./_redefine-all":130,"./_set-species":133,"./_set-to-string-tag":134,"./_species-constructor":137,"./_task":139,"./_wks":149}],169:[function(require,module,exports){
+'use strict';
+
+var _fromCodePoint = require('babel-runtime/core-js/string/from-code-point');
+
+var _fromCodePoint2 = _interopRequireDefault(_fromCodePoint);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var $export = require('./_export'),
+    toIndex = require('./_to-index'),
+    fromCharCode = String.fromCharCode,
+    $fromCodePoint = _fromCodePoint2.default;
+
+// length should be 1, old FF problem
+$export($export.S + $export.F * (!!$fromCodePoint && $fromCodePoint.length != 1), 'String', {
+  // 21.1.2.2 String.fromCodePoint(...codePoints)
+  fromCodePoint: function fromCodePoint(x) {
+    // eslint-disable-line no-unused-vars
+    var res = [],
+        aLen = arguments.length,
+        i = 0,
+        code;
+    while (aLen > i) {
+      code = +arguments[i++];
+      if (toIndex(code, 0x10ffff) !== code) throw RangeError(code + ' is not a valid code point');
+      res.push(code < 0x10000 ? fromCharCode(code) : fromCharCode(((code -= 0x10000) >> 10) + 0xd800, code % 0x400 + 0xdc00));
+    }return res.join('');
+  }
+});
+
+},{"./_export":94,"./_to-index":140,"babel-runtime/core-js/string/from-code-point":35}],170:[function(require,module,exports){
+'use strict';
+
+var $at = require('./_string-at')(true);
+
+// 21.1.3.27 String.prototype[@@iterator]()
+require('./_iter-define')(String, 'String', function (iterated) {
+  this._t = String(iterated); // target
+  this._i = 0; // next index
+  // 21.1.5.2.1 %StringIteratorPrototype%.next()
+}, function () {
+  var O = this._t,
+      index = this._i,
+      point;
+  if (index >= O.length) return { value: undefined, done: true };
+  point = $at(O, index);
+  this._i += point.length;
+  return { value: point, done: false };
+});
+
+},{"./_iter-define":109,"./_string-at":138}],171:[function(require,module,exports){
+'use strict';
+// ECMAScript 6 symbols shim
+
+var _typeof2 = require('babel-runtime/helpers/typeof');
+
+var _typeof3 = _interopRequireDefault(_typeof2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var global = require('./_global'),
+    has = require('./_has'),
+    DESCRIPTORS = require('./_descriptors'),
+    $export = require('./_export'),
+    redefine = require('./_redefine'),
+    META = require('./_meta').KEY,
+    $fails = require('./_fails'),
+    shared = require('./_shared'),
+    setToStringTag = require('./_set-to-string-tag'),
+    uid = require('./_uid'),
+    wks = require('./_wks'),
+    wksExt = require('./_wks-ext'),
+    wksDefine = require('./_wks-define'),
+    keyOf = require('./_keyof'),
+    enumKeys = require('./_enum-keys'),
+    isArray = require('./_is-array'),
+    anObject = require('./_an-object'),
+    toIObject = require('./_to-iobject'),
+    toPrimitive = require('./_to-primitive'),
+    createDesc = require('./_property-desc'),
+    _create = require('./_object-create'),
+    gOPNExt = require('./_object-gopn-ext'),
+    $GOPD = require('./_object-gopd'),
+    $DP = require('./_object-dp'),
+    $keys = require('./_object-keys'),
+    gOPD = $GOPD.f,
+    dP = $DP.f,
+    gOPN = gOPNExt.f,
+    $Symbol = global.Symbol,
+    $JSON = global.JSON,
+    _stringify = $JSON && $JSON.stringify,
+    PROTOTYPE = 'prototype',
+    HIDDEN = wks('_hidden'),
+    TO_PRIMITIVE = wks('toPrimitive'),
+    isEnum = {}.propertyIsEnumerable,
+    SymbolRegistry = shared('symbol-registry'),
+    AllSymbols = shared('symbols'),
+    OPSymbols = shared('op-symbols'),
+    ObjectProto = Object[PROTOTYPE],
+    USE_NATIVE = typeof $Symbol == 'function',
+    QObject = global.QObject;
+// Don't use setters in Qt Script, https://github.com/zloirock/core-js/issues/173
+var setter = !QObject || !QObject[PROTOTYPE] || !QObject[PROTOTYPE].findChild;
+
+// fallback for old Android, https://code.google.com/p/v8/issues/detail?id=687
+var setSymbolDesc = DESCRIPTORS && $fails(function () {
+  return _create(dP({}, 'a', {
+    get: function get() {
+      return dP(this, 'a', { value: 7 }).a;
+    }
+  })).a != 7;
+}) ? function (it, key, D) {
+  var protoDesc = gOPD(ObjectProto, key);
+  if (protoDesc) delete ObjectProto[key];
+  dP(it, key, D);
+  if (protoDesc && it !== ObjectProto) dP(ObjectProto, key, protoDesc);
+} : dP;
+
+var wrap = function wrap(tag) {
+  var sym = AllSymbols[tag] = _create($Symbol[PROTOTYPE]);
+  sym._k = tag;
+  return sym;
+};
+
+var isSymbol = USE_NATIVE && (0, _typeof3.default)($Symbol.iterator) == 'symbol' ? function (it) {
+  return (typeof it === 'undefined' ? 'undefined' : (0, _typeof3.default)(it)) == 'symbol';
+} : function (it) {
+  return it instanceof $Symbol;
+};
+
+var $defineProperty = function defineProperty(it, key, D) {
+  if (it === ObjectProto) $defineProperty(OPSymbols, key, D);
+  anObject(it);
+  key = toPrimitive(key, true);
+  anObject(D);
+  if (has(AllSymbols, key)) {
+    if (!D.enumerable) {
+      if (!has(it, HIDDEN)) dP(it, HIDDEN, createDesc(1, {}));
+      it[HIDDEN][key] = true;
+    } else {
+      if (has(it, HIDDEN) && it[HIDDEN][key]) it[HIDDEN][key] = false;
+      D = _create(D, { enumerable: createDesc(0, false) });
+    }return setSymbolDesc(it, key, D);
+  }return dP(it, key, D);
+};
+var $defineProperties = function defineProperties(it, P) {
+  anObject(it);
+  var keys = enumKeys(P = toIObject(P)),
+      i = 0,
+      l = keys.length,
+      key;
+  while (l > i) {
+    $defineProperty(it, key = keys[i++], P[key]);
+  }return it;
+};
+var $create = function create(it, P) {
+  return P === undefined ? _create(it) : $defineProperties(_create(it), P);
+};
+var $propertyIsEnumerable = function propertyIsEnumerable(key) {
+  var E = isEnum.call(this, key = toPrimitive(key, true));
+  if (this === ObjectProto && has(AllSymbols, key) && !has(OPSymbols, key)) return false;
+  return E || !has(this, key) || !has(AllSymbols, key) || has(this, HIDDEN) && this[HIDDEN][key] ? E : true;
+};
+var $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(it, key) {
+  it = toIObject(it);
+  key = toPrimitive(key, true);
+  if (it === ObjectProto && has(AllSymbols, key) && !has(OPSymbols, key)) return;
+  var D = gOPD(it, key);
+  if (D && has(AllSymbols, key) && !(has(it, HIDDEN) && it[HIDDEN][key])) D.enumerable = true;
+  return D;
+};
+var $getOwnPropertyNames = function getOwnPropertyNames(it) {
+  var names = gOPN(toIObject(it)),
+      result = [],
+      i = 0,
+      key;
+  while (names.length > i) {
+    if (!has(AllSymbols, key = names[i++]) && key != HIDDEN && key != META) result.push(key);
+  }return result;
+};
+var $getOwnPropertySymbols = function getOwnPropertySymbols(it) {
+  var IS_OP = it === ObjectProto,
+      names = gOPN(IS_OP ? OPSymbols : toIObject(it)),
+      result = [],
+      i = 0,
+      key;
+  while (names.length > i) {
+    if (has(AllSymbols, key = names[i++]) && (IS_OP ? has(ObjectProto, key) : true)) result.push(AllSymbols[key]);
+  }return result;
+};
+
+// 19.4.1.1 Symbol([description])
+if (!USE_NATIVE) {
+  $Symbol = function _Symbol() {
+    if (this instanceof $Symbol) throw TypeError('Symbol is not a constructor!');
+    var tag = uid(arguments.length > 0 ? arguments[0] : undefined);
+    var $set = function $set(value) {
+      if (this === ObjectProto) $set.call(OPSymbols, value);
+      if (has(this, HIDDEN) && has(this[HIDDEN], tag)) this[HIDDEN][tag] = false;
+      setSymbolDesc(this, tag, createDesc(1, value));
+    };
+    if (DESCRIPTORS && setter) setSymbolDesc(ObjectProto, tag, { configurable: true, set: $set });
+    return wrap(tag);
+  };
+  redefine($Symbol[PROTOTYPE], 'toString', function toString() {
+    return this._k;
+  });
+
+  $GOPD.f = $getOwnPropertyDescriptor;
+  $DP.f = $defineProperty;
+  require('./_object-gopn').f = gOPNExt.f = $getOwnPropertyNames;
+  require('./_object-pie').f = $propertyIsEnumerable;
+  require('./_object-gops').f = $getOwnPropertySymbols;
+
+  if (DESCRIPTORS && !require('./_library')) {
+    redefine(ObjectProto, 'propertyIsEnumerable', $propertyIsEnumerable, true);
+  }
+
+  wksExt.f = function (name) {
+    return wrap(wks(name));
+  };
+}
+
+$export($export.G + $export.W + $export.F * !USE_NATIVE, { Symbol: $Symbol });
+
+for (var symbols =
+// 19.4.2.2, 19.4.2.3, 19.4.2.4, 19.4.2.6, 19.4.2.8, 19.4.2.9, 19.4.2.10, 19.4.2.11, 19.4.2.12, 19.4.2.13, 19.4.2.14
+'hasInstance,isConcatSpreadable,iterator,match,replace,search,species,split,toPrimitive,toStringTag,unscopables'.split(','), i = 0; symbols.length > i;) {
+  wks(symbols[i++]);
+}for (var symbols = $keys(wks.store), i = 0; symbols.length > i;) {
+  wksDefine(symbols[i++]);
+}$export($export.S + $export.F * !USE_NATIVE, 'Symbol', {
+  // 19.4.2.1 Symbol.for(key)
+  'for': function _for(key) {
+    return has(SymbolRegistry, key += '') ? SymbolRegistry[key] : SymbolRegistry[key] = $Symbol(key);
+  },
+  // 19.4.2.5 Symbol.keyFor(sym)
+  keyFor: function keyFor(key) {
+    if (isSymbol(key)) return keyOf(SymbolRegistry, key);
+    throw TypeError(key + ' is not a symbol!');
+  },
+  useSetter: function useSetter() {
+    setter = true;
+  },
+  useSimple: function useSimple() {
+    setter = false;
+  }
+});
+
+$export($export.S + $export.F * !USE_NATIVE, 'Object', {
+  // 19.1.2.2 Object.create(O [, Properties])
+  create: $create,
+  // 19.1.2.4 Object.defineProperty(O, P, Attributes)
+  defineProperty: $defineProperty,
+  // 19.1.2.3 Object.defineProperties(O, Properties)
+  defineProperties: $defineProperties,
+  // 19.1.2.6 Object.getOwnPropertyDescriptor(O, P)
+  getOwnPropertyDescriptor: $getOwnPropertyDescriptor,
+  // 19.1.2.7 Object.getOwnPropertyNames(O)
+  getOwnPropertyNames: $getOwnPropertyNames,
+  // 19.1.2.8 Object.getOwnPropertySymbols(O)
+  getOwnPropertySymbols: $getOwnPropertySymbols
+});
+
+// 24.3.2 JSON.stringify(value [, replacer [, space]])
+$JSON && $export($export.S + $export.F * (!USE_NATIVE || $fails(function () {
+  var S = $Symbol();
+  // MS Edge converts symbol values to JSON as {}
+  // WebKit converts symbol values to JSON as null
+  // V8 throws on boxed symbols
+  return _stringify([S]) != '[null]' || _stringify({ a: S }) != '{}' || _stringify(Object(S)) != '{}';
+})), 'JSON', {
+  stringify: function stringify(it) {
+    if (it === undefined || isSymbol(it)) return; // IE8 returns string on undefined
+    var args = [it],
+        i = 1,
+        replacer,
+        $replacer;
+    while (arguments.length > i) {
+      args.push(arguments[i++]);
+    }replacer = args[1];
+    if (typeof replacer == 'function') $replacer = replacer;
+    if ($replacer || !isArray(replacer)) replacer = function replacer(key, value) {
+      if ($replacer) value = $replacer.call(this, key, value);
+      if (!isSymbol(value)) return value;
+    };
+    args[1] = replacer;
+    return _stringify.apply($JSON, args);
+  }
+});
+
+// 19.4.3.4 Symbol.prototype[@@toPrimitive](hint)
+$Symbol[PROTOTYPE][TO_PRIMITIVE] || require('./_hide')($Symbol[PROTOTYPE], TO_PRIMITIVE, $Symbol[PROTOTYPE].valueOf);
+// 19.4.3.5 Symbol.prototype[@@toStringTag]
+setToStringTag($Symbol, 'Symbol');
+// 20.2.1.9 Math[@@toStringTag]
+setToStringTag(Math, 'Math', true);
+// 24.3.3 JSON[@@toStringTag]
+setToStringTag(global.JSON, 'JSON', true);
+
+},{"./_an-object":82,"./_descriptors":90,"./_enum-keys":93,"./_export":94,"./_fails":95,"./_global":97,"./_has":98,"./_hide":99,"./_is-array":105,"./_keyof":113,"./_library":114,"./_meta":115,"./_object-create":117,"./_object-dp":118,"./_object-gopd":120,"./_object-gopn":122,"./_object-gopn-ext":121,"./_object-gops":123,"./_object-keys":126,"./_object-pie":127,"./_property-desc":129,"./_redefine":131,"./_set-to-string-tag":134,"./_shared":136,"./_to-iobject":142,"./_to-primitive":145,"./_uid":146,"./_wks":149,"./_wks-define":147,"./_wks-ext":148,"babel-runtime/helpers/typeof":39}],172:[function(require,module,exports){
+'use strict';
+
+require('./_wks-define')('asyncIterator');
+
+},{"./_wks-define":147}],173:[function(require,module,exports){
+'use strict';
+
+require('./_wks-define')('observable');
+
+},{"./_wks-define":147}],174:[function(require,module,exports){
+'use strict';
+
+require('./es6.array.iterator');
+var global = require('./_global'),
+    hide = require('./_hide'),
+    Iterators = require('./_iterators'),
+    TO_STRING_TAG = require('./_wks')('toStringTag');
+
+for (var collections = ['NodeList', 'DOMTokenList', 'MediaList', 'StyleSheetList', 'CSSRuleList'], i = 0; i < 5; i++) {
+  var NAME = collections[i],
+      Collection = global[NAME],
+      proto = Collection && Collection.prototype;
+  if (proto && !proto[TO_STRING_TAG]) hide(proto, TO_STRING_TAG, NAME);
+  Iterators[NAME] = Iterators.Array;
+}
+
+},{"./_global":97,"./_hide":99,"./_iterators":112,"./_wks":149,"./es6.array.iterator":153}],175:[function(require,module,exports){
+'use strict';
+
+var $export = require('./_export'),
+    $task = require('./_task');
+$export($export.G + $export.B, {
+  setImmediate: $task.set,
+  clearImmediate: $task.clear
+});
+
+},{"./_export":94,"./_task":139}],176:[function(require,module,exports){
+(function (Buffer){
+'use strict';
+
+var _typeof2 = require('babel-runtime/helpers/typeof');
+
+var _typeof3 = _interopRequireDefault(_typeof2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// NOTE: These type checking functions intentionally don't use `instanceof`
+// because it is fragile and can be easily faked with `Object.create()`.
+
+function isArray(arg) {
+  if (Array.isArray) {
+    return Array.isArray(arg);
+  }
+  return objectToString(arg) === '[object Array]';
+}
+exports.isArray = isArray;
+
+function isBoolean(arg) {
+  return typeof arg === 'boolean';
+}
+exports.isBoolean = isBoolean;
+
+function isNull(arg) {
+  return arg === null;
+}
+exports.isNull = isNull;
+
+function isNullOrUndefined(arg) {
+  return arg == null;
+}
+exports.isNullOrUndefined = isNullOrUndefined;
+
+function isNumber(arg) {
+  return typeof arg === 'number';
+}
+exports.isNumber = isNumber;
+
+function isString(arg) {
+  return typeof arg === 'string';
+}
+exports.isString = isString;
+
+function isSymbol(arg) {
+  return (typeof arg === 'undefined' ? 'undefined' : (0, _typeof3.default)(arg)) === 'symbol';
+}
+exports.isSymbol = isSymbol;
+
+function isUndefined(arg) {
+  return arg === void 0;
+}
+exports.isUndefined = isUndefined;
+
+function isRegExp(re) {
+  return objectToString(re) === '[object RegExp]';
+}
+exports.isRegExp = isRegExp;
+
+function isObject(arg) {
+  return (typeof arg === 'undefined' ? 'undefined' : (0, _typeof3.default)(arg)) === 'object' && arg !== null;
+}
+exports.isObject = isObject;
+
+function isDate(d) {
+  return objectToString(d) === '[object Date]';
+}
+exports.isDate = isDate;
+
+function isError(e) {
+  return objectToString(e) === '[object Error]' || e instanceof Error;
+}
+exports.isError = isError;
+
+function isFunction(arg) {
+  return typeof arg === 'function';
+}
+exports.isFunction = isFunction;
+
+function isPrimitive(arg) {
+  return arg === null || typeof arg === 'boolean' || typeof arg === 'number' || typeof arg === 'string' || (typeof arg === 'undefined' ? 'undefined' : (0, _typeof3.default)(arg)) === 'symbol' || // ES6 symbol
+  typeof arg === 'undefined';
+}
+exports.isPrimitive = isPrimitive;
+
+exports.isBuffer = Buffer.isBuffer;
+
+function objectToString(o) {
+  return Object.prototype.toString.call(o);
+}
+
+}).call(this,{"isBuffer":require("../../is-buffer/index.js")})
+},{"../../is-buffer/index.js":199,"babel-runtime/helpers/typeof":39}],177:[function(require,module,exports){
+'use strict';
+
+var Buffer = require('buffer').Buffer;
+var intSize = 4;
+var zeroBuffer = new Buffer(intSize);zeroBuffer.fill(0);
+var chrsz = 8;
+
+function toArray(buf, bigEndian) {
+  if (buf.length % intSize !== 0) {
+    var len = buf.length + (intSize - buf.length % intSize);
+    buf = Buffer.concat([buf, zeroBuffer], len);
+  }
+
+  var arr = [];
+  var fn = bigEndian ? buf.readInt32BE : buf.readInt32LE;
+  for (var i = 0; i < buf.length; i += intSize) {
+    arr.push(fn.call(buf, i));
+  }
+  return arr;
+}
+
+function toBuffer(arr, size, bigEndian) {
+  var buf = new Buffer(size);
+  var fn = bigEndian ? buf.writeInt32BE : buf.writeInt32LE;
+  for (var i = 0; i < arr.length; i++) {
+    fn.call(buf, arr[i], i * 4, true);
+  }
+  return buf;
+}
+
+function hash(buf, fn, hashSize, bigEndian) {
+  if (!Buffer.isBuffer(buf)) buf = new Buffer(buf);
+  var arr = fn(toArray(buf, bigEndian), buf.length * chrsz);
+  return toBuffer(arr, hashSize, bigEndian);
+}
+
+module.exports = { hash: hash };
+
+},{"buffer":45}],178:[function(require,module,exports){
+'use strict';
+
+var Buffer = require('buffer').Buffer;
+var sha = require('./sha');
+var sha256 = require('./sha256');
+var rng = require('./rng');
+var md5 = require('./md5');
+
+var algorithms = {
+  sha1: sha,
+  sha256: sha256,
+  md5: md5
+};
+
+var blocksize = 64;
+var zeroBuffer = new Buffer(blocksize);zeroBuffer.fill(0);
+function hmac(fn, key, data) {
+  if (!Buffer.isBuffer(key)) key = new Buffer(key);
+  if (!Buffer.isBuffer(data)) data = new Buffer(data);
+
+  if (key.length > blocksize) {
+    key = fn(key);
+  } else if (key.length < blocksize) {
+    key = Buffer.concat([key, zeroBuffer], blocksize);
+  }
+
+  var ipad = new Buffer(blocksize),
+      opad = new Buffer(blocksize);
+  for (var i = 0; i < blocksize; i++) {
+    ipad[i] = key[i] ^ 0x36;
+    opad[i] = key[i] ^ 0x5C;
+  }
+
+  var hash = fn(Buffer.concat([ipad, data]));
+  return fn(Buffer.concat([opad, hash]));
+}
+
+function hash(alg, key) {
+  alg = alg || 'sha1';
+  var fn = algorithms[alg];
+  var bufs = [];
+  var length = 0;
+  if (!fn) error('algorithm:', alg, 'is not yet supported');
+  return {
+    update: function update(data) {
+      if (!Buffer.isBuffer(data)) data = new Buffer(data);
+
+      bufs.push(data);
+      length += data.length;
+      return this;
+    },
+    digest: function digest(enc) {
+      var buf = Buffer.concat(bufs);
+      var r = key ? hmac(fn, key, buf) : fn(buf);
+      bufs = null;
+      return enc ? r.toString(enc) : r;
+    }
+  };
+}
+
+function error() {
+  var m = [].slice.call(arguments).join(' ');
+  throw new Error([m, 'we accept pull requests', 'http://github.com/dominictarr/crypto-browserify'].join('\n'));
+}
+
+exports.createHash = function (alg) {
+  return hash(alg);
+};
+exports.createHmac = function (alg, key) {
+  return hash(alg, key);
+};
+exports.randomBytes = function (size, callback) {
+  if (callback && callback.call) {
+    try {
+      callback.call(this, undefined, new Buffer(rng(size)));
+    } catch (err) {
+      callback(err);
+    }
+  } else {
+    return new Buffer(rng(size));
+  }
+};
+
+function each(a, f) {
+  for (var i in a) {
+    f(a[i], i);
+  }
+}
+
+// the least I can do is make error messages for the rest of the node.js/crypto api.
+each(['createCredentials', 'createCipher', 'createCipheriv', 'createDecipher', 'createDecipheriv', 'createSign', 'createVerify', 'createDiffieHellman', 'pbkdf2'], function (name) {
+  exports[name] = function () {
+    error('sorry,', name, 'is not implemented yet');
+  };
+});
+
+},{"./md5":179,"./rng":180,"./sha":181,"./sha256":182,"buffer":45}],179:[function(require,module,exports){
+"use strict";
+
+/*
+ * A JavaScript implementation of the RSA Data Security, Inc. MD5 Message
+ * Digest Algorithm, as defined in RFC 1321.
+ * Version 2.1 Copyright (C) Paul Johnston 1999 - 2002.
+ * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
+ * Distributed under the BSD License
+ * See http://pajhome.org.uk/crypt/md5 for more info.
+ */
+
+var helpers = require('./helpers');
+
+/*
+ * Perform a simple self-test to see if the VM is working
+ */
+function md5_vm_test() {
+  return hex_md5("abc") == "900150983cd24fb0d6963f7d28e17f72";
+}
+
+/*
+ * Calculate the MD5 of an array of little-endian words, and a bit length
+ */
+function core_md5(x, len) {
+  /* append padding */
+  x[len >> 5] |= 0x80 << len % 32;
+  x[(len + 64 >>> 9 << 4) + 14] = len;
+
+  var a = 1732584193;
+  var b = -271733879;
+  var c = -1732584194;
+  var d = 271733878;
+
+  for (var i = 0; i < x.length; i += 16) {
+    var olda = a;
+    var oldb = b;
+    var oldc = c;
+    var oldd = d;
+
+    a = md5_ff(a, b, c, d, x[i + 0], 7, -680876936);
+    d = md5_ff(d, a, b, c, x[i + 1], 12, -389564586);
+    c = md5_ff(c, d, a, b, x[i + 2], 17, 606105819);
+    b = md5_ff(b, c, d, a, x[i + 3], 22, -1044525330);
+    a = md5_ff(a, b, c, d, x[i + 4], 7, -176418897);
+    d = md5_ff(d, a, b, c, x[i + 5], 12, 1200080426);
+    c = md5_ff(c, d, a, b, x[i + 6], 17, -1473231341);
+    b = md5_ff(b, c, d, a, x[i + 7], 22, -45705983);
+    a = md5_ff(a, b, c, d, x[i + 8], 7, 1770035416);
+    d = md5_ff(d, a, b, c, x[i + 9], 12, -1958414417);
+    c = md5_ff(c, d, a, b, x[i + 10], 17, -42063);
+    b = md5_ff(b, c, d, a, x[i + 11], 22, -1990404162);
+    a = md5_ff(a, b, c, d, x[i + 12], 7, 1804603682);
+    d = md5_ff(d, a, b, c, x[i + 13], 12, -40341101);
+    c = md5_ff(c, d, a, b, x[i + 14], 17, -1502002290);
+    b = md5_ff(b, c, d, a, x[i + 15], 22, 1236535329);
+
+    a = md5_gg(a, b, c, d, x[i + 1], 5, -165796510);
+    d = md5_gg(d, a, b, c, x[i + 6], 9, -1069501632);
+    c = md5_gg(c, d, a, b, x[i + 11], 14, 643717713);
+    b = md5_gg(b, c, d, a, x[i + 0], 20, -373897302);
+    a = md5_gg(a, b, c, d, x[i + 5], 5, -701558691);
+    d = md5_gg(d, a, b, c, x[i + 10], 9, 38016083);
+    c = md5_gg(c, d, a, b, x[i + 15], 14, -660478335);
+    b = md5_gg(b, c, d, a, x[i + 4], 20, -405537848);
+    a = md5_gg(a, b, c, d, x[i + 9], 5, 568446438);
+    d = md5_gg(d, a, b, c, x[i + 14], 9, -1019803690);
+    c = md5_gg(c, d, a, b, x[i + 3], 14, -187363961);
+    b = md5_gg(b, c, d, a, x[i + 8], 20, 1163531501);
+    a = md5_gg(a, b, c, d, x[i + 13], 5, -1444681467);
+    d = md5_gg(d, a, b, c, x[i + 2], 9, -51403784);
+    c = md5_gg(c, d, a, b, x[i + 7], 14, 1735328473);
+    b = md5_gg(b, c, d, a, x[i + 12], 20, -1926607734);
+
+    a = md5_hh(a, b, c, d, x[i + 5], 4, -378558);
+    d = md5_hh(d, a, b, c, x[i + 8], 11, -2022574463);
+    c = md5_hh(c, d, a, b, x[i + 11], 16, 1839030562);
+    b = md5_hh(b, c, d, a, x[i + 14], 23, -35309556);
+    a = md5_hh(a, b, c, d, x[i + 1], 4, -1530992060);
+    d = md5_hh(d, a, b, c, x[i + 4], 11, 1272893353);
+    c = md5_hh(c, d, a, b, x[i + 7], 16, -155497632);
+    b = md5_hh(b, c, d, a, x[i + 10], 23, -1094730640);
+    a = md5_hh(a, b, c, d, x[i + 13], 4, 681279174);
+    d = md5_hh(d, a, b, c, x[i + 0], 11, -358537222);
+    c = md5_hh(c, d, a, b, x[i + 3], 16, -722521979);
+    b = md5_hh(b, c, d, a, x[i + 6], 23, 76029189);
+    a = md5_hh(a, b, c, d, x[i + 9], 4, -640364487);
+    d = md5_hh(d, a, b, c, x[i + 12], 11, -421815835);
+    c = md5_hh(c, d, a, b, x[i + 15], 16, 530742520);
+    b = md5_hh(b, c, d, a, x[i + 2], 23, -995338651);
+
+    a = md5_ii(a, b, c, d, x[i + 0], 6, -198630844);
+    d = md5_ii(d, a, b, c, x[i + 7], 10, 1126891415);
+    c = md5_ii(c, d, a, b, x[i + 14], 15, -1416354905);
+    b = md5_ii(b, c, d, a, x[i + 5], 21, -57434055);
+    a = md5_ii(a, b, c, d, x[i + 12], 6, 1700485571);
+    d = md5_ii(d, a, b, c, x[i + 3], 10, -1894986606);
+    c = md5_ii(c, d, a, b, x[i + 10], 15, -1051523);
+    b = md5_ii(b, c, d, a, x[i + 1], 21, -2054922799);
+    a = md5_ii(a, b, c, d, x[i + 8], 6, 1873313359);
+    d = md5_ii(d, a, b, c, x[i + 15], 10, -30611744);
+    c = md5_ii(c, d, a, b, x[i + 6], 15, -1560198380);
+    b = md5_ii(b, c, d, a, x[i + 13], 21, 1309151649);
+    a = md5_ii(a, b, c, d, x[i + 4], 6, -145523070);
+    d = md5_ii(d, a, b, c, x[i + 11], 10, -1120210379);
+    c = md5_ii(c, d, a, b, x[i + 2], 15, 718787259);
+    b = md5_ii(b, c, d, a, x[i + 9], 21, -343485551);
+
+    a = safe_add(a, olda);
+    b = safe_add(b, oldb);
+    c = safe_add(c, oldc);
+    d = safe_add(d, oldd);
+  }
+  return Array(a, b, c, d);
+}
+
+/*
+ * These functions implement the four basic operations the algorithm uses.
+ */
+function md5_cmn(q, a, b, x, s, t) {
+  return safe_add(bit_rol(safe_add(safe_add(a, q), safe_add(x, t)), s), b);
+}
+function md5_ff(a, b, c, d, x, s, t) {
+  return md5_cmn(b & c | ~b & d, a, b, x, s, t);
+}
+function md5_gg(a, b, c, d, x, s, t) {
+  return md5_cmn(b & d | c & ~d, a, b, x, s, t);
+}
+function md5_hh(a, b, c, d, x, s, t) {
+  return md5_cmn(b ^ c ^ d, a, b, x, s, t);
+}
+function md5_ii(a, b, c, d, x, s, t) {
+  return md5_cmn(c ^ (b | ~d), a, b, x, s, t);
+}
+
+/*
+ * Add integers, wrapping at 2^32. This uses 16-bit operations internally
+ * to work around bugs in some JS interpreters.
+ */
+function safe_add(x, y) {
+  var lsw = (x & 0xFFFF) + (y & 0xFFFF);
+  var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
+  return msw << 16 | lsw & 0xFFFF;
+}
+
+/*
+ * Bitwise rotate a 32-bit number to the left.
+ */
+function bit_rol(num, cnt) {
+  return num << cnt | num >>> 32 - cnt;
+}
+
+module.exports = function md5(buf) {
+  return helpers.hash(buf, core_md5, 16);
+};
+
+},{"./helpers":177}],180:[function(require,module,exports){
+"use strict";
+
+// Original code adapted from Robert Kieffer.
+// details at https://github.com/broofa/node-uuid
+(function () {
+  var _global = this;
+
+  var mathRNG, whatwgRNG;
+
+  // NOTE: Math.random() does not guarantee "cryptographic quality"
+  mathRNG = function mathRNG(size) {
+    var bytes = new Array(size);
+    var r;
+
+    for (var i = 0, r; i < size; i++) {
+      if ((i & 0x03) == 0) r = Math.random() * 0x100000000;
+      bytes[i] = r >>> ((i & 0x03) << 3) & 0xff;
+    }
+
+    return bytes;
+  };
+
+  if (_global.crypto && crypto.getRandomValues) {
+    whatwgRNG = function whatwgRNG(size) {
+      var bytes = new Uint8Array(size);
+      crypto.getRandomValues(bytes);
+      return bytes;
+    };
+  }
+
+  module.exports = whatwgRNG || mathRNG;
+})();
+
+},{}],181:[function(require,module,exports){
+'use strict';
+
+/*
+ * A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined
+ * in FIPS PUB 180-1
+ * Version 2.1a Copyright Paul Johnston 2000 - 2002.
+ * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
+ * Distributed under the BSD License
+ * See http://pajhome.org.uk/crypt/md5 for details.
+ */
+
+var helpers = require('./helpers');
+
+/*
+ * Calculate the SHA-1 of an array of big-endian words, and a bit length
+ */
+function core_sha1(x, len) {
+  /* append padding */
+  x[len >> 5] |= 0x80 << 24 - len % 32;
+  x[(len + 64 >> 9 << 4) + 15] = len;
+
+  var w = Array(80);
+  var a = 1732584193;
+  var b = -271733879;
+  var c = -1732584194;
+  var d = 271733878;
+  var e = -1009589776;
+
+  for (var i = 0; i < x.length; i += 16) {
+    var olda = a;
+    var oldb = b;
+    var oldc = c;
+    var oldd = d;
+    var olde = e;
+
+    for (var j = 0; j < 80; j++) {
+      if (j < 16) w[j] = x[i + j];else w[j] = rol(w[j - 3] ^ w[j - 8] ^ w[j - 14] ^ w[j - 16], 1);
+      var t = safe_add(safe_add(rol(a, 5), sha1_ft(j, b, c, d)), safe_add(safe_add(e, w[j]), sha1_kt(j)));
+      e = d;
+      d = c;
+      c = rol(b, 30);
+      b = a;
+      a = t;
+    }
+
+    a = safe_add(a, olda);
+    b = safe_add(b, oldb);
+    c = safe_add(c, oldc);
+    d = safe_add(d, oldd);
+    e = safe_add(e, olde);
+  }
+  return Array(a, b, c, d, e);
+}
+
+/*
+ * Perform the appropriate triplet combination function for the current
+ * iteration
+ */
+function sha1_ft(t, b, c, d) {
+  if (t < 20) return b & c | ~b & d;
+  if (t < 40) return b ^ c ^ d;
+  if (t < 60) return b & c | b & d | c & d;
+  return b ^ c ^ d;
+}
+
+/*
+ * Determine the appropriate additive constant for the current iteration
+ */
+function sha1_kt(t) {
+  return t < 20 ? 1518500249 : t < 40 ? 1859775393 : t < 60 ? -1894007588 : -899497514;
+}
+
+/*
+ * Add integers, wrapping at 2^32. This uses 16-bit operations internally
+ * to work around bugs in some JS interpreters.
+ */
+function safe_add(x, y) {
+  var lsw = (x & 0xFFFF) + (y & 0xFFFF);
+  var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
+  return msw << 16 | lsw & 0xFFFF;
+}
+
+/*
+ * Bitwise rotate a 32-bit number to the left.
+ */
+function rol(num, cnt) {
+  return num << cnt | num >>> 32 - cnt;
+}
+
+module.exports = function sha1(buf) {
+  return helpers.hash(buf, core_sha1, 20, true);
+};
+
+},{"./helpers":177}],182:[function(require,module,exports){
+'use strict';
+
+/**
+ * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined
+ * in FIPS 180-2
+ * Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.
+ * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
+ *
+ */
+
+var helpers = require('./helpers');
+
+var safe_add = function safe_add(x, y) {
+  var lsw = (x & 0xFFFF) + (y & 0xFFFF);
+  var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
+  return msw << 16 | lsw & 0xFFFF;
+};
+
+var S = function S(X, n) {
+  return X >>> n | X << 32 - n;
+};
+
+var R = function R(X, n) {
+  return X >>> n;
+};
+
+var Ch = function Ch(x, y, z) {
+  return x & y ^ ~x & z;
+};
+
+var Maj = function Maj(x, y, z) {
+  return x & y ^ x & z ^ y & z;
+};
+
+var Sigma0256 = function Sigma0256(x) {
+  return S(x, 2) ^ S(x, 13) ^ S(x, 22);
+};
+
+var Sigma1256 = function Sigma1256(x) {
+  return S(x, 6) ^ S(x, 11) ^ S(x, 25);
+};
+
+var Gamma0256 = function Gamma0256(x) {
+  return S(x, 7) ^ S(x, 18) ^ R(x, 3);
+};
+
+var Gamma1256 = function Gamma1256(x) {
+  return S(x, 17) ^ S(x, 19) ^ R(x, 10);
+};
+
+var core_sha256 = function core_sha256(m, l) {
+  var K = new Array(0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5, 0x3956C25B, 0x59F111F1, 0x923F82A4, 0xAB1C5ED5, 0xD807AA98, 0x12835B01, 0x243185BE, 0x550C7DC3, 0x72BE5D74, 0x80DEB1FE, 0x9BDC06A7, 0xC19BF174, 0xE49B69C1, 0xEFBE4786, 0xFC19DC6, 0x240CA1CC, 0x2DE92C6F, 0x4A7484AA, 0x5CB0A9DC, 0x76F988DA, 0x983E5152, 0xA831C66D, 0xB00327C8, 0xBF597FC7, 0xC6E00BF3, 0xD5A79147, 0x6CA6351, 0x14292967, 0x27B70A85, 0x2E1B2138, 0x4D2C6DFC, 0x53380D13, 0x650A7354, 0x766A0ABB, 0x81C2C92E, 0x92722C85, 0xA2BFE8A1, 0xA81A664B, 0xC24B8B70, 0xC76C51A3, 0xD192E819, 0xD6990624, 0xF40E3585, 0x106AA070, 0x19A4C116, 0x1E376C08, 0x2748774C, 0x34B0BCB5, 0x391C0CB3, 0x4ED8AA4A, 0x5B9CCA4F, 0x682E6FF3, 0x748F82EE, 0x78A5636F, 0x84C87814, 0x8CC70208, 0x90BEFFFA, 0xA4506CEB, 0xBEF9A3F7, 0xC67178F2);
+  var HASH = new Array(0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A, 0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19);
+  var W = new Array(64);
+  var a, b, c, d, e, f, g, h, i, j;
+  var T1, T2;
+  /* append padding */
+  m[l >> 5] |= 0x80 << 24 - l % 32;
+  m[(l + 64 >> 9 << 4) + 15] = l;
+  for (var i = 0; i < m.length; i += 16) {
+    a = HASH[0];b = HASH[1];c = HASH[2];d = HASH[3];e = HASH[4];f = HASH[5];g = HASH[6];h = HASH[7];
+    for (var j = 0; j < 64; j++) {
+      if (j < 16) {
+        W[j] = m[j + i];
+      } else {
+        W[j] = safe_add(safe_add(safe_add(Gamma1256(W[j - 2]), W[j - 7]), Gamma0256(W[j - 15])), W[j - 16]);
+      }
+      T1 = safe_add(safe_add(safe_add(safe_add(h, Sigma1256(e)), Ch(e, f, g)), K[j]), W[j]);
+      T2 = safe_add(Sigma0256(a), Maj(a, b, c));
+      h = g;g = f;f = e;e = safe_add(d, T1);d = c;c = b;b = a;a = safe_add(T1, T2);
+    }
+    HASH[0] = safe_add(a, HASH[0]);HASH[1] = safe_add(b, HASH[1]);HASH[2] = safe_add(c, HASH[2]);HASH[3] = safe_add(d, HASH[3]);
+    HASH[4] = safe_add(e, HASH[4]);HASH[5] = safe_add(f, HASH[5]);HASH[6] = safe_add(g, HASH[6]);HASH[7] = safe_add(h, HASH[7]);
+  }
+  return HASH;
+};
+
+module.exports = function sha256(buf) {
+  return helpers.hash(buf, core_sha256, 32, true);
+};
+
+},{"./helpers":177}],183:[function(require,module,exports){
+'use strict';
+
+var _typeof2 = require('babel-runtime/helpers/typeof');
+
+var _typeof3 = _interopRequireDefault(_typeof2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/*
+ * Date Format 1.2.3
+ * (c) 2007-2009 Steven Levithan <stevenlevithan.com>
+ * MIT license
+ *
+ * Includes enhancements by Scott Trenda <scott.trenda.net>
+ * and Kris Kowal <cixar.com/~kris.kowal/>
+ *
+ * Accepts a date, a mask, or a date and a mask.
+ * Returns a formatted version of the given date.
+ * The date defaults to the current date/time.
+ * The mask defaults to dateFormat.masks.default.
+ */
+
+(function (global) {
+  'use strict';
+
+  var dateFormat = function () {
+    var token = /d{1,4}|m{1,4}|yy(?:yy)?|([HhMsTt])\1?|[LloSZWN]|'[^']*'|'[^']*'/g;
+    var timezone = /\b(?:[PMCEA][SDP]T|(?:Pacific|Mountain|Central|Eastern|Atlantic) (?:Standard|Daylight|Prevailing) Time|(?:GMT|UTC)(?:[-+]\d{4})?)\b/g;
+    var timezoneClip = /[^-+\dA-Z]/g;
+
+    // Regexes and supporting functions are cached through closure
+    return function (date, mask, utc, gmt) {
+
+      // You can't provide utc if you skip other args (use the 'UTC:' mask prefix)
+      if (arguments.length === 1 && kindOf(date) === 'string' && !/\d/.test(date)) {
+        mask = date;
+        date = undefined;
+      }
+
+      date = date || new Date();
+
+      if (!(date instanceof Date)) {
+        date = new Date(date);
+      }
+
+      if (isNaN(date)) {
+        throw TypeError('Invalid date');
+      }
+
+      mask = String(dateFormat.masks[mask] || mask || dateFormat.masks['default']);
+
+      // Allow setting the utc/gmt argument via the mask
+      var maskSlice = mask.slice(0, 4);
+      if (maskSlice === 'UTC:' || maskSlice === 'GMT:') {
+        mask = mask.slice(4);
+        utc = true;
+        if (maskSlice === 'GMT:') {
+          gmt = true;
+        }
+      }
+
+      var _ = utc ? 'getUTC' : 'get';
+      var d = date[_ + 'Date']();
+      var D = date[_ + 'Day']();
+      var m = date[_ + 'Month']();
+      var y = date[_ + 'FullYear']();
+      var H = date[_ + 'Hours']();
+      var M = date[_ + 'Minutes']();
+      var s = date[_ + 'Seconds']();
+      var L = date[_ + 'Milliseconds']();
+      var o = utc ? 0 : date.getTimezoneOffset();
+      var W = getWeek(date);
+      var N = getDayOfWeek(date);
+      var flags = {
+        d: d,
+        dd: pad(d),
+        ddd: dateFormat.i18n.dayNames[D],
+        dddd: dateFormat.i18n.dayNames[D + 7],
+        m: m + 1,
+        mm: pad(m + 1),
+        mmm: dateFormat.i18n.monthNames[m],
+        mmmm: dateFormat.i18n.monthNames[m + 12],
+        yy: String(y).slice(2),
+        yyyy: y,
+        h: H % 12 || 12,
+        hh: pad(H % 12 || 12),
+        H: H,
+        HH: pad(H),
+        M: M,
+        MM: pad(M),
+        s: s,
+        ss: pad(s),
+        l: pad(L, 3),
+        L: pad(Math.round(L / 10)),
+        t: H < 12 ? 'a' : 'p',
+        tt: H < 12 ? 'am' : 'pm',
+        T: H < 12 ? 'A' : 'P',
+        TT: H < 12 ? 'AM' : 'PM',
+        Z: gmt ? 'GMT' : utc ? 'UTC' : (String(date).match(timezone) || ['']).pop().replace(timezoneClip, ''),
+        o: (o > 0 ? '-' : '+') + pad(Math.floor(Math.abs(o) / 60) * 100 + Math.abs(o) % 60, 4),
+        S: ['th', 'st', 'nd', 'rd'][d % 10 > 3 ? 0 : (d % 100 - d % 10 != 10) * d % 10],
+        W: W,
+        N: N
+      };
+
+      return mask.replace(token, function (match) {
+        if (match in flags) {
+          return flags[match];
+        }
+        return match.slice(1, match.length - 1);
+      });
+    };
+  }();
+
+  dateFormat.masks = {
+    'default': 'ddd mmm dd yyyy HH:MM:ss',
+    'shortDate': 'm/d/yy',
+    'mediumDate': 'mmm d, yyyy',
+    'longDate': 'mmmm d, yyyy',
+    'fullDate': 'dddd, mmmm d, yyyy',
+    'shortTime': 'h:MM TT',
+    'mediumTime': 'h:MM:ss TT',
+    'longTime': 'h:MM:ss TT Z',
+    'isoDate': 'yyyy-mm-dd',
+    'isoTime': 'HH:MM:ss',
+    'isoDateTime': 'yyyy-mm-dd\'T\'HH:MM:sso',
+    'isoUtcDateTime': 'UTC:yyyy-mm-dd\'T\'HH:MM:ss\'Z\'',
+    'expiresHeaderFormat': 'ddd, dd mmm yyyy HH:MM:ss Z'
+  };
+
+  // Internationalization strings
+  dateFormat.i18n = {
+    dayNames: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'],
+    monthNames: ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec', 'January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December']
+  };
+
+  function pad(val, len) {
+    val = String(val);
+    len = len || 2;
+    while (val.length < len) {
+      val = '0' + val;
+    }
+    return val;
+  }
+
+  /**
+   * Get the ISO 8601 week number
+   * Based on comments from
+   * http://techblog.procurios.nl/k/n618/news/view/33796/14863/Calculate-ISO-8601-week-and-year-in-javascript.html
+   *
+   * @param  {Object} `date`
+   * @return {Number}
+   */
+  function getWeek(date) {
+    // Remove time components of date
+    var targetThursday = new Date(date.getFullYear(), date.getMonth(), date.getDate());
+
+    // Change date to Thursday same week
+    targetThursday.setDate(targetThursday.getDate() - (targetThursday.getDay() + 6) % 7 + 3);
+
+    // Take January 4th as it is always in week 1 (see ISO 8601)
+    var firstThursday = new Date(targetThursday.getFullYear(), 0, 4);
+
+    // Change date to Thursday same week
+    firstThursday.setDate(firstThursday.getDate() - (firstThursday.getDay() + 6) % 7 + 3);
+
+    // Check if daylight-saving-time-switch occured and correct for it
+    var ds = targetThursday.getTimezoneOffset() - firstThursday.getTimezoneOffset();
+    targetThursday.setHours(targetThursday.getHours() - ds);
+
+    // Number of weeks between target Thursday and first Thursday
+    var weekDiff = (targetThursday - firstThursday) / (86400000 * 7);
+    return 1 + Math.floor(weekDiff);
+  }
+
+  /**
+   * Get ISO-8601 numeric representation of the day of the week
+   * 1 (for Monday) through 7 (for Sunday)
+   * 
+   * @param  {Object} `date`
+   * @return {Number}
+   */
+  function getDayOfWeek(date) {
+    var dow = date.getDay();
+    if (dow === 0) {
+      dow = 7;
+    }
+    return dow;
+  }
+
+  /**
+   * kind-of shortcut
+   * @param  {*} val
+   * @return {String}
+   */
+  function kindOf(val) {
+    if (val === null) {
+      return 'null';
+    }
+
+    if (val === undefined) {
+      return 'undefined';
+    }
+
+    if ((typeof val === 'undefined' ? 'undefined' : (0, _typeof3.default)(val)) !== 'object') {
+      return typeof val === 'undefined' ? 'undefined' : (0, _typeof3.default)(val);
+    }
+
+    if (Array.isArray(val)) {
+      return 'array';
+    }
+
+    return {}.toString.call(val).slice(8, -1).toLowerCase();
+  };
+
+  if (typeof define === 'function' && define.amd) {
+    define(function () {
+      return dateFormat;
+    });
+  } else if ((typeof exports === 'undefined' ? 'undefined' : (0, _typeof3.default)(exports)) === 'object') {
+    module.exports = dateFormat;
+  } else {
+    global.dateFormat = dateFormat;
+  }
+})(undefined);
+
+},{"babel-runtime/helpers/typeof":39}],184:[function(require,module,exports){
+'use strict';
+
+var _typeof2 = require('babel-runtime/helpers/typeof');
+
+var _typeof3 = _interopRequireDefault(_typeof2);
+
+var _stringify = require('babel-runtime/core-js/json/stringify');
+
+var _stringify2 = _interopRequireDefault(_stringify);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * This is the web browser implementation of `debug()`.
+ *
+ * Expose `debug()` as the module.
+ */
+
+exports = module.exports = require('./debug');
+exports.log = log;
+exports.formatArgs = formatArgs;
+exports.save = save;
+exports.load = load;
+exports.useColors = useColors;
+exports.storage = 'undefined' != typeof chrome && 'undefined' != typeof chrome.storage ? chrome.storage.local : localstorage();
+
+/**
+ * Colors.
+ */
+
+exports.colors = ['lightseagreen', 'forestgreen', 'goldenrod', 'dodgerblue', 'darkorchid', 'crimson'];
+
+/**
+ * Currently only WebKit-based Web Inspectors, Firefox >= v31,
+ * and the Firebug extension (any Firefox version) are known
+ * to support "%c" CSS customizations.
+ *
+ * TODO: add a `localStorage` variable to explicitly enable/disable colors
+ */
+
+function useColors() {
+  // is webkit? http://stackoverflow.com/a/16459606/376773
+  return 'WebkitAppearance' in document.documentElement.style ||
+  // is firebug? http://stackoverflow.com/a/398120/376773
+  window.console && (console.firebug || console.exception && console.table) ||
+  // is firefox >= v31?
+  // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
+  navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31;
+}
+
+/**
+ * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
+ */
+
+exports.formatters.j = function (v) {
+  return (0, _stringify2.default)(v);
+};
+
+/**
+ * Colorize log arguments if enabled.
+ *
+ * @api public
+ */
+
+function formatArgs() {
+  var args = arguments;
+  var useColors = this.useColors;
+
+  args[0] = (useColors ? '%c' : '') + this.namespace + (useColors ? ' %c' : ' ') + args[0] + (useColors ? '%c ' : ' ') + '+' + exports.humanize(this.diff);
+
+  if (!useColors) return args;
+
+  var c = 'color: ' + this.color;
+  args = [args[0], c, 'color: inherit'].concat(Array.prototype.slice.call(args, 1));
+
+  // the final "%c" is somewhat tricky, because there could be other
+  // arguments passed either before or after the %c, so we need to
+  // figure out the correct index to insert the CSS into
+  var index = 0;
+  var lastC = 0;
+  args[0].replace(/%[a-z%]/g, function (match) {
+    if ('%%' === match) return;
+    index++;
+    if ('%c' === match) {
+      // we only are interested in the *last* %c
+      // (the user may have provided their own)
+      lastC = index;
+    }
+  });
+
+  args.splice(lastC, 0, c);
+  return args;
+}
+
+/**
+ * Invokes `console.log()` when available.
+ * No-op when `console.log` is not a "function".
+ *
+ * @api public
+ */
+
+function log() {
+  // this hackery is required for IE8/9, where
+  // the `console.log` function doesn't have 'apply'
+  return 'object' === (typeof console === 'undefined' ? 'undefined' : (0, _typeof3.default)(console)) && console.log && Function.prototype.apply.call(console.log, console, arguments);
+}
+
+/**
+ * Save `namespaces`.
+ *
+ * @param {String} namespaces
+ * @api private
+ */
+
+function save(namespaces) {
+  try {
+    if (null == namespaces) {
+      exports.storage.removeItem('debug');
+    } else {
+      exports.storage.debug = namespaces;
+    }
+  } catch (e) {}
+}
+
+/**
+ * Load `namespaces`.
+ *
+ * @return {String} returns the previously persisted debug modes
+ * @api private
+ */
+
+function load() {
+  var r;
+  try {
+    r = exports.storage.debug;
+  } catch (e) {}
+  return r;
+}
+
+/**
+ * Enable namespaces listed in `localStorage.debug` initially.
+ */
+
+exports.enable(load());
+
+/**
+ * Localstorage attempts to return the localstorage.
+ *
+ * This is necessary because safari throws
+ * when a user disables cookies/localstorage
+ * and you attempt to access it.
+ *
+ * @return {LocalStorage}
+ * @api private
+ */
+
+function localstorage() {
+  try {
+    return window.localStorage;
+  } catch (e) {}
+}
+
+},{"./debug":185,"babel-runtime/core-js/json/stringify":18,"babel-runtime/helpers/typeof":39}],185:[function(require,module,exports){
+'use strict';
+
+/**
+ * This is the common logic for both the Node.js and web browser
+ * implementations of `debug()`.
+ *
+ * Expose `debug()` as the module.
+ */
+
+exports = module.exports = debug;
+exports.coerce = coerce;
+exports.disable = disable;
+exports.enable = enable;
+exports.enabled = enabled;
+exports.humanize = require('ms');
+
+/**
+ * The currently active debug mode names, and names to skip.
+ */
+
+exports.names = [];
+exports.skips = [];
+
+/**
+ * Map of special "%n" handling functions, for the debug "format" argument.
+ *
+ * Valid key names are a single, lowercased letter, i.e. "n".
+ */
+
+exports.formatters = {};
+
+/**
+ * Previously assigned color.
+ */
+
+var prevColor = 0;
+
+/**
+ * Previous log timestamp.
+ */
+
+var prevTime;
+
+/**
+ * Select a color.
+ *
+ * @return {Number}
+ * @api private
+ */
+
+function selectColor() {
+  return exports.colors[prevColor++ % exports.colors.length];
+}
+
+/**
+ * Create a debugger with the given `namespace`.
+ *
+ * @param {String} namespace
+ * @return {Function}
+ * @api public
+ */
+
+function debug(namespace) {
+
+  // define the `disabled` version
+  function disabled() {}
+  disabled.enabled = false;
+
+  // define the `enabled` version
+  function enabled() {
+
+    var self = enabled;
+
+    // set `diff` timestamp
+    var curr = +new Date();
+    var ms = curr - (prevTime || curr);
+    self.diff = ms;
+    self.prev = prevTime;
+    self.curr = curr;
+    prevTime = curr;
+
+    // add the `color` if not set
+    if (null == self.useColors) self.useColors = exports.useColors();
+    if (null == self.color && self.useColors) self.color = selectColor();
+
+    var args = Array.prototype.slice.call(arguments);
+
+    args[0] = exports.coerce(args[0]);
+
+    if ('string' !== typeof args[0]) {
+      // anything else let's inspect with %o
+      args = ['%o'].concat(args);
+    }
+
+    // apply any `formatters` transformations
+    var index = 0;
+    args[0] = args[0].replace(/%([a-z%])/g, function (match, format) {
+      // if we encounter an escaped % then don't increase the array index
+      if (match === '%%') return match;
+      index++;
+      var formatter = exports.formatters[format];
+      if ('function' === typeof formatter) {
+        var val = args[index];
+        match = formatter.call(self, val);
+
+        // now we need to remove `args[index]` since it's inlined in the `format`
+        args.splice(index, 1);
+        index--;
+      }
+      return match;
+    });
+
+    if ('function' === typeof exports.formatArgs) {
+      args = exports.formatArgs.apply(self, args);
+    }
+    var logFn = enabled.log || exports.log || console.log.bind(console);
+    logFn.apply(self, args);
+  }
+  enabled.enabled = true;
+
+  var fn = exports.enabled(namespace) ? enabled : disabled;
+
+  fn.namespace = namespace;
+
+  return fn;
+}
+
+/**
+ * Enables a debug mode by namespaces. This can include modes
+ * separated by a colon and wildcards.
+ *
+ * @param {String} namespaces
+ * @api public
+ */
+
+function enable(namespaces) {
+  exports.save(namespaces);
+
+  var split = (namespaces || '').split(/[\s,]+/);
+  var len = split.length;
+
+  for (var i = 0; i < len; i++) {
+    if (!split[i]) continue; // ignore empty strings
+    namespaces = split[i].replace(/\*/g, '.*?');
+    if (namespaces[0] === '-') {
+      exports.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));
+    } else {
+      exports.names.push(new RegExp('^' + namespaces + '$'));
+    }
+  }
+}
+
+/**
+ * Disable debug output.
+ *
+ * @api public
+ */
+
+function disable() {
+  exports.enable('');
+}
+
+/**
+ * Returns true if the given mode name is enabled, false otherwise.
+ *
+ * @param {String} name
+ * @return {Boolean}
+ * @api public
+ */
+
+function enabled(name) {
+  var i, len;
+  for (i = 0, len = exports.skips.length; i < len; i++) {
+    if (exports.skips[i].test(name)) {
+      return false;
+    }
+  }
+  for (i = 0, len = exports.names.length; i < len; i++) {
+    if (exports.names[i].test(name)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Coerce `val`.
+ *
+ * @param {Mixed} val
+ * @return {Mixed}
+ * @api private
+ */
+
+function coerce(val) {
+  if (val instanceof Error) return val.stack || val.message;
+  return val;
+}
+
+},{"ms":338}],186:[function(require,module,exports){
+(function (process){
+/**!
+ * default-user-agent - index.js
+ *
+ * Copyright(c) fengmk2 and other contributors.
+ * MIT Licensed
+ *
+ * Authors:
+ *   fengmk2 <fengmk2@gmail.com> (http://fengmk2.com)
+ */
+
+'use strict';
+
+/**
+ * Module dependencies.
+ */
+
+var osName = require('os-name');
+
+var USER_AGENT = 'Node.js/' + process.version.slice(1) + ' (' + osName() + '; ' + process.arch + ')';
+
+module.exports = function ua(name, version) {
+  if (arguments.length !== 2) {
+    return USER_AGENT;
+  }
+  return name + '/' + version + ' ' + USER_AGENT;
+};
+
+}).call(this,require('_process'))
+},{"_process":345,"os-name":340}],187:[function(require,module,exports){
+/*!
+ * destroy
+ * Copyright(c) 2014 Jonathan Ong
+ * MIT Licensed
+ */
+
+'use strict';
+
+/**
+ * Module dependencies.
+ * @private
+ */
+
+var ReadStream = require('fs').ReadStream;
+var Stream = require('stream');
+
+/**
+ * Module exports.
+ * @public
+ */
+
+module.exports = destroy;
+
+/**
+ * Destroy a stream.
+ *
+ * @param {object} stream
+ * @public
+ */
+
+function destroy(stream) {
+  if (stream instanceof ReadStream) {
+    return destroyReadStream(stream);
+  }
+
+  if (!(stream instanceof Stream)) {
+    return stream;
+  }
+
+  if (typeof stream.destroy === 'function') {
+    stream.destroy();
+  }
+
+  return stream;
+}
+
+/**
+ * Destroy a ReadStream.
+ *
+ * @param {object} stream
+ * @private
+ */
+
+function destroyReadStream(stream) {
+  stream.destroy();
+
+  if (typeof stream.close === 'function') {
+    // node.js core bug work-around
+    stream.on('open', onOpenClose);
+  }
+
+  return stream;
+}
+
+/**
+ * On open handler to close stream.
+ * @private
+ */
+
+function onOpenClose() {
+  if (typeof this.fd === 'number') {
+    // actually close down the fd
+    this.close();
+  }
+}
+
+},{"fs":43,"stream":369}],188:[function(require,module,exports){
+/**!
+ * digest-header - index.js
+ *
+ * Copyright(c) fengmk2 and other contributors.
+ * MIT Licensed
+ *
+ * Authors:
+ *   fengmk2 <fengmk2@gmail.com> (http://fengmk2.github.com)
+ */
+
+'use strict';
+
+/**
+ * Module dependencies.
+ */
+
+var crypto = require('./../../shims/crypto.js');
+var utility = require('utility');
+
+var AUTH_KEY_VALUE_RE = /(\w+)=["']?([^'"]+)["']?/;
+var NC = 0;
+var NC_PAD = '00000000';
+
+function digestAuthHeader(method, uri, wwwAuthenticate, userpass) {
+  var parts = wwwAuthenticate.split(',');
+  var opts = {};
+  for (var i = 0; i < parts.length; i++) {
+    var m = parts[i].match(AUTH_KEY_VALUE_RE);
+    if (m) {
+      opts[m[1]] = m[2].replace(/["']/g, '');
+    }
+  }
+
+  if (!opts.realm || !opts.nonce) {
+    return '';
+  }
+
+  var qop = opts.qop || '';
+
+  // WWW-Authenticate: Digest realm="testrealm@host.com",
+  //                       qop="auth,auth-int",
+  //                       nonce="dcd98b7102dd2f0e8b11d0f600bfb0c093",
+  //                       opaque="5ccc069c403ebaf9f0171e9517f40e41"
+  // Authorization: Digest username="Mufasa",
+  //                    realm="testrealm@host.com",
+  //                    nonce="dcd98b7102dd2f0e8b11d0f600bfb0c093",
+  //                    uri="/dir/index.html",
+  //                    qop=auth,
+  //                    nc=00000001,
+  //                    cnonce="0a4f113b",
+  //                    response="6629fae49393a05397450978507c4ef1",
+  //                    opaque="5ccc069c403ebaf9f0171e9517f40e41"
+  // HA1 = MD5( "Mufasa:testrealm@host.com:Circle Of Life" )
+  //      = 939e7578ed9e3c518a452acee763bce9
+  //
+  //  HA2 = MD5( "GET:/dir/index.html" )
+  //      = 39aff3a2bab6126f332b942af96d3366
+  //
+  //  Response = MD5( "939e7578ed9e3c518a452acee763bce9:\
+  //                   dcd98b7102dd2f0e8b11d0f600bfb0c093:\
+  //                   00000001:0a4f113b:auth:\
+  //                   39aff3a2bab6126f332b942af96d3366" )
+  //           = 6629fae49393a05397450978507c4ef1
+  userpass = userpass.split(':');
+
+  var nc = String(++NC);
+  nc = NC_PAD.substring(nc.length) + nc;
+  var cnonce = crypto.randomBytes(8).toString('hex');
+
+  var ha1 = utility.md5(userpass[0] + ':' + opts.realm + ':' + userpass[1]);
+  var ha2 = utility.md5(method.toUpperCase() + ':' + uri);
+  var s = ha1 + ':' + opts.nonce;
+  if (qop) {
+    qop = qop.split(',')[0];
+    s += ':' + nc + ':' + cnonce + ':' + qop;
+  }
+  s += ':' + ha2;
+  var response = utility.md5(s);
+  var authstring = 'Digest username="' + userpass[0] + '", realm="' + opts.realm + '", nonce="' + opts.nonce + '", uri="' + uri + '", response="' + response + '"';
+  if (opts.opaque) {
+    authstring += ', opaque="' + opts.opaque + '"';
+  }
+  if (qop) {
+    authstring += ', qop=' + qop + ', nc=' + nc + ', cnonce="' + cnonce + '"';
+  }
+  return authstring;
+}
+
+module.exports = digestAuthHeader;
+
+},{"./../../shims/crypto.js":420,"utility":189}],189:[function(require,module,exports){
+'use strict';
+
+module.exports = require('./lib/utility');
+
+},{"./lib/utility":190}],190:[function(require,module,exports){
+(function (process,Buffer){
+/*!
+ * utility - lib/utility.js
+ *
+ * Copyright(c) 2012 - 2013 fengmk2 <fengmk2@gmail.com>
+ * MIT Licensed
+ */
+
+"use strict";
+
+/**
+ * Module dependencies.
+ */
+
+var _setImmediate3 = require('babel-runtime/core-js/set-immediate');
+
+var _setImmediate4 = _interopRequireDefault(_setImmediate3);
+
+var _stringify = require('babel-runtime/core-js/json/stringify');
+
+var _stringify2 = _interopRequireDefault(_stringify);
+
+var _keys = require('babel-runtime/core-js/object/keys');
+
+var _keys2 = _interopRequireDefault(_keys);
+
+var _typeof2 = require('babel-runtime/helpers/typeof');
+
+var _typeof3 = _interopRequireDefault(_typeof2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var crypto = require('./../../../../../shims/crypto.js');
+var address = require('address');
+
+/**
+ * A empty function.
+ *
+ * @return {Function}
+ * @public
+ */
+exports.noop = function () {};
+
+function sortObject(o) {
+  if (!o || Array.isArray(o) || (typeof o === 'undefined' ? 'undefined' : (0, _typeof3.default)(o)) !== 'object') {
+    return o;
+  }
+  var keys = (0, _keys2.default)(o);
+  keys.sort();
+  var values = [];
+  for (var i = 0; i < keys.length; i++) {
+    var k = keys[i];
+    values.push([k, sortObject(o[k])]);
+  }
+  return values;
+}
+
+/**
+ * hash
+ *
+ * @param {String} method hash method, e.g.: 'md5', 'sha1'
+ * @param {String|Buffer} s
+ * @param {String} [format] output string format, could be 'hex' or 'base64'. default is 'hex'.
+ * @return {String} md5 hash string
+ * @public
+ */
+exports.hash = function hash(method, s, format) {
+  var sum = crypto.createHash(method);
+  var isBuffer = Buffer.isBuffer(s);
+  if (!isBuffer && (typeof s === 'undefined' ? 'undefined' : (0, _typeof3.default)(s)) === 'object') {
+    s = (0, _stringify2.default)(sortObject(s));
+  }
+  sum.update(s, isBuffer ? 'binary' : 'utf8');
+  return sum.digest(format || 'hex');
+};
+
+/**
+ * md5 hash
+ *
+ * @param {String|Buffer} s
+ * @param {String} [format] output string format, could be 'hex' or 'base64'. default is 'hex'.
+ * @return {String} md5 hash string
+ * @public
+ */
+exports.md5 = function (s, format) {
+  return exports.hash('md5', s, format);
+};
+
+/**
+ * sha1 hash
+ *
+ * @param {String|Buffer} s
+ * @param {String} [format] output string format, could be 'hex' or 'base64'. default is 'hex'.
+ * @return {String} sha1 hash string
+ * @public
+ */
+exports.sha1 = function (s, format) {
+  return exports.hash('sha1', s, format);
+};
+
+/**
+ * HMAC algorithm.
+ *
+ * Equal bash:
+ *
+ * ```bash
+ * $ echo -n "$data" | openssl dgst -binary -$algorithm -hmac "$key" | openssl $encoding
+ * ```
+ *
+ * @param {String} algorithm, dependent on the available algorithms supported by the version of OpenSSL on the platform.
+ *   Examples are 'sha1', 'md5', 'sha256', 'sha512', etc.
+ *   On recent releases, `openssl list-message-digest-algorithms` will display the available digest algorithms.
+ * @param {String} key, the hmac key to be used.
+ * @param {String|Buffer} data, content string.
+ * @param {String} [encoding='base64']
+ * @return {String} digest string.
+ */
+exports.hmac = function (algorithm, key, data, encoding) {
+  encoding = encoding || 'base64';
+  var hmac = crypto.createHmac(algorithm, key);
+  hmac.update(data, Buffer.isBuffer(data) ? 'binary' : 'utf8');
+  return hmac.digest(encoding);
+};
+
+/**
+ * Base64 encode string.
+ *
+ * @param {String|Buffer} s
+ * @param {Boolean} [urlsafe=false] Encode string s using a URL-safe alphabet,
+ *   which substitutes - instead of + and _ instead of / in the standard Base64 alphabet.
+ * @return {String} base64 encode format string.
+ */
+exports.base64encode = function (s, urlsafe) {
+  if (!Buffer.isBuffer(s)) {
+    s = new Buffer(s);
+  }
+  var encode = s.toString('base64');
+  if (urlsafe) {
+    encode = encode.replace(/\+/g, '-').replace(/\//g, '_');
+  }
+  return encode;
+};
+
+/**
+ * Base64 string decode.
+ *
+ * @param {String} encode, base64 encoding string.
+ * @param {Boolean} [urlsafe=false] Decode string s using a URL-safe alphabet,
+ *   which substitutes - instead of + and _ instead of / in the standard Base64 alphabet.
+ * @return {String} plain text.
+ */
+exports.base64decode = function (encode, urlsafe) {
+  if (urlsafe) {
+    encode = encode.replace(/\-/g, '+').replace(/_/g, '/');
+  }
+  encode = new Buffer(encode, 'base64');
+  return encode.toString();
+};
+
+/**
+ * Escape the given string of `html`.
+ *
+ * @param {String} html
+ * @return {String}
+ * @public
+ */
+exports.escape = function (html) {
+  return String(html).replace(/&(?!\w+;)/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+};
+
+/**
+ * Array random slice with items count.
+ * @param {Array} arr
+ * @param {Number} num, number of sub items.
+ * @return {Array}
+ */
+exports.randomSlice = function (arr, num) {
+  if (!num || num >= arr.length) {
+    return arr.slice();
+  }
+  var index = Math.floor(Math.random() * arr.length);
+  var a = [];
+  for (var i = 0, j = index; i < num; i++) {
+    a.push(arr[j++]);
+    if (j === arr.length) {
+      j = 0;
+    }
+  }
+  return a;
+};
+
+/**
+ * Safe encodeURIComponent, won't throw any error.
+ * If `encodeURIComponent` error happen, just return the original value.
+ *
+ * @param {String} text
+ * @return {String} URL encode string.
+ */
+exports.encodeURIComponent = function (text) {
+  try {
+    return encodeURIComponent(text);
+  } catch (e) {
+    return text;
+  }
+};
+
+/**
+ * Safe decodeURIComponent, won't throw any error.
+ * If `decodeURIComponent` error happen, just return the original value.
+ *
+ * @param {String} encodeText
+ * @return {String} URL decode original string.
+ */
+exports.decodeURIComponent = function (encodeText) {
+  try {
+    return decodeURIComponent(encodeText);
+  } catch (e) {
+    return encodeText;
+  }
+};
+
+var MONTHS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+
+// only set once.
+var TIMEZONE = ' ';
+var _hourOffset = parseInt(-new Date().getTimezoneOffset() / 60, 10);
+if (_hourOffset >= 0) {
+  TIMEZONE += '+';
+} else {
+  TIMEZONE += '-';
+}
+_hourOffset = Math.abs(_hourOffset);
+if (_hourOffset < 10) {
+  _hourOffset = '0' + _hourOffset;
+}
+TIMEZONE += _hourOffset + '00';
+
+/**
+ * Access log format date. format: `moment().format('DD/MMM/YYYY:HH:mm:ss ZZ')`
+ *
+ * @return {String}
+ */
+exports.accessLogDate = function (d) {
+  // 16/Apr/2013:16:40:09 +0800
+  d = d || new Date();
+  var date = d.getDate();
+  if (date < 10) {
+    date = '0' + date;
+  }
+  var hours = d.getHours();
+  if (hours < 10) {
+    hours = '0' + hours;
+  }
+  var mintues = d.getMinutes();
+  if (mintues < 10) {
+    mintues = '0' + mintues;
+  }
+  var seconds = d.getSeconds();
+  if (seconds < 10) {
+    seconds = '0' + seconds;
+  }
+  return date + '/' + MONTHS[d.getMonth()] + '/' + d.getFullYear() + ':' + hours + ':' + mintues + ':' + seconds + TIMEZONE;
+};
+
+/**
+ * Normal log format date. format: `moment().format('YYYY-MM-DD HH:mm:ss.SSS')`
+ *
+ * @return {String}
+ */
+exports.logDate = exports.YYYYMMDDHHmmssSSS = function (d) {
+  d = d || new Date();
+  var date = d.getDate();
+  if (date < 10) {
+    date = '0' + date;
+  }
+  var month = d.getMonth() + 1;
+  if (month < 10) {
+    month = '0' + month;
+  }
+  var hours = d.getHours();
+  if (hours < 10) {
+    hours = '0' + hours;
+  }
+  var mintues = d.getMinutes();
+  if (mintues < 10) {
+    mintues = '0' + mintues;
+  }
+  var seconds = d.getSeconds();
+  if (seconds < 10) {
+    seconds = '0' + seconds;
+  }
+  var milliseconds = d.getMilliseconds();
+  if (milliseconds < 10) {
+    milliseconds = '00' + milliseconds;
+  } else if (milliseconds < 100) {
+    milliseconds = '0' + milliseconds;
+  }
+  return d.getFullYear() + '-' + month + '-' + date + ' ' + hours + ':' + mintues + ':' + seconds + '.' + milliseconds;
+};
+
+/**
+ * `moment().format('YYYY-MM-DD HH:mm:ss')` format date string.
+ *
+ * @return {String}
+ */
+exports.YYYYMMDDHHmmss = function (d) {
+  d = d || new Date();
+  var date = d.getDate();
+  if (date < 10) {
+    date = '0' + date;
+  }
+  var month = d.getMonth() + 1;
+  if (month < 10) {
+    month = '0' + month;
+  }
+  var hours = d.getHours();
+  if (hours < 10) {
+    hours = '0' + hours;
+  }
+  var mintues = d.getMinutes();
+  if (mintues < 10) {
+    mintues = '0' + mintues;
+  }
+  var seconds = d.getSeconds();
+  if (seconds < 10) {
+    seconds = '0' + seconds;
+  }
+  return d.getFullYear() + '-' + month + '-' + date + ' ' + hours + ':' + mintues + ':' + seconds;
+};
+
+/**
+ * `moment().format('YYYY-MM-DD')` format date string.
+ *
+ * @return {String}
+ */
+exports.YYYYMMDD = function YYYYMMDD(d) {
+  d = d || new Date();
+  var date = d.getDate();
+  if (date < 10) {
+    date = '0' + date;
+  }
+  var month = d.getMonth() + 1;
+  if (month < 10) {
+    month = '0' + month;
+  }
+  return d.getFullYear() + '-' + month + '-' + date;
+};
+
+/**
+ * return datetime struct.
+ *
+ * @return {Object} date
+ *  - {Number} YYYYMMDD, 20130401
+ *  - {Number} H, 0, 1, 9, 12, 23
+ */
+exports.datestruct = function (now) {
+  now = now || new Date();
+  return {
+    YYYYMMDD: now.getFullYear() * 10000 + (now.getMonth() + 1) * 100 + now.getDate(),
+    H: now.getHours()
+  };
+};
+
+var _showWarnning = false;
+
+/**
+ * Get current machine IPv4
+ *
+ * @param {String} [interfaceName] interface name, default is 'eth' on linux, 'en' on mac os.
+ * @return {String} IP address
+ */
+exports.getIP = exports.getIPv4 = function (interfaceName) {
+  if (!_showWarnning) {
+    _showWarnning = true;
+    console.warn('[WARNNING] getIP() remove, PLEASE use `https://github.com/fengmk2/address` module instead');
+  }
+  return address.ip(interfaceName);
+};
+
+/**
+ * Get current machine IPv6
+ *
+ * @param {String} [interfaceName] interface name, default is 'eth' on linux, 'en' on mac os.
+ * @return {String} IP address
+ */
+exports.getIPv6 = function (interfaceName) {
+  return address.ipv6(interfaceName);
+};
+
+/**
+ * Get a function parameter's names.
+ *
+ * @param {Function} func
+ * @param {Boolean} [useCache], default is true
+ * @return {Array} names
+ */
+exports.getParamNames = function (func, cache) {
+  cache = cache !== false;
+  if (cache && func.__cache_names) {
+    return func.__cache_names;
+  }
+  var str = func.toString();
+  var names = str.slice(str.indexOf('(') + 1, str.indexOf(')')).match(/([^\s,]+)/g) || [];
+  func.__cache_names = names;
+  return names;
+};
+
+// http://www.2ality.com/2013/10/safe-integers.html
+exports.MAX_SAFE_INTEGER = Math.pow(2, 53) - 1;
+exports.MIN_SAFE_INTEGER = -exports.MAX_SAFE_INTEGER;
+var MAX_SAFE_INTEGER_STR = exports.MAX_SAFE_INTEGER_STR = String(exports.MAX_SAFE_INTEGER);
+var MAX_SAFE_INTEGER_STR_LENGTH = MAX_SAFE_INTEGER_STR.length;
+
+/**
+ * Detect a number string can safe convert to Javascript Number.
+ *
+ * @param {String} s number format string, like `"123"`, `"-1000123123123123123123"`
+ * @return {Boolean}
+ */
+exports.isSafeNumberString = function (s) {
+  if (s[0] === '-') {
+    s = s.substring(1);
+  }
+  if (s.length < MAX_SAFE_INTEGER_STR_LENGTH || s.length === MAX_SAFE_INTEGER_STR_LENGTH && s <= MAX_SAFE_INTEGER_STR) {
+    return true;
+  }
+  return false;
+};
+
+/**
+ * Convert string to Number if string in safe Number scope.
+ *
+ * @param {String} s number format string.
+ * @return {Number|String} success will return Number, otherise return the original string.
+ */
+exports.toSafeNumber = function (s) {
+  if (typeof s === 'number') {
+    return s;
+  }
+
+  return exports.isSafeNumberString(s) ? Number(s) : s;
+};
+
+/**
+ * Get Unix's timestamp in seconds.
+ * @return {Number}
+ */
+exports.timestamp = function (t) {
+  if (t) {
+    var v = t;
+    if (typeof v === 'string') {
+      v = Number(v);
+    }
+    if (String(t).length === 10) {
+      v *= 1000;
+    }
+    return new Date(v);
+  }
+  return Math.round(Date.now() / 1000);
+};
+
+var _setImmediate = typeof _setImmediate4.default === 'function' ? _setImmediate4.default : process.nextTick;
+
+exports.setImmediate = function (callback) {
+  _setImmediate(callback);
+};
+
+exports.randomString = function (length, charSet) {
+  var result = [];
+  length = length || 16;
+  charSet = charSet || 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+
+  while (length--) {
+    result.push(charSet[Math.floor(Math.random() * charSet.length)]);
+  }
+  return result.join('');
+};
+
+exports.has = function (obj, prop) {
+  return Object.prototype.hasOwnProperty.call(obj, prop);
+};
+
+}).call(this,require('_process'),require("buffer").Buffer)
+},{"./../../../../../shims/crypto.js":420,"_process":345,"address":10,"babel-runtime/core-js/json/stringify":18,"babel-runtime/core-js/object/keys":30,"babel-runtime/core-js/set-immediate":34,"babel-runtime/helpers/typeof":39,"buffer":45}],191:[function(require,module,exports){
+/**!
+ * end-or-error - index.js
+ *
+ * Copyright(c) stream-utils and other contributors.
+ * MIT Licensed
+ *
+ * Authors:
+ *   fengmk2 <m@fengmk2.com> (http://fengmk2.com)
+ */
+
+'use strict';
+
+/**
+ * Module dependencies.
+ */
+
+module.exports = function eoe(stream, cb) {
+  if (!stream.readable) {
+    return cb();
+  }
+
+  stream.on('error', onerror);
+  stream.on('end', onend);
+
+  function onerror(err) {
+    cleanup();
+    cb(err);
+  }
+
+  function onend(data) {
+    cleanup();
+    cb(null, data);
+  }
+
+  function cleanup() {
+    stream.removeListener('error', onerror);
+    stream.removeListener('end', onend);
+  }
+};
+
+},{}],192:[function(require,module,exports){
+/*!
+ * escape-html
+ * Copyright(c) 2012-2013 TJ Holowaychuk
+ * Copyright(c) 2015 Andreas Lubbe
+ * Copyright(c) 2015 Tiancheng "Timothy" Gu
+ * MIT Licensed
+ */
+
+'use strict';
+
+/**
+ * Module variables.
+ * @private
+ */
+
+var matchHtmlRegExp = /["'&<>]/;
+
+/**
+ * Module exports.
+ * @public
+ */
+
+module.exports = escapeHtml;
+
+/**
+ * Escape special characters in the given string of html.
+ *
+ * @param  {string} string The string to escape for inserting into HTML
+ * @return {string}
+ * @public
+ */
+
+function escapeHtml(string) {
+  var str = '' + string;
+  var match = matchHtmlRegExp.exec(str);
+
+  if (!match) {
+    return str;
+  }
+
+  var escape;
+  var html = '';
+  var index = 0;
+  var lastIndex = 0;
+
+  for (index = match.index; index < str.length; index++) {
+    switch (str.charCodeAt(index)) {
+      case 34:
+        // "
+        escape = '&quot;';
+        break;
+      case 38:
+        // &
+        escape = '&amp;';
+        break;
+      case 39:
+        // '
+        escape = '&#39;';
+        break;
+      case 60:
+        // <
+        escape = '&lt;';
+        break;
+      case 62:
+        // >
+        escape = '&gt;';
+        break;
+      default:
+        continue;
+    }
+
+    if (lastIndex !== index) {
+      html += str.substring(lastIndex, index);
+    }
+
+    lastIndex = index + 1;
+    html += escape;
+  }
+
+  return lastIndex !== index ? html + str.substring(lastIndex, index) : html;
+}
+
+},{}],193:[function(require,module,exports){
+'use strict';
+
+var _typeof2 = require('babel-runtime/helpers/typeof');
+
+var _typeof3 = _interopRequireDefault(_typeof2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+function EventEmitter() {
+  this._events = this._events || {};
+  this._maxListeners = this._maxListeners || undefined;
+}
+module.exports = EventEmitter;
+
+// Backwards-compat with node 0.10.x
+EventEmitter.EventEmitter = EventEmitter;
+
+EventEmitter.prototype._events = undefined;
+EventEmitter.prototype._maxListeners = undefined;
+
+// By default EventEmitters will print a warning if more than 10 listeners are
+// added to it. This is a useful default which helps finding memory leaks.
+EventEmitter.defaultMaxListeners = 10;
+
+// Obviously not all Emitters should be limited to 10. This function allows
+// that to be increased. Set to zero for unlimited.
+EventEmitter.prototype.setMaxListeners = function (n) {
+  if (!isNumber(n) || n < 0 || isNaN(n)) throw TypeError('n must be a positive number');
+  this._maxListeners = n;
+  return this;
+};
+
+EventEmitter.prototype.emit = function (type) {
+  var er, handler, len, args, i, listeners;
+
+  if (!this._events) this._events = {};
+
+  // If there is no 'error' event listener then throw.
+  if (type === 'error') {
+    if (!this._events.error || isObject(this._events.error) && !this._events.error.length) {
+      er = arguments[1];
+      if (er instanceof Error) {
+        throw er; // Unhandled 'error' event
+      } else {
+        // At least give some kind of context to the user
+        var err = new Error('Uncaught, unspecified "error" event. (' + er + ')');
+        err.context = er;
+        throw err;
+      }
+    }
+  }
+
+  handler = this._events[type];
+
+  if (isUndefined(handler)) return false;
+
+  if (isFunction(handler)) {
+    switch (arguments.length) {
+      // fast cases
+      case 1:
+        handler.call(this);
+        break;
+      case 2:
+        handler.call(this, arguments[1]);
+        break;
+      case 3:
+        handler.call(this, arguments[1], arguments[2]);
+        break;
+      // slower
+      default:
+        args = Array.prototype.slice.call(arguments, 1);
+        handler.apply(this, args);
+    }
+  } else if (isObject(handler)) {
+    args = Array.prototype.slice.call(arguments, 1);
+    listeners = handler.slice();
+    len = listeners.length;
+    for (i = 0; i < len; i++) {
+      listeners[i].apply(this, args);
+    }
+  }
+
+  return true;
+};
+
+EventEmitter.prototype.addListener = function (type, listener) {
+  var m;
+
+  if (!isFunction(listener)) throw TypeError('listener must be a function');
+
+  if (!this._events) this._events = {};
+
+  // To avoid recursion in the case that type === "newListener"! Before
+  // adding it to the listeners, first emit "newListener".
+  if (this._events.newListener) this.emit('newListener', type, isFunction(listener.listener) ? listener.listener : listener);
+
+  if (!this._events[type])
+    // Optimize the case of one listener. Don't need the extra array object.
+    this._events[type] = listener;else if (isObject(this._events[type]))
+    // If we've already got an array, just append.
+    this._events[type].push(listener);else
+    // Adding the second element, need to change to array.
+    this._events[type] = [this._events[type], listener];
+
+  // Check for listener leak
+  if (isObject(this._events[type]) && !this._events[type].warned) {
+    if (!isUndefined(this._maxListeners)) {
+      m = this._maxListeners;
+    } else {
+      m = EventEmitter.defaultMaxListeners;
+    }
+
+    if (m && m > 0 && this._events[type].length > m) {
+      this._events[type].warned = true;
+      console.error('(node) warning: possible EventEmitter memory ' + 'leak detected. %d listeners added. ' + 'Use emitter.setMaxListeners() to increase limit.', this._events[type].length);
+      if (typeof console.trace === 'function') {
+        // not supported in IE 10
+        console.trace();
+      }
+    }
+  }
+
+  return this;
+};
+
+EventEmitter.prototype.on = EventEmitter.prototype.addListener;
+
+EventEmitter.prototype.once = function (type, listener) {
+  if (!isFunction(listener)) throw TypeError('listener must be a function');
+
+  var fired = false;
+
+  function g() {
+    this.removeListener(type, g);
+
+    if (!fired) {
+      fired = true;
+      listener.apply(this, arguments);
+    }
+  }
+
+  g.listener = listener;
+  this.on(type, g);
+
+  return this;
+};
+
+// emits a 'removeListener' event iff the listener was removed
+EventEmitter.prototype.removeListener = function (type, listener) {
+  var list, position, length, i;
+
+  if (!isFunction(listener)) throw TypeError('listener must be a function');
+
+  if (!this._events || !this._events[type]) return this;
+
+  list = this._events[type];
+  length = list.length;
+  position = -1;
+
+  if (list === listener || isFunction(list.listener) && list.listener === listener) {
+    delete this._events[type];
+    if (this._events.removeListener) this.emit('removeListener', type, listener);
+  } else if (isObject(list)) {
+    for (i = length; i-- > 0;) {
+      if (list[i] === listener || list[i].listener && list[i].listener === listener) {
+        position = i;
+        break;
+      }
+    }
+
+    if (position < 0) return this;
+
+    if (list.length === 1) {
+      list.length = 0;
+      delete this._events[type];
+    } else {
+      list.splice(position, 1);
+    }
+
+    if (this._events.removeListener) this.emit('removeListener', type, listener);
+  }
+
+  return this;
+};
+
+EventEmitter.prototype.removeAllListeners = function (type) {
+  var key, listeners;
+
+  if (!this._events) return this;
+
+  // not listening for removeListener, no need to emit
+  if (!this._events.removeListener) {
+    if (arguments.length === 0) this._events = {};else if (this._events[type]) delete this._events[type];
+    return this;
+  }
+
+  // emit removeListener for all listeners on all events
+  if (arguments.length === 0) {
+    for (key in this._events) {
+      if (key === 'removeListener') continue;
+      this.removeAllListeners(key);
+    }
+    this.removeAllListeners('removeListener');
+    this._events = {};
+    return this;
+  }
+
+  listeners = this._events[type];
+
+  if (isFunction(listeners)) {
+    this.removeListener(type, listeners);
+  } else if (listeners) {
+    // LIFO order
+    while (listeners.length) {
+      this.removeListener(type, listeners[listeners.length - 1]);
+    }
+  }
+  delete this._events[type];
+
+  return this;
+};
+
+EventEmitter.prototype.listeners = function (type) {
+  var ret;
+  if (!this._events || !this._events[type]) ret = [];else if (isFunction(this._events[type])) ret = [this._events[type]];else ret = this._events[type].slice();
+  return ret;
+};
+
+EventEmitter.prototype.listenerCount = function (type) {
+  if (this._events) {
+    var evlistener = this._events[type];
+
+    if (isFunction(evlistener)) return 1;else if (evlistener) return evlistener.length;
+  }
+  return 0;
+};
+
+EventEmitter.listenerCount = function (emitter, type) {
+  return emitter.listenerCount(type);
+};
+
+function isFunction(arg) {
+  return typeof arg === 'function';
+}
+
+function isNumber(arg) {
+  return typeof arg === 'number';
+}
+
+function isObject(arg) {
+  return (typeof arg === 'undefined' ? 'undefined' : (0, _typeof3.default)(arg)) === 'object' && arg !== null;
+}
+
+function isUndefined(arg) {
+  return arg === void 0;
+}
+
+},{"babel-runtime/helpers/typeof":39}],194:[function(require,module,exports){
+(function (process){
+'use strict';
+
+var _promise = require('babel-runtime/core-js/promise');
+
+var _promise2 = _interopRequireDefault(_promise);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function ready(flagOrFunction) {
+  this._ready = !!this._ready;
+  this._readyCallbacks = this._readyCallbacks || [];
+
+  if (arguments.length === 0) {
+    // return a promise
+    // support `this.ready().then(onready);` and `yield this.ready()`;
+    return new _promise2.default(function (resolve) {
+      if (this._ready) {
+        return resolve();
+      }
+      this._readyCallbacks.push(resolve);
+    }.bind(this));
+  } else if (typeof flagOrFunction === 'function') {
+    this._readyCallbacks.push(flagOrFunction);
+  } else {
+    this._ready = !!flagOrFunction;
+  }
+
+  if (this._ready) {
+    this._readyCallbacks.splice(0, Infinity).forEach(function (callback) {
+      process.nextTick(callback);
+    });
+  }
+}
+
+function mixin(object) {
+  object.ready = ready;
+}
+
+module.exports = mixin;
+module.exports.mixin = mixin;
+
+}).call(this,require('_process'))
+},{"_process":345,"babel-runtime/core-js/promise":33}],195:[function(require,module,exports){
+'use strict';
+
+var http = require('http');
+
+var https = module.exports;
+
+for (var key in http) {
+    if (http.hasOwnProperty(key)) https[key] = http[key];
+};
+
+https.request = function (params, cb) {
+    if (!params) params = {};
+    params.scheme = 'https';
+    params.protocol = 'https:';
+    return http.request.call(this, params, cb);
+};
+
+},{"http":370}],196:[function(require,module,exports){
+/*!
+ * humanize-ms - index.js
+ * Copyright(c) 2014 dead_horse <dead_horse@qq.com>
+ * MIT Licensed
+ */
+
+'use strict';
+
+/**
+ * Module dependencies.
+ */
+
+var util = require('util');
+var ms = require('ms');
+
+module.exports = function (t) {
+  if (typeof t === 'number') return t;
+  var r = ms(t);
+  if (r === undefined) {
+    var err = new Error(util.format('humanize-ms(%j) result undefined', t));
+    console.warn(err.stack);
+  }
+  return r;
+};
+
+},{"ms":338,"util":384}],197:[function(require,module,exports){
+"use strict";
+
+exports.read = function (buffer, offset, isLE, mLen, nBytes) {
+  var e, m;
+  var eLen = nBytes * 8 - mLen - 1;
+  var eMax = (1 << eLen) - 1;
+  var eBias = eMax >> 1;
+  var nBits = -7;
+  var i = isLE ? nBytes - 1 : 0;
+  var d = isLE ? -1 : 1;
+  var s = buffer[offset + i];
+
+  i += d;
+
+  e = s & (1 << -nBits) - 1;
+  s >>= -nBits;
+  nBits += eLen;
+  for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}
+
+  m = e & (1 << -nBits) - 1;
+  e >>= -nBits;
+  nBits += mLen;
+  for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}
+
+  if (e === 0) {
+    e = 1 - eBias;
+  } else if (e === eMax) {
+    return m ? NaN : (s ? -1 : 1) * Infinity;
+  } else {
+    m = m + Math.pow(2, mLen);
+    e = e - eBias;
+  }
+  return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
+};
+
+exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
+  var e, m, c;
+  var eLen = nBytes * 8 - mLen - 1;
+  var eMax = (1 << eLen) - 1;
+  var eBias = eMax >> 1;
+  var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;
+  var i = isLE ? 0 : nBytes - 1;
+  var d = isLE ? 1 : -1;
+  var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;
+
+  value = Math.abs(value);
+
+  if (isNaN(value) || value === Infinity) {
+    m = isNaN(value) ? 1 : 0;
+    e = eMax;
+  } else {
+    e = Math.floor(Math.log(value) / Math.LN2);
+    if (value * (c = Math.pow(2, -e)) < 1) {
+      e--;
+      c *= 2;
+    }
+    if (e + eBias >= 1) {
+      value += rt / c;
+    } else {
+      value += rt * Math.pow(2, 1 - eBias);
+    }
+    if (value * c >= 2) {
+      e++;
+      c /= 2;
+    }
+
+    if (e + eBias >= eMax) {
+      m = 0;
+      e = eMax;
+    } else if (e + eBias >= 1) {
+      m = (value * c - 1) * Math.pow(2, mLen);
+      e = e + eBias;
+    } else {
+      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
+      e = 0;
+    }
+  }
+
+  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}
+
+  e = e << mLen | m;
+  eLen += mLen;
+  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}
+
+  buffer[offset + i - d] |= s * 128;
+};
+
+},{}],198:[function(require,module,exports){
+'use strict';
+
+var _create = require('babel-runtime/core-js/object/create');
+
+var _create2 = _interopRequireDefault(_create);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+if (typeof _create2.default === 'function') {
+  // implementation from standard node.js 'util' module
+  module.exports = function inherits(ctor, superCtor) {
+    ctor.super_ = superCtor;
+    ctor.prototype = (0, _create2.default)(superCtor.prototype, {
+      constructor: {
+        value: ctor,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+  };
+} else {
+  // old school shim for old browsers
+  module.exports = function inherits(ctor, superCtor) {
+    ctor.super_ = superCtor;
+    var TempCtor = function TempCtor() {};
+    TempCtor.prototype = superCtor.prototype;
+    ctor.prototype = new TempCtor();
+    ctor.prototype.constructor = ctor;
+  };
+}
+
+},{"babel-runtime/core-js/object/create":22}],199:[function(require,module,exports){
+'use strict';
+
+/*!
+ * Determine if an object is a Buffer
+ *
+ * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
+ * @license  MIT
+ */
+
+// The _isBuffer check is for Safari 5-7 support, because it's missing
+// Object.prototype.constructor. Remove this eventually
+module.exports = function (obj) {
+  return obj != null && (isBuffer(obj) || isSlowBuffer(obj) || !!obj._isBuffer);
+};
+
+function isBuffer(obj) {
+  return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj);
+}
+
+// For Node v0.10 support. Remove this eventually.
+function isSlowBuffer(obj) {
+  return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isBuffer(obj.slice(0, 0));
+}
+
+},{}],200:[function(require,module,exports){
+'use strict';
+
+(function (root) {
+  var toString = Function.prototype.toString;
+
+  function fnBody(fn) {
+    return toString.call(fn).replace(/^[^{]*{\s*/, '').replace(/\s*}[^}]*$/, '');
+  }
+
+  function isClass(fn) {
+    return typeof fn === 'function' && (/^class\s/.test(toString.call(fn)) || /^.*classCallCheck\(/.test(fnBody(fn))) // babel.js
+    ;
+  }
+
+  if (typeof exports !== 'undefined') {
+    if (typeof module !== 'undefined' && module.exports) {
+      exports = module.exports = isClass;
+    }
+    exports.isClass = isClass;
+  } else if (typeof define === 'function' && define.amd) {
+    define([], function () {
+      return isClass;
+    });
+  } else {
+    root.isClass = isClass;
+  }
+})(undefined);
+
+},{}],201:[function(require,module,exports){
+/*!
+ * is-type-of - index.js
+ * Copyright(c) 2014 dead_horse <dead_horse@qq.com>
+ * MIT Licensed
+ */
+
+'use strict';
+
+/**
+ * Module dependencies.
+ */
+
+var _isNan = require('babel-runtime/core-js/number/is-nan');
+
+var _isNan2 = _interopRequireDefault(_isNan);
+
+var _isFinite = require('babel-runtime/core-js/number/is-finite');
+
+var _isFinite2 = _interopRequireDefault(_isFinite);
+
+var _keys = require('babel-runtime/core-js/object/keys');
+
+var _keys2 = _interopRequireDefault(_keys);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var utils = require('core-util-is');
+var isStearm = require('isstream');
+var isClass = require('is-class');
+
+/**
+ * Expose all methods in core-util-is
+ */
+
+(0, _keys2.default)(utils).map(function (name) {
+  exports[transform(name)] = utils[name];
+});
+
+/**
+ * Stream detected by isstream
+ */
+
+exports.stream = isStearm;
+exports.readableStream = isStearm.isReadable;
+exports.writableStream = isStearm.isWritable;
+exports.duplexStream = isStearm.isDuplex;
+
+/**
+ * Class detected by is-class
+ */
+exports.class = isClass;
+
+/**
+ * Extend method
+ */
+
+exports.finite = function (obj) {
+  return (0, _isFinite2.default)(obj);
+};
+
+exports.NaN = function (obj) {
+  return (0, _isNan2.default)(obj);
+};
+
+exports.generator = function (obj) {
+  return obj && 'function' === typeof obj.next && 'function' === typeof obj.throw;
+};
+
+exports.generatorFunction = function (obj) {
+  return obj && obj.constructor && 'GeneratorFunction' === obj.constructor.name;
+};
+
+exports.promise = function (obj) {
+  return obj && 'function' === typeof obj.then;
+};
+
+var MAX_INT_31 = Math.pow(2, 31);
+
+exports.int = function (obj) {
+  return utils.isNumber(obj) && obj % 1 === 0;
+};
+
+exports.int32 = function (obj) {
+  return exports.int(obj) && obj < MAX_INT_31 && obj >= -MAX_INT_31;
+};
+
+exports.long = function (obj) {
+  return exports.int(obj) && (obj >= MAX_INT_31 || obj < -MAX_INT_31);
+};
+
+exports.Long = function (obj) {
+  return exports.object(obj) && exports.number(obj.high) && exports.number(obj.low);
+};
+
+exports.double = function (obj) {
+  return utils.isNumber(obj) && !isNaN(obj) && obj % 1 !== 0;
+};
+
+/**
+ * transform isNull type to null
+ * @param {[type]} m [description]
+ * @return {[type]} [description]
+ */
+
+function transform(m) {
+  var name = m.slice(2);
+  name = name[0].toLowerCase() + name.slice(1);
+  return name;
+}
+
+},{"babel-runtime/core-js/number/is-finite":19,"babel-runtime/core-js/number/is-nan":20,"babel-runtime/core-js/object/keys":30,"core-util-is":176,"is-class":200,"isstream":202}],202:[function(require,module,exports){
+'use strict';
+
+var _typeof2 = require('babel-runtime/helpers/typeof');
+
+var _typeof3 = _interopRequireDefault(_typeof2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var stream = require('stream');
+
+function isStream(obj) {
+  return obj instanceof stream.Stream;
+}
+
+function isReadable(obj) {
+  return isStream(obj) && typeof obj._read == 'function' && (0, _typeof3.default)(obj._readableState) == 'object';
+}
+
+function isWritable(obj) {
+  return isStream(obj) && typeof obj._write == 'function' && (0, _typeof3.default)(obj._writableState) == 'object';
+}
+
+function isDuplex(obj) {
+  return isReadable(obj) && isWritable(obj);
+}
+
+module.exports = isStream;
+module.exports.isReadable = isReadable;
+module.exports.isWritable = isWritable;
+module.exports.isDuplex = isDuplex;
+
+},{"babel-runtime/helpers/typeof":39,"stream":369}],203:[function(require,module,exports){
+'use strict';
+
+var getNative = require('./_getNative'),
+    root = require('./_root');
+
+/* Built-in method references that are verified to be native. */
+var DataView = getNative(root, 'DataView');
+
+module.exports = DataView;
+
+},{"./_getNative":263,"./_root":297}],204:[function(require,module,exports){
+'use strict';
+
+var hashClear = require('./_hashClear'),
+    hashDelete = require('./_hashDelete'),
+    hashGet = require('./_hashGet'),
+    hashHas = require('./_hashHas'),
+    hashSet = require('./_hashSet');
+
+/**
+ * Creates a hash object.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function Hash(entries) {
+    var index = -1,
+        length = entries ? entries.length : 0;
+
+    this.clear();
+    while (++index < length) {
+        var entry = entries[index];
+        this.set(entry[0], entry[1]);
+    }
+}
+
+// Add methods to `Hash`.
+Hash.prototype.clear = hashClear;
+Hash.prototype['delete'] = hashDelete;
+Hash.prototype.get = hashGet;
+Hash.prototype.has = hashHas;
+Hash.prototype.set = hashSet;
+
+module.exports = Hash;
+
+},{"./_hashClear":267,"./_hashDelete":268,"./_hashGet":269,"./_hashHas":270,"./_hashSet":271}],205:[function(require,module,exports){
+'use strict';
+
+var listCacheClear = require('./_listCacheClear'),
+    listCacheDelete = require('./_listCacheDelete'),
+    listCacheGet = require('./_listCacheGet'),
+    listCacheHas = require('./_listCacheHas'),
+    listCacheSet = require('./_listCacheSet');
+
+/**
+ * Creates an list cache object.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function ListCache(entries) {
+    var index = -1,
+        length = entries ? entries.length : 0;
+
+    this.clear();
+    while (++index < length) {
+        var entry = entries[index];
+        this.set(entry[0], entry[1]);
+    }
+}
+
+// Add methods to `ListCache`.
+ListCache.prototype.clear = listCacheClear;
+ListCache.prototype['delete'] = listCacheDelete;
+ListCache.prototype.get = listCacheGet;
+ListCache.prototype.has = listCacheHas;
+ListCache.prototype.set = listCacheSet;
+
+module.exports = ListCache;
+
+},{"./_listCacheClear":279,"./_listCacheDelete":280,"./_listCacheGet":281,"./_listCacheHas":282,"./_listCacheSet":283}],206:[function(require,module,exports){
+'use strict';
+
+var getNative = require('./_getNative'),
+    root = require('./_root');
+
+/* Built-in method references that are verified to be native. */
+var Map = getNative(root, 'Map');
+
+module.exports = Map;
+
+},{"./_getNative":263,"./_root":297}],207:[function(require,module,exports){
+'use strict';
+
+var mapCacheClear = require('./_mapCacheClear'),
+    mapCacheDelete = require('./_mapCacheDelete'),
+    mapCacheGet = require('./_mapCacheGet'),
+    mapCacheHas = require('./_mapCacheHas'),
+    mapCacheSet = require('./_mapCacheSet');
+
+/**
+ * Creates a map cache object to store key-value pairs.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function MapCache(entries) {
+    var index = -1,
+        length = entries ? entries.length : 0;
+
+    this.clear();
+    while (++index < length) {
+        var entry = entries[index];
+        this.set(entry[0], entry[1]);
+    }
+}
+
+// Add methods to `MapCache`.
+MapCache.prototype.clear = mapCacheClear;
+MapCache.prototype['delete'] = mapCacheDelete;
+MapCache.prototype.get = mapCacheGet;
+MapCache.prototype.has = mapCacheHas;
+MapCache.prototype.set = mapCacheSet;
+
+module.exports = MapCache;
+
+},{"./_mapCacheClear":284,"./_mapCacheDelete":285,"./_mapCacheGet":286,"./_mapCacheHas":287,"./_mapCacheSet":288}],208:[function(require,module,exports){
+'use strict';
+
+var getNative = require('./_getNative'),
+    root = require('./_root');
+
+/* Built-in method references that are verified to be native. */
+var Promise = getNative(root, 'Promise');
+
+module.exports = Promise;
+
+},{"./_getNative":263,"./_root":297}],209:[function(require,module,exports){
+'use strict';
+
+var getNative = require('./_getNative'),
+    root = require('./_root');
+
+/* Built-in method references that are verified to be native. */
+var Set = getNative(root, 'Set');
+
+module.exports = Set;
+
+},{"./_getNative":263,"./_root":297}],210:[function(require,module,exports){
+'use strict';
+
+var MapCache = require('./_MapCache'),
+    setCacheAdd = require('./_setCacheAdd'),
+    setCacheHas = require('./_setCacheHas');
+
+/**
+ *
+ * Creates an array cache object to store unique values.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [values] The values to cache.
+ */
+function SetCache(values) {
+    var index = -1,
+        length = values ? values.length : 0;
+
+    this.__data__ = new MapCache();
+    while (++index < length) {
+        this.add(values[index]);
+    }
+}
+
+// Add methods to `SetCache`.
+SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
+SetCache.prototype.has = setCacheHas;
+
+module.exports = SetCache;
+
+},{"./_MapCache":207,"./_setCacheAdd":298,"./_setCacheHas":299}],211:[function(require,module,exports){
+'use strict';
+
+var ListCache = require('./_ListCache'),
+    stackClear = require('./_stackClear'),
+    stackDelete = require('./_stackDelete'),
+    stackGet = require('./_stackGet'),
+    stackHas = require('./_stackHas'),
+    stackSet = require('./_stackSet');
+
+/**
+ * Creates a stack cache object to store key-value pairs.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function Stack(entries) {
+  var data = this.__data__ = new ListCache(entries);
+  this.size = data.size;
+}
+
+// Add methods to `Stack`.
+Stack.prototype.clear = stackClear;
+Stack.prototype['delete'] = stackDelete;
+Stack.prototype.get = stackGet;
+Stack.prototype.has = stackHas;
+Stack.prototype.set = stackSet;
+
+module.exports = Stack;
+
+},{"./_ListCache":205,"./_stackClear":303,"./_stackDelete":304,"./_stackGet":305,"./_stackHas":306,"./_stackSet":307}],212:[function(require,module,exports){
+'use strict';
+
+var root = require('./_root');
+
+/** Built-in value references. */
+var _Symbol = root.Symbol;
+
+module.exports = _Symbol;
+
+},{"./_root":297}],213:[function(require,module,exports){
+'use strict';
+
+var root = require('./_root');
+
+/** Built-in value references. */
+var Uint8Array = root.Uint8Array;
+
+module.exports = Uint8Array;
+
+},{"./_root":297}],214:[function(require,module,exports){
+'use strict';
+
+var getNative = require('./_getNative'),
+    root = require('./_root');
+
+/* Built-in method references that are verified to be native. */
+var WeakMap = getNative(root, 'WeakMap');
+
+module.exports = WeakMap;
+
+},{"./_getNative":263,"./_root":297}],215:[function(require,module,exports){
+"use strict";
+
+/**
+ * A faster alternative to `Function#apply`, this function invokes `func`
+ * with the `this` binding of `thisArg` and the arguments of `args`.
+ *
+ * @private
+ * @param {Function} func The function to invoke.
+ * @param {*} thisArg The `this` binding of `func`.
+ * @param {Array} args The arguments to invoke `func` with.
+ * @returns {*} Returns the result of `func`.
+ */
+function apply(func, thisArg, args) {
+  switch (args.length) {
+    case 0:
+      return func.call(thisArg);
+    case 1:
+      return func.call(thisArg, args[0]);
+    case 2:
+      return func.call(thisArg, args[0], args[1]);
+    case 3:
+      return func.call(thisArg, args[0], args[1], args[2]);
+  }
+  return func.apply(thisArg, args);
+}
+
+module.exports = apply;
+
+},{}],216:[function(require,module,exports){
+"use strict";
+
+/**
+ * A specialized version of `_.every` for arrays without support for
+ * iteratee shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} predicate The function invoked per iteration.
+ * @returns {boolean} Returns `true` if all elements pass the predicate check,
+ *  else `false`.
+ */
+function arrayEvery(array, predicate) {
+  var index = -1,
+      length = array ? array.length : 0;
+
+  while (++index < length) {
+    if (!predicate(array[index], index, array)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+module.exports = arrayEvery;
+
+},{}],217:[function(require,module,exports){
+'use strict';
+
+var baseTimes = require('./_baseTimes'),
+    isArguments = require('./isArguments'),
+    isArray = require('./isArray'),
+    isBuffer = require('./isBuffer'),
+    isIndex = require('./_isIndex'),
+    isTypedArray = require('./isTypedArray');
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * Creates an array of the enumerable property names of the array-like `value`.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @param {boolean} inherited Specify returning inherited property names.
+ * @returns {Array} Returns the array of property names.
+ */
+function arrayLikeKeys(value, inherited) {
+  var isArr = isArray(value),
+      isArg = !isArr && isArguments(value),
+      isBuff = !isArr && !isArg && isBuffer(value),
+      isType = !isArr && !isArg && !isBuff && isTypedArray(value),
+      skipIndexes = isArr || isArg || isBuff || isType,
+      result = skipIndexes ? baseTimes(value.length, String) : [],
+      length = result.length;
+
+  for (var key in value) {
+    if ((inherited || hasOwnProperty.call(value, key)) && !(skipIndexes && (
+    // Safari 9 has enumerable `arguments.length` in strict mode.
+    key == 'length' ||
+    // Node.js 0.10 has enumerable non-index properties on buffers.
+    isBuff && (key == 'offset' || key == 'parent') ||
+    // PhantomJS 2 has enumerable non-index properties on typed arrays.
+    isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset') ||
+    // Skip index properties.
+    isIndex(key, length)))) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+
+module.exports = arrayLikeKeys;
+
+},{"./_baseTimes":246,"./_isIndex":272,"./isArguments":319,"./isArray":320,"./isBuffer":322,"./isTypedArray":329}],218:[function(require,module,exports){
+"use strict";
+
+/**
+ * A specialized version of `_.map` for arrays without support for iteratee
+ * shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array} Returns the new mapped array.
+ */
+function arrayMap(array, iteratee) {
+  var index = -1,
+      length = array ? array.length : 0,
+      result = Array(length);
+
+  while (++index < length) {
+    result[index] = iteratee(array[index], index, array);
+  }
+  return result;
+}
+
+module.exports = arrayMap;
+
+},{}],219:[function(require,module,exports){
+"use strict";
+
+/**
+ * A specialized version of `_.some` for arrays without support for iteratee
+ * shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} predicate The function invoked per iteration.
+ * @returns {boolean} Returns `true` if any element passes the predicate check,
+ *  else `false`.
+ */
+function arraySome(array, predicate) {
+  var index = -1,
+      length = array ? array.length : 0;
+
+  while (++index < length) {
+    if (predicate(array[index], index, array)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+module.exports = arraySome;
+
+},{}],220:[function(require,module,exports){
+'use strict';
+
+var baseAssignValue = require('./_baseAssignValue'),
+    eq = require('./eq');
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * Assigns `value` to `key` of `object` if the existing value is not equivalent
+ * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+ * for equality comparisons.
+ *
+ * @private
+ * @param {Object} object The object to modify.
+ * @param {string} key The key of the property to assign.
+ * @param {*} value The value to assign.
+ */
+function assignValue(object, key, value) {
+  var objValue = object[key];
+  if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) || value === undefined && !(key in object)) {
+    baseAssignValue(object, key, value);
+  }
+}
+
+module.exports = assignValue;
+
+},{"./_baseAssignValue":223,"./eq":314}],221:[function(require,module,exports){
+'use strict';
+
+var eq = require('./eq');
+
+/**
+ * Gets the index at which the `key` is found in `array` of key-value pairs.
+ *
+ * @private
+ * @param {Array} array The array to inspect.
+ * @param {*} key The key to search for.
+ * @returns {number} Returns the index of the matched value, else `-1`.
+ */
+function assocIndexOf(array, key) {
+  var length = array.length;
+  while (length--) {
+    if (eq(array[length][0], key)) {
+      return length;
+    }
+  }
+  return -1;
+}
+
+module.exports = assocIndexOf;
+
+},{"./eq":314}],222:[function(require,module,exports){
+'use strict';
+
+var copyObject = require('./_copyObject'),
+    keys = require('./keys');
+
+/**
+ * The base implementation of `_.assign` without support for multiple sources
+ * or `customizer` functions.
+ *
+ * @private
+ * @param {Object} object The destination object.
+ * @param {Object} source The source object.
+ * @returns {Object} Returns `object`.
+ */
+function baseAssign(object, source) {
+  return object && copyObject(source, keys(source), object);
+}
+
+module.exports = baseAssign;
+
+},{"./_copyObject":251,"./keys":330}],223:[function(require,module,exports){
+'use strict';
+
+var defineProperty = require('./_defineProperty');
+
+/**
+ * The base implementation of `assignValue` and `assignMergeValue` without
+ * value checks.
+ *
+ * @private
+ * @param {Object} object The object to modify.
+ * @param {string} key The key of the property to assign.
+ * @param {*} value The value to assign.
+ */
+function baseAssignValue(object, key, value) {
+  if (key == '__proto__' && defineProperty) {
+    defineProperty(object, key, {
+      'configurable': true,
+      'enumerable': true,
+      'value': value,
+      'writable': true
+    });
+  } else {
+    object[key] = value;
+  }
+}
+
+module.exports = baseAssignValue;
+
+},{"./_defineProperty":256}],224:[function(require,module,exports){
+'use strict';
+
+var _create = require('babel-runtime/core-js/object/create');
+
+var _create2 = _interopRequireDefault(_create);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var isObject = require('./isObject');
+
+/** Built-in value references. */
+var objectCreate = _create2.default;
+
+/**
+ * The base implementation of `_.create` without support for assigning
+ * properties to the created object.
+ *
+ * @private
+ * @param {Object} proto The object to inherit from.
+ * @returns {Object} Returns the new object.
+ */
+var baseCreate = function () {
+  function object() {}
+  return function (proto) {
+    if (!isObject(proto)) {
+      return {};
+    }
+    if (objectCreate) {
+      return objectCreate(proto);
+    }
+    object.prototype = proto;
+    var result = new object();
+    object.prototype = undefined;
+    return result;
+  };
+}();
+
+module.exports = baseCreate;
+
+},{"./isObject":326,"babel-runtime/core-js/object/create":22}],225:[function(require,module,exports){
+'use strict';
+
+var baseForOwn = require('./_baseForOwn'),
+    createBaseEach = require('./_createBaseEach');
+
+/**
+ * The base implementation of `_.forEach` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array|Object} Returns `collection`.
+ */
+var baseEach = createBaseEach(baseForOwn);
+
+module.exports = baseEach;
+
+},{"./_baseForOwn":228,"./_createBaseEach":254}],226:[function(require,module,exports){
+'use strict';
+
+var baseEach = require('./_baseEach');
+
+/**
+ * The base implementation of `_.every` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} predicate The function invoked per iteration.
+ * @returns {boolean} Returns `true` if all elements pass the predicate check,
+ *  else `false`
+ */
+function baseEvery(collection, predicate) {
+  var result = true;
+  baseEach(collection, function (value, index, collection) {
+    result = !!predicate(value, index, collection);
+    return result;
+  });
+  return result;
+}
+
+module.exports = baseEvery;
+
+},{"./_baseEach":225}],227:[function(require,module,exports){
+'use strict';
+
+var createBaseFor = require('./_createBaseFor');
+
+/**
+ * The base implementation of `baseForOwn` which iterates over `object`
+ * properties returned by `keysFunc` and invokes `iteratee` for each property.
+ * Iteratee functions may exit iteration early by explicitly returning `false`.
+ *
+ * @private
+ * @param {Object} object The object to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @param {Function} keysFunc The function to get the keys of `object`.
+ * @returns {Object} Returns `object`.
+ */
+var baseFor = createBaseFor();
+
+module.exports = baseFor;
+
+},{"./_createBaseFor":255}],228:[function(require,module,exports){
+'use strict';
+
+var baseFor = require('./_baseFor'),
+    keys = require('./keys');
+
+/**
+ * The base implementation of `_.forOwn` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Object} object The object to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Object} Returns `object`.
+ */
+function baseForOwn(object, iteratee) {
+  return object && baseFor(object, iteratee, keys);
+}
+
+module.exports = baseForOwn;
+
+},{"./_baseFor":227,"./keys":330}],229:[function(require,module,exports){
+'use strict';
+
+var castPath = require('./_castPath'),
+    isKey = require('./_isKey'),
+    toKey = require('./_toKey');
+
+/**
+ * The base implementation of `_.get` without support for default values.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path of the property to get.
+ * @returns {*} Returns the resolved value.
+ */
+function baseGet(object, path) {
+  path = isKey(path, object) ? [path] : castPath(path);
+
+  var index = 0,
+      length = path.length;
+
+  while (object != null && index < length) {
+    object = object[toKey(path[index++])];
+  }
+  return index && index == length ? object : undefined;
+}
+
+module.exports = baseGet;
+
+},{"./_castPath":250,"./_isKey":274,"./_toKey":309}],230:[function(require,module,exports){
+"use strict";
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/**
+ * Used to resolve the
+ * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+ * of values.
+ */
+var objectToString = objectProto.toString;
+
+/**
+ * The base implementation of `getTag`.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @returns {string} Returns the `toStringTag`.
+ */
+function baseGetTag(value) {
+  return objectToString.call(value);
+}
+
+module.exports = baseGetTag;
+
+},{}],231:[function(require,module,exports){
+"use strict";
+
+/**
+ * The base implementation of `_.hasIn` without support for deep paths.
+ *
+ * @private
+ * @param {Object} [object] The object to query.
+ * @param {Array|string} key The key to check.
+ * @returns {boolean} Returns `true` if `key` exists, else `false`.
+ */
+function baseHasIn(object, key) {
+  return object != null && key in Object(object);
+}
+
+module.exports = baseHasIn;
+
+},{}],232:[function(require,module,exports){
+'use strict';
+
+var isObjectLike = require('./isObjectLike');
+
+/** `Object#toString` result references. */
+var argsTag = '[object Arguments]';
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/**
+ * Used to resolve the
+ * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+ * of values.
+ */
+var objectToString = objectProto.toString;
+
+/**
+ * The base implementation of `_.isArguments`.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an `arguments` object,
+ */
+function baseIsArguments(value) {
+  return isObjectLike(value) && objectToString.call(value) == argsTag;
+}
+
+module.exports = baseIsArguments;
+
+},{"./isObjectLike":327}],233:[function(require,module,exports){
+'use strict';
+
+var baseIsEqualDeep = require('./_baseIsEqualDeep'),
+    isObject = require('./isObject'),
+    isObjectLike = require('./isObjectLike');
+
+/**
+ * The base implementation of `_.isEqual` which supports partial comparisons
+ * and tracks traversed objects.
+ *
+ * @private
+ * @param {*} value The value to compare.
+ * @param {*} other The other value to compare.
+ * @param {Function} [customizer] The function to customize comparisons.
+ * @param {boolean} [bitmask] The bitmask of comparison flags.
+ *  The bitmask may be composed of the following flags:
+ *     1 - Unordered comparison
+ *     2 - Partial comparison
+ * @param {Object} [stack] Tracks traversed `value` and `other` objects.
+ * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+ */
+function baseIsEqual(value, other, customizer, bitmask, stack) {
+  if (value === other) {
+    return true;
+  }
+  if (value == null || other == null || !isObject(value) && !isObjectLike(other)) {
+    return value !== value && other !== other;
+  }
+  return baseIsEqualDeep(value, other, baseIsEqual, customizer, bitmask, stack);
+}
+
+module.exports = baseIsEqual;
+
+},{"./_baseIsEqualDeep":234,"./isObject":326,"./isObjectLike":327}],234:[function(require,module,exports){
+'use strict';
+
+var Stack = require('./_Stack'),
+    equalArrays = require('./_equalArrays'),
+    equalByTag = require('./_equalByTag'),
+    equalObjects = require('./_equalObjects'),
+    getTag = require('./_getTag'),
+    isArray = require('./isArray'),
+    isBuffer = require('./isBuffer'),
+    isTypedArray = require('./isTypedArray');
+
+/** Used to compose bitmasks for comparison styles. */
+var PARTIAL_COMPARE_FLAG = 2;
+
+/** `Object#toString` result references. */
+var argsTag = '[object Arguments]',
+    arrayTag = '[object Array]',
+    objectTag = '[object Object]';
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * A specialized version of `baseIsEqual` for arrays and objects which performs
+ * deep comparisons and tracks traversed objects enabling objects with circular
+ * references to be compared.
+ *
+ * @private
+ * @param {Object} object The object to compare.
+ * @param {Object} other The other object to compare.
+ * @param {Function} equalFunc The function to determine equivalents of values.
+ * @param {Function} [customizer] The function to customize comparisons.
+ * @param {number} [bitmask] The bitmask of comparison flags. See `baseIsEqual`
+ *  for more details.
+ * @param {Object} [stack] Tracks traversed `object` and `other` objects.
+ * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
+ */
+function baseIsEqualDeep(object, other, equalFunc, customizer, bitmask, stack) {
+  var objIsArr = isArray(object),
+      othIsArr = isArray(other),
+      objTag = arrayTag,
+      othTag = arrayTag;
+
+  if (!objIsArr) {
+    objTag = getTag(object);
+    objTag = objTag == argsTag ? objectTag : objTag;
+  }
+  if (!othIsArr) {
+    othTag = getTag(other);
+    othTag = othTag == argsTag ? objectTag : othTag;
+  }
+  var objIsObj = objTag == objectTag,
+      othIsObj = othTag == objectTag,
+      isSameTag = objTag == othTag;
+
+  if (isSameTag && isBuffer(object)) {
+    if (!isBuffer(other)) {
+      return false;
+    }
+    objIsArr = true;
+    objIsObj = false;
+  }
+  if (isSameTag && !objIsObj) {
+    stack || (stack = new Stack());
+    return objIsArr || isTypedArray(object) ? equalArrays(object, other, equalFunc, customizer, bitmask, stack) : equalByTag(object, other, objTag, equalFunc, customizer, bitmask, stack);
+  }
+  if (!(bitmask & PARTIAL_COMPARE_FLAG)) {
+    var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),
+        othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');
+
+    if (objIsWrapped || othIsWrapped) {
+      var objUnwrapped = objIsWrapped ? object.value() : object,
+          othUnwrapped = othIsWrapped ? other.value() : other;
+
+      stack || (stack = new Stack());
+      return equalFunc(objUnwrapped, othUnwrapped, customizer, bitmask, stack);
+    }
+  }
+  if (!isSameTag) {
+    return false;
+  }
+  stack || (stack = new Stack());
+  return equalObjects(object, other, equalFunc, customizer, bitmask, stack);
+}
+
+module.exports = baseIsEqualDeep;
+
+},{"./_Stack":211,"./_equalArrays":257,"./_equalByTag":258,"./_equalObjects":259,"./_getTag":264,"./isArray":320,"./isBuffer":322,"./isTypedArray":329}],235:[function(require,module,exports){
+'use strict';
+
+var Stack = require('./_Stack'),
+    baseIsEqual = require('./_baseIsEqual');
+
+/** Used to compose bitmasks for comparison styles. */
+var UNORDERED_COMPARE_FLAG = 1,
+    PARTIAL_COMPARE_FLAG = 2;
+
+/**
+ * The base implementation of `_.isMatch` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Object} object The object to inspect.
+ * @param {Object} source The object of property values to match.
+ * @param {Array} matchData The property names, values, and compare flags to match.
+ * @param {Function} [customizer] The function to customize comparisons.
+ * @returns {boolean} Returns `true` if `object` is a match, else `false`.
+ */
+function baseIsMatch(object, source, matchData, customizer) {
+  var index = matchData.length,
+      length = index,
+      noCustomizer = !customizer;
+
+  if (object == null) {
+    return !length;
+  }
+  object = Object(object);
+  while (index--) {
+    var data = matchData[index];
+    if (noCustomizer && data[2] ? data[1] !== object[data[0]] : !(data[0] in object)) {
+      return false;
+    }
+  }
+  while (++index < length) {
+    data = matchData[index];
+    var key = data[0],
+        objValue = object[key],
+        srcValue = data[1];
+
+    if (noCustomizer && data[2]) {
+      if (objValue === undefined && !(key in object)) {
+        return false;
+      }
+    } else {
+      var stack = new Stack();
+      if (customizer) {
+        var result = customizer(objValue, srcValue, key, object, source, stack);
+      }
+      if (!(result === undefined ? baseIsEqual(srcValue, objValue, customizer, UNORDERED_COMPARE_FLAG | PARTIAL_COMPARE_FLAG, stack) : result)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+module.exports = baseIsMatch;
+
+},{"./_Stack":211,"./_baseIsEqual":233}],236:[function(require,module,exports){
+'use strict';
+
+var isFunction = require('./isFunction'),
+    isMasked = require('./_isMasked'),
+    isObject = require('./isObject'),
+    toSource = require('./_toSource');
+
+/**
+ * Used to match `RegExp`
+ * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
+ */
+var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+
+/** Used to detect host constructors (Safari). */
+var reIsHostCtor = /^\[object .+?Constructor\]$/;
+
+/** Used for built-in method references. */
+var funcProto = Function.prototype,
+    objectProto = Object.prototype;
+
+/** Used to resolve the decompiled source of functions. */
+var funcToString = funcProto.toString;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/** Used to detect if a method is native. */
+var reIsNative = RegExp('^' + funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&').replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$');
+
+/**
+ * The base implementation of `_.isNative` without bad shim checks.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a native function,
+ *  else `false`.
+ */
+function baseIsNative(value) {
+  if (!isObject(value) || isMasked(value)) {
+    return false;
+  }
+  var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
+  return pattern.test(toSource(value));
+}
+
+module.exports = baseIsNative;
+
+},{"./_isMasked":276,"./_toSource":310,"./isFunction":324,"./isObject":326}],237:[function(require,module,exports){
+'use strict';
+
+var isLength = require('./isLength'),
+    isObjectLike = require('./isObjectLike');
+
+/** `Object#toString` result references. */
+var argsTag = '[object Arguments]',
+    arrayTag = '[object Array]',
+    boolTag = '[object Boolean]',
+    dateTag = '[object Date]',
+    errorTag = '[object Error]',
+    funcTag = '[object Function]',
+    mapTag = '[object Map]',
+    numberTag = '[object Number]',
+    objectTag = '[object Object]',
+    regexpTag = '[object RegExp]',
+    setTag = '[object Set]',
+    stringTag = '[object String]',
+    weakMapTag = '[object WeakMap]';
+
+var arrayBufferTag = '[object ArrayBuffer]',
+    dataViewTag = '[object DataView]',
+    float32Tag = '[object Float32Array]',
+    float64Tag = '[object Float64Array]',
+    int8Tag = '[object Int8Array]',
+    int16Tag = '[object Int16Array]',
+    int32Tag = '[object Int32Array]',
+    uint8Tag = '[object Uint8Array]',
+    uint8ClampedTag = '[object Uint8ClampedArray]',
+    uint16Tag = '[object Uint16Array]',
+    uint32Tag = '[object Uint32Array]';
+
+/** Used to identify `toStringTag` values of typed arrays. */
+var typedArrayTags = {};
+typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true;
+typedArrayTags[argsTag] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag] = typedArrayTags[mapTag] = typedArrayTags[numberTag] = typedArrayTags[objectTag] = typedArrayTags[regexpTag] = typedArrayTags[setTag] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/**
+ * Used to resolve the
+ * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+ * of values.
+ */
+var objectToString = objectProto.toString;
+
+/**
+ * The base implementation of `_.isTypedArray` without Node.js optimizations.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
+ */
+function baseIsTypedArray(value) {
+    return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[objectToString.call(value)];
+}
+
+module.exports = baseIsTypedArray;
+
+},{"./isLength":325,"./isObjectLike":327}],238:[function(require,module,exports){
+'use strict';
+
+var _typeof2 = require('babel-runtime/helpers/typeof');
+
+var _typeof3 = _interopRequireDefault(_typeof2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var baseMatches = require('./_baseMatches'),
+    baseMatchesProperty = require('./_baseMatchesProperty'),
+    identity = require('./identity'),
+    isArray = require('./isArray'),
+    property = require('./property');
+
+/**
+ * The base implementation of `_.iteratee`.
+ *
+ * @private
+ * @param {*} [value=_.identity] The value to convert to an iteratee.
+ * @returns {Function} Returns the iteratee.
+ */
+function baseIteratee(value) {
+  // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9.
+  // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details.
+  if (typeof value == 'function') {
+    return value;
+  }
+  if (value == null) {
+    return identity;
+  }
+  if ((typeof value === 'undefined' ? 'undefined' : (0, _typeof3.default)(value)) == 'object') {
+    return isArray(value) ? baseMatchesProperty(value[0], value[1]) : baseMatches(value);
+  }
+  return property(value);
+}
+
+module.exports = baseIteratee;
+
+},{"./_baseMatches":240,"./_baseMatchesProperty":241,"./identity":318,"./isArray":320,"./property":332,"babel-runtime/helpers/typeof":39}],239:[function(require,module,exports){
+'use strict';
+
+var isPrototype = require('./_isPrototype'),
+    nativeKeys = require('./_nativeKeys');
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names.
+ */
+function baseKeys(object) {
+  if (!isPrototype(object)) {
+    return nativeKeys(object);
+  }
+  var result = [];
+  for (var key in Object(object)) {
+    if (hasOwnProperty.call(object, key) && key != 'constructor') {
+      result.push(key);
+    }
+  }
+  return result;
+}
+
+module.exports = baseKeys;
+
+},{"./_isPrototype":277,"./_nativeKeys":293}],240:[function(require,module,exports){
+'use strict';
+
+var baseIsMatch = require('./_baseIsMatch'),
+    getMatchData = require('./_getMatchData'),
+    matchesStrictComparable = require('./_matchesStrictComparable');
+
+/**
+ * The base implementation of `_.matches` which doesn't clone `source`.
+ *
+ * @private
+ * @param {Object} source The object of property values to match.
+ * @returns {Function} Returns the new spec function.
+ */
+function baseMatches(source) {
+  var matchData = getMatchData(source);
+  if (matchData.length == 1 && matchData[0][2]) {
+    return matchesStrictComparable(matchData[0][0], matchData[0][1]);
+  }
+  return function (object) {
+    return object === source || baseIsMatch(object, source, matchData);
+  };
+}
+
+module.exports = baseMatches;
+
+},{"./_baseIsMatch":235,"./_getMatchData":262,"./_matchesStrictComparable":290}],241:[function(require,module,exports){
+'use strict';
+
+var baseIsEqual = require('./_baseIsEqual'),
+    get = require('./get'),
+    hasIn = require('./hasIn'),
+    isKey = require('./_isKey'),
+    isStrictComparable = require('./_isStrictComparable'),
+    matchesStrictComparable = require('./_matchesStrictComparable'),
+    toKey = require('./_toKey');
+
+/** Used to compose bitmasks for comparison styles. */
+var UNORDERED_COMPARE_FLAG = 1,
+    PARTIAL_COMPARE_FLAG = 2;
+
+/**
+ * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`.
+ *
+ * @private
+ * @param {string} path The path of the property to get.
+ * @param {*} srcValue The value to match.
+ * @returns {Function} Returns the new spec function.
+ */
+function baseMatchesProperty(path, srcValue) {
+  if (isKey(path) && isStrictComparable(srcValue)) {
+    return matchesStrictComparable(toKey(path), srcValue);
+  }
+  return function (object) {
+    var objValue = get(object, path);
+    return objValue === undefined && objValue === srcValue ? hasIn(object, path) : baseIsEqual(srcValue, objValue, undefined, UNORDERED_COMPARE_FLAG | PARTIAL_COMPARE_FLAG);
+  };
+}
+
+module.exports = baseMatchesProperty;
+
+},{"./_baseIsEqual":233,"./_isKey":274,"./_isStrictComparable":278,"./_matchesStrictComparable":290,"./_toKey":309,"./get":316,"./hasIn":317}],242:[function(require,module,exports){
+"use strict";
+
+/**
+ * The base implementation of `_.property` without support for deep paths.
+ *
+ * @private
+ * @param {string} key The key of the property to get.
+ * @returns {Function} Returns the new accessor function.
+ */
+function baseProperty(key) {
+  return function (object) {
+    return object == null ? undefined : object[key];
+  };
+}
+
+module.exports = baseProperty;
+
+},{}],243:[function(require,module,exports){
+'use strict';
+
+var baseGet = require('./_baseGet');
+
+/**
+ * A specialized version of `baseProperty` which supports deep paths.
+ *
+ * @private
+ * @param {Array|string} path The path of the property to get.
+ * @returns {Function} Returns the new accessor function.
+ */
+function basePropertyDeep(path) {
+  return function (object) {
+    return baseGet(object, path);
+  };
+}
+
+module.exports = basePropertyDeep;
+
+},{"./_baseGet":229}],244:[function(require,module,exports){
+'use strict';
+
+var identity = require('./identity'),
+    overRest = require('./_overRest'),
+    setToString = require('./_setToString');
+
+/**
+ * The base implementation of `_.rest` which doesn't validate or coerce arguments.
+ *
+ * @private
+ * @param {Function} func The function to apply a rest parameter to.
+ * @param {number} [start=func.length-1] The start position of the rest parameter.
+ * @returns {Function} Returns the new function.
+ */
+function baseRest(func, start) {
+  return setToString(overRest(func, start, identity), func + '');
+}
+
+module.exports = baseRest;
+
+},{"./_overRest":296,"./_setToString":301,"./identity":318}],245:[function(require,module,exports){
+'use strict';
+
+var constant = require('./constant'),
+    defineProperty = require('./_defineProperty'),
+    identity = require('./identity');
+
+/**
+ * The base implementation of `setToString` without support for hot loop shorting.
+ *
+ * @private
+ * @param {Function} func The function to modify.
+ * @param {Function} string The `toString` result.
+ * @returns {Function} Returns `func`.
+ */
+var baseSetToString = !defineProperty ? identity : function (func, string) {
+  return defineProperty(func, 'toString', {
+    'configurable': true,
+    'enumerable': false,
+    'value': constant(string),
+    'writable': true
+  });
+};
+
+module.exports = baseSetToString;
+
+},{"./_defineProperty":256,"./constant":312,"./identity":318}],246:[function(require,module,exports){
+"use strict";
+
+/**
+ * The base implementation of `_.times` without support for iteratee shorthands
+ * or max array length checks.
+ *
+ * @private
+ * @param {number} n The number of times to invoke `iteratee`.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array} Returns the array of results.
+ */
+function baseTimes(n, iteratee) {
+  var index = -1,
+      result = Array(n);
+
+  while (++index < n) {
+    result[index] = iteratee(index);
+  }
+  return result;
+}
+
+module.exports = baseTimes;
+
+},{}],247:[function(require,module,exports){
+'use strict';
+
+var _Symbol = require('./_Symbol'),
+    arrayMap = require('./_arrayMap'),
+    isArray = require('./isArray'),
+    isSymbol = require('./isSymbol');
+
+/** Used as references for various `Number` constants. */
+var INFINITY = 1 / 0;
+
+/** Used to convert symbols to primitives and strings. */
+var symbolProto = _Symbol ? _Symbol.prototype : undefined,
+    symbolToString = symbolProto ? symbolProto.toString : undefined;
+
+/**
+ * The base implementation of `_.toString` which doesn't convert nullish
+ * values to empty strings.
+ *
+ * @private
+ * @param {*} value The value to process.
+ * @returns {string} Returns the string.
+ */
+function baseToString(value) {
+  // Exit early for strings to avoid a performance hit in some environments.
+  if (typeof value == 'string') {
+    return value;
+  }
+  if (isArray(value)) {
+    // Recursively convert values (susceptible to call stack limits).
+    return arrayMap(value, baseToString) + '';
+  }
+  if (isSymbol(value)) {
+    return symbolToString ? symbolToString.call(value) : '';
+  }
+  var result = value + '';
+  return result == '0' && 1 / value == -INFINITY ? '-0' : result;
+}
+
+module.exports = baseToString;
+
+},{"./_Symbol":212,"./_arrayMap":218,"./isArray":320,"./isSymbol":328}],248:[function(require,module,exports){
+"use strict";
+
+/**
+ * The base implementation of `_.unary` without support for storing metadata.
+ *
+ * @private
+ * @param {Function} func The function to cap arguments for.
+ * @returns {Function} Returns the new capped function.
+ */
+function baseUnary(func) {
+  return function (value) {
+    return func(value);
+  };
+}
+
+module.exports = baseUnary;
+
+},{}],249:[function(require,module,exports){
+"use strict";
+
+/**
+ * Checks if a `cache` value for `key` exists.
+ *
+ * @private
+ * @param {Object} cache The cache to query.
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+function cacheHas(cache, key) {
+  return cache.has(key);
+}
+
+module.exports = cacheHas;
+
+},{}],250:[function(require,module,exports){
+'use strict';
+
+var isArray = require('./isArray'),
+    stringToPath = require('./_stringToPath');
+
+/**
+ * Casts `value` to a path array if it's not one.
+ *
+ * @private
+ * @param {*} value The value to inspect.
+ * @returns {Array} Returns the cast property path array.
+ */
+function castPath(value) {
+  return isArray(value) ? value : stringToPath(value);
+}
+
+module.exports = castPath;
+
+},{"./_stringToPath":308,"./isArray":320}],251:[function(require,module,exports){
+'use strict';
+
+var assignValue = require('./_assignValue'),
+    baseAssignValue = require('./_baseAssignValue');
+
+/**
+ * Copies properties of `source` to `object`.
+ *
+ * @private
+ * @param {Object} source The object to copy properties from.
+ * @param {Array} props The property identifiers to copy.
+ * @param {Object} [object={}] The object to copy properties to.
+ * @param {Function} [customizer] The function to customize copied values.
+ * @returns {Object} Returns `object`.
+ */
+function copyObject(source, props, object, customizer) {
+  var isNew = !object;
+  object || (object = {});
+
+  var index = -1,
+      length = props.length;
+
+  while (++index < length) {
+    var key = props[index];
+
+    var newValue = customizer ? customizer(object[key], source[key], key, object, source) : undefined;
+
+    if (newValue === undefined) {
+      newValue = source[key];
+    }
+    if (isNew) {
+      baseAssignValue(object, key, newValue);
+    } else {
+      assignValue(object, key, newValue);
+    }
+  }
+  return object;
+}
+
+module.exports = copyObject;
+
+},{"./_assignValue":220,"./_baseAssignValue":223}],252:[function(require,module,exports){
+'use strict';
+
+var root = require('./_root');
+
+/** Used to detect overreaching core-js shims. */
+var coreJsData = root['__core-js_shared__'];
+
+module.exports = coreJsData;
+
+},{"./_root":297}],253:[function(require,module,exports){
+'use strict';
+
+var baseRest = require('./_baseRest'),
+    isIterateeCall = require('./_isIterateeCall');
+
+/**
+ * Creates a function like `_.assign`.
+ *
+ * @private
+ * @param {Function} assigner The function to assign values.
+ * @returns {Function} Returns the new assigner function.
+ */
+function createAssigner(assigner) {
+  return baseRest(function (object, sources) {
+    var index = -1,
+        length = sources.length,
+        customizer = length > 1 ? sources[length - 1] : undefined,
+        guard = length > 2 ? sources[2] : undefined;
+
+    customizer = assigner.length > 3 && typeof customizer == 'function' ? (length--, customizer) : undefined;
+
+    if (guard && isIterateeCall(sources[0], sources[1], guard)) {
+      customizer = length < 3 ? undefined : customizer;
+      length = 1;
+    }
+    object = Object(object);
+    while (++index < length) {
+      var source = sources[index];
+      if (source) {
+        assigner(object, source, index, customizer);
+      }
+    }
+    return object;
+  });
+}
+
+module.exports = createAssigner;
+
+},{"./_baseRest":244,"./_isIterateeCall":273}],254:[function(require,module,exports){
+'use strict';
+
+var isArrayLike = require('./isArrayLike');
+
+/**
+ * Creates a `baseEach` or `baseEachRight` function.
+ *
+ * @private
+ * @param {Function} eachFunc The function to iterate over a collection.
+ * @param {boolean} [fromRight] Specify iterating from right to left.
+ * @returns {Function} Returns the new base function.
+ */
+function createBaseEach(eachFunc, fromRight) {
+  return function (collection, iteratee) {
+    if (collection == null) {
+      return collection;
+    }
+    if (!isArrayLike(collection)) {
+      return eachFunc(collection, iteratee);
+    }
+    var length = collection.length,
+        index = fromRight ? length : -1,
+        iterable = Object(collection);
+
+    while (fromRight ? index-- : ++index < length) {
+      if (iteratee(iterable[index], index, iterable) === false) {
+        break;
+      }
+    }
+    return collection;
+  };
+}
+
+module.exports = createBaseEach;
+
+},{"./isArrayLike":321}],255:[function(require,module,exports){
+"use strict";
+
+/**
+ * Creates a base function for methods like `_.forIn` and `_.forOwn`.
+ *
+ * @private
+ * @param {boolean} [fromRight] Specify iterating from right to left.
+ * @returns {Function} Returns the new base function.
+ */
+function createBaseFor(fromRight) {
+  return function (object, iteratee, keysFunc) {
+    var index = -1,
+        iterable = Object(object),
+        props = keysFunc(object),
+        length = props.length;
+
+    while (length--) {
+      var key = props[fromRight ? length : ++index];
+      if (iteratee(iterable[key], key, iterable) === false) {
+        break;
+      }
+    }
+    return object;
+  };
+}
+
+module.exports = createBaseFor;
+
+},{}],256:[function(require,module,exports){
+'use strict';
+
+var getNative = require('./_getNative');
+
+var defineProperty = function () {
+  try {
+    var func = getNative(Object, 'defineProperty');
+    func({}, '', {});
+    return func;
+  } catch (e) {}
+}();
+
+module.exports = defineProperty;
+
+},{"./_getNative":263}],257:[function(require,module,exports){
+'use strict';
+
+var SetCache = require('./_SetCache'),
+    arraySome = require('./_arraySome'),
+    cacheHas = require('./_cacheHas');
+
+/** Used to compose bitmasks for comparison styles. */
+var UNORDERED_COMPARE_FLAG = 1,
+    PARTIAL_COMPARE_FLAG = 2;
+
+/**
+ * A specialized version of `baseIsEqualDeep` for arrays with support for
+ * partial deep comparisons.
+ *
+ * @private
+ * @param {Array} array The array to compare.
+ * @param {Array} other The other array to compare.
+ * @param {Function} equalFunc The function to determine equivalents of values.
+ * @param {Function} customizer The function to customize comparisons.
+ * @param {number} bitmask The bitmask of comparison flags. See `baseIsEqual`
+ *  for more details.
+ * @param {Object} stack Tracks traversed `array` and `other` objects.
+ * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.
+ */
+function equalArrays(array, other, equalFunc, customizer, bitmask, stack) {
+  var isPartial = bitmask & PARTIAL_COMPARE_FLAG,
+      arrLength = array.length,
+      othLength = other.length;
+
+  if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
+    return false;
+  }
+  // Assume cyclic values are equal.
+  var stacked = stack.get(array);
+  if (stacked && stack.get(other)) {
+    return stacked == other;
+  }
+  var index = -1,
+      result = true,
+      seen = bitmask & UNORDERED_COMPARE_FLAG ? new SetCache() : undefined;
+
+  stack.set(array, other);
+  stack.set(other, array);
+
+  // Ignore non-index properties.
+  while (++index < arrLength) {
+    var arrValue = array[index],
+        othValue = other[index];
+
+    if (customizer) {
+      var compared = isPartial ? customizer(othValue, arrValue, index, other, array, stack) : customizer(arrValue, othValue, index, array, other, stack);
+    }
+    if (compared !== undefined) {
+      if (compared) {
+        continue;
+      }
+      result = false;
+      break;
+    }
+    // Recursively compare arrays (susceptible to call stack limits).
+    if (seen) {
+      if (!arraySome(other, function (othValue, othIndex) {
+        if (!cacheHas(seen, othIndex) && (arrValue === othValue || equalFunc(arrValue, othValue, customizer, bitmask, stack))) {
+          return seen.push(othIndex);
+        }
+      })) {
+        result = false;
+        break;
+      }
+    } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, customizer, bitmask, stack))) {
+      result = false;
+      break;
+    }
+  }
+  stack['delete'](array);
+  stack['delete'](other);
+  return result;
+}
+
+module.exports = equalArrays;
+
+},{"./_SetCache":210,"./_arraySome":219,"./_cacheHas":249}],258:[function(require,module,exports){
+'use strict';
+
+var _Symbol = require('./_Symbol'),
+    Uint8Array = require('./_Uint8Array'),
+    eq = require('./eq'),
+    equalArrays = require('./_equalArrays'),
+    mapToArray = require('./_mapToArray'),
+    setToArray = require('./_setToArray');
+
+/** Used to compose bitmasks for comparison styles. */
+var UNORDERED_COMPARE_FLAG = 1,
+    PARTIAL_COMPARE_FLAG = 2;
+
+/** `Object#toString` result references. */
+var boolTag = '[object Boolean]',
+    dateTag = '[object Date]',
+    errorTag = '[object Error]',
+    mapTag = '[object Map]',
+    numberTag = '[object Number]',
+    regexpTag = '[object RegExp]',
+    setTag = '[object Set]',
+    stringTag = '[object String]',
+    symbolTag = '[object Symbol]';
+
+var arrayBufferTag = '[object ArrayBuffer]',
+    dataViewTag = '[object DataView]';
+
+/** Used to convert symbols to primitives and strings. */
+var symbolProto = _Symbol ? _Symbol.prototype : undefined,
+    symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;
+
+/**
+ * A specialized version of `baseIsEqualDeep` for comparing objects of
+ * the same `toStringTag`.
+ *
+ * **Note:** This function only supports comparing values with tags of
+ * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.
+ *
+ * @private
+ * @param {Object} object The object to compare.
+ * @param {Object} other The other object to compare.
+ * @param {string} tag The `toStringTag` of the objects to compare.
+ * @param {Function} equalFunc The function to determine equivalents of values.
+ * @param {Function} customizer The function to customize comparisons.
+ * @param {number} bitmask The bitmask of comparison flags. See `baseIsEqual`
+ *  for more details.
+ * @param {Object} stack Tracks traversed `object` and `other` objects.
+ * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
+ */
+function equalByTag(object, other, tag, equalFunc, customizer, bitmask, stack) {
+  switch (tag) {
+    case dataViewTag:
+      if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset) {
+        return false;
+      }
+      object = object.buffer;
+      other = other.buffer;
+
+    case arrayBufferTag:
+      if (object.byteLength != other.byteLength || !equalFunc(new Uint8Array(object), new Uint8Array(other))) {
+        return false;
+      }
+      return true;
+
+    case boolTag:
+    case dateTag:
+    case numberTag:
+      // Coerce booleans to `1` or `0` and dates to milliseconds.
+      // Invalid dates are coerced to `NaN`.
+      return eq(+object, +other);
+
+    case errorTag:
+      return object.name == other.name && object.message == other.message;
+
+    case regexpTag:
+    case stringTag:
+      // Coerce regexes to strings and treat strings, primitives and objects,
+      // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring
+      // for more details.
+      return object == other + '';
+
+    case mapTag:
+      var convert = mapToArray;
+
+    case setTag:
+      var isPartial = bitmask & PARTIAL_COMPARE_FLAG;
+      convert || (convert = setToArray);
+
+      if (object.size != other.size && !isPartial) {
+        return false;
+      }
+      // Assume cyclic values are equal.
+      var stacked = stack.get(object);
+      if (stacked) {
+        return stacked == other;
+      }
+      bitmask |= UNORDERED_COMPARE_FLAG;
+
+      // Recursively compare objects (susceptible to call stack limits).
+      stack.set(object, other);
+      var result = equalArrays(convert(object), convert(other), equalFunc, customizer, bitmask, stack);
+      stack['delete'](object);
+      return result;
+
+    case symbolTag:
+      if (symbolValueOf) {
+        return symbolValueOf.call(object) == symbolValueOf.call(other);
+      }
+  }
+  return false;
+}
+
+module.exports = equalByTag;
+
+},{"./_Symbol":212,"./_Uint8Array":213,"./_equalArrays":257,"./_mapToArray":289,"./_setToArray":300,"./eq":314}],259:[function(require,module,exports){
+'use strict';
+
+var keys = require('./keys');
+
+/** Used to compose bitmasks for comparison styles. */
+var PARTIAL_COMPARE_FLAG = 2;
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * A specialized version of `baseIsEqualDeep` for objects with support for
+ * partial deep comparisons.
+ *
+ * @private
+ * @param {Object} object The object to compare.
+ * @param {Object} other The other object to compare.
+ * @param {Function} equalFunc The function to determine equivalents of values.
+ * @param {Function} customizer The function to customize comparisons.
+ * @param {number} bitmask The bitmask of comparison flags. See `baseIsEqual`
+ *  for more details.
+ * @param {Object} stack Tracks traversed `object` and `other` objects.
+ * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
+ */
+function equalObjects(object, other, equalFunc, customizer, bitmask, stack) {
+  var isPartial = bitmask & PARTIAL_COMPARE_FLAG,
+      objProps = keys(object),
+      objLength = objProps.length,
+      othProps = keys(other),
+      othLength = othProps.length;
+
+  if (objLength != othLength && !isPartial) {
+    return false;
+  }
+  var index = objLength;
+  while (index--) {
+    var key = objProps[index];
+    if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {
+      return false;
+    }
+  }
+  // Assume cyclic values are equal.
+  var stacked = stack.get(object);
+  if (stacked && stack.get(other)) {
+    return stacked == other;
+  }
+  var result = true;
+  stack.set(object, other);
+  stack.set(other, object);
+
+  var skipCtor = isPartial;
+  while (++index < objLength) {
+    key = objProps[index];
+    var objValue = object[key],
+        othValue = other[key];
+
+    if (customizer) {
+      var compared = isPartial ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, other, stack);
+    }
+    // Recursively compare objects (susceptible to call stack limits).
+    if (!(compared === undefined ? objValue === othValue || equalFunc(objValue, othValue, customizer, bitmask, stack) : compared)) {
+      result = false;
+      break;
+    }
+    skipCtor || (skipCtor = key == 'constructor');
+  }
+  if (result && !skipCtor) {
+    var objCtor = object.constructor,
+        othCtor = other.constructor;
+
+    // Non `Object` object instances with different constructors are not equal.
+    if (objCtor != othCtor && 'constructor' in object && 'constructor' in other && !(typeof objCtor == 'function' && objCtor instanceof objCtor && typeof othCtor == 'function' && othCtor instanceof othCtor)) {
+      result = false;
+    }
+  }
+  stack['delete'](object);
+  stack['delete'](other);
+  return result;
+}
+
+module.exports = equalObjects;
+
+},{"./keys":330}],260:[function(require,module,exports){
+(function (global){
+'use strict';
+
+var _typeof2 = require('babel-runtime/helpers/typeof');
+
+var _typeof3 = _interopRequireDefault(_typeof2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/** Detect free variable `global` from Node.js. */
+var freeGlobal = (typeof global === 'undefined' ? 'undefined' : (0, _typeof3.default)(global)) == 'object' && global && global.Object === Object && global;
+
+module.exports = freeGlobal;
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"babel-runtime/helpers/typeof":39}],261:[function(require,module,exports){
+'use strict';
+
+var isKeyable = require('./_isKeyable');
+
+/**
+ * Gets the data for `map`.
+ *
+ * @private
+ * @param {Object} map The map to query.
+ * @param {string} key The reference key.
+ * @returns {*} Returns the map data.
+ */
+function getMapData(map, key) {
+  var data = map.__data__;
+  return isKeyable(key) ? data[typeof key == 'string' ? 'string' : 'hash'] : data.map;
+}
+
+module.exports = getMapData;
+
+},{"./_isKeyable":275}],262:[function(require,module,exports){
+'use strict';
+
+var isStrictComparable = require('./_isStrictComparable'),
+    keys = require('./keys');
+
+/**
+ * Gets the property names, values, and compare flags of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the match data of `object`.
+ */
+function getMatchData(object) {
+    var result = keys(object),
+        length = result.length;
+
+    while (length--) {
+        var key = result[length],
+            value = object[key];
+
+        result[length] = [key, value, isStrictComparable(value)];
+    }
+    return result;
+}
+
+module.exports = getMatchData;
+
+},{"./_isStrictComparable":278,"./keys":330}],263:[function(require,module,exports){
+'use strict';
+
+var baseIsNative = require('./_baseIsNative'),
+    getValue = require('./_getValue');
+
+/**
+ * Gets the native function at `key` of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {string} key The key of the method to get.
+ * @returns {*} Returns the function if it's native, else `undefined`.
+ */
+function getNative(object, key) {
+  var value = getValue(object, key);
+  return baseIsNative(value) ? value : undefined;
+}
+
+module.exports = getNative;
+
+},{"./_baseIsNative":236,"./_getValue":265}],264:[function(require,module,exports){
+'use strict';
+
+var DataView = require('./_DataView'),
+    Map = require('./_Map'),
+    Promise = require('./_Promise'),
+    Set = require('./_Set'),
+    WeakMap = require('./_WeakMap'),
+    baseGetTag = require('./_baseGetTag'),
+    toSource = require('./_toSource');
+
+/** `Object#toString` result references. */
+var mapTag = '[object Map]',
+    objectTag = '[object Object]',
+    promiseTag = '[object Promise]',
+    setTag = '[object Set]',
+    weakMapTag = '[object WeakMap]';
+
+var dataViewTag = '[object DataView]';
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/**
+ * Used to resolve the
+ * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+ * of values.
+ */
+var objectToString = objectProto.toString;
+
+/** Used to detect maps, sets, and weakmaps. */
+var dataViewCtorString = toSource(DataView),
+    mapCtorString = toSource(Map),
+    promiseCtorString = toSource(Promise),
+    setCtorString = toSource(Set),
+    weakMapCtorString = toSource(WeakMap);
+
+/**
+ * Gets the `toStringTag` of `value`.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @returns {string} Returns the `toStringTag`.
+ */
+var getTag = baseGetTag;
+
+// Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.
+if (DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag || Map && getTag(new Map()) != mapTag || Promise && getTag(Promise.resolve()) != promiseTag || Set && getTag(new Set()) != setTag || WeakMap && getTag(new WeakMap()) != weakMapTag) {
+    getTag = function getTag(value) {
+        var result = objectToString.call(value),
+            Ctor = result == objectTag ? value.constructor : undefined,
+            ctorString = Ctor ? toSource(Ctor) : undefined;
+
+        if (ctorString) {
+            switch (ctorString) {
+                case dataViewCtorString:
+                    return dataViewTag;
+                case mapCtorString:
+                    return mapTag;
+                case promiseCtorString:
+                    return promiseTag;
+                case setCtorString:
+                    return setTag;
+                case weakMapCtorString:
+                    return weakMapTag;
+            }
+        }
+        return result;
+    };
+}
+
+module.exports = getTag;
+
+},{"./_DataView":203,"./_Map":206,"./_Promise":208,"./_Set":209,"./_WeakMap":214,"./_baseGetTag":230,"./_toSource":310}],265:[function(require,module,exports){
+"use strict";
+
+/**
+ * Gets the value at `key` of `object`.
+ *
+ * @private
+ * @param {Object} [object] The object to query.
+ * @param {string} key The key of the property to get.
+ * @returns {*} Returns the property value.
+ */
+function getValue(object, key) {
+  return object == null ? undefined : object[key];
+}
+
+module.exports = getValue;
+
+},{}],266:[function(require,module,exports){
+'use strict';
+
+var castPath = require('./_castPath'),
+    isArguments = require('./isArguments'),
+    isArray = require('./isArray'),
+    isIndex = require('./_isIndex'),
+    isKey = require('./_isKey'),
+    isLength = require('./isLength'),
+    toKey = require('./_toKey');
+
+/**
+ * Checks if `path` exists on `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path to check.
+ * @param {Function} hasFunc The function to check properties.
+ * @returns {boolean} Returns `true` if `path` exists, else `false`.
+ */
+function hasPath(object, path, hasFunc) {
+  path = isKey(path, object) ? [path] : castPath(path);
+
+  var index = -1,
+      length = path.length,
+      result = false;
+
+  while (++index < length) {
+    var key = toKey(path[index]);
+    if (!(result = object != null && hasFunc(object, key))) {
+      break;
+    }
+    object = object[key];
+  }
+  if (result || ++index != length) {
+    return result;
+  }
+  length = object ? object.length : 0;
+  return !!length && isLength(length) && isIndex(key, length) && (isArray(object) || isArguments(object));
+}
+
+module.exports = hasPath;
+
+},{"./_castPath":250,"./_isIndex":272,"./_isKey":274,"./_toKey":309,"./isArguments":319,"./isArray":320,"./isLength":325}],267:[function(require,module,exports){
+'use strict';
+
+var nativeCreate = require('./_nativeCreate');
+
+/**
+ * Removes all key-value entries from the hash.
+ *
+ * @private
+ * @name clear
+ * @memberOf Hash
+ */
+function hashClear() {
+  this.__data__ = nativeCreate ? nativeCreate(null) : {};
+  this.size = 0;
+}
+
+module.exports = hashClear;
+
+},{"./_nativeCreate":292}],268:[function(require,module,exports){
+"use strict";
+
+/**
+ * Removes `key` and its value from the hash.
+ *
+ * @private
+ * @name delete
+ * @memberOf Hash
+ * @param {Object} hash The hash to modify.
+ * @param {string} key The key of the value to remove.
+ * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+ */
+function hashDelete(key) {
+  var result = this.has(key) && delete this.__data__[key];
+  this.size -= result ? 1 : 0;
+  return result;
+}
+
+module.exports = hashDelete;
+
+},{}],269:[function(require,module,exports){
+'use strict';
+
+var nativeCreate = require('./_nativeCreate');
+
+/** Used to stand-in for `undefined` hash values. */
+var HASH_UNDEFINED = '__lodash_hash_undefined__';
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * Gets the hash value for `key`.
+ *
+ * @private
+ * @name get
+ * @memberOf Hash
+ * @param {string} key The key of the value to get.
+ * @returns {*} Returns the entry value.
+ */
+function hashGet(key) {
+  var data = this.__data__;
+  if (nativeCreate) {
+    var result = data[key];
+    return result === HASH_UNDEFINED ? undefined : result;
+  }
+  return hasOwnProperty.call(data, key) ? data[key] : undefined;
+}
+
+module.exports = hashGet;
+
+},{"./_nativeCreate":292}],270:[function(require,module,exports){
+'use strict';
+
+var nativeCreate = require('./_nativeCreate');
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * Checks if a hash value for `key` exists.
+ *
+ * @private
+ * @name has
+ * @memberOf Hash
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+function hashHas(key) {
+  var data = this.__data__;
+  return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key);
+}
+
+module.exports = hashHas;
+
+},{"./_nativeCreate":292}],271:[function(require,module,exports){
+'use strict';
+
+var nativeCreate = require('./_nativeCreate');
+
+/** Used to stand-in for `undefined` hash values. */
+var HASH_UNDEFINED = '__lodash_hash_undefined__';
+
+/**
+ * Sets the hash `key` to `value`.
+ *
+ * @private
+ * @name set
+ * @memberOf Hash
+ * @param {string} key The key of the value to set.
+ * @param {*} value The value to set.
+ * @returns {Object} Returns the hash instance.
+ */
+function hashSet(key, value) {
+  var data = this.__data__;
+  this.size += this.has(key) ? 0 : 1;
+  data[key] = nativeCreate && value === undefined ? HASH_UNDEFINED : value;
+  return this;
+}
+
+module.exports = hashSet;
+
+},{"./_nativeCreate":292}],272:[function(require,module,exports){
+'use strict';
+
+/** Used as references for various `Number` constants. */
+var MAX_SAFE_INTEGER = 9007199254740991;
+
+/** Used to detect unsigned integer values. */
+var reIsUint = /^(?:0|[1-9]\d*)$/;
+
+/**
+ * Checks if `value` is a valid array-like index.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
+ * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
+ */
+function isIndex(value, length) {
+  length = length == null ? MAX_SAFE_INTEGER : length;
+  return !!length && (typeof value == 'number' || reIsUint.test(value)) && value > -1 && value % 1 == 0 && value < length;
+}
+
+module.exports = isIndex;
+
+},{}],273:[function(require,module,exports){
+'use strict';
+
+var _typeof2 = require('babel-runtime/helpers/typeof');
+
+var _typeof3 = _interopRequireDefault(_typeof2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var eq = require('./eq'),
+    isArrayLike = require('./isArrayLike'),
+    isIndex = require('./_isIndex'),
+    isObject = require('./isObject');
+
+/**
+ * Checks if the given arguments are from an iteratee call.
+ *
+ * @private
+ * @param {*} value The potential iteratee value argument.
+ * @param {*} index The potential iteratee index or key argument.
+ * @param {*} object The potential iteratee object argument.
+ * @returns {boolean} Returns `true` if the arguments are from an iteratee call,
+ *  else `false`.
+ */
+function isIterateeCall(value, index, object) {
+  if (!isObject(object)) {
+    return false;
+  }
+  var type = typeof index === 'undefined' ? 'undefined' : (0, _typeof3.default)(index);
+  if (type == 'number' ? isArrayLike(object) && isIndex(index, object.length) : type == 'string' && index in object) {
+    return eq(object[index], value);
+  }
+  return false;
+}
+
+module.exports = isIterateeCall;
+
+},{"./_isIndex":272,"./eq":314,"./isArrayLike":321,"./isObject":326,"babel-runtime/helpers/typeof":39}],274:[function(require,module,exports){
+'use strict';
+
+var _typeof2 = require('babel-runtime/helpers/typeof');
+
+var _typeof3 = _interopRequireDefault(_typeof2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var isArray = require('./isArray'),
+    isSymbol = require('./isSymbol');
+
+/** Used to match property names within property paths. */
+var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,
+    reIsPlainProp = /^\w*$/;
+
+/**
+ * Checks if `value` is a property name and not a property path.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @param {Object} [object] The object to query keys on.
+ * @returns {boolean} Returns `true` if `value` is a property name, else `false`.
+ */
+function isKey(value, object) {
+  if (isArray(value)) {
+    return false;
+  }
+  var type = typeof value === 'undefined' ? 'undefined' : (0, _typeof3.default)(value);
+  if (type == 'number' || type == 'symbol' || type == 'boolean' || value == null || isSymbol(value)) {
+    return true;
+  }
+  return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object != null && value in Object(object);
+}
+
+module.exports = isKey;
+
+},{"./isArray":320,"./isSymbol":328,"babel-runtime/helpers/typeof":39}],275:[function(require,module,exports){
+'use strict';
+
+var _typeof2 = require('babel-runtime/helpers/typeof');
+
+var _typeof3 = _interopRequireDefault(_typeof2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * Checks if `value` is suitable for use as unique object key.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is suitable, else `false`.
+ */
+function isKeyable(value) {
+  var type = typeof value === 'undefined' ? 'undefined' : (0, _typeof3.default)(value);
+  return type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean' ? value !== '__proto__' : value === null;
+}
+
+module.exports = isKeyable;
+
+},{"babel-runtime/helpers/typeof":39}],276:[function(require,module,exports){
+'use strict';
+
+var coreJsData = require('./_coreJsData');
+
+/** Used to detect methods masquerading as native. */
+var maskSrcKey = function () {
+  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');
+  return uid ? 'Symbol(src)_1.' + uid : '';
+}();
+
+/**
+ * Checks if `func` has its source masked.
+ *
+ * @private
+ * @param {Function} func The function to check.
+ * @returns {boolean} Returns `true` if `func` is masked, else `false`.
+ */
+function isMasked(func) {
+  return !!maskSrcKey && maskSrcKey in func;
+}
+
+module.exports = isMasked;
+
+},{"./_coreJsData":252}],277:[function(require,module,exports){
+'use strict';
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/**
+ * Checks if `value` is likely a prototype object.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.
+ */
+function isPrototype(value) {
+  var Ctor = value && value.constructor,
+      proto = typeof Ctor == 'function' && Ctor.prototype || objectProto;
+
+  return value === proto;
+}
+
+module.exports = isPrototype;
+
+},{}],278:[function(require,module,exports){
+'use strict';
+
+var isObject = require('./isObject');
+
+/**
+ * Checks if `value` is suitable for strict equality comparisons, i.e. `===`.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` if suitable for strict
+ *  equality comparisons, else `false`.
+ */
+function isStrictComparable(value) {
+  return value === value && !isObject(value);
+}
+
+module.exports = isStrictComparable;
+
+},{"./isObject":326}],279:[function(require,module,exports){
+"use strict";
+
+/**
+ * Removes all key-value entries from the list cache.
+ *
+ * @private
+ * @name clear
+ * @memberOf ListCache
+ */
+function listCacheClear() {
+  this.__data__ = [];
+  this.size = 0;
+}
+
+module.exports = listCacheClear;
+
+},{}],280:[function(require,module,exports){
+'use strict';
+
+var assocIndexOf = require('./_assocIndexOf');
+
+/** Used for built-in method references. */
+var arrayProto = Array.prototype;
+
+/** Built-in value references. */
+var splice = arrayProto.splice;
+
+/**
+ * Removes `key` and its value from the list cache.
+ *
+ * @private
+ * @name delete
+ * @memberOf ListCache
+ * @param {string} key The key of the value to remove.
+ * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+ */
+function listCacheDelete(key) {
+  var data = this.__data__,
+      index = assocIndexOf(data, key);
+
+  if (index < 0) {
+    return false;
+  }
+  var lastIndex = data.length - 1;
+  if (index == lastIndex) {
+    data.pop();
+  } else {
+    splice.call(data, index, 1);
+  }
+  --this.size;
+  return true;
+}
+
+module.exports = listCacheDelete;
+
+},{"./_assocIndexOf":221}],281:[function(require,module,exports){
+'use strict';
+
+var assocIndexOf = require('./_assocIndexOf');
+
+/**
+ * Gets the list cache value for `key`.
+ *
+ * @private
+ * @name get
+ * @memberOf ListCache
+ * @param {string} key The key of the value to get.
+ * @returns {*} Returns the entry value.
+ */
+function listCacheGet(key) {
+  var data = this.__data__,
+      index = assocIndexOf(data, key);
+
+  return index < 0 ? undefined : data[index][1];
+}
+
+module.exports = listCacheGet;
+
+},{"./_assocIndexOf":221}],282:[function(require,module,exports){
+'use strict';
+
+var assocIndexOf = require('./_assocIndexOf');
+
+/**
+ * Checks if a list cache value for `key` exists.
+ *
+ * @private
+ * @name has
+ * @memberOf ListCache
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+function listCacheHas(key) {
+  return assocIndexOf(this.__data__, key) > -1;
+}
+
+module.exports = listCacheHas;
+
+},{"./_assocIndexOf":221}],283:[function(require,module,exports){
+'use strict';
+
+var assocIndexOf = require('./_assocIndexOf');
+
+/**
+ * Sets the list cache `key` to `value`.
+ *
+ * @private
+ * @name set
+ * @memberOf ListCache
+ * @param {string} key The key of the value to set.
+ * @param {*} value The value to set.
+ * @returns {Object} Returns the list cache instance.
+ */
+function listCacheSet(key, value) {
+  var data = this.__data__,
+      index = assocIndexOf(data, key);
+
+  if (index < 0) {
+    ++this.size;
+    data.push([key, value]);
+  } else {
+    data[index][1] = value;
+  }
+  return this;
+}
+
+module.exports = listCacheSet;
+
+},{"./_assocIndexOf":221}],284:[function(require,module,exports){
+'use strict';
+
+var Hash = require('./_Hash'),
+    ListCache = require('./_ListCache'),
+    Map = require('./_Map');
+
+/**
+ * Removes all key-value entries from the map.
+ *
+ * @private
+ * @name clear
+ * @memberOf MapCache
+ */
+function mapCacheClear() {
+  this.size = 0;
+  this.__data__ = {
+    'hash': new Hash(),
+    'map': new (Map || ListCache)(),
+    'string': new Hash()
+  };
+}
+
+module.exports = mapCacheClear;
+
+},{"./_Hash":204,"./_ListCache":205,"./_Map":206}],285:[function(require,module,exports){
+'use strict';
+
+var getMapData = require('./_getMapData');
+
+/**
+ * Removes `key` and its value from the map.
+ *
+ * @private
+ * @name delete
+ * @memberOf MapCache
+ * @param {string} key The key of the value to remove.
+ * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+ */
+function mapCacheDelete(key) {
+  var result = getMapData(this, key)['delete'](key);
+  this.size -= result ? 1 : 0;
+  return result;
+}
+
+module.exports = mapCacheDelete;
+
+},{"./_getMapData":261}],286:[function(require,module,exports){
+'use strict';
+
+var getMapData = require('./_getMapData');
+
+/**
+ * Gets the map value for `key`.
+ *
+ * @private
+ * @name get
+ * @memberOf MapCache
+ * @param {string} key The key of the value to get.
+ * @returns {*} Returns the entry value.
+ */
+function mapCacheGet(key) {
+  return getMapData(this, key).get(key);
+}
+
+module.exports = mapCacheGet;
+
+},{"./_getMapData":261}],287:[function(require,module,exports){
+'use strict';
+
+var getMapData = require('./_getMapData');
+
+/**
+ * Checks if a map value for `key` exists.
+ *
+ * @private
+ * @name has
+ * @memberOf MapCache
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+function mapCacheHas(key) {
+  return getMapData(this, key).has(key);
+}
+
+module.exports = mapCacheHas;
+
+},{"./_getMapData":261}],288:[function(require,module,exports){
+'use strict';
+
+var getMapData = require('./_getMapData');
+
+/**
+ * Sets the map `key` to `value`.
+ *
+ * @private
+ * @name set
+ * @memberOf MapCache
+ * @param {string} key The key of the value to set.
+ * @param {*} value The value to set.
+ * @returns {Object} Returns the map cache instance.
+ */
+function mapCacheSet(key, value) {
+  var data = getMapData(this, key),
+      size = data.size;
+
+  data.set(key, value);
+  this.size += data.size == size ? 0 : 1;
+  return this;
+}
+
+module.exports = mapCacheSet;
+
+},{"./_getMapData":261}],289:[function(require,module,exports){
+"use strict";
+
+/**
+ * Converts `map` to its key-value pairs.
+ *
+ * @private
+ * @param {Object} map The map to convert.
+ * @returns {Array} Returns the key-value pairs.
+ */
+function mapToArray(map) {
+  var index = -1,
+      result = Array(map.size);
+
+  map.forEach(function (value, key) {
+    result[++index] = [key, value];
+  });
+  return result;
+}
+
+module.exports = mapToArray;
+
+},{}],290:[function(require,module,exports){
+"use strict";
+
+/**
+ * A specialized version of `matchesProperty` for source values suitable
+ * for strict equality comparisons, i.e. `===`.
+ *
+ * @private
+ * @param {string} key The key of the property to get.
+ * @param {*} srcValue The value to match.
+ * @returns {Function} Returns the new spec function.
+ */
+function matchesStrictComparable(key, srcValue) {
+  return function (object) {
+    if (object == null) {
+      return false;
+    }
+    return object[key] === srcValue && (srcValue !== undefined || key in Object(object));
+  };
+}
+
+module.exports = matchesStrictComparable;
+
+},{}],291:[function(require,module,exports){
+'use strict';
+
+var memoize = require('./memoize');
+
+/** Used as the maximum memoize cache size. */
+var MAX_MEMOIZE_SIZE = 500;
+
+/**
+ * A specialized version of `_.memoize` which clears the memoized function's
+ * cache when it exceeds `MAX_MEMOIZE_SIZE`.
+ *
+ * @private
+ * @param {Function} func The function to have its output memoized.
+ * @returns {Function} Returns the new memoized function.
+ */
+function memoizeCapped(func) {
+  var result = memoize(func, function (key) {
+    if (cache.size === MAX_MEMOIZE_SIZE) {
+      cache.clear();
+    }
+    return key;
+  });
+
+  var cache = result.cache;
+  return result;
+}
+
+module.exports = memoizeCapped;
+
+},{"./memoize":331}],292:[function(require,module,exports){
+'use strict';
+
+var getNative = require('./_getNative');
+
+/* Built-in method references that are verified to be native. */
+var nativeCreate = getNative(Object, 'create');
+
+module.exports = nativeCreate;
+
+},{"./_getNative":263}],293:[function(require,module,exports){
+'use strict';
+
+var _keys = require('babel-runtime/core-js/object/keys');
+
+var _keys2 = _interopRequireDefault(_keys);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var overArg = require('./_overArg');
+
+/* Built-in method references for those with the same name as other `lodash` methods. */
+var nativeKeys = overArg(_keys2.default, Object);
+
+module.exports = nativeKeys;
+
+},{"./_overArg":295,"babel-runtime/core-js/object/keys":30}],294:[function(require,module,exports){
+'use strict';
+
+var _typeof2 = require('babel-runtime/helpers/typeof');
+
+var _typeof3 = _interopRequireDefault(_typeof2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var freeGlobal = require('./_freeGlobal');
+
+/** Detect free variable `exports`. */
+var freeExports = (typeof exports === 'undefined' ? 'undefined' : (0, _typeof3.default)(exports)) == 'object' && exports && !exports.nodeType && exports;
+
+/** Detect free variable `module`. */
+var freeModule = freeExports && (typeof module === 'undefined' ? 'undefined' : (0, _typeof3.default)(module)) == 'object' && module && !module.nodeType && module;
+
+/** Detect the popular CommonJS extension `module.exports`. */
+var moduleExports = freeModule && freeModule.exports === freeExports;
+
+/** Detect free variable `process` from Node.js. */
+var freeProcess = moduleExports && freeGlobal.process;
+
+/** Used to access faster Node.js helpers. */
+var nodeUtil = function () {
+  try {
+    return freeProcess && freeProcess.binding('util');
+  } catch (e) {}
+}();
+
+module.exports = nodeUtil;
+
+},{"./_freeGlobal":260,"babel-runtime/helpers/typeof":39}],295:[function(require,module,exports){
+"use strict";
+
+/**
+ * Creates a unary function that invokes `func` with its argument transformed.
+ *
+ * @private
+ * @param {Function} func The function to wrap.
+ * @param {Function} transform The argument transform.
+ * @returns {Function} Returns the new function.
+ */
+function overArg(func, transform) {
+  return function (arg) {
+    return func(transform(arg));
+  };
+}
+
+module.exports = overArg;
+
+},{}],296:[function(require,module,exports){
+'use strict';
+
+var apply = require('./_apply');
+
+/* Built-in method references for those with the same name as other `lodash` methods. */
+var nativeMax = Math.max;
+
+/**
+ * A specialized version of `baseRest` which transforms the rest array.
+ *
+ * @private
+ * @param {Function} func The function to apply a rest parameter to.
+ * @param {number} [start=func.length-1] The start position of the rest parameter.
+ * @param {Function} transform The rest array transform.
+ * @returns {Function} Returns the new function.
+ */
+function overRest(func, start, transform) {
+  start = nativeMax(start === undefined ? func.length - 1 : start, 0);
+  return function () {
+    var args = arguments,
+        index = -1,
+        length = nativeMax(args.length - start, 0),
+        array = Array(length);
+
+    while (++index < length) {
+      array[index] = args[start + index];
+    }
+    index = -1;
+    var otherArgs = Array(start + 1);
+    while (++index < start) {
+      otherArgs[index] = args[index];
+    }
+    otherArgs[start] = transform(array);
+    return apply(func, this, otherArgs);
+  };
+}
+
+module.exports = overRest;
+
+},{"./_apply":215}],297:[function(require,module,exports){
+'use strict';
+
+var _typeof2 = require('babel-runtime/helpers/typeof');
+
+var _typeof3 = _interopRequireDefault(_typeof2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var freeGlobal = require('./_freeGlobal');
+
+/** Detect free variable `self`. */
+var freeSelf = (typeof self === 'undefined' ? 'undefined' : (0, _typeof3.default)(self)) == 'object' && self && self.Object === Object && self;
+
+/** Used as a reference to the global object. */
+var root = freeGlobal || freeSelf || Function('return this')();
+
+module.exports = root;
+
+},{"./_freeGlobal":260,"babel-runtime/helpers/typeof":39}],298:[function(require,module,exports){
+'use strict';
+
+/** Used to stand-in for `undefined` hash values. */
+var HASH_UNDEFINED = '__lodash_hash_undefined__';
+
+/**
+ * Adds `value` to the array cache.
+ *
+ * @private
+ * @name add
+ * @memberOf SetCache
+ * @alias push
+ * @param {*} value The value to cache.
+ * @returns {Object} Returns the cache instance.
+ */
+function setCacheAdd(value) {
+  this.__data__.set(value, HASH_UNDEFINED);
+  return this;
+}
+
+module.exports = setCacheAdd;
+
+},{}],299:[function(require,module,exports){
+"use strict";
+
+/**
+ * Checks if `value` is in the array cache.
+ *
+ * @private
+ * @name has
+ * @memberOf SetCache
+ * @param {*} value The value to search for.
+ * @returns {number} Returns `true` if `value` is found, else `false`.
+ */
+function setCacheHas(value) {
+  return this.__data__.has(value);
+}
+
+module.exports = setCacheHas;
+
+},{}],300:[function(require,module,exports){
+"use strict";
+
+/**
+ * Converts `set` to an array of its values.
+ *
+ * @private
+ * @param {Object} set The set to convert.
+ * @returns {Array} Returns the values.
+ */
+function setToArray(set) {
+  var index = -1,
+      result = Array(set.size);
+
+  set.forEach(function (value) {
+    result[++index] = value;
+  });
+  return result;
+}
+
+module.exports = setToArray;
+
+},{}],301:[function(require,module,exports){
+'use strict';
+
+var baseSetToString = require('./_baseSetToString'),
+    shortOut = require('./_shortOut');
+
+/**
+ * Sets the `toString` method of `func` to return `string`.
+ *
+ * @private
+ * @param {Function} func The function to modify.
+ * @param {Function} string The `toString` result.
+ * @returns {Function} Returns `func`.
+ */
+var setToString = shortOut(baseSetToString);
+
+module.exports = setToString;
+
+},{"./_baseSetToString":245,"./_shortOut":302}],302:[function(require,module,exports){
+"use strict";
+
+/** Used to detect hot functions by number of calls within a span of milliseconds. */
+var HOT_COUNT = 500,
+    HOT_SPAN = 16;
+
+/* Built-in method references for those with the same name as other `lodash` methods. */
+var nativeNow = Date.now;
+
+/**
+ * Creates a function that'll short out and invoke `identity` instead
+ * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`
+ * milliseconds.
+ *
+ * @private
+ * @param {Function} func The function to restrict.
+ * @returns {Function} Returns the new shortable function.
+ */
+function shortOut(func) {
+  var count = 0,
+      lastCalled = 0;
+
+  return function () {
+    var stamp = nativeNow(),
+        remaining = HOT_SPAN - (stamp - lastCalled);
+
+    lastCalled = stamp;
+    if (remaining > 0) {
+      if (++count >= HOT_COUNT) {
+        return arguments[0];
+      }
+    } else {
+      count = 0;
+    }
+    return func.apply(undefined, arguments);
+  };
+}
+
+module.exports = shortOut;
+
+},{}],303:[function(require,module,exports){
+'use strict';
+
+var ListCache = require('./_ListCache');
+
+/**
+ * Removes all key-value entries from the stack.
+ *
+ * @private
+ * @name clear
+ * @memberOf Stack
+ */
+function stackClear() {
+  this.__data__ = new ListCache();
+  this.size = 0;
+}
+
+module.exports = stackClear;
+
+},{"./_ListCache":205}],304:[function(require,module,exports){
+'use strict';
+
+/**
+ * Removes `key` and its value from the stack.
+ *
+ * @private
+ * @name delete
+ * @memberOf Stack
+ * @param {string} key The key of the value to remove.
+ * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+ */
+function stackDelete(key) {
+  var data = this.__data__,
+      result = data['delete'](key);
+
+  this.size = data.size;
+  return result;
+}
+
+module.exports = stackDelete;
+
+},{}],305:[function(require,module,exports){
+"use strict";
+
+/**
+ * Gets the stack value for `key`.
+ *
+ * @private
+ * @name get
+ * @memberOf Stack
+ * @param {string} key The key of the value to get.
+ * @returns {*} Returns the entry value.
+ */
+function stackGet(key) {
+  return this.__data__.get(key);
+}
+
+module.exports = stackGet;
+
+},{}],306:[function(require,module,exports){
+"use strict";
+
+/**
+ * Checks if a stack value for `key` exists.
+ *
+ * @private
+ * @name has
+ * @memberOf Stack
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+function stackHas(key) {
+  return this.__data__.has(key);
+}
+
+module.exports = stackHas;
+
+},{}],307:[function(require,module,exports){
+'use strict';
+
+var ListCache = require('./_ListCache'),
+    Map = require('./_Map'),
+    MapCache = require('./_MapCache');
+
+/** Used as the size to enable large array optimizations. */
+var LARGE_ARRAY_SIZE = 200;
+
+/**
+ * Sets the stack `key` to `value`.
+ *
+ * @private
+ * @name set
+ * @memberOf Stack
+ * @param {string} key The key of the value to set.
+ * @param {*} value The value to set.
+ * @returns {Object} Returns the stack cache instance.
+ */
+function stackSet(key, value) {
+  var data = this.__data__;
+  if (data instanceof ListCache) {
+    var pairs = data.__data__;
+    if (!Map || pairs.length < LARGE_ARRAY_SIZE - 1) {
+      pairs.push([key, value]);
+      this.size = ++data.size;
+      return this;
+    }
+    data = this.__data__ = new MapCache(pairs);
+  }
+  data.set(key, value);
+  this.size = data.size;
+  return this;
+}
+
+module.exports = stackSet;
+
+},{"./_ListCache":205,"./_Map":206,"./_MapCache":207}],308:[function(require,module,exports){
+'use strict';
+
+var memoizeCapped = require('./_memoizeCapped'),
+    toString = require('./toString');
+
+/** Used to match property names within property paths. */
+var reLeadingDot = /^\./,
+    rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
+
+/** Used to match backslashes in property paths. */
+var reEscapeChar = /\\(\\)?/g;
+
+/**
+ * Converts `string` to a property path array.
+ *
+ * @private
+ * @param {string} string The string to convert.
+ * @returns {Array} Returns the property path array.
+ */
+var stringToPath = memoizeCapped(function (string) {
+  string = toString(string);
+
+  var result = [];
+  if (reLeadingDot.test(string)) {
+    result.push('');
+  }
+  string.replace(rePropName, function (match, number, quote, string) {
+    result.push(quote ? string.replace(reEscapeChar, '$1') : number || match);
+  });
+  return result;
+});
+
+module.exports = stringToPath;
+
+},{"./_memoizeCapped":291,"./toString":334}],309:[function(require,module,exports){
+'use strict';
+
+var isSymbol = require('./isSymbol');
+
+/** Used as references for various `Number` constants. */
+var INFINITY = 1 / 0;
+
+/**
+ * Converts `value` to a string key if it's not a string or symbol.
+ *
+ * @private
+ * @param {*} value The value to inspect.
+ * @returns {string|symbol} Returns the key.
+ */
+function toKey(value) {
+  if (typeof value == 'string' || isSymbol(value)) {
+    return value;
+  }
+  var result = value + '';
+  return result == '0' && 1 / value == -INFINITY ? '-0' : result;
+}
+
+module.exports = toKey;
+
+},{"./isSymbol":328}],310:[function(require,module,exports){
+'use strict';
+
+/** Used for built-in method references. */
+var funcProto = Function.prototype;
+
+/** Used to resolve the decompiled source of functions. */
+var funcToString = funcProto.toString;
+
+/**
+ * Converts `func` to its source code.
+ *
+ * @private
+ * @param {Function} func The function to process.
+ * @returns {string} Returns the source code.
+ */
+function toSource(func) {
+  if (func != null) {
+    try {
+      return funcToString.call(func);
+    } catch (e) {}
+    try {
+      return func + '';
+    } catch (e) {}
+  }
+  return '';
+}
+
+module.exports = toSource;
+
+},{}],311:[function(require,module,exports){
+'use strict';
+
+var assignValue = require('./_assignValue'),
+    copyObject = require('./_copyObject'),
+    createAssigner = require('./_createAssigner'),
+    isArrayLike = require('./isArrayLike'),
+    isPrototype = require('./_isPrototype'),
+    keys = require('./keys');
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * Assigns own enumerable string keyed properties of source objects to the
+ * destination object. Source objects are applied from left to right.
+ * Subsequent sources overwrite property assignments of previous sources.
+ *
+ * **Note:** This method mutates `object` and is loosely based on
+ * [`Object.assign`](https://mdn.io/Object/assign).
+ *
+ * @static
+ * @memberOf _
+ * @since 0.10.0
+ * @category Object
+ * @param {Object} object The destination object.
+ * @param {...Object} [sources] The source objects.
+ * @returns {Object} Returns `object`.
+ * @see _.assignIn
+ * @example
+ *
+ * function Foo() {
+ *   this.a = 1;
+ * }
+ *
+ * function Bar() {
+ *   this.c = 3;
+ * }
+ *
+ * Foo.prototype.b = 2;
+ * Bar.prototype.d = 4;
+ *
+ * _.assign({ 'a': 0 }, new Foo, new Bar);
+ * // => { 'a': 1, 'c': 3 }
+ */
+var assign = createAssigner(function (object, source) {
+  if (isPrototype(source) || isArrayLike(source)) {
+    copyObject(source, keys(source), object);
+    return;
+  }
+  for (var key in source) {
+    if (hasOwnProperty.call(source, key)) {
+      assignValue(object, key, source[key]);
+    }
+  }
+});
+
+module.exports = assign;
+
+},{"./_assignValue":220,"./_copyObject":251,"./_createAssigner":253,"./_isPrototype":277,"./isArrayLike":321,"./keys":330}],312:[function(require,module,exports){
+"use strict";
+
+/**
+ * Creates a function that returns `value`.
+ *
+ * @static
+ * @memberOf _
+ * @since 2.4.0
+ * @category Util
+ * @param {*} value The value to return from the new function.
+ * @returns {Function} Returns the new constant function.
+ * @example
+ *
+ * var objects = _.times(2, _.constant({ 'a': 1 }));
+ *
+ * console.log(objects);
+ * // => [{ 'a': 1 }, { 'a': 1 }]
+ *
+ * console.log(objects[0] === objects[1]);
+ * // => true
+ */
+function constant(value) {
+  return function () {
+    return value;
+  };
+}
+
+module.exports = constant;
+
+},{}],313:[function(require,module,exports){
+'use strict';
+
+var baseAssign = require('./_baseAssign'),
+    baseCreate = require('./_baseCreate');
+
+/**
+ * Creates an object that inherits from the `prototype` object. If a
+ * `properties` object is given, its own enumerable string keyed properties
+ * are assigned to the created object.
+ *
+ * @static
+ * @memberOf _
+ * @since 2.3.0
+ * @category Object
+ * @param {Object} prototype The object to inherit from.
+ * @param {Object} [properties] The properties to assign to the object.
+ * @returns {Object} Returns the new object.
+ * @example
+ *
+ * function Shape() {
+ *   this.x = 0;
+ *   this.y = 0;
+ * }
+ *
+ * function Circle() {
+ *   Shape.call(this);
+ * }
+ *
+ * Circle.prototype = _.create(Shape.prototype, {
+ *   'constructor': Circle
+ * });
+ *
+ * var circle = new Circle;
+ * circle instanceof Circle;
+ * // => true
+ *
+ * circle instanceof Shape;
+ * // => true
+ */
+function create(prototype, properties) {
+  var result = baseCreate(prototype);
+  return properties ? baseAssign(result, properties) : result;
+}
+
+module.exports = create;
+
+},{"./_baseAssign":222,"./_baseCreate":224}],314:[function(require,module,exports){
+"use strict";
+
+/**
+ * Performs a
+ * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+ * comparison between two values to determine if they are equivalent.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to compare.
+ * @param {*} other The other value to compare.
+ * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+ * @example
+ *
+ * var object = { 'a': 1 };
+ * var other = { 'a': 1 };
+ *
+ * _.eq(object, object);
+ * // => true
+ *
+ * _.eq(object, other);
+ * // => false
+ *
+ * _.eq('a', 'a');
+ * // => true
+ *
+ * _.eq('a', Object('a'));
+ * // => false
+ *
+ * _.eq(NaN, NaN);
+ * // => true
+ */
+function eq(value, other) {
+  return value === other || value !== value && other !== other;
+}
+
+module.exports = eq;
+
+},{}],315:[function(require,module,exports){
+'use strict';
+
+var arrayEvery = require('./_arrayEvery'),
+    baseEvery = require('./_baseEvery'),
+    baseIteratee = require('./_baseIteratee'),
+    isArray = require('./isArray'),
+    isIterateeCall = require('./_isIterateeCall');
+
+/**
+ * Checks if `predicate` returns truthy for **all** elements of `collection`.
+ * Iteration is stopped once `predicate` returns falsey. The predicate is
+ * invoked with three arguments: (value, index|key, collection).
+ *
+ * **Note:** This method returns `true` for
+ * [empty collections](https://en.wikipedia.org/wiki/Empty_set) because
+ * [everything is true](https://en.wikipedia.org/wiki/Vacuous_truth) of
+ * elements of empty collections.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Collection
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} [predicate=_.identity]
+ *  The function invoked per iteration.
+ * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
+ * @returns {boolean} Returns `true` if all elements pass the predicate check,
+ *  else `false`.
+ * @example
+ *
+ * _.every([true, 1, null, 'yes'], Boolean);
+ * // => false
+ *
+ * var users = [
+ *   { 'user': 'barney', 'age': 36, 'active': false },
+ *   { 'user': 'fred',   'age': 40, 'active': false }
+ * ];
+ *
+ * // The `_.matches` iteratee shorthand.
+ * _.every(users, { 'user': 'barney', 'active': false });
+ * // => false
+ *
+ * // The `_.matchesProperty` iteratee shorthand.
+ * _.every(users, ['active', false]);
+ * // => true
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.every(users, 'active');
+ * // => false
+ */
+function every(collection, predicate, guard) {
+  var func = isArray(collection) ? arrayEvery : baseEvery;
+  if (guard && isIterateeCall(collection, predicate, guard)) {
+    predicate = undefined;
+  }
+  return func(collection, baseIteratee(predicate, 3));
+}
+
+module.exports = every;
+
+},{"./_arrayEvery":216,"./_baseEvery":226,"./_baseIteratee":238,"./_isIterateeCall":273,"./isArray":320}],316:[function(require,module,exports){
+'use strict';
+
+var baseGet = require('./_baseGet');
+
+/**
+ * Gets the value at `path` of `object`. If the resolved value is
+ * `undefined`, the `defaultValue` is returned in its place.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.7.0
+ * @category Object
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path of the property to get.
+ * @param {*} [defaultValue] The value returned for `undefined` resolved values.
+ * @returns {*} Returns the resolved value.
+ * @example
+ *
+ * var object = { 'a': [{ 'b': { 'c': 3 } }] };
+ *
+ * _.get(object, 'a[0].b.c');
+ * // => 3
+ *
+ * _.get(object, ['a', '0', 'b', 'c']);
+ * // => 3
+ *
+ * _.get(object, 'a.b.c', 'default');
+ * // => 'default'
+ */
+function get(object, path, defaultValue) {
+  var result = object == null ? undefined : baseGet(object, path);
+  return result === undefined ? defaultValue : result;
+}
+
+module.exports = get;
+
+},{"./_baseGet":229}],317:[function(require,module,exports){
+'use strict';
+
+var baseHasIn = require('./_baseHasIn'),
+    hasPath = require('./_hasPath');
+
+/**
+ * Checks if `path` is a direct or inherited property of `object`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Object
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path to check.
+ * @returns {boolean} Returns `true` if `path` exists, else `false`.
+ * @example
+ *
+ * var object = _.create({ 'a': _.create({ 'b': 2 }) });
+ *
+ * _.hasIn(object, 'a');
+ * // => true
+ *
+ * _.hasIn(object, 'a.b');
+ * // => true
+ *
+ * _.hasIn(object, ['a', 'b']);
+ * // => true
+ *
+ * _.hasIn(object, 'b');
+ * // => false
+ */
+function hasIn(object, path) {
+  return object != null && hasPath(object, path, baseHasIn);
+}
+
+module.exports = hasIn;
+
+},{"./_baseHasIn":231,"./_hasPath":266}],318:[function(require,module,exports){
+"use strict";
+
+/**
+ * This method returns the first argument it receives.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Util
+ * @param {*} value Any value.
+ * @returns {*} Returns `value`.
+ * @example
+ *
+ * var object = { 'a': 1 };
+ *
+ * console.log(_.identity(object) === object);
+ * // => true
+ */
+function identity(value) {
+  return value;
+}
+
+module.exports = identity;
+
+},{}],319:[function(require,module,exports){
+'use strict';
+
+var baseIsArguments = require('./_baseIsArguments'),
+    isObjectLike = require('./isObjectLike');
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/** Built-in value references. */
+var propertyIsEnumerable = objectProto.propertyIsEnumerable;
+
+/**
+ * Checks if `value` is likely an `arguments` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an `arguments` object,
+ *  else `false`.
+ * @example
+ *
+ * _.isArguments(function() { return arguments; }());
+ * // => true
+ *
+ * _.isArguments([1, 2, 3]);
+ * // => false
+ */
+var isArguments = baseIsArguments(function () {
+    return arguments;
+}()) ? baseIsArguments : function (value) {
+    return isObjectLike(value) && hasOwnProperty.call(value, 'callee') && !propertyIsEnumerable.call(value, 'callee');
+};
+
+module.exports = isArguments;
+
+},{"./_baseIsArguments":232,"./isObjectLike":327}],320:[function(require,module,exports){
+"use strict";
+
+/**
+ * Checks if `value` is classified as an `Array` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an array, else `false`.
+ * @example
+ *
+ * _.isArray([1, 2, 3]);
+ * // => true
+ *
+ * _.isArray(document.body.children);
+ * // => false
+ *
+ * _.isArray('abc');
+ * // => false
+ *
+ * _.isArray(_.noop);
+ * // => false
+ */
+var isArray = Array.isArray;
+
+module.exports = isArray;
+
+},{}],321:[function(require,module,exports){
+'use strict';
+
+var isFunction = require('./isFunction'),
+    isLength = require('./isLength');
+
+/**
+ * Checks if `value` is array-like. A value is considered array-like if it's
+ * not a function and has a `value.length` that's an integer greater than or
+ * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
+ * @example
+ *
+ * _.isArrayLike([1, 2, 3]);
+ * // => true
+ *
+ * _.isArrayLike(document.body.children);
+ * // => true
+ *
+ * _.isArrayLike('abc');
+ * // => true
+ *
+ * _.isArrayLike(_.noop);
+ * // => false
+ */
+function isArrayLike(value) {
+  return value != null && isLength(value.length) && !isFunction(value);
+}
+
+module.exports = isArrayLike;
+
+},{"./isFunction":324,"./isLength":325}],322:[function(require,module,exports){
+'use strict';
+
+var _typeof2 = require('babel-runtime/helpers/typeof');
+
+var _typeof3 = _interopRequireDefault(_typeof2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var root = require('./_root'),
+    stubFalse = require('./stubFalse');
+
+/** Detect free variable `exports`. */
+var freeExports = (typeof exports === 'undefined' ? 'undefined' : (0, _typeof3.default)(exports)) == 'object' && exports && !exports.nodeType && exports;
+
+/** Detect free variable `module`. */
+var freeModule = freeExports && (typeof module === 'undefined' ? 'undefined' : (0, _typeof3.default)(module)) == 'object' && module && !module.nodeType && module;
+
+/** Detect the popular CommonJS extension `module.exports`. */
+var moduleExports = freeModule && freeModule.exports === freeExports;
+
+/** Built-in value references. */
+var Buffer = moduleExports ? root.Buffer : undefined;
+
+/* Built-in method references for those with the same name as other `lodash` methods. */
+var nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined;
+
+/**
+ * Checks if `value` is a buffer.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.3.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.
+ * @example
+ *
+ * _.isBuffer(new Buffer(2));
+ * // => true
+ *
+ * _.isBuffer(new Uint8Array(2));
+ * // => false
+ */
+var isBuffer = nativeIsBuffer || stubFalse;
+
+module.exports = isBuffer;
+
+},{"./_root":297,"./stubFalse":333,"babel-runtime/helpers/typeof":39}],323:[function(require,module,exports){
+'use strict';
+
+var baseKeys = require('./_baseKeys'),
+    getTag = require('./_getTag'),
+    isArguments = require('./isArguments'),
+    isArray = require('./isArray'),
+    isArrayLike = require('./isArrayLike'),
+    isBuffer = require('./isBuffer'),
+    isPrototype = require('./_isPrototype'),
+    isTypedArray = require('./isTypedArray');
+
+/** `Object#toString` result references. */
+var mapTag = '[object Map]',
+    setTag = '[object Set]';
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * Checks if `value` is an empty object, collection, map, or set.
+ *
+ * Objects are considered empty if they have no own enumerable string keyed
+ * properties.
+ *
+ * Array-like values such as `arguments` objects, arrays, buffers, strings, or
+ * jQuery-like collections are considered empty if they have a `length` of `0`.
+ * Similarly, maps and sets are considered empty if they have a `size` of `0`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is empty, else `false`.
+ * @example
+ *
+ * _.isEmpty(null);
+ * // => true
+ *
+ * _.isEmpty(true);
+ * // => true
+ *
+ * _.isEmpty(1);
+ * // => true
+ *
+ * _.isEmpty([1, 2, 3]);
+ * // => false
+ *
+ * _.isEmpty({ 'a': 1 });
+ * // => false
+ */
+function isEmpty(value) {
+  if (isArrayLike(value) && (isArray(value) || typeof value == 'string' || typeof value.splice == 'function' || isBuffer(value) || isTypedArray(value) || isArguments(value))) {
+    return !value.length;
+  }
+  var tag = getTag(value);
+  if (tag == mapTag || tag == setTag) {
+    return !value.size;
+  }
+  if (isPrototype(value)) {
+    return !baseKeys(value).length;
+  }
+  for (var key in value) {
+    if (hasOwnProperty.call(value, key)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+module.exports = isEmpty;
+
+},{"./_baseKeys":239,"./_getTag":264,"./_isPrototype":277,"./isArguments":319,"./isArray":320,"./isArrayLike":321,"./isBuffer":322,"./isTypedArray":329}],324:[function(require,module,exports){
+'use strict';
+
+var isObject = require('./isObject');
+
+/** `Object#toString` result references. */
+var funcTag = '[object Function]',
+    genTag = '[object GeneratorFunction]',
+    proxyTag = '[object Proxy]';
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/**
+ * Used to resolve the
+ * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+ * of values.
+ */
+var objectToString = objectProto.toString;
+
+/**
+ * Checks if `value` is classified as a `Function` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a function, else `false`.
+ * @example
+ *
+ * _.isFunction(_);
+ * // => true
+ *
+ * _.isFunction(/abc/);
+ * // => false
+ */
+function isFunction(value) {
+  // The use of `Object#toString` avoids issues with the `typeof` operator
+  // in Safari 9 which returns 'object' for typed array and other constructors.
+  var tag = isObject(value) ? objectToString.call(value) : '';
+  return tag == funcTag || tag == genTag || tag == proxyTag;
+}
+
+module.exports = isFunction;
+
+},{"./isObject":326}],325:[function(require,module,exports){
+'use strict';
+
+/** Used as references for various `Number` constants. */
+var MAX_SAFE_INTEGER = 9007199254740991;
+
+/**
+ * Checks if `value` is a valid array-like length.
+ *
+ * **Note:** This method is loosely based on
+ * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
+ * @example
+ *
+ * _.isLength(3);
+ * // => true
+ *
+ * _.isLength(Number.MIN_VALUE);
+ * // => false
+ *
+ * _.isLength(Infinity);
+ * // => false
+ *
+ * _.isLength('3');
+ * // => false
+ */
+function isLength(value) {
+  return typeof value == 'number' && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+}
+
+module.exports = isLength;
+
+},{}],326:[function(require,module,exports){
+'use strict';
+
+var _typeof2 = require('babel-runtime/helpers/typeof');
+
+var _typeof3 = _interopRequireDefault(_typeof2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * Checks if `value` is the
+ * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
+ * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @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(_.noop);
+ * // => true
+ *
+ * _.isObject(null);
+ * // => false
+ */
+function isObject(value) {
+  var type = typeof value === 'undefined' ? 'undefined' : (0, _typeof3.default)(value);
+  return value != null && (type == 'object' || type == 'function');
+}
+
+module.exports = isObject;
+
+},{"babel-runtime/helpers/typeof":39}],327:[function(require,module,exports){
+'use strict';
+
+var _typeof2 = require('babel-runtime/helpers/typeof');
+
+var _typeof3 = _interopRequireDefault(_typeof2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * 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 _
+ * @since 4.0.0
+ * @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 != null && (typeof value === 'undefined' ? 'undefined' : (0, _typeof3.default)(value)) == 'object';
+}
+
+module.exports = isObjectLike;
+
+},{"babel-runtime/helpers/typeof":39}],328:[function(require,module,exports){
+'use strict';
+
+var _typeof2 = require('babel-runtime/helpers/typeof');
+
+var _typeof3 = _interopRequireDefault(_typeof2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var isObjectLike = require('./isObjectLike');
+
+/** `Object#toString` result references. */
+var symbolTag = '[object Symbol]';
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/**
+ * Used to resolve the
+ * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+ * of values.
+ */
+var objectToString = objectProto.toString;
+
+/**
+ * Checks if `value` is classified as a `Symbol` primitive or object.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
+ * @example
+ *
+ * _.isSymbol(Symbol.iterator);
+ * // => true
+ *
+ * _.isSymbol('abc');
+ * // => false
+ */
+function isSymbol(value) {
+  return (typeof value === 'undefined' ? 'undefined' : (0, _typeof3.default)(value)) == 'symbol' || isObjectLike(value) && objectToString.call(value) == symbolTag;
+}
+
+module.exports = isSymbol;
+
+},{"./isObjectLike":327,"babel-runtime/helpers/typeof":39}],329:[function(require,module,exports){
+'use strict';
+
+var baseIsTypedArray = require('./_baseIsTypedArray'),
+    baseUnary = require('./_baseUnary'),
+    nodeUtil = require('./_nodeUtil');
+
+/* Node.js helper references. */
+var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
+
+/**
+ * Checks if `value` is classified as a typed array.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
+ * @example
+ *
+ * _.isTypedArray(new Uint8Array);
+ * // => true
+ *
+ * _.isTypedArray([]);
+ * // => false
+ */
+var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
+
+module.exports = isTypedArray;
+
+},{"./_baseIsTypedArray":237,"./_baseUnary":248,"./_nodeUtil":294}],330:[function(require,module,exports){
+'use strict';
+
+var arrayLikeKeys = require('./_arrayLikeKeys'),
+    baseKeys = require('./_baseKeys'),
+    isArrayLike = require('./isArrayLike');
+
+/**
+ * Creates an array of the own enumerable property names of `object`.
+ *
+ * **Note:** Non-object values are coerced to objects. See the
+ * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
+ * for more details.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Object
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names.
+ * @example
+ *
+ * function Foo() {
+ *   this.a = 1;
+ *   this.b = 2;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ *
+ * _.keys(new Foo);
+ * // => ['a', 'b'] (iteration order is not guaranteed)
+ *
+ * _.keys('hi');
+ * // => ['0', '1']
+ */
+function keys(object) {
+  return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
+}
+
+module.exports = keys;
+
+},{"./_arrayLikeKeys":217,"./_baseKeys":239,"./isArrayLike":321}],331:[function(require,module,exports){
+'use strict';
+
+var MapCache = require('./_MapCache');
+
+/** Error message constants. */
+var FUNC_ERROR_TEXT = 'Expected a function';
+
+/**
+ * Creates a function that memoizes the result of `func`. If `resolver` is
+ * provided, it determines the cache key for storing the result based on the
+ * arguments provided to the memoized function. By default, the first argument
+ * provided to the memoized function is used as the map cache key. The `func`
+ * is invoked with the `this` binding of the memoized function.
+ *
+ * **Note:** The cache is exposed as the `cache` property on the memoized
+ * function. Its creation may be customized by replacing the `_.memoize.Cache`
+ * constructor with one whose instances implement the
+ * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)
+ * method interface of `delete`, `get`, `has`, and `set`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Function
+ * @param {Function} func The function to have its output memoized.
+ * @param {Function} [resolver] The function to resolve the cache key.
+ * @returns {Function} Returns the new memoized function.
+ * @example
+ *
+ * var object = { 'a': 1, 'b': 2 };
+ * var other = { 'c': 3, 'd': 4 };
+ *
+ * var values = _.memoize(_.values);
+ * values(object);
+ * // => [1, 2]
+ *
+ * values(other);
+ * // => [3, 4]
+ *
+ * object.a = 2;
+ * values(object);
+ * // => [1, 2]
+ *
+ * // Modify the result cache.
+ * values.cache.set(object, ['a', 'b']);
+ * values(object);
+ * // => ['a', 'b']
+ *
+ * // Replace `_.memoize.Cache`.
+ * _.memoize.Cache = WeakMap;
+ */
+function memoize(func, resolver) {
+  if (typeof func != 'function' || resolver && typeof resolver != 'function') {
+    throw new TypeError(FUNC_ERROR_TEXT);
+  }
+  var memoized = function memoized() {
+    var args = arguments,
+        key = resolver ? resolver.apply(this, args) : args[0],
+        cache = memoized.cache;
+
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+    var result = func.apply(this, args);
+    memoized.cache = cache.set(key, result) || cache;
+    return result;
+  };
+  memoized.cache = new (memoize.Cache || MapCache)();
+  return memoized;
+}
+
+// Expose `MapCache`.
+memoize.Cache = MapCache;
+
+module.exports = memoize;
+
+},{"./_MapCache":207}],332:[function(require,module,exports){
+'use strict';
+
+var baseProperty = require('./_baseProperty'),
+    basePropertyDeep = require('./_basePropertyDeep'),
+    isKey = require('./_isKey'),
+    toKey = require('./_toKey');
+
+/**
+ * Creates a function that returns the value at `path` of a given object.
+ *
+ * @static
+ * @memberOf _
+ * @since 2.4.0
+ * @category Util
+ * @param {Array|string} path The path of the property to get.
+ * @returns {Function} Returns the new accessor function.
+ * @example
+ *
+ * var objects = [
+ *   { 'a': { 'b': 2 } },
+ *   { 'a': { 'b': 1 } }
+ * ];
+ *
+ * _.map(objects, _.property('a.b'));
+ * // => [2, 1]
+ *
+ * _.map(_.sortBy(objects, _.property(['a', 'b'])), 'a.b');
+ * // => [1, 2]
+ */
+function property(path) {
+  return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path);
+}
+
+module.exports = property;
+
+},{"./_baseProperty":242,"./_basePropertyDeep":243,"./_isKey":274,"./_toKey":309}],333:[function(require,module,exports){
+"use strict";
+
+/**
+ * This method returns `false`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.13.0
+ * @category Util
+ * @returns {boolean} Returns `false`.
+ * @example
+ *
+ * _.times(2, _.stubFalse);
+ * // => [false, false]
+ */
+function stubFalse() {
+  return false;
+}
+
+module.exports = stubFalse;
+
+},{}],334:[function(require,module,exports){
+'use strict';
+
+var baseToString = require('./_baseToString');
+
+/**
+ * Converts `value` to a string. An empty string is returned for `null`
+ * and `undefined` values. The sign of `-0` is preserved.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to convert.
+ * @returns {string} Returns the converted string.
+ * @example
+ *
+ * _.toString(null);
+ * // => ''
+ *
+ * _.toString(-0);
+ * // => '-0'
+ *
+ * _.toString([1, 2, 3]);
+ * // => '1,2,3'
+ */
+function toString(value) {
+  return value == null ? '' : baseToString(value);
+}
+
+module.exports = toString;
+
+},{"./_baseToString":247}],335:[function(require,module,exports){
+/*!
+ * merge-descriptors
+ * Copyright(c) 2014 Jonathan Ong
+ * Copyright(c) 2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+'use strict';
+
+/**
+ * Module exports.
+ * @public
+ */
+
+var _defineProperty = require('babel-runtime/core-js/object/define-property');
+
+var _defineProperty2 = _interopRequireDefault(_defineProperty);
+
+var _getOwnPropertyDescriptor = require('babel-runtime/core-js/object/get-own-property-descriptor');
+
+var _getOwnPropertyDescriptor2 = _interopRequireDefault(_getOwnPropertyDescriptor);
+
+var _getOwnPropertyNames = require('babel-runtime/core-js/object/get-own-property-names');
+
+var _getOwnPropertyNames2 = _interopRequireDefault(_getOwnPropertyNames);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+module.exports = merge;
+
+/**
+ * Module variables.
+ * @private
+ */
+
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+
+/**
+ * Merge the property descriptors of `src` into `dest`
+ *
+ * @param {object} dest Object to add descriptors to
+ * @param {object} src Object to clone descriptors from
+ * @param {boolean} [redefine=true] Redefine `dest` properties with `src` properties
+ * @returns {object} Reference to dest
+ * @public
+ */
+
+function merge(dest, src, redefine) {
+  if (!dest) {
+    throw new TypeError('argument dest is required');
+  }
+
+  if (!src) {
+    throw new TypeError('argument src is required');
+  }
+
+  if (redefine === undefined) {
+    // Default to true
+    redefine = true;
+  }
+
+  (0, _getOwnPropertyNames2.default)(src).forEach(function forEachOwnPropertyName(name) {
+    if (!redefine && hasOwnProperty.call(dest, name)) {
+      // Skip desriptor
+      return;
+    }
+
+    // Copy descriptor
+    var descriptor = (0, _getOwnPropertyDescriptor2.default)(src, name);
+    (0, _defineProperty2.default)(dest, name, descriptor);
+  });
+
+  return dest;
+}
+
+},{"babel-runtime/core-js/object/define-property":24,"babel-runtime/core-js/object/get-own-property-descriptor":25,"babel-runtime/core-js/object/get-own-property-names":26}],336:[function(require,module,exports){
+(function (process){
+'use strict';
+
+var _create = require('babel-runtime/core-js/object/create');
+
+var _create2 = _interopRequireDefault(_create);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var path = require('path');
+var fs = require('fs');
+
+function Mime() {
+  // Map of extension -> mime type
+  this.types = (0, _create2.default)(null);
+
+  // Map of mime type -> extension
+  this.extensions = (0, _create2.default)(null);
+}
+
+/**
+ * Define mimetype -> extension mappings.  Each key is a mime-type that maps
+ * to an array of extensions associated with the type.  The first extension is
+ * used as the default extension for the type.
+ *
+ * e.g. mime.define({'audio/ogg', ['oga', 'ogg', 'spx']});
+ *
+ * @param map (Object) type definitions
+ */
+Mime.prototype.define = function (map) {
+  for (var type in map) {
+    var exts = map[type];
+    for (var i = 0; i < exts.length; i++) {
+      if (process.env.DEBUG_MIME && this.types[exts]) {
+        console.warn(this._loading.replace(/.*\//, ''), 'changes "' + exts[i] + '" extension type from ' + this.types[exts] + ' to ' + type);
+      }
+
+      this.types[exts[i]] = type;
+    }
+
+    // Default extension is the first one we encounter
+    if (!this.extensions[type]) {
+      this.extensions[type] = exts[0];
+    }
+  }
+};
+
+/**
+ * Load an Apache2-style ".types" file
+ *
+ * This may be called multiple times (it's expected).  Where files declare
+ * overlapping types/extensions, the last file wins.
+ *
+ * @param file (String) path of file to load.
+ */
+Mime.prototype.load = function (file) {
+  this._loading = file;
+  // Read file and split into lines
+  var map = {},
+      content = fs.readFileSync(file, 'ascii'),
+      lines = content.split(/[\r\n]+/);
+
+  lines.forEach(function (line) {
+    // Clean up whitespace/comments, and split into fields
+    var fields = line.replace(/\s*#.*|^\s*|\s*$/g, '').split(/\s+/);
+    map[fields.shift()] = fields;
+  });
+
+  this.define(map);
+
+  this._loading = null;
+};
+
+/**
+ * Lookup a mime type based on extension
+ */
+Mime.prototype.lookup = function (path, fallback) {
+  var ext = path.replace(/.*[\.\/\\]/, '').toLowerCase();
+
+  return this.types[ext] || fallback || this.default_type;
+};
+
+/**
+ * Return file extension associated with a mime type
+ */
+Mime.prototype.extension = function (mimeType) {
+  var type = mimeType.match(/^\s*([^;\s]*)(?:;|\s|$)/)[1].toLowerCase();
+  return this.extensions[type];
+};
+
+// Default instance
+var mime = new Mime();
+
+// Define built-in types
+mime.define(require('./types.json'));
+
+// Default type
+mime.default_type = mime.lookup('bin');
+
+//
+// Additional API specific to the default instance
+//
+
+mime.Mime = Mime;
+
+/**
+ * Lookup a charset based on mime type.
+ */
+mime.charsets = {
+  lookup: function lookup(mimeType, fallback) {
+    // Assume text types are utf8
+    return (/^text\//.test(mimeType) ? 'UTF-8' : fallback
+    );
+  }
+};
+
+module.exports = mime;
+
+}).call(this,require('_process'))
+},{"./types.json":337,"_process":345,"babel-runtime/core-js/object/create":22,"fs":43,"path":342}],337:[function(require,module,exports){
+module.exports={"application/andrew-inset":["ez"],"application/applixware":["aw"],"application/atom+xml":["atom"],"application/atomcat+xml":["atomcat"],"application/atomsvc+xml":["atomsvc"],"application/ccxml+xml":["ccxml"],"application/cdmi-capability":["cdmia"],"application/cdmi-container":["cdmic"],"application/cdmi-domain":["cdmid"],"application/cdmi-object":["cdmio"],"application/cdmi-queue":["cdmiq"],"application/cu-seeme":["cu"],"application/dash+xml":["mdp"],"application/davmount+xml":["davmount"],"application/docbook+xml":["dbk"],"application/dssc+der":["dssc"],"application/dssc+xml":["xdssc"],"application/ecmascript":["ecma"],"application/emma+xml":["emma"],"application/epub+zip":["epub"],"application/exi":["exi"],"application/font-tdpfr":["pfr"],"application/font-woff":["woff"],"application/font-woff2":["woff2"],"application/gml+xml":["gml"],"application/gpx+xml":["gpx"],"application/gxf":["gxf"],"application/hyperstudio":["stk"],"application/inkml+xml":["ink","inkml"],"application/ipfix":["ipfix"],"application/java-archive":["jar"],"application/java-serialized-object":["ser"],"application/java-vm":["class"],"application/javascript":["js"],"application/json":["json","map"],"application/json5":["json5"],"application/jsonml+json":["jsonml"],"application/lost+xml":["lostxml"],"application/mac-binhex40":["hqx"],"application/mac-compactpro":["cpt"],"application/mads+xml":["mads"],"application/marc":["mrc"],"application/marcxml+xml":["mrcx"],"application/mathematica":["ma","nb","mb"],"application/mathml+xml":["mathml"],"application/mbox":["mbox"],"application/mediaservercontrol+xml":["mscml"],"application/metalink+xml":["metalink"],"application/metalink4+xml":["meta4"],"application/mets+xml":["mets"],"application/mods+xml":["mods"],"application/mp21":["m21","mp21"],"application/mp4":["mp4s","m4p"],"application/msword":["doc","dot"],"application/mxf":["mxf"],"application/octet-stream":["bin","dms","lrf","mar","so","dist","distz","pkg","bpk","dump","elc","deploy","buffer"],"application/oda":["oda"],"application/oebps-package+xml":["opf"],"application/ogg":["ogx"],"application/omdoc+xml":["omdoc"],"application/onenote":["onetoc","onetoc2","onetmp","onepkg"],"application/oxps":["oxps"],"application/patch-ops-error+xml":["xer"],"application/pdf":["pdf"],"application/pgp-encrypted":["pgp"],"application/pgp-signature":["asc","sig"],"application/pics-rules":["prf"],"application/pkcs10":["p10"],"application/pkcs7-mime":["p7m","p7c"],"application/pkcs7-signature":["p7s"],"application/pkcs8":["p8"],"application/pkix-attr-cert":["ac"],"application/pkix-cert":["cer"],"application/pkix-crl":["crl"],"application/pkix-pkipath":["pkipath"],"application/pkixcmp":["pki"],"application/pls+xml":["pls"],"application/postscript":["ai","eps","ps"],"application/prs.cww":["cww"],"application/pskc+xml":["pskcxml"],"application/rdf+xml":["rdf"],"application/reginfo+xml":["rif"],"application/relax-ng-compact-syntax":["rnc"],"application/resource-lists+xml":["rl"],"application/resource-lists-diff+xml":["rld"],"application/rls-services+xml":["rs"],"application/rpki-ghostbusters":["gbr"],"application/rpki-manifest":["mft"],"application/rpki-roa":["roa"],"application/rsd+xml":["rsd"],"application/rss+xml":["rss"],"application/rtf":["rtf"],"application/sbml+xml":["sbml"],"application/scvp-cv-request":["scq"],"application/scvp-cv-response":["scs"],"application/scvp-vp-request":["spq"],"application/scvp-vp-response":["spp"],"application/sdp":["sdp"],"application/set-payment-initiation":["setpay"],"application/set-registration-initiation":["setreg"],"application/shf+xml":["shf"],"application/smil+xml":["smi","smil"],"application/sparql-query":["rq"],"application/sparql-results+xml":["srx"],"application/srgs":["gram"],"application/srgs+xml":["grxml"],"application/sru+xml":["sru"],"application/ssdl+xml":["ssdl"],"application/ssml+xml":["ssml"],"application/tei+xml":["tei","teicorpus"],"application/thraud+xml":["tfi"],"application/timestamped-data":["tsd"],"application/vnd.3gpp.pic-bw-large":["plb"],"application/vnd.3gpp.pic-bw-small":["psb"],"application/vnd.3gpp.pic-bw-var":["pvb"],"application/vnd.3gpp2.tcap":["tcap"],"application/vnd.3m.post-it-notes":["pwn"],"application/vnd.accpac.simply.aso":["aso"],"application/vnd.accpac.simply.imp":["imp"],"application/vnd.acucobol":["acu"],"application/vnd.acucorp":["atc","acutc"],"application/vnd.adobe.air-application-installer-package+zip":["air"],"application/vnd.adobe.formscentral.fcdt":["fcdt"],"application/vnd.adobe.fxp":["fxp","fxpl"],"application/vnd.adobe.xdp+xml":["xdp"],"application/vnd.adobe.xfdf":["xfdf"],"application/vnd.ahead.space":["ahead"],"application/vnd.airzip.filesecure.azf":["azf"],"application/vnd.airzip.filesecure.azs":["azs"],"application/vnd.amazon.ebook":["azw"],"application/vnd.americandynamics.acc":["acc"],"application/vnd.amiga.ami":["ami"],"application/vnd.android.package-archive":["apk"],"application/vnd.anser-web-certificate-issue-initiation":["cii"],"application/vnd.anser-web-funds-transfer-initiation":["fti"],"application/vnd.antix.game-component":["atx"],"application/vnd.apple.installer+xml":["mpkg"],"application/vnd.apple.mpegurl":["m3u8"],"application/vnd.aristanetworks.swi":["swi"],"application/vnd.astraea-software.iota":["iota"],"application/vnd.audiograph":["aep"],"application/vnd.blueice.multipass":["mpm"],"application/vnd.bmi":["bmi"],"application/vnd.businessobjects":["rep"],"application/vnd.chemdraw+xml":["cdxml"],"application/vnd.chipnuts.karaoke-mmd":["mmd"],"application/vnd.cinderella":["cdy"],"application/vnd.claymore":["cla"],"application/vnd.cloanto.rp9":["rp9"],"application/vnd.clonk.c4group":["c4g","c4d","c4f","c4p","c4u"],"application/vnd.cluetrust.cartomobile-config":["c11amc"],"application/vnd.cluetrust.cartomobile-config-pkg":["c11amz"],"application/vnd.commonspace":["csp"],"application/vnd.contact.cmsg":["cdbcmsg"],"application/vnd.cosmocaller":["cmc"],"application/vnd.crick.clicker":["clkx"],"application/vnd.crick.clicker.keyboard":["clkk"],"application/vnd.crick.clicker.palette":["clkp"],"application/vnd.crick.clicker.template":["clkt"],"application/vnd.crick.clicker.wordbank":["clkw"],"application/vnd.criticaltools.wbs+xml":["wbs"],"application/vnd.ctc-posml":["pml"],"application/vnd.cups-ppd":["ppd"],"application/vnd.curl.car":["car"],"application/vnd.curl.pcurl":["pcurl"],"application/vnd.dart":["dart"],"application/vnd.data-vision.rdz":["rdz"],"application/vnd.dece.data":["uvf","uvvf","uvd","uvvd"],"application/vnd.dece.ttml+xml":["uvt","uvvt"],"application/vnd.dece.unspecified":["uvx","uvvx"],"application/vnd.dece.zip":["uvz","uvvz"],"application/vnd.denovo.fcselayout-link":["fe_launch"],"application/vnd.dna":["dna"],"application/vnd.dolby.mlp":["mlp"],"application/vnd.dpgraph":["dpg"],"application/vnd.dreamfactory":["dfac"],"application/vnd.ds-keypoint":["kpxx"],"application/vnd.dvb.ait":["ait"],"application/vnd.dvb.service":["svc"],"application/vnd.dynageo":["geo"],"application/vnd.ecowin.chart":["mag"],"application/vnd.enliven":["nml"],"application/vnd.epson.esf":["esf"],"application/vnd.epson.msf":["msf"],"application/vnd.epson.quickanime":["qam"],"application/vnd.epson.salt":["slt"],"application/vnd.epson.ssf":["ssf"],"application/vnd.eszigno3+xml":["es3","et3"],"application/vnd.ezpix-album":["ez2"],"application/vnd.ezpix-package":["ez3"],"application/vnd.fdf":["fdf"],"application/vnd.fdsn.mseed":["mseed"],"application/vnd.fdsn.seed":["seed","dataless"],"application/vnd.flographit":["gph"],"application/vnd.fluxtime.clip":["ftc"],"application/vnd.framemaker":["fm","frame","maker","book"],"application/vnd.frogans.fnc":["fnc"],"application/vnd.frogans.ltf":["ltf"],"application/vnd.fsc.weblaunch":["fsc"],"application/vnd.fujitsu.oasys":["oas"],"application/vnd.fujitsu.oasys2":["oa2"],"application/vnd.fujitsu.oasys3":["oa3"],"application/vnd.fujitsu.oasysgp":["fg5"],"application/vnd.fujitsu.oasysprs":["bh2"],"application/vnd.fujixerox.ddd":["ddd"],"application/vnd.fujixerox.docuworks":["xdw"],"application/vnd.fujixerox.docuworks.binder":["xbd"],"application/vnd.fuzzysheet":["fzs"],"application/vnd.genomatix.tuxedo":["txd"],"application/vnd.geogebra.file":["ggb"],"application/vnd.geogebra.tool":["ggt"],"application/vnd.geometry-explorer":["gex","gre"],"application/vnd.geonext":["gxt"],"application/vnd.geoplan":["g2w"],"application/vnd.geospace":["g3w"],"application/vnd.gmx":["gmx"],"application/vnd.google-earth.kml+xml":["kml"],"application/vnd.google-earth.kmz":["kmz"],"application/vnd.grafeq":["gqf","gqs"],"application/vnd.groove-account":["gac"],"application/vnd.groove-help":["ghf"],"application/vnd.groove-identity-message":["gim"],"application/vnd.groove-injector":["grv"],"application/vnd.groove-tool-message":["gtm"],"application/vnd.groove-tool-template":["tpl"],"application/vnd.groove-vcard":["vcg"],"application/vnd.hal+xml":["hal"],"application/vnd.handheld-entertainment+xml":["zmm"],"application/vnd.hbci":["hbci"],"application/vnd.hhe.lesson-player":["les"],"application/vnd.hp-hpgl":["hpgl"],"application/vnd.hp-hpid":["hpid"],"application/vnd.hp-hps":["hps"],"application/vnd.hp-jlyt":["jlt"],"application/vnd.hp-pcl":["pcl"],"application/vnd.hp-pclxl":["pclxl"],"application/vnd.ibm.minipay":["mpy"],"application/vnd.ibm.modcap":["afp","listafp","list3820"],"application/vnd.ibm.rights-management":["irm"],"application/vnd.ibm.secure-container":["sc"],"application/vnd.iccprofile":["icc","icm"],"application/vnd.igloader":["igl"],"application/vnd.immervision-ivp":["ivp"],"application/vnd.immervision-ivu":["ivu"],"application/vnd.insors.igm":["igm"],"application/vnd.intercon.formnet":["xpw","xpx"],"application/vnd.intergeo":["i2g"],"application/vnd.intu.qbo":["qbo"],"application/vnd.intu.qfx":["qfx"],"application/vnd.ipunplugged.rcprofile":["rcprofile"],"application/vnd.irepository.package+xml":["irp"],"application/vnd.is-xpr":["xpr"],"application/vnd.isac.fcs":["fcs"],"application/vnd.jam":["jam"],"application/vnd.jcp.javame.midlet-rms":["rms"],"application/vnd.jisp":["jisp"],"application/vnd.joost.joda-archive":["joda"],"application/vnd.kahootz":["ktz","ktr"],"application/vnd.kde.karbon":["karbon"],"application/vnd.kde.kchart":["chrt"],"application/vnd.kde.kformula":["kfo"],"application/vnd.kde.kivio":["flw"],"application/vnd.kde.kontour":["kon"],"application/vnd.kde.kpresenter":["kpr","kpt"],"application/vnd.kde.kspread":["ksp"],"application/vnd.kde.kword":["kwd","kwt"],"application/vnd.kenameaapp":["htke"],"application/vnd.kidspiration":["kia"],"application/vnd.kinar":["kne","knp"],"application/vnd.koan":["skp","skd","skt","skm"],"application/vnd.kodak-descriptor":["sse"],"application/vnd.las.las+xml":["lasxml"],"application/vnd.llamagraphics.life-balance.desktop":["lbd"],"application/vnd.llamagraphics.life-balance.exchange+xml":["lbe"],"application/vnd.lotus-1-2-3":["123"],"application/vnd.lotus-approach":["apr"],"application/vnd.lotus-freelance":["pre"],"application/vnd.lotus-notes":["nsf"],"application/vnd.lotus-organizer":["org"],"application/vnd.lotus-screencam":["scm"],"application/vnd.lotus-wordpro":["lwp"],"application/vnd.macports.portpkg":["portpkg"],"application/vnd.mcd":["mcd"],"application/vnd.medcalcdata":["mc1"],"application/vnd.mediastation.cdkey":["cdkey"],"application/vnd.mfer":["mwf"],"application/vnd.mfmp":["mfm"],"application/vnd.micrografx.flo":["flo"],"application/vnd.micrografx.igx":["igx"],"application/vnd.mif":["mif"],"application/vnd.mobius.daf":["daf"],"application/vnd.mobius.dis":["dis"],"application/vnd.mobius.mbk":["mbk"],"application/vnd.mobius.mqy":["mqy"],"application/vnd.mobius.msl":["msl"],"application/vnd.mobius.plc":["plc"],"application/vnd.mobius.txf":["txf"],"application/vnd.mophun.application":["mpn"],"application/vnd.mophun.certificate":["mpc"],"application/vnd.mozilla.xul+xml":["xul"],"application/vnd.ms-artgalry":["cil"],"application/vnd.ms-cab-compressed":["cab"],"application/vnd.ms-excel":["xls","xlm","xla","xlc","xlt","xlw"],"application/vnd.ms-excel.addin.macroenabled.12":["xlam"],"application/vnd.ms-excel.sheet.binary.macroenabled.12":["xlsb"],"application/vnd.ms-excel.sheet.macroenabled.12":["xlsm"],"application/vnd.ms-excel.template.macroenabled.12":["xltm"],"application/vnd.ms-fontobject":["eot"],"application/vnd.ms-htmlhelp":["chm"],"application/vnd.ms-ims":["ims"],"application/vnd.ms-lrm":["lrm"],"application/vnd.ms-officetheme":["thmx"],"application/vnd.ms-pki.seccat":["cat"],"application/vnd.ms-pki.stl":["stl"],"application/vnd.ms-powerpoint":["ppt","pps","pot"],"application/vnd.ms-powerpoint.addin.macroenabled.12":["ppam"],"application/vnd.ms-powerpoint.presentation.macroenabled.12":["pptm"],"application/vnd.ms-powerpoint.slide.macroenabled.12":["sldm"],"application/vnd.ms-powerpoint.slideshow.macroenabled.12":["ppsm"],"application/vnd.ms-powerpoint.template.macroenabled.12":["potm"],"application/vnd.ms-project":["mpp","mpt"],"application/vnd.ms-word.document.macroenabled.12":["docm"],"application/vnd.ms-word.template.macroenabled.12":["dotm"],"application/vnd.ms-works":["wps","wks","wcm","wdb"],"application/vnd.ms-wpl":["wpl"],"application/vnd.ms-xpsdocument":["xps"],"application/vnd.mseq":["mseq"],"application/vnd.musician":["mus"],"application/vnd.muvee.style":["msty"],"application/vnd.mynfc":["taglet"],"application/vnd.neurolanguage.nlu":["nlu"],"application/vnd.nitf":["ntf","nitf"],"application/vnd.noblenet-directory":["nnd"],"application/vnd.noblenet-sealer":["nns"],"application/vnd.noblenet-web":["nnw"],"application/vnd.nokia.n-gage.data":["ngdat"],"application/vnd.nokia.radio-preset":["rpst"],"application/vnd.nokia.radio-presets":["rpss"],"application/vnd.novadigm.edm":["edm"],"application/vnd.novadigm.edx":["edx"],"application/vnd.novadigm.ext":["ext"],"application/vnd.oasis.opendocument.chart":["odc"],"application/vnd.oasis.opendocument.chart-template":["otc"],"application/vnd.oasis.opendocument.database":["odb"],"application/vnd.oasis.opendocument.formula":["odf"],"application/vnd.oasis.opendocument.formula-template":["odft"],"application/vnd.oasis.opendocument.graphics":["odg"],"application/vnd.oasis.opendocument.graphics-template":["otg"],"application/vnd.oasis.opendocument.image":["odi"],"application/vnd.oasis.opendocument.image-template":["oti"],"application/vnd.oasis.opendocument.presentation":["odp"],"application/vnd.oasis.opendocument.presentation-template":["otp"],"application/vnd.oasis.opendocument.spreadsheet":["ods"],"application/vnd.oasis.opendocument.spreadsheet-template":["ots"],"application/vnd.oasis.opendocument.text":["odt"],"application/vnd.oasis.opendocument.text-master":["odm"],"application/vnd.oasis.opendocument.text-template":["ott"],"application/vnd.oasis.opendocument.text-web":["oth"],"application/vnd.olpc-sugar":["xo"],"application/vnd.oma.dd2+xml":["dd2"],"application/vnd.openofficeorg.extension":["oxt"],"application/vnd.openxmlformats-officedocument.presentationml.presentation":["pptx"],"application/vnd.openxmlformats-officedocument.presentationml.slide":["sldx"],"application/vnd.openxmlformats-officedocument.presentationml.slideshow":["ppsx"],"application/vnd.openxmlformats-officedocument.presentationml.template":["potx"],"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet":["xlsx"],"application/vnd.openxmlformats-officedocument.spreadsheetml.template":["xltx"],"application/vnd.openxmlformats-officedocument.wordprocessingml.document":["docx"],"application/vnd.openxmlformats-officedocument.wordprocessingml.template":["dotx"],"application/vnd.osgeo.mapguide.package":["mgp"],"application/vnd.osgi.dp":["dp"],"application/vnd.osgi.subsystem":["esa"],"application/vnd.palm":["pdb","pqa","oprc"],"application/vnd.pawaafile":["paw"],"application/vnd.pg.format":["str"],"application/vnd.pg.osasli":["ei6"],"application/vnd.picsel":["efif"],"application/vnd.pmi.widget":["wg"],"application/vnd.pocketlearn":["plf"],"application/vnd.powerbuilder6":["pbd"],"application/vnd.previewsystems.box":["box"],"application/vnd.proteus.magazine":["mgz"],"application/vnd.publishare-delta-tree":["qps"],"application/vnd.pvi.ptid1":["ptid"],"application/vnd.quark.quarkxpress":["qxd","qxt","qwd","qwt","qxl","qxb"],"application/vnd.realvnc.bed":["bed"],"application/vnd.recordare.musicxml":["mxl"],"application/vnd.recordare.musicxml+xml":["musicxml"],"application/vnd.rig.cryptonote":["cryptonote"],"application/vnd.rim.cod":["cod"],"application/vnd.rn-realmedia":["rm"],"application/vnd.rn-realmedia-vbr":["rmvb"],"application/vnd.route66.link66+xml":["link66"],"application/vnd.sailingtracker.track":["st"],"application/vnd.seemail":["see"],"application/vnd.sema":["sema"],"application/vnd.semd":["semd"],"application/vnd.semf":["semf"],"application/vnd.shana.informed.formdata":["ifm"],"application/vnd.shana.informed.formtemplate":["itp"],"application/vnd.shana.informed.interchange":["iif"],"application/vnd.shana.informed.package":["ipk"],"application/vnd.simtech-mindmapper":["twd","twds"],"application/vnd.smaf":["mmf"],"application/vnd.smart.teacher":["teacher"],"application/vnd.solent.sdkm+xml":["sdkm","sdkd"],"application/vnd.spotfire.dxp":["dxp"],"application/vnd.spotfire.sfs":["sfs"],"application/vnd.stardivision.calc":["sdc"],"application/vnd.stardivision.draw":["sda"],"application/vnd.stardivision.impress":["sdd"],"application/vnd.stardivision.math":["smf"],"application/vnd.stardivision.writer":["sdw","vor"],"application/vnd.stardivision.writer-global":["sgl"],"application/vnd.stepmania.package":["smzip"],"application/vnd.stepmania.stepchart":["sm"],"application/vnd.sun.xml.calc":["sxc"],"application/vnd.sun.xml.calc.template":["stc"],"application/vnd.sun.xml.draw":["sxd"],"application/vnd.sun.xml.draw.template":["std"],"application/vnd.sun.xml.impress":["sxi"],"application/vnd.sun.xml.impress.template":["sti"],"application/vnd.sun.xml.math":["sxm"],"application/vnd.sun.xml.writer":["sxw"],"application/vnd.sun.xml.writer.global":["sxg"],"application/vnd.sun.xml.writer.template":["stw"],"application/vnd.sus-calendar":["sus","susp"],"application/vnd.svd":["svd"],"application/vnd.symbian.install":["sis","sisx"],"application/vnd.syncml+xml":["xsm"],"application/vnd.syncml.dm+wbxml":["bdm"],"application/vnd.syncml.dm+xml":["xdm"],"application/vnd.tao.intent-module-archive":["tao"],"application/vnd.tcpdump.pcap":["pcap","cap","dmp"],"application/vnd.tmobile-livetv":["tmo"],"application/vnd.trid.tpt":["tpt"],"application/vnd.triscape.mxs":["mxs"],"application/vnd.trueapp":["tra"],"application/vnd.ufdl":["ufd","ufdl"],"application/vnd.uiq.theme":["utz"],"application/vnd.umajin":["umj"],"application/vnd.unity":["unityweb"],"application/vnd.uoml+xml":["uoml"],"application/vnd.vcx":["vcx"],"application/vnd.visio":["vsd","vst","vss","vsw"],"application/vnd.visionary":["vis"],"application/vnd.vsf":["vsf"],"application/vnd.wap.wbxml":["wbxml"],"application/vnd.wap.wmlc":["wmlc"],"application/vnd.wap.wmlscriptc":["wmlsc"],"application/vnd.webturbo":["wtb"],"application/vnd.wolfram.player":["nbp"],"application/vnd.wordperfect":["wpd"],"application/vnd.wqd":["wqd"],"application/vnd.wt.stf":["stf"],"application/vnd.xara":["xar"],"application/vnd.xfdl":["xfdl"],"application/vnd.yamaha.hv-dic":["hvd"],"application/vnd.yamaha.hv-script":["hvs"],"application/vnd.yamaha.hv-voice":["hvp"],"application/vnd.yamaha.openscoreformat":["osf"],"application/vnd.yamaha.openscoreformat.osfpvg+xml":["osfpvg"],"application/vnd.yamaha.smaf-audio":["saf"],"application/vnd.yamaha.smaf-phrase":["spf"],"application/vnd.yellowriver-custom-menu":["cmp"],"application/vnd.zul":["zir","zirz"],"application/vnd.zzazz.deck+xml":["zaz"],"application/voicexml+xml":["vxml"],"application/widget":["wgt"],"application/winhlp":["hlp"],"application/wsdl+xml":["wsdl"],"application/wspolicy+xml":["wspolicy"],"application/x-7z-compressed":["7z"],"application/x-abiword":["abw"],"application/x-ace-compressed":["ace"],"application/x-apple-diskimage":["dmg"],"application/x-authorware-bin":["aab","x32","u32","vox"],"application/x-authorware-map":["aam"],"application/x-authorware-seg":["aas"],"application/x-bcpio":["bcpio"],"application/x-bittorrent":["torrent"],"application/x-blorb":["blb","blorb"],"application/x-bzip":["bz"],"application/x-bzip2":["bz2","boz"],"application/x-cbr":["cbr","cba","cbt","cbz","cb7"],"application/x-cdlink":["vcd"],"application/x-cfs-compressed":["cfs"],"application/x-chat":["chat"],"application/x-chess-pgn":["pgn"],"application/x-chrome-extension":["crx"],"application/x-conference":["nsc"],"application/x-cpio":["cpio"],"application/x-csh":["csh"],"application/x-debian-package":["deb","udeb"],"application/x-dgc-compressed":["dgc"],"application/x-director":["dir","dcr","dxr","cst","cct","cxt","w3d","fgd","swa"],"application/x-doom":["wad"],"application/x-dtbncx+xml":["ncx"],"application/x-dtbook+xml":["dtb"],"application/x-dtbresource+xml":["res"],"application/x-dvi":["dvi"],"application/x-envoy":["evy"],"application/x-eva":["eva"],"application/x-font-bdf":["bdf"],"application/x-font-ghostscript":["gsf"],"application/x-font-linux-psf":["psf"],"application/x-font-otf":["otf"],"application/x-font-pcf":["pcf"],"application/x-font-snf":["snf"],"application/x-font-ttf":["ttf","ttc"],"application/x-font-type1":["pfa","pfb","pfm","afm"],"application/x-freearc":["arc"],"application/x-futuresplash":["spl"],"application/x-gca-compressed":["gca"],"application/x-glulx":["ulx"],"application/x-gnumeric":["gnumeric"],"application/x-gramps-xml":["gramps"],"application/x-gtar":["gtar"],"application/x-hdf":["hdf"],"application/x-install-instructions":["install"],"application/x-iso9660-image":["iso"],"application/x-java-jnlp-file":["jnlp"],"application/x-latex":["latex"],"application/x-lua-bytecode":["luac"],"application/x-lzh-compressed":["lzh","lha"],"application/x-mie":["mie"],"application/x-mobipocket-ebook":["prc","mobi"],"application/x-ms-application":["application"],"application/x-ms-shortcut":["lnk"],"application/x-ms-wmd":["wmd"],"application/x-ms-wmz":["wmz"],"application/x-ms-xbap":["xbap"],"application/x-msaccess":["mdb"],"application/x-msbinder":["obd"],"application/x-mscardfile":["crd"],"application/x-msclip":["clp"],"application/x-msdownload":["exe","dll","com","bat","msi"],"application/x-msmediaview":["mvb","m13","m14"],"application/x-msmetafile":["wmf","wmz","emf","emz"],"application/x-msmoney":["mny"],"application/x-mspublisher":["pub"],"application/x-msschedule":["scd"],"application/x-msterminal":["trm"],"application/x-mswrite":["wri"],"application/x-netcdf":["nc","cdf"],"application/x-nzb":["nzb"],"application/x-pkcs12":["p12","pfx"],"application/x-pkcs7-certificates":["p7b","spc"],"application/x-pkcs7-certreqresp":["p7r"],"application/x-rar-compressed":["rar"],"application/x-research-info-systems":["ris"],"application/x-sh":["sh"],"application/x-shar":["shar"],"application/x-shockwave-flash":["swf"],"application/x-silverlight-app":["xap"],"application/x-sql":["sql"],"application/x-stuffit":["sit"],"application/x-stuffitx":["sitx"],"application/x-subrip":["srt"],"application/x-sv4cpio":["sv4cpio"],"application/x-sv4crc":["sv4crc"],"application/x-t3vm-image":["t3"],"application/x-tads":["gam"],"application/x-tar":["tar"],"application/x-tcl":["tcl"],"application/x-tex":["tex"],"application/x-tex-tfm":["tfm"],"application/x-texinfo":["texinfo","texi"],"application/x-tgif":["obj"],"application/x-ustar":["ustar"],"application/x-wais-source":["src"],"application/x-web-app-manifest+json":["webapp"],"application/x-x509-ca-cert":["der","crt"],"application/x-xfig":["fig"],"application/x-xliff+xml":["xlf"],"application/x-xpinstall":["xpi"],"application/x-xz":["xz"],"application/x-zmachine":["z1","z2","z3","z4","z5","z6","z7","z8"],"application/xaml+xml":["xaml"],"application/xcap-diff+xml":["xdf"],"application/xenc+xml":["xenc"],"application/xhtml+xml":["xhtml","xht"],"application/xml":["xml","xsl","xsd"],"application/xml-dtd":["dtd"],"application/xop+xml":["xop"],"application/xproc+xml":["xpl"],"application/xslt+xml":["xslt"],"application/xspf+xml":["xspf"],"application/xv+xml":["mxml","xhvml","xvml","xvm"],"application/yang":["yang"],"application/yin+xml":["yin"],"application/zip":["zip"],"audio/adpcm":["adp"],"audio/basic":["au","snd"],"audio/midi":["mid","midi","kar","rmi"],"audio/mp4":["mp4a","m4a"],"audio/mpeg":["mpga","mp2","mp2a","mp3","m2a","m3a"],"audio/ogg":["oga","ogg","spx"],"audio/s3m":["s3m"],"audio/silk":["sil"],"audio/vnd.dece.audio":["uva","uvva"],"audio/vnd.digital-winds":["eol"],"audio/vnd.dra":["dra"],"audio/vnd.dts":["dts"],"audio/vnd.dts.hd":["dtshd"],"audio/vnd.lucent.voice":["lvp"],"audio/vnd.ms-playready.media.pya":["pya"],"audio/vnd.nuera.ecelp4800":["ecelp4800"],"audio/vnd.nuera.ecelp7470":["ecelp7470"],"audio/vnd.nuera.ecelp9600":["ecelp9600"],"audio/vnd.rip":["rip"],"audio/webm":["weba"],"audio/x-aac":["aac"],"audio/x-aiff":["aif","aiff","aifc"],"audio/x-caf":["caf"],"audio/x-flac":["flac"],"audio/x-matroska":["mka"],"audio/x-mpegurl":["m3u"],"audio/x-ms-wax":["wax"],"audio/x-ms-wma":["wma"],"audio/x-pn-realaudio":["ram","ra"],"audio/x-pn-realaudio-plugin":["rmp"],"audio/x-wav":["wav"],"audio/xm":["xm"],"chemical/x-cdx":["cdx"],"chemical/x-cif":["cif"],"chemical/x-cmdf":["cmdf"],"chemical/x-cml":["cml"],"chemical/x-csml":["csml"],"chemical/x-xyz":["xyz"],"font/opentype":["otf"],"image/bmp":["bmp"],"image/cgm":["cgm"],"image/g3fax":["g3"],"image/gif":["gif"],"image/ief":["ief"],"image/jpeg":["jpeg","jpg","jpe"],"image/ktx":["ktx"],"image/png":["png"],"image/prs.btif":["btif"],"image/sgi":["sgi"],"image/svg+xml":["svg","svgz"],"image/tiff":["tiff","tif"],"image/vnd.adobe.photoshop":["psd"],"image/vnd.dece.graphic":["uvi","uvvi","uvg","uvvg"],"image/vnd.djvu":["djvu","djv"],"image/vnd.dvb.subtitle":["sub"],"image/vnd.dwg":["dwg"],"image/vnd.dxf":["dxf"],"image/vnd.fastbidsheet":["fbs"],"image/vnd.fpx":["fpx"],"image/vnd.fst":["fst"],"image/vnd.fujixerox.edmics-mmr":["mmr"],"image/vnd.fujixerox.edmics-rlc":["rlc"],"image/vnd.ms-modi":["mdi"],"image/vnd.ms-photo":["wdp"],"image/vnd.net-fpx":["npx"],"image/vnd.wap.wbmp":["wbmp"],"image/vnd.xiff":["xif"],"image/webp":["webp"],"image/x-3ds":["3ds"],"image/x-cmu-raster":["ras"],"image/x-cmx":["cmx"],"image/x-freehand":["fh","fhc","fh4","fh5","fh7"],"image/x-icon":["ico"],"image/x-mrsid-image":["sid"],"image/x-pcx":["pcx"],"image/x-pict":["pic","pct"],"image/x-portable-anymap":["pnm"],"image/x-portable-bitmap":["pbm"],"image/x-portable-graymap":["pgm"],"image/x-portable-pixmap":["ppm"],"image/x-rgb":["rgb"],"image/x-tga":["tga"],"image/x-xbitmap":["xbm"],"image/x-xpixmap":["xpm"],"image/x-xwindowdump":["xwd"],"message/rfc822":["eml","mime"],"model/iges":["igs","iges"],"model/mesh":["msh","mesh","silo"],"model/vnd.collada+xml":["dae"],"model/vnd.dwf":["dwf"],"model/vnd.gdl":["gdl"],"model/vnd.gtw":["gtw"],"model/vnd.mts":["mts"],"model/vnd.vtu":["vtu"],"model/vrml":["wrl","vrml"],"model/x3d+binary":["x3db","x3dbz"],"model/x3d+vrml":["x3dv","x3dvz"],"model/x3d+xml":["x3d","x3dz"],"text/cache-manifest":["appcache","manifest"],"text/calendar":["ics","ifb"],"text/coffeescript":["coffee"],"text/css":["css"],"text/csv":["csv"],"text/hjson":["hjson"],"text/html":["html","htm"],"text/jade":["jade"],"text/jsx":["jsx"],"text/less":["less"],"text/n3":["n3"],"text/plain":["txt","text","conf","def","list","log","in","ini"],"text/prs.lines.tag":["dsc"],"text/richtext":["rtx"],"text/sgml":["sgml","sgm"],"text/stylus":["stylus","styl"],"text/tab-separated-values":["tsv"],"text/troff":["t","tr","roff","man","me","ms"],"text/turtle":["ttl"],"text/uri-list":["uri","uris","urls"],"text/vcard":["vcard"],"text/vnd.curl":["curl"],"text/vnd.curl.dcurl":["dcurl"],"text/vnd.curl.mcurl":["mcurl"],"text/vnd.curl.scurl":["scurl"],"text/vnd.dvb.subtitle":["sub"],"text/vnd.fly":["fly"],"text/vnd.fmi.flexstor":["flx"],"text/vnd.graphviz":["gv"],"text/vnd.in3d.3dml":["3dml"],"text/vnd.in3d.spot":["spot"],"text/vnd.sun.j2me.app-descriptor":["jad"],"text/vnd.wap.wml":["wml"],"text/vnd.wap.wmlscript":["wmls"],"text/vtt":["vtt"],"text/x-asm":["s","asm"],"text/x-c":["c","cc","cxx","cpp","h","hh","dic"],"text/x-component":["htc"],"text/x-fortran":["f","for","f77","f90"],"text/x-handlebars-template":["hbs"],"text/x-java-source":["java"],"text/x-lua":["lua"],"text/x-markdown":["markdown","md","mkd"],"text/x-nfo":["nfo"],"text/x-opml":["opml"],"text/x-pascal":["p","pas"],"text/x-sass":["sass"],"text/x-scss":["scss"],"text/x-setext":["etx"],"text/x-sfv":["sfv"],"text/x-uuencode":["uu"],"text/x-vcalendar":["vcs"],"text/x-vcard":["vcf"],"text/yaml":["yaml","yml"],"video/3gpp":["3gp"],"video/3gpp2":["3g2"],"video/h261":["h261"],"video/h263":["h263"],"video/h264":["h264"],"video/jpeg":["jpgv"],"video/jpm":["jpm","jpgm"],"video/mj2":["mj2","mjp2"],"video/mp2t":["ts"],"video/mp4":["mp4","mp4v","mpg4"],"video/mpeg":["mpeg","mpg","mpe","m1v","m2v"],"video/ogg":["ogv"],"video/quicktime":["qt","mov"],"video/vnd.dece.hd":["uvh","uvvh"],"video/vnd.dece.mobile":["uvm","uvvm"],"video/vnd.dece.pd":["uvp","uvvp"],"video/vnd.dece.sd":["uvs","uvvs"],"video/vnd.dece.video":["uvv","uvvv"],"video/vnd.dvb.file":["dvb"],"video/vnd.fvt":["fvt"],"video/vnd.mpegurl":["mxu","m4u"],"video/vnd.ms-playready.media.pyv":["pyv"],"video/vnd.uvvu.mp4":["uvu","uvvu"],"video/vnd.vivo":["viv"],"video/webm":["webm"],"video/x-f4v":["f4v"],"video/x-fli":["fli"],"video/x-flv":["flv"],"video/x-m4v":["m4v"],"video/x-matroska":["mkv","mk3d","mks"],"video/x-mng":["mng"],"video/x-ms-asf":["asf","asx"],"video/x-ms-vob":["vob"],"video/x-ms-wm":["wm"],"video/x-ms-wmv":["wmv"],"video/x-ms-wmx":["wmx"],"video/x-ms-wvx":["wvx"],"video/x-msvideo":["avi"],"video/x-sgi-movie":["movie"],"video/x-smv":["smv"],"x-conference/x-cooltalk":["ice"]}
+
+},{}],338:[function(require,module,exports){
+'use strict';
+
+/**
+ * Helpers.
+ */
+
+var s = 1000;
+var m = s * 60;
+var h = m * 60;
+var d = h * 24;
+var y = d * 365.25;
+
+/**
+ * Parse or format the given `val`.
+ *
+ * Options:
+ *
+ *  - `long` verbose formatting [false]
+ *
+ * @param {String|Number} val
+ * @param {Object} options
+ * @return {String|Number}
+ * @api public
+ */
+
+module.exports = function (val, options) {
+  options = options || {};
+  if ('string' == typeof val) return parse(val);
+  return options.long ? long(val) : short(val);
+};
+
+/**
+ * Parse the given `str` and return milliseconds.
+ *
+ * @param {String} str
+ * @return {Number}
+ * @api private
+ */
+
+function parse(str) {
+  str = '' + str;
+  if (str.length > 10000) return;
+  var match = /^((?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec(str);
+  if (!match) return;
+  var n = parseFloat(match[1]);
+  var type = (match[2] || 'ms').toLowerCase();
+  switch (type) {
+    case 'years':
+    case 'year':
+    case 'yrs':
+    case 'yr':
+    case 'y':
+      return n * y;
+    case 'days':
+    case 'day':
+    case 'd':
+      return n * d;
+    case 'hours':
+    case 'hour':
+    case 'hrs':
+    case 'hr':
+    case 'h':
+      return n * h;
+    case 'minutes':
+    case 'minute':
+    case 'mins':
+    case 'min':
+    case 'm':
+      return n * m;
+    case 'seconds':
+    case 'second':
+    case 'secs':
+    case 'sec':
+    case 's':
+      return n * s;
+    case 'milliseconds':
+    case 'millisecond':
+    case 'msecs':
+    case 'msec':
+    case 'ms':
+      return n;
+  }
+}
+
+/**
+ * Short format for `ms`.
+ *
+ * @param {Number} ms
+ * @return {String}
+ * @api private
+ */
+
+function short(ms) {
+  if (ms >= d) return Math.round(ms / d) + 'd';
+  if (ms >= h) return Math.round(ms / h) + 'h';
+  if (ms >= m) return Math.round(ms / m) + 'm';
+  if (ms >= s) return Math.round(ms / s) + 's';
+  return ms + 'ms';
+}
+
+/**
+ * Long format for `ms`.
+ *
+ * @param {Number} ms
+ * @return {String}
+ * @api private
+ */
+
+function long(ms) {
+  return plural(ms, d, 'day') || plural(ms, h, 'hour') || plural(ms, m, 'minute') || plural(ms, s, 'second') || ms + ' ms';
+}
+
+/**
+ * Pluralization helper.
+ */
+
+function plural(ms, n, name) {
+  if (ms < n) return;
+  if (ms < n * 1.5) return Math.floor(ms / n) + ' ' + name;
+  return Math.ceil(ms / n) + ' ' + name + 's';
+}
+
+},{}],339:[function(require,module,exports){
+'use strict';
+
+exports.endianness = function () {
+    return 'LE';
+};
+
+exports.hostname = function () {
+    if (typeof location !== 'undefined') {
+        return location.hostname;
+    } else return '';
+};
+
+exports.loadavg = function () {
+    return [];
+};
+
+exports.uptime = function () {
+    return 0;
+};
+
+exports.freemem = function () {
+    return Number.MAX_VALUE;
+};
+
+exports.totalmem = function () {
+    return Number.MAX_VALUE;
+};
+
+exports.cpus = function () {
+    return [];
+};
+
+exports.type = function () {
+    return 'Browser';
+};
+
+exports.release = function () {
+    if (typeof navigator !== 'undefined') {
+        return navigator.appVersion;
+    }
+    return '';
+};
+
+exports.networkInterfaces = exports.getNetworkInterfaces = function () {
+    return {};
+};
+
+exports.arch = function () {
+    return 'javascript';
+};
+
+exports.platform = function () {
+    return 'browser';
+};
+
+exports.tmpdir = exports.tmpDir = function () {
+    return '/tmp';
+};
+
+exports.EOL = '\n';
+
+},{}],340:[function(require,module,exports){
+'use strict';
+
+var os = require('os');
+var osxRelease = require('osx-release');
+var winRelease = require('win-release');
+
+module.exports = function (platform, release) {
+	if (!platform && release) {
+		throw new Error('You can\'t specify a `release` without specfying `platform`');
+	}
+
+	platform = platform || os.platform();
+	release = release || os.release();
+
+	var id;
+
+	if (platform === 'darwin') {
+		id = osxRelease(release).name;
+		return 'OS X' + (id ? ' ' + id : '');
+	}
+
+	if (platform === 'linux') {
+		id = release.replace(/^(\d+\.\d+).*/, '$1');
+		return 'Linux' + (id ? ' ' + id : '');
+	}
+
+	if (platform === 'win32') {
+		id = winRelease(release);
+		return 'Windows' + (id ? ' ' + id : '');
+	}
+
+	return platform;
+};
+
+},{"os":339,"osx-release":341,"win-release":397}],341:[function(require,module,exports){
+'use strict';
+
+var os = require('os');
+
+var nameMap = {
+	'15': 'El Capitan',
+	'14': 'Yosemite',
+	'13': 'Mavericks',
+	'12': 'Mountain Lion',
+	'11': 'Lion',
+	'10': 'Snow Leopard',
+	'9': 'Leopard',
+	'8': 'Tiger',
+	'7': 'Panther',
+	'6': 'Jaguar',
+	'5': 'Puma'
+};
+
+module.exports = function (release) {
+	release = (release || os.release()).split('.')[0];
+	return {
+		name: nameMap[release],
+		version: '10.' + (Number(release) - 4)
+	};
+};
+
+},{"os":339}],342:[function(require,module,exports){
+(function (process){
+'use strict';
+
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// 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;
+}
+
+// Split a filename into [root, dir, basename, ext], unix version
+// 'root' is just a slash, or nothing.
+var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
+var splitPath = function splitPath(filename) {
+  return splitPathRe.exec(filename).slice(1);
+};
+
+// path.resolve([from ...], to)
+// posix version
+exports.resolve = function () {
+  var resolvedPath = '',
+      resolvedAbsolute = false;
+
+  for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+    var path = i >= 0 ? arguments[i] : process.cwd();
+
+    // Skip empty and invalid entries
+    if (typeof path !== 'string') {
+      throw new TypeError('Arguments to path.resolve must be strings');
+    } else if (!path) {
+      continue;
+    }
+
+    resolvedPath = path + '/' + resolvedPath;
+    resolvedAbsolute = path.charAt(0) === '/';
+  }
+
+  // At this point the path should be resolved to a full absolute path, but
+  // handle relative paths to be safe (might happen when process.cwd() fails)
+
+  // Normalize the path
+  resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function (p) {
+    return !!p;
+  }), !resolvedAbsolute).join('/');
+
+  return (resolvedAbsolute ? '/' : '') + resolvedPath || '.';
+};
+
+// path.normalize(path)
+// posix version
+exports.normalize = function (path) {
+  var isAbsolute = exports.isAbsolute(path),
+      trailingSlash = substr(path, -1) === '/';
+
+  // Normalize the path
+  path = normalizeArray(filter(path.split('/'), function (p) {
+    return !!p;
+  }), !isAbsolute).join('/');
+
+  if (!path && !isAbsolute) {
+    path = '.';
+  }
+  if (path && trailingSlash) {
+    path += '/';
+  }
+
+  return (isAbsolute ? '/' : '') + path;
+};
+
+// posix version
+exports.isAbsolute = function (path) {
+  return path.charAt(0) === '/';
+};
+
+// posix version
+exports.join = function () {
+  var paths = Array.prototype.slice.call(arguments, 0);
+  return exports.normalize(filter(paths, function (p, index) {
+    if (typeof p !== 'string') {
+      throw new TypeError('Arguments to path.join must be strings');
+    }
+    return p;
+  }).join('/'));
+};
+
+// path.relative(from, to)
+// posix version
+exports.relative = function (from, to) {
+  from = exports.resolve(from).substr(1);
+  to = exports.resolve(to).substr(1);
+
+  function trim(arr) {
+    var start = 0;
+    for (; start < arr.length; start++) {
+      if (arr[start] !== '') break;
+    }
+
+    var end = arr.length - 1;
+    for (; end >= 0; end--) {
+      if (arr[end] !== '') break;
+    }
+
+    if (start > end) return [];
+    return arr.slice(start, end - start + 1);
+  }
+
+  var fromParts = trim(from.split('/'));
+  var toParts = trim(to.split('/'));
+
+  var length = Math.min(fromParts.length, toParts.length);
+  var samePartsLength = length;
+  for (var i = 0; i < length; i++) {
+    if (fromParts[i] !== toParts[i]) {
+      samePartsLength = i;
+      break;
+    }
+  }
+
+  var outputParts = [];
+  for (var i = samePartsLength; i < fromParts.length; i++) {
+    outputParts.push('..');
+  }
+
+  outputParts = outputParts.concat(toParts.slice(samePartsLength));
+
+  return outputParts.join('/');
+};
+
+exports.sep = '/';
+exports.delimiter = ':';
+
+exports.dirname = function (path) {
+  var result = splitPath(path),
+      root = result[0],
+      dir = result[1];
+
+  if (!root && !dir) {
+    // No dirname whatsoever
+    return '.';
+  }
+
+  if (dir) {
+    // It has a dirname, strip trailing slash
+    dir = dir.substr(0, dir.length - 1);
+  }
+
+  return root + dir;
+};
+
+exports.basename = function (path, ext) {
+  var f = splitPath(path)[2];
+  // TODO: make this comparison case-insensitive on windows?
+  if (ext && f.substr(-1 * ext.length) === ext) {
+    f = f.substr(0, f.length - ext.length);
+  }
+  return f;
+};
+
+exports.extname = function (path) {
+  return splitPath(path)[3];
+};
+
+function filter(xs, f) {
+  if (xs.filter) return xs.filter(f);
+  var res = [];
+  for (var i = 0; i < xs.length; i++) {
+    if (f(xs[i], i, xs)) res.push(xs[i]);
+  }
+  return res;
+}
+
+// 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);
+};
+
+}).call(this,require('_process'))
+},{"_process":345}],343:[function(require,module,exports){
+(function (global){
+'use strict';
+
+var _typeof2 = require('babel-runtime/helpers/typeof');
+
+var _typeof3 = _interopRequireDefault(_typeof2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/*!
+ * Platform.js v1.3.1 <http://mths.be/platform>
+ * Copyright 2014-2016 Benjamin Tan <https://d10.github.io/>
+ * Copyright 2011-2013 John-David Dalton <http://allyoucanleet.com/>
+ * Available under MIT license <http://mths.be/mit>
+ */
+;(function () {
+  'use strict';
+
+  /** Used to determine if values are of the language type `Object` */
+
+  var objectTypes = {
+    'function': true,
+    'object': true
+  };
+
+  /** Used as a reference to the global object */
+  var root = objectTypes[typeof window === 'undefined' ? 'undefined' : (0, _typeof3.default)(window)] && window || this;
+
+  /** Backup possible global object */
+  var oldRoot = root;
+
+  /** Detect free variable `exports` */
+  var freeExports = objectTypes[typeof exports === 'undefined' ? 'undefined' : (0, _typeof3.default)(exports)] && exports;
+
+  /** Detect free variable `module` */
+  var freeModule = objectTypes[typeof module === 'undefined' ? 'undefined' : (0, _typeof3.default)(module)] && module && !module.nodeType && module;
+
+  /** Detect free variable `global` from Node.js or Browserified code and use it as `root` */
+  var freeGlobal = freeExports && freeModule && (typeof global === 'undefined' ? 'undefined' : (0, _typeof3.default)(global)) == 'object' && global;
+  if (freeGlobal && (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal || freeGlobal.self === freeGlobal)) {
+    root = freeGlobal;
+  }
+
+  /**
+   * Used as the maximum length of an array-like object.
+   * See the [ES6 spec](http://people.mozilla.org/~jorendorff/es6-draft.html#sec-tolength)
+   * for more details.
+   */
+  var maxSafeInteger = Math.pow(2, 53) - 1;
+
+  /** Opera regexp */
+  var reOpera = /\bOpera/;
+
+  /** Possible global object */
+  var thisBinding = this;
+
+  /** Used for native method references */
+  var objectProto = Object.prototype;
+
+  /** Used to check for own properties of an object */
+  var hasOwnProperty = objectProto.hasOwnProperty;
+
+  /** Used to resolve the internal `[[Class]]` of values */
+  var toString = objectProto.toString;
+
+  /*--------------------------------------------------------------------------*/
+
+  /**
+   * Capitalizes a string value.
+   *
+   * @private
+   * @param {string} string The string to capitalize.
+   * @returns {string} The capitalized string.
+   */
+  function capitalize(string) {
+    string = String(string);
+    return string.charAt(0).toUpperCase() + string.slice(1);
+  }
+
+  /**
+   * A utility function to clean up the OS name.
+   *
+   * @private
+   * @param {string} os The OS name to clean up.
+   * @param {string} [pattern] A `RegExp` pattern matching the OS name.
+   * @param {string} [label] A label for the OS.
+   */
+  function cleanupOS(os, pattern, label) {
+    // platform tokens defined at
+    // http://msdn.microsoft.com/en-us/library/ms537503(VS.85).aspx
+    // http://web.archive.org/web/20081122053950/http://msdn.microsoft.com/en-us/library/ms537503(VS.85).aspx
+    var data = {
+      '6.4': '10',
+      '6.3': '8.1',
+      '6.2': '8',
+      '6.1': 'Server 2008 R2 / 7',
+      '6.0': 'Server 2008 / Vista',
+      '5.2': 'Server 2003 / XP 64-bit',
+      '5.1': 'XP',
+      '5.01': '2000 SP1',
+      '5.0': '2000',
+      '4.0': 'NT',
+      '4.90': 'ME'
+    };
+    // detect Windows version from platform tokens
+    if (pattern && label && /^Win/i.test(os) && (data = data[(0 /*Opera 9.25 fix*/, /[\d.]+$/.exec(os))])) {
+      os = 'Windows ' + data;
+    }
+    // correct character case and cleanup
+    os = String(os);
+
+    if (pattern && label) {
+      os = os.replace(RegExp(pattern, 'i'), label);
+    }
+
+    os = format(os.replace(/ ce$/i, ' CE').replace(/\bhpw/i, 'web').replace(/\bMacintosh\b/, 'Mac OS').replace(/_PowerPC\b/i, ' OS').replace(/\b(OS X) [^ \d]+/i, '$1').replace(/\bMac (OS X)\b/, '$1').replace(/\/(\d)/, ' $1').replace(/_/g, '.').replace(/(?: BePC|[ .]*fc[ \d.]+)$/i, '').replace(/\bx86\.64\b/gi, 'x86_64').replace(/\b(Windows Phone) OS\b/, '$1').split(' on ')[0]);
+
+    return os;
+  }
+
+  /**
+   * An iteration utility for arrays and objects.
+   *
+   * @private
+   * @param {Array|Object} object The object to iterate over.
+   * @param {Function} callback The function called per iteration.
+   */
+  function each(object, callback) {
+    var index = -1,
+        length = object ? object.length : 0;
+
+    if (typeof length == 'number' && length > -1 && length <= maxSafeInteger) {
+      while (++index < length) {
+        callback(object[index], index, object);
+      }
+    } else {
+      forOwn(object, callback);
+    }
+  }
+
+  /**
+   * Trim and conditionally capitalize string values.
+   *
+   * @private
+   * @param {string} string The string to format.
+   * @returns {string} The formatted string.
+   */
+  function format(string) {
+    string = trim(string);
+    return (/^(?:webOS|i(?:OS|P))/.test(string) ? string : capitalize(string)
+    );
+  }
+
+  /**
+   * Iterates over an object's own properties, executing the `callback` for each.
+   *
+   * @private
+   * @param {Object} object The object to iterate over.
+   * @param {Function} callback The function executed per own property.
+   */
+  function forOwn(object, callback) {
+    for (var key in object) {
+      if (hasOwnProperty.call(object, key)) {
+        callback(object[key], key, object);
+      }
+    }
+  }
+
+  /**
+   * Gets the internal `[[Class]]` of a value.
+   *
+   * @private
+   * @param {*} value The value.
+   * @returns {string} The `[[Class]]`.
+   */
+  function getClassOf(value) {
+    return value == null ? capitalize(value) : toString.call(value).slice(8, -1);
+  }
+
+  /**
+   * Host objects can return type values that are different from their actual
+   * data type. The objects we are concerned with usually return non-primitive
+   * types of "object", "function", or "unknown".
+   *
+   * @private
+   * @param {*} object The owner of the property.
+   * @param {string} property The property to check.
+   * @returns {boolean} Returns `true` if the property value is a non-primitive, else `false`.
+   */
+  function isHostType(object, property) {
+    var type = object != null ? (0, _typeof3.default)(object[property]) : 'number';
+    return !/^(?:boolean|number|string|undefined)$/.test(type) && (type == 'object' ? !!object[property] : true);
+  }
+
+  /**
+   * Prepares a string for use in a `RegExp` by making hyphens and spaces optional.
+   *
+   * @private
+   * @param {string} string The string to qualify.
+   * @returns {string} The qualified string.
+   */
+  function qualify(string) {
+    return String(string).replace(/([ -])(?!$)/g, '$1?');
+  }
+
+  /**
+   * A bare-bones `Array#reduce` like utility function.
+   *
+   * @private
+   * @param {Array} array The array to iterate over.
+   * @param {Function} callback The function called per iteration.
+   * @returns {*} The accumulated result.
+   */
+  function reduce(array, callback) {
+    var accumulator = null;
+    each(array, function (value, index) {
+      accumulator = callback(accumulator, value, index, array);
+    });
+    return accumulator;
+  }
+
+  /**
+   * Removes leading and trailing whitespace from a string.
+   *
+   * @private
+   * @param {string} string The string to trim.
+   * @returns {string} The trimmed string.
+   */
+  function trim(string) {
+    return String(string).replace(/^ +| +$/g, '');
+  }
+
+  /*--------------------------------------------------------------------------*/
+
+  /**
+   * Creates a new platform object.
+   *
+   * @memberOf platform
+   * @param {Object|string} [ua=navigator.userAgent] The user agent string or
+   *  context object.
+   * @returns {Object} A platform object.
+   */
+  function parse(ua) {
+
+    /** The environment context object */
+    var context = root;
+
+    /** Used to flag when a custom context is provided */
+    var isCustomContext = ua && (typeof ua === 'undefined' ? 'undefined' : (0, _typeof3.default)(ua)) == 'object' && getClassOf(ua) != 'String';
+
+    // juggle arguments
+    if (isCustomContext) {
+      context = ua;
+      ua = null;
+    }
+
+    /** Browser navigator object */
+    var nav = context.navigator || {};
+
+    /** Browser user agent string */
+    var userAgent = nav.userAgent || '';
+
+    ua || (ua = userAgent);
+
+    /** Used to flag when `thisBinding` is the [ModuleScope] */
+    var isModuleScope = isCustomContext || thisBinding == oldRoot;
+
+    /** Used to detect if browser is like Chrome */
+    var likeChrome = isCustomContext ? !!nav.likeChrome : /\bChrome\b/.test(ua) && !/internal|\n/i.test(toString.toString());
+
+    /** Internal `[[Class]]` value shortcuts */
+    var objectClass = 'Object',
+        airRuntimeClass = isCustomContext ? objectClass : 'ScriptBridgingProxyObject',
+        enviroClass = isCustomContext ? objectClass : 'Environment',
+        javaClass = isCustomContext && context.java ? 'JavaPackage' : getClassOf(context.java),
+        phantomClass = isCustomContext ? objectClass : 'RuntimeObject';
+
+    /** Detect Java environment */
+    var java = /\bJava/.test(javaClass) && context.java;
+
+    /** Detect Rhino */
+    var rhino = java && getClassOf(context.environment) == enviroClass;
+
+    /** A character to represent alpha */
+    var alpha = java ? 'a' : '\u03B1';
+
+    /** A character to represent beta */
+    var beta = java ? 'b' : '\u03B2';
+
+    /** Browser document object */
+    var doc = context.document || {};
+
+    /**
+     * Detect Opera browser (Presto-based)
+     * http://www.howtocreate.co.uk/operaStuff/operaObject.html
+     * http://dev.opera.com/articles/view/opera-mini-web-content-authoring-guidelines/#operamini
+     */
+    var opera = context.operamini || context.opera;
+
+    /** Opera `[[Class]]` */
+    var operaClass = reOpera.test(operaClass = isCustomContext && opera ? opera['[[Class]]'] : getClassOf(opera)) ? operaClass : opera = null;
+
+    /*------------------------------------------------------------------------*/
+
+    /** Temporary variable used over the script's lifetime */
+    var data;
+
+    /** The CPU architecture */
+    var arch = ua;
+
+    /** Platform description array */
+    var description = [];
+
+    /** Platform alpha/beta indicator */
+    var prerelease = null;
+
+    /** A flag to indicate that environment features should be used to resolve the platform */
+    var useFeatures = ua == userAgent;
+
+    /** The browser/environment version */
+    var version = useFeatures && opera && typeof opera.version == 'function' && opera.version();
+
+    /** A flag to indicate if the OS ends with "/ Version" */
+    var isSpecialCasedOS;
+
+    /* Detectable layout engines (order is important) */
+    var layout = getLayout(['Trident', { 'label': 'WebKit', 'pattern': 'AppleWebKit' }, 'iCab', 'Presto', 'NetFront', 'Tasman', 'KHTML', 'Gecko']);
+
+    /* Detectable browser names (order is important) */
+    var name = getName(['Adobe AIR', 'Arora', 'Avant Browser', 'Breach', 'Camino', 'Epiphany', 'Fennec', 'Flock', 'Galeon', 'GreenBrowser', 'iCab', 'Iceweasel', { 'label': 'SRWare Iron', 'pattern': 'Iron' }, 'K-Meleon', 'Konqueror', 'Lunascape', 'Maxthon', 'Midori', 'Nook Browser', 'PhantomJS', 'Raven', 'Rekonq', 'RockMelt', 'SeaMonkey', { 'label': 'Silk', 'pattern': '(?:Cloud9|Silk-Accelerated)' }, 'Sleipnir', 'SlimBrowser', 'Sunrise', 'Swiftfox', 'WebPositive', 'Opera Mini', { 'label': 'Opera Mini', 'pattern': 'OPiOS' }, 'Opera', { 'label': 'Opera', 'pattern': 'OPR' }, 'Chrome', { 'label': 'Chrome Mobile', 'pattern': '(?:CriOS|CrMo)' }, { 'label': 'Firefox', 'pattern': '(?:Firefox|Minefield)' }, { 'label': 'IE', 'pattern': 'IEMobile' }, { 'label': 'IE', 'pattern': 'MSIE' }, 'Safari']);
+
+    /* Detectable products (order is important) */
+    var product = getProduct([{ 'label': 'BlackBerry', 'pattern': 'BB10' }, 'BlackBerry', { 'label': 'Galaxy S', 'pattern': 'GT-I9000' }, { 'label': 'Galaxy S2', 'pattern': 'GT-I9100' }, { 'label': 'Galaxy S3', 'pattern': 'GT-I9300' }, { 'label': 'Galaxy S4', 'pattern': 'GT-I9500' }, 'Google TV', 'Lumia', 'iPad', 'iPod', 'iPhone', 'Kindle', { 'label': 'Kindle Fire', 'pattern': '(?:Cloud9|Silk-Accelerated)' }, 'Nook', 'PlayBook', 'PlayStation 4', 'PlayStation 3', 'PlayStation Vita', 'TouchPad', 'Transformer', { 'label': 'Wii U', 'pattern': 'WiiU' }, 'Wii', 'Xbox One', { 'label': 'Xbox 360', 'pattern': 'Xbox' }, 'Xoom']);
+
+    /* Detectable manufacturers */
+    var manufacturer = getManufacturer({
+      'Apple': { 'iPad': 1, 'iPhone': 1, 'iPod': 1 },
+      'Amazon': { 'Kindle': 1, 'Kindle Fire': 1 },
+      'Asus': { 'Transformer': 1 },
+      'Barnes & Noble': { 'Nook': 1 },
+      'BlackBerry': { 'PlayBook': 1 },
+      'Google': { 'Google TV': 1 },
+      'HP': { 'TouchPad': 1 },
+      'HTC': {},
+      'LG': {},
+      'Microsoft': { 'Xbox': 1, 'Xbox One': 1 },
+      'Motorola': { 'Xoom': 1 },
+      'Nintendo': { 'Wii U': 1, 'Wii': 1 },
+      'Nokia': { 'Lumia': 1 },
+      'Samsung': { 'Galaxy S': 1, 'Galaxy S2': 1, 'Galaxy S3': 1, 'Galaxy S4': 1 },
+      'Sony': { 'PlayStation 4': 1, 'PlayStation 3': 1, 'PlayStation Vita': 1 }
+    });
+
+    /* Detectable OSes (order is important) */
+    var os = getOS(['Windows Phone ', 'Android', 'CentOS', 'Debian', 'Fedora', 'FreeBSD', 'Gentoo', 'Haiku', 'Kubuntu', 'Linux Mint', 'Red Hat', 'SuSE', 'Ubuntu', 'Xubuntu', 'Cygwin', 'Symbian OS', 'hpwOS', 'webOS ', 'webOS', 'Tablet OS', 'Linux', 'Mac OS X', 'Macintosh', 'Mac', 'Windows 98;', 'Windows ']);
+
+    /*------------------------------------------------------------------------*/
+
+    /**
+     * Picks the layout engine from an array of guesses.
+     *
+     * @private
+     * @param {Array} guesses An array of guesses.
+     * @returns {null|string} The detected layout engine.
+     */
+    function getLayout(guesses) {
+      return reduce(guesses, function (result, guess) {
+        return result || RegExp('\\b' + (guess.pattern || qualify(guess)) + '\\b', 'i').exec(ua) && (guess.label || guess);
+      });
+    }
+
+    /**
+     * Picks the manufacturer from an array of guesses.
+     *
+     * @private
+     * @param {Array} guesses An object of guesses.
+     * @returns {null|string} The detected manufacturer.
+     */
+    function getManufacturer(guesses) {
+      return reduce(guesses, function (result, value, key) {
+        // lookup the manufacturer by product or scan the UA for the manufacturer
+        return result || (value[product] || value[(0 /*Opera 9.25 fix*/, /^[a-z]+(?: +[a-z]+\b)*/i.exec(product))] || RegExp('\\b' + qualify(key) + '(?:\\b|\\w*\\d)', 'i').exec(ua)) && key;
+      });
+    }
+
+    /**
+     * Picks the browser name from an array of guesses.
+     *
+     * @private
+     * @param {Array} guesses An array of guesses.
+     * @returns {null|string} The detected browser name.
+     */
+    function getName(guesses) {
+      return reduce(guesses, function (result, guess) {
+        return result || RegExp('\\b' + (guess.pattern || qualify(guess)) + '\\b', 'i').exec(ua) && (guess.label || guess);
+      });
+    }
+
+    /**
+     * Picks the OS name from an array of guesses.
+     *
+     * @private
+     * @param {Array} guesses An array of guesses.
+     * @returns {null|string} The detected OS name.
+     */
+    function getOS(guesses) {
+      return reduce(guesses, function (result, guess) {
+        var pattern = guess.pattern || qualify(guess);
+        if (!result && (result = RegExp('\\b' + pattern + '(?:/[\\d.]+|[ \\w.]*)', 'i').exec(ua))) {
+          result = cleanupOS(result, pattern, guess.label || guess);
+        }
+        return result;
+      });
+    }
+
+    /**
+     * Picks the product name from an array of guesses.
+     *
+     * @private
+     * @param {Array} guesses An array of guesses.
+     * @returns {null|string} The detected product name.
+     */
+    function getProduct(guesses) {
+      return reduce(guesses, function (result, guess) {
+        var pattern = guess.pattern || qualify(guess);
+        if (!result && (result = RegExp('\\b' + pattern + ' *\\d+[.\\w_]*', 'i').exec(ua) || RegExp('\\b' + pattern + '(?:; *(?:[a-z]+[_-])?[a-z]+\\d+|[^ ();-]*)', 'i').exec(ua))) {
+          // split by forward slash and append product version if needed
+          if ((result = String(guess.label && !RegExp(pattern, 'i').test(guess.label) ? guess.label : result).split('/'))[1] && !/[\d.]+/.test(result[0])) {
+            result[0] += ' ' + result[1];
+          }
+          // correct character case and cleanup
+          guess = guess.label || guess;
+          result = format(result[0].replace(RegExp(pattern, 'i'), guess).replace(RegExp('; *(?:' + guess + '[_-])?', 'i'), ' ').replace(RegExp('(' + guess + ')[-_.]?(\\w)', 'i'), '$1 $2'));
+        }
+        return result;
+      });
+    }
+
+    /**
+     * Resolves the version using an array of UA patterns.
+     *
+     * @private
+     * @param {Array} patterns An array of UA patterns.
+     * @returns {null|string} The detected version.
+     */
+    function getVersion(patterns) {
+      return reduce(patterns, function (result, pattern) {
+        return result || (RegExp(pattern + '(?:-[\\d.]+/|(?: for [\\w-]+)?[ /-])([\\d.]+[^ ();/_-]*)', 'i').exec(ua) || 0)[1] || null;
+      });
+    }
+
+    /**
+     * Returns `platform.description` when the platform object is coerced to a string.
+     *
+     * @name toString
+     * @memberOf platform
+     * @returns {string} Returns `platform.description` if available, else an empty string.
+     */
+    function toStringPlatform() {
+      return this.description || '';
+    }
+
+    /*------------------------------------------------------------------------*/
+
+    // convert layout to an array so we can add extra details
+    layout && (layout = [layout]);
+
+    // detect product names that contain their manufacturer's name
+    if (manufacturer && !product) {
+      product = getProduct([manufacturer]);
+    }
+    // clean up Google TV
+    if (data = /\bGoogle TV\b/.exec(product)) {
+      product = data[0];
+    }
+    // detect simulators
+    if (/\bSimulator\b/i.test(ua)) {
+      product = (product ? product + ' ' : '') + 'Simulator';
+    }
+    // detect Opera Mini 8+ running in Turbo/Uncompressed mode on iOS
+    if (name == 'Opera Mini' && /\bOPiOS\b/.test(ua)) {
+      description.push('running in Turbo/Uncompressed mode');
+    }
+    // detect iOS
+    if (/^iP/.test(product)) {
+      name || (name = 'Safari');
+      os = 'iOS' + ((data = / OS ([\d_]+)/i.exec(ua)) ? ' ' + data[1].replace(/_/g, '.') : '');
+    }
+    // detect Kubuntu
+    else if (name == 'Konqueror' && !/buntu/i.test(os)) {
+        os = 'Kubuntu';
+      }
+      // detect Android browsers
+      else if (manufacturer && manufacturer != 'Google' && (/Chrome/.test(name) && !/\bMobile Safari\b/i.test(ua) || /\bVita\b/.test(product))) {
+          name = 'Android Browser';
+          os = /\bAndroid\b/.test(os) ? os : 'Android';
+        }
+        // detect false positives for Firefox/Safari
+        else if (!name || (data = !/\bMinefield\b|\(Android;/i.test(ua) && /\b(?:Firefox|Safari)\b/.exec(name))) {
+            // escape the `/` for Firefox 1
+            if (name && !product && /[\/,]|^[^(]+?\)/.test(ua.slice(ua.indexOf(data + '/') + 8))) {
+              // clear name of false positives
+              name = null;
+            }
+            // reassign a generic name
+            if ((data = product || manufacturer || os) && (product || manufacturer || /\b(?:Android|Symbian OS|Tablet OS|webOS)\b/.test(os))) {
+              name = /[a-z]+(?: Hat)?/i.exec(/\bAndroid\b/.test(os) ? os : data) + ' Browser';
+            }
+          }
+    // detect Firefox OS
+    if ((data = /\((Mobile|Tablet).*?Firefox\b/i.exec(ua)) && data[1]) {
+      os = 'Firefox OS';
+      if (!product) {
+        product = data[1];
+      }
+    }
+    // detect non-Opera versions (order is important)
+    if (!version) {
+      version = getVersion(['(?:Cloud9|CriOS|CrMo|IEMobile|Iron|Opera ?Mini|OPiOS|OPR|Raven|Silk(?!/[\\d.]+$))', 'Version', qualify(name), '(?:Firefox|Minefield|NetFront)']);
+    }
+    // detect stubborn layout engines
+    if (layout == 'iCab' && parseFloat(version) > 3) {
+      layout = ['WebKit'];
+    } else if (layout != 'Trident' && (data = /\bOpera\b/.test(name) && (/\bOPR\b/.test(ua) ? 'Blink' : 'Presto') || /\b(?:Midori|Nook|Safari)\b/i.test(ua) && 'WebKit' || !layout && /\bMSIE\b/i.test(ua) && (os == 'Mac OS' ? 'Tasman' : 'Trident'))) {
+      layout = [data];
+    }
+    // detect NetFront on PlayStation
+    else if (/\bPlayStation\b(?! Vita\b)/i.test(name) && layout == 'WebKit') {
+        layout = ['NetFront'];
+      }
+    // detect Windows Phone 7 desktop mode
+    if (name == 'IE' && (data = (/; *(?:XBLWP|ZuneWP)(\d+)/i.exec(ua) || 0)[1])) {
+      name += ' Mobile';
+      os = 'Windows Phone ' + (/\+$/.test(data) ? data : data + '.x');
+      description.unshift('desktop mode');
+    }
+    // detect Windows Phone 8+ desktop mode
+    else if (/\bWPDesktop\b/i.test(ua)) {
+        name = 'IE Mobile';
+        os = 'Windows Phone 8+';
+        description.unshift('desktop mode');
+        version || (version = (/\brv:([\d.]+)/.exec(ua) || 0)[1]);
+      }
+      // detect IE 11 and above
+      else if (name != 'IE' && layout == 'Trident' && (data = /\brv:([\d.]+)/.exec(ua))) {
+          if (!/\bWPDesktop\b/i.test(ua)) {
+            if (name) {
+              description.push('identifying as ' + name + (version ? ' ' + version : ''));
+            }
+            name = 'IE';
+          }
+          version = data[1];
+        }
+        // detect Microsoft Edge
+        else if ((name == 'Chrome' || name != 'IE') && (data = /\bEdge\/([\d.]+)/.exec(ua))) {
+            name = 'Microsoft Edge';
+            version = data[1];
+            layout = ['Trident'];
+          }
+    // leverage environment features
+    if (useFeatures) {
+      // detect server-side environments
+      // Rhino has a global function while others have a global object
+      if (isHostType(context, 'global')) {
+        if (java) {
+          data = java.lang.System;
+          arch = data.getProperty('os.arch');
+          os = os || data.getProperty('os.name') + ' ' + data.getProperty('os.version');
+        }
+        if (isModuleScope && isHostType(context, 'system') && (data = [context.system])[0]) {
+          os || (os = data[0].os || null);
+          try {
+            data[1] = context.require('ringo/engine').version;
+            version = data[1].join('.');
+            name = 'RingoJS';
+          } catch (e) {
+            if (data[0].global.system == context.system) {
+              name = 'Narwhal';
+            }
+          }
+        } else if ((0, _typeof3.default)(context.process) == 'object' && (data = context.process)) {
+          name = 'Node.js';
+          arch = data.arch;
+          os = data.platform;
+          version = /[\d.]+/.exec(data.version)[0];
+        } else if (rhino) {
+          name = 'Rhino';
+        }
+      }
+      // detect Adobe AIR
+      else if (getClassOf(data = context.runtime) == airRuntimeClass) {
+          name = 'Adobe AIR';
+          os = data.flash.system.Capabilities.os;
+        }
+        // detect PhantomJS
+        else if (getClassOf(data = context.phantom) == phantomClass) {
+            name = 'PhantomJS';
+            version = (data = data.version || null) && data.major + '.' + data.minor + '.' + data.patch;
+          }
+          // detect IE compatibility modes
+          else if (typeof doc.documentMode == 'number' && (data = /\bTrident\/(\d+)/i.exec(ua))) {
+              // we're in compatibility mode when the Trident version + 4 doesn't
+              // equal the document mode
+              version = [version, doc.documentMode];
+              if ((data = +data[1] + 4) != version[1]) {
+                description.push('IE ' + version[1] + ' mode');
+                layout && (layout[1] = '');
+                version[1] = data;
+              }
+              version = name == 'IE' ? String(version[1].toFixed(1)) : version[0];
+            }
+      os = os && format(os);
+    }
+    // detect prerelease phases
+    if (version && (data = /(?:[ab]|dp|pre|[ab]\d+pre)(?:\d+\+?)?$/i.exec(version) || /(?:alpha|beta)(?: ?\d)?/i.exec(ua + ';' + (useFeatures && nav.appMinorVersion)) || /\bMinefield\b/i.test(ua) && 'a')) {
+      prerelease = /b/i.test(data) ? 'beta' : 'alpha';
+      version = version.replace(RegExp(data + '\\+?$'), '') + (prerelease == 'beta' ? beta : alpha) + (/\d+\+?/.exec(data) || '');
+    }
+    // detect Firefox Mobile
+    if (name == 'Fennec' || name == 'Firefox' && /\b(?:Android|Firefox OS)\b/.test(os)) {
+      name = 'Firefox Mobile';
+    }
+    // obscure Maxthon's unreliable version
+    else if (name == 'Maxthon' && version) {
+        version = version.replace(/\.[\d.]+/, '.x');
+      }
+      // detect Silk desktop/accelerated modes
+      else if (name == 'Silk') {
+          if (!/\bMobi/i.test(ua)) {
+            os = 'Android';
+            description.unshift('desktop mode');
+          }
+          if (/Accelerated *= *true/i.test(ua)) {
+            description.unshift('accelerated');
+          }
+        }
+        // detect Xbox 360 and Xbox One
+        else if (/\bXbox\b/i.test(product)) {
+            os = null;
+            if (product == 'Xbox 360' && /\bIEMobile\b/.test(ua)) {
+              description.unshift('mobile mode');
+            }
+          }
+          // add mobile postfix
+          else if ((/^(?:Chrome|IE|Opera)$/.test(name) || name && !product && !/Browser|Mobi/.test(name)) && (os == 'Windows CE' || /Mobi/i.test(ua))) {
+              name += ' Mobile';
+            }
+            // detect IE platform preview
+            else if (name == 'IE' && useFeatures && context.external === null) {
+                description.unshift('platform preview');
+              }
+              // detect BlackBerry OS version
+              // http://docs.blackberry.com/en/developers/deliverables/18169/HTTP_headers_sent_by_BB_Browser_1234911_11.jsp
+              else if ((/\bBlackBerry\b/.test(product) || /\bBB10\b/.test(ua)) && (data = (RegExp(product.replace(/ +/g, ' *') + '/([.\\d]+)', 'i').exec(ua) || 0)[1] || version)) {
+                  data = [data, /BB10/.test(ua)];
+                  os = (data[1] ? (product = null, manufacturer = 'BlackBerry') : 'Device Software') + ' ' + data[0];
+                  version = null;
+                }
+                // detect Opera identifying/masking itself as another browser
+                // http://www.opera.com/support/kb/view/843/
+                else if (this != forOwn && product != 'Wii' && (useFeatures && opera || /Opera/.test(name) && /\b(?:MSIE|Firefox)\b/i.test(ua) || name == 'Firefox' && /\bOS X (?:\d+\.){2,}/.test(os) || name == 'IE' && (os && !/^Win/.test(os) && version > 5.5 || /\bWindows XP\b/.test(os) && version > 8 || version == 8 && !/\bTrident\b/.test(ua))) && !reOpera.test(data = parse.call(forOwn, ua.replace(reOpera, '') + ';')) && data.name) {
+
+                    // when "indentifying", the UA contains both Opera and the other browser's name
+                    data = 'ing as ' + data.name + ((data = data.version) ? ' ' + data : '');
+                    if (reOpera.test(name)) {
+                      if (/\bIE\b/.test(data) && os == 'Mac OS') {
+                        os = null;
+                      }
+                      data = 'identify' + data;
+                    }
+                    // when "masking", the UA contains only the other browser's name
+                    else {
+                        data = 'mask' + data;
+                        if (operaClass) {
+                          name = format(operaClass.replace(/([a-z])([A-Z])/g, '$1 $2'));
+                        } else {
+                          name = 'Opera';
+                        }
+                        if (/\bIE\b/.test(data)) {
+                          os = null;
+                        }
+                        if (!useFeatures) {
+                          version = null;
+                        }
+                      }
+                    layout = ['Presto'];
+                    description.push(data);
+                  }
+    // detect WebKit Nightly and approximate Chrome/Safari versions
+    if (data = (/\bAppleWebKit\/([\d.]+\+?)/i.exec(ua) || 0)[1]) {
+      // correct build for numeric comparison
+      // (e.g. "532.5" becomes "532.05")
+      data = [parseFloat(data.replace(/\.(\d)$/, '.0$1')), data];
+      // nightly builds are postfixed with a `+`
+      if (name == 'Safari' && data[1].slice(-1) == '+') {
+        name = 'WebKit Nightly';
+        prerelease = 'alpha';
+        version = data[1].slice(0, -1);
+      }
+      // clear incorrect browser versions
+      else if (version == data[1] || version == (data[2] = (/\bSafari\/([\d.]+\+?)/i.exec(ua) || 0)[1])) {
+          version = null;
+        }
+      // use the full Chrome version when available
+      data[1] = (/\bChrome\/([\d.]+)/i.exec(ua) || 0)[1];
+      // detect Blink layout engine
+      if (data[0] == 537.36 && data[2] == 537.36 && parseFloat(data[1]) >= 28 && name != 'IE' && name != 'Microsoft Edge') {
+        layout = ['Blink'];
+      }
+      // detect JavaScriptCore
+      // http://stackoverflow.com/questions/6768474/how-can-i-detect-which-javascript-engine-v8-or-jsc-is-used-at-runtime-in-androi
+      if (!useFeatures || !likeChrome && !data[1]) {
+        layout && (layout[1] = 'like Safari');
+        data = (data = data[0], data < 400 ? 1 : data < 500 ? 2 : data < 526 ? 3 : data < 533 ? 4 : data < 534 ? '4+' : data < 535 ? 5 : data < 537 ? 6 : data < 538 ? 7 : data < 601 ? 8 : '8');
+      } else {
+        layout && (layout[1] = 'like Chrome');
+        data = data[1] || (data = data[0], data < 530 ? 1 : data < 532 ? 2 : data < 532.05 ? 3 : data < 533 ? 4 : data < 534.03 ? 5 : data < 534.07 ? 6 : data < 534.10 ? 7 : data < 534.13 ? 8 : data < 534.16 ? 9 : data < 534.24 ? 10 : data < 534.30 ? 11 : data < 535.01 ? 12 : data < 535.02 ? '13+' : data < 535.07 ? 15 : data < 535.11 ? 16 : data < 535.19 ? 17 : data < 536.05 ? 18 : data < 536.10 ? 19 : data < 537.01 ? 20 : data < 537.11 ? '21+' : data < 537.13 ? 23 : data < 537.18 ? 24 : data < 537.24 ? 25 : data < 537.36 ? 26 : layout != 'Blink' ? '27' : '28');
+      }
+      // add the postfix of ".x" or "+" for approximate versions
+      layout && (layout[1] += ' ' + (data += typeof data == 'number' ? '.x' : /[.+]/.test(data) ? '' : '+'));
+      // obscure version for some Safari 1-2 releases
+      if (name == 'Safari' && (!version || parseInt(version) > 45)) {
+        version = data;
+      }
+    }
+    // detect Opera desktop modes
+    if (name == 'Opera' && (data = /\bzbov|zvav$/.exec(os))) {
+      name += ' ';
+      description.unshift('desktop mode');
+      if (data == 'zvav') {
+        name += 'Mini';
+        version = null;
+      } else {
+        name += 'Mobile';
+      }
+      os = os.replace(RegExp(' *' + data + '$'), '');
+    }
+    // detect Chrome desktop mode
+    else if (name == 'Safari' && /\bChrome\b/.exec(layout && layout[1])) {
+        description.unshift('desktop mode');
+        name = 'Chrome Mobile';
+        version = null;
+
+        if (/\bOS X\b/.test(os)) {
+          manufacturer = 'Apple';
+          os = 'iOS 4.3+';
+        } else {
+          os = null;
+        }
+      }
+    // strip incorrect OS versions
+    if (version && version.indexOf(data = /[\d.]+$/.exec(os)) == 0 && ua.indexOf('/' + data + '-') > -1) {
+      os = trim(os.replace(data, ''));
+    }
+    // add layout engine
+    if (layout && !/\b(?:Avant|Nook)\b/.test(name) && (/Browser|Lunascape|Maxthon/.test(name) || /^(?:Adobe|Arora|Breach|Midori|Opera|Phantom|Rekonq|Rock|Sleipnir|Web)/.test(name) && layout[1])) {
+      // don't add layout details to description if they are falsey
+      (data = layout[layout.length - 1]) && description.push(data);
+    }
+    // combine contextual information
+    if (description.length) {
+      description = ['(' + description.join('; ') + ')'];
+    }
+    // append manufacturer
+    if (manufacturer && product && product.indexOf(manufacturer) < 0) {
+      description.push('on ' + manufacturer);
+    }
+    // append product
+    if (product) {
+      description.push((/^on /.test(description[description.length - 1]) ? '' : 'on ') + product);
+    }
+    // parse OS into an object
+    if (os) {
+      data = / ([\d.+]+)$/.exec(os);
+      isSpecialCasedOS = data && os.charAt(os.length - data[0].length - 1) == '/';
+      os = {
+        'architecture': 32,
+        'family': data && !isSpecialCasedOS ? os.replace(data[0], '') : os,
+        'version': data ? data[1] : null,
+        'toString': function toString() {
+          var version = this.version;
+          return this.family + (version && !isSpecialCasedOS ? ' ' + version : '') + (this.architecture == 64 ? ' 64-bit' : '');
+        }
+      };
+    }
+    // add browser/OS architecture
+    if ((data = /\b(?:AMD|IA|Win|WOW|x86_|x)64\b/i.exec(arch)) && !/\bi686\b/i.test(arch)) {
+      if (os) {
+        os.architecture = 64;
+        os.family = os.family.replace(RegExp(' *' + data), '');
+      }
+      if (name && (/\bWOW64\b/i.test(ua) || useFeatures && /\w(?:86|32)$/.test(nav.cpuClass || nav.platform) && !/\bWin64; x64\b/i.test(ua))) {
+        description.unshift('32-bit');
+      }
+    }
+
+    ua || (ua = null);
+
+    /*------------------------------------------------------------------------*/
+
+    /**
+     * The platform object.
+     *
+     * @name platform
+     * @type Object
+     */
+    var platform = {};
+
+    /**
+     * The platform description.
+     *
+     * @memberOf platform
+     * @type string|null
+     */
+    platform.description = ua;
+
+    /**
+     * The name of the browser's layout engine.
+     *
+     * @memberOf platform
+     * @type string|null
+     */
+    platform.layout = layout && layout[0];
+
+    /**
+     * The name of the product's manufacturer.
+     *
+     * @memberOf platform
+     * @type string|null
+     */
+    platform.manufacturer = manufacturer;
+
+    /**
+     * The name of the browser/environment.
+     *
+     * @memberOf platform
+     * @type string|null
+     */
+    platform.name = name;
+
+    /**
+     * The alpha/beta release indicator.
+     *
+     * @memberOf platform
+     * @type string|null
+     */
+    platform.prerelease = prerelease;
+
+    /**
+     * The name of the product hosting the browser.
+     *
+     * @memberOf platform
+     * @type string|null
+     */
+    platform.product = product;
+
+    /**
+     * The browser's user agent string.
+     *
+     * @memberOf platform
+     * @type string|null
+     */
+    platform.ua = ua;
+
+    /**
+     * The browser/environment version.
+     *
+     * @memberOf platform
+     * @type string|null
+     */
+    platform.version = name && version;
+
+    /**
+     * The name of the operating system.
+     *
+     * @memberOf platform
+     * @type Object
+     */
+    platform.os = os || {
+
+      /**
+       * The CPU architecture the OS is built for.
+       *
+       * @memberOf platform.os
+       * @type number|null
+       */
+      'architecture': null,
+
+      /**
+       * The family of the OS.
+       *
+       * Common values include:
+       * "Windows", "Windows Server 2008 R2 / 7", "Windows Server 2008 / Vista",
+       * "Windows XP", "OS X", "Ubuntu", "Debian", "Fedora", "Red Hat", "SuSE",
+       * "Android", "iOS" and "Windows Phone"
+       *
+       * @memberOf platform.os
+       * @type string|null
+       */
+      'family': null,
+
+      /**
+       * The version of the OS.
+       *
+       * @memberOf platform.os
+       * @type string|null
+       */
+      'version': null,
+
+      /**
+       * Returns the OS string.
+       *
+       * @memberOf platform.os
+       * @returns {string} The OS string.
+       */
+      'toString': function toString() {
+        return 'null';
+      }
+    };
+
+    platform.parse = parse;
+    platform.toString = toStringPlatform;
+
+    if (platform.version) {
+      description.unshift(version);
+    }
+    if (platform.name) {
+      description.unshift(name);
+    }
+    if (os && name && !(os == String(os).split(' ')[0] && (os == name.split(' ')[0] || product))) {
+      description.push(product ? '(' + os + ')' : 'on ' + os);
+    }
+    if (description.length) {
+      platform.description = description.join(' ');
+    }
+    return platform;
+  }
+
+  /*--------------------------------------------------------------------------*/
+
+  // export platform
+  // some AMD build optimizers, like r.js, check for condition patterns like the following:
+  if (typeof define == 'function' && (0, _typeof3.default)(define.amd) == 'object' && define.amd) {
+    // define as an anonymous module so, through path mapping, it can be aliased
+    define(function () {
+      return parse();
+    });
+  }
+  // check for `exports` after `define` in case a build optimizer adds an `exports` object
+  else if (freeExports && freeModule) {
+      // in Narwhal, Node.js, Rhino -require, or RingoJS
+      forOwn(parse(), function (value, key) {
+        freeExports[key] = value;
+      });
+    }
+    // in a browser or Rhino
+    else {
+        root.platform = parse();
+      }
+}).call(undefined);
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"babel-runtime/helpers/typeof":39}],344:[function(require,module,exports){
+(function (process){
+'use strict';
+
+if (!process.version || process.version.indexOf('v0.') === 0 || process.version.indexOf('v1.') === 0 && process.version.indexOf('v1.8.') !== 0) {
+  module.exports = nextTick;
+} else {
+  module.exports = process.nextTick;
+}
+
+function nextTick(fn, arg1, arg2, arg3) {
+  if (typeof fn !== 'function') {
+    throw new TypeError('"callback" argument must be a function');
+  }
+  var len = arguments.length;
+  var args, i;
+  switch (len) {
+    case 0:
+    case 1:
+      return process.nextTick(fn);
+    case 2:
+      return process.nextTick(function afterTickOne() {
+        fn.call(null, arg1);
+      });
+    case 3:
+      return process.nextTick(function afterTickTwo() {
+        fn.call(null, arg1, arg2);
+      });
+    case 4:
+      return process.nextTick(function afterTickThree() {
+        fn.call(null, arg1, arg2, arg3);
+      });
+    default:
+      args = new Array(len - 1);
+      i = 0;
+      while (i < args.length) {
+        args[i++] = arguments[i];
+      }
+      return process.nextTick(function afterTick() {
+        fn.apply(null, args);
+      });
+  }
+}
+
+}).call(this,require('_process'))
+},{"_process":345}],345:[function(require,module,exports){
+'use strict';
+
+// shim for using process in browser
+var process = module.exports = {};
+
+// cached from whatever global is present so that test runners that stub it
+// don't break things.  But we need to wrap it in a try catch in case it is
+// wrapped in strict mode code which doesn't define any globals.  It's inside a
+// function because try/catches deoptimize in certain engines.
+
+var cachedSetTimeout;
+var cachedClearTimeout;
+
+function defaultSetTimout() {
+    throw new Error('setTimeout has not been defined');
+}
+function defaultClearTimeout() {
+    throw new Error('clearTimeout has not been defined');
+}
+(function () {
+    try {
+        if (typeof setTimeout === 'function') {
+            cachedSetTimeout = setTimeout;
+        } else {
+            cachedSetTimeout = defaultSetTimout;
+        }
+    } catch (e) {
+        cachedSetTimeout = defaultSetTimout;
+    }
+    try {
+        if (typeof clearTimeout === 'function') {
+            cachedClearTimeout = clearTimeout;
+        } else {
+            cachedClearTimeout = defaultClearTimeout;
+        }
+    } catch (e) {
+        cachedClearTimeout = defaultClearTimeout;
+    }
+})();
+function runTimeout(fun) {
+    if (cachedSetTimeout === setTimeout) {
+        //normal enviroments in sane situations
+        return setTimeout(fun, 0);
+    }
+    // if setTimeout wasn't available but was latter defined
+    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
+        cachedSetTimeout = setTimeout;
+        return setTimeout(fun, 0);
+    }
+    try {
+        // when when somebody has screwed with setTimeout but no I.E. maddness
+        return cachedSetTimeout(fun, 0);
+    } catch (e) {
+        try {
+            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
+            return cachedSetTimeout.call(null, fun, 0);
+        } catch (e) {
+            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
+            return cachedSetTimeout.call(this, fun, 0);
+        }
+    }
+}
+function runClearTimeout(marker) {
+    if (cachedClearTimeout === clearTimeout) {
+        //normal enviroments in sane situations
+        return clearTimeout(marker);
+    }
+    // if clearTimeout wasn't available but was latter defined
+    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
+        cachedClearTimeout = clearTimeout;
+        return clearTimeout(marker);
+    }
+    try {
+        // when when somebody has screwed with setTimeout but no I.E. maddness
+        return cachedClearTimeout(marker);
+    } catch (e) {
+        try {
+            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
+            return cachedClearTimeout.call(null, marker);
+        } catch (e) {
+            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
+            // Some versions of I.E. have different rules for clearTimeout vs setTimeout
+            return cachedClearTimeout.call(this, marker);
+        }
+    }
+}
+var queue = [];
+var draining = false;
+var currentQueue;
+var queueIndex = -1;
+
+function cleanUpNextTick() {
+    if (!draining || !currentQueue) {
+        return;
+    }
+    draining = false;
+    if (currentQueue.length) {
+        queue = currentQueue.concat(queue);
+    } else {
+        queueIndex = -1;
+    }
+    if (queue.length) {
+        drainQueue();
+    }
+}
+
+function drainQueue() {
+    if (draining) {
+        return;
+    }
+    var timeout = runTimeout(cleanUpNextTick);
+    draining = true;
+
+    var len = queue.length;
+    while (len) {
+        currentQueue = queue;
+        queue = [];
+        while (++queueIndex < len) {
+            if (currentQueue) {
+                currentQueue[queueIndex].run();
+            }
+        }
+        queueIndex = -1;
+        len = queue.length;
+    }
+    currentQueue = null;
+    draining = false;
+    runClearTimeout(timeout);
+}
+
+process.nextTick = function (fun) {
+    var args = new Array(arguments.length - 1);
+    if (arguments.length > 1) {
+        for (var i = 1; i < arguments.length; i++) {
+            args[i - 1] = arguments[i];
+        }
+    }
+    queue.push(new Item(fun, args));
+    if (queue.length === 1 && !draining) {
+        runTimeout(drainQueue);
+    }
+};
+
+// v8 likes predictible objects
+function Item(fun, array) {
+    this.fun = fun;
+    this.array = array;
+}
+Item.prototype.run = function () {
+    this.fun.apply(null, this.array);
+};
+process.title = 'browser';
+process.browser = true;
+process.env = {};
+process.argv = [];
+process.version = ''; // empty string to avoid regexp issues
+process.versions = {};
+
+function noop() {}
+
+process.on = noop;
+process.addListener = noop;
+process.once = noop;
+process.off = noop;
+process.removeListener = noop;
+process.removeAllListeners = noop;
+process.emit = noop;
+
+process.binding = function (name) {
+    throw new Error('process.binding is not supported');
+};
+
+process.cwd = function () {
+    return '/';
+};
+process.chdir = function (dir) {
+    throw new Error('process.chdir is not supported');
+};
+process.umask = function () {
+    return 0;
+};
+
+},{}],346:[function(require,module,exports){
+(function (global){
+'use strict';
+
+var _typeof2 = require('babel-runtime/helpers/typeof');
+
+var _typeof3 = _interopRequireDefault(_typeof2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/*! https://mths.be/punycode v1.4.1 by @mathias */
+;(function (root) {
+
+	/** Detect free variables */
+	var freeExports = (typeof exports === 'undefined' ? 'undefined' : (0, _typeof3.default)(exports)) == 'object' && exports && !exports.nodeType && exports;
+	var freeModule = (typeof module === 'undefined' ? 'undefined' : (0, _typeof3.default)(module)) == 'object' && module && !module.nodeType && module;
+	var freeGlobal = (typeof global === 'undefined' ? 'undefined' : (0, _typeof3.default)(global)) == 'object' && global;
+	if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal || freeGlobal.self === freeGlobal) {
+		root = freeGlobal;
+	}
+
+	/**
+  * The `punycode` object.
+  * @name punycode
+  * @type Object
+  */
+	var punycode,
+
+
+	/** Highest positive signed 32-bit float value */
+	maxInt = 2147483647,
+	    // aka. 0x7FFFFFFF or 2^31-1
+
+	/** Bootstring parameters */
+	base = 36,
+	    tMin = 1,
+	    tMax = 26,
+	    skew = 38,
+	    damp = 700,
+	    initialBias = 72,
+	    initialN = 128,
+	    // 0x80
+	delimiter = '-',
+	    // '\x2D'
+
+	/** Regular expressions */
+	regexPunycode = /^xn--/,
+	    regexNonASCII = /[^\x20-\x7E]/,
+	    // unprintable ASCII chars + non-ASCII chars
+	regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g,
+	    // RFC 3490 separators
+
+	/** Error messages */
+	errors = {
+		'overflow': 'Overflow: input needs wider integers to process',
+		'not-basic': 'Illegal input >= 0x80 (not a basic code point)',
+		'invalid-input': 'Invalid input'
+	},
+
+
+	/** Convenience shortcuts */
+	baseMinusTMin = base - tMin,
+	    floor = Math.floor,
+	    stringFromCharCode = String.fromCharCode,
+
+
+	/** Temporary variable */
+	key;
+
+	/*--------------------------------------------------------------------------*/
+
+	/**
+  * A generic error utility function.
+  * @private
+  * @param {String} type The error type.
+  * @returns {Error} Throws a `RangeError` with the applicable error message.
+  */
+	function error(type) {
+		throw new RangeError(errors[type]);
+	}
+
+	/**
+  * A generic `Array#map` utility function.
+  * @private
+  * @param {Array} array The array to iterate over.
+  * @param {Function} callback The function that gets called for every array
+  * item.
+  * @returns {Array} A new array of values returned by the callback function.
+  */
+	function map(array, fn) {
+		var length = array.length;
+		var result = [];
+		while (length--) {
+			result[length] = fn(array[length]);
+		}
+		return result;
+	}
+
+	/**
+  * A simple `Array#map`-like wrapper to work with domain name strings or email
+  * addresses.
+  * @private
+  * @param {String} domain The domain name or email address.
+  * @param {Function} callback The function that gets called for every
+  * character.
+  * @returns {Array} A new string of characters returned by the callback
+  * function.
+  */
+	function mapDomain(string, fn) {
+		var parts = string.split('@');
+		var result = '';
+		if (parts.length > 1) {
+			// In email addresses, only the domain name should be punycoded. Leave
+			// the local part (i.e. everything up to `@`) intact.
+			result = parts[0] + '@';
+			string = parts[1];
+		}
+		// Avoid `split(regex)` for IE8 compatibility. See #17.
+		string = string.replace(regexSeparators, '\x2E');
+		var labels = string.split('.');
+		var encoded = map(labels, fn).join('.');
+		return result + encoded;
+	}
+
+	/**
+  * Creates an array containing the numeric code points of each Unicode
+  * character in the string. While JavaScript uses UCS-2 internally,
+  * this function will convert a pair of surrogate halves (each of which
+  * UCS-2 exposes as separate characters) into a single code point,
+  * matching UTF-16.
+  * @see `punycode.ucs2.encode`
+  * @see <https://mathiasbynens.be/notes/javascript-encoding>
+  * @memberOf punycode.ucs2
+  * @name decode
+  * @param {String} string The Unicode input string (UCS-2).
+  * @returns {Array} The new array of code points.
+  */
+	function ucs2decode(string) {
+		var output = [],
+		    counter = 0,
+		    length = string.length,
+		    value,
+		    extra;
+		while (counter < length) {
+			value = string.charCodeAt(counter++);
+			if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
+				// high surrogate, and there is a next character
+				extra = string.charCodeAt(counter++);
+				if ((extra & 0xFC00) == 0xDC00) {
+					// low surrogate
+					output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
+				} else {
+					// unmatched surrogate; only append this code unit, in case the next
+					// code unit is the high surrogate of a surrogate pair
+					output.push(value);
+					counter--;
+				}
+			} else {
+				output.push(value);
+			}
+		}
+		return output;
+	}
+
+	/**
+  * Creates a string based on an array of numeric code points.
+  * @see `punycode.ucs2.decode`
+  * @memberOf punycode.ucs2
+  * @name encode
+  * @param {Array} codePoints The array of numeric code points.
+  * @returns {String} The new Unicode string (UCS-2).
+  */
+	function ucs2encode(array) {
+		return map(array, function (value) {
+			var output = '';
+			if (value > 0xFFFF) {
+				value -= 0x10000;
+				output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);
+				value = 0xDC00 | value & 0x3FF;
+			}
+			output += stringFromCharCode(value);
+			return output;
+		}).join('');
+	}
+
+	/**
+  * Converts a basic code point into a digit/integer.
+  * @see `digitToBasic()`
+  * @private
+  * @param {Number} codePoint The basic numeric code point value.
+  * @returns {Number} The numeric value of a basic code point (for use in
+  * representing integers) in the range `0` to `base - 1`, or `base` if
+  * the code point does not represent a value.
+  */
+	function basicToDigit(codePoint) {
+		if (codePoint - 48 < 10) {
+			return codePoint - 22;
+		}
+		if (codePoint - 65 < 26) {
+			return codePoint - 65;
+		}
+		if (codePoint - 97 < 26) {
+			return codePoint - 97;
+		}
+		return base;
+	}
+
+	/**
+  * Converts a digit/integer into a basic code point.
+  * @see `basicToDigit()`
+  * @private
+  * @param {Number} digit The numeric value of a basic code point.
+  * @returns {Number} The basic code point whose value (when used for
+  * representing integers) is `digit`, which needs to be in the range
+  * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is
+  * used; else, the lowercase form is used. The behavior is undefined
+  * if `flag` is non-zero and `digit` has no uppercase form.
+  */
+	function digitToBasic(digit, flag) {
+		//  0..25 map to ASCII a..z or A..Z
+		// 26..35 map to ASCII 0..9
+		return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
+	}
+
+	/**
+  * Bias adaptation function as per section 3.4 of RFC 3492.
+  * https://tools.ietf.org/html/rfc3492#section-3.4
+  * @private
+  */
+	function adapt(delta, numPoints, firstTime) {
+		var k = 0;
+		delta = firstTime ? floor(delta / damp) : delta >> 1;
+		delta += floor(delta / numPoints);
+		for (; /* no initialization */delta > baseMinusTMin * tMax >> 1; k += base) {
+			delta = floor(delta / baseMinusTMin);
+		}
+		return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
+	}
+
+	/**
+  * Converts a Punycode string of ASCII-only symbols to a string of Unicode
+  * symbols.
+  * @memberOf punycode
+  * @param {String} input The Punycode string of ASCII-only symbols.
+  * @returns {String} The resulting string of Unicode symbols.
+  */
+	function decode(input) {
+		// Don't use UCS-2
+		var output = [],
+		    inputLength = input.length,
+		    out,
+		    i = 0,
+		    n = initialN,
+		    bias = initialBias,
+		    basic,
+		    j,
+		    index,
+		    oldi,
+		    w,
+		    k,
+		    digit,
+		    t,
+
+		/** Cached calculation results */
+		baseMinusT;
+
+		// Handle the basic code points: let `basic` be the number of input code
+		// points before the last delimiter, or `0` if there is none, then copy
+		// the first basic code points to the output.
+
+		basic = input.lastIndexOf(delimiter);
+		if (basic < 0) {
+			basic = 0;
+		}
+
+		for (j = 0; j < basic; ++j) {
+			// if it's not a basic code point
+			if (input.charCodeAt(j) >= 0x80) {
+				error('not-basic');
+			}
+			output.push(input.charCodeAt(j));
+		}
+
+		// Main decoding loop: start just after the last delimiter if any basic code
+		// points were copied; start at the beginning otherwise.
+
+		for (index = basic > 0 ? basic + 1 : 0; index < inputLength;) /* no final expression */{
+
+			// `index` is the index of the next character to be consumed.
+			// Decode a generalized variable-length integer into `delta`,
+			// which gets added to `i`. The overflow checking is easier
+			// if we increase `i` as we go, then subtract off its starting
+			// value at the end to obtain `delta`.
+			for (oldi = i, w = 1, k = base;; /* no condition */k += base) {
+
+				if (index >= inputLength) {
+					error('invalid-input');
+				}
+
+				digit = basicToDigit(input.charCodeAt(index++));
+
+				if (digit >= base || digit > floor((maxInt - i) / w)) {
+					error('overflow');
+				}
+
+				i += digit * w;
+				t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
+
+				if (digit < t) {
+					break;
+				}
+
+				baseMinusT = base - t;
+				if (w > floor(maxInt / baseMinusT)) {
+					error('overflow');
+				}
+
+				w *= baseMinusT;
+			}
+
+			out = output.length + 1;
+			bias = adapt(i - oldi, out, oldi == 0);
+
+			// `i` was supposed to wrap around from `out` to `0`,
+			// incrementing `n` each time, so we'll fix that now:
+			if (floor(i / out) > maxInt - n) {
+				error('overflow');
+			}
+
+			n += floor(i / out);
+			i %= out;
+
+			// Insert `n` at position `i` of the output
+			output.splice(i++, 0, n);
+		}
+
+		return ucs2encode(output);
+	}
+
+	/**
+  * Converts a string of Unicode symbols (e.g. a domain name label) to a
+  * Punycode string of ASCII-only symbols.
+  * @memberOf punycode
+  * @param {String} input The string of Unicode symbols.
+  * @returns {String} The resulting Punycode string of ASCII-only symbols.
+  */
+	function encode(input) {
+		var n,
+		    delta,
+		    handledCPCount,
+		    basicLength,
+		    bias,
+		    j,
+		    m,
+		    q,
+		    k,
+		    t,
+		    currentValue,
+		    output = [],
+
+		/** `inputLength` will hold the number of code points in `input`. */
+		inputLength,
+
+		/** Cached calculation results */
+		handledCPCountPlusOne,
+		    baseMinusT,
+		    qMinusT;
+
+		// Convert the input in UCS-2 to Unicode
+		input = ucs2decode(input);
+
+		// Cache the length
+		inputLength = input.length;
+
+		// Initialize the state
+		n = initialN;
+		delta = 0;
+		bias = initialBias;
+
+		// Handle the basic code points
+		for (j = 0; j < inputLength; ++j) {
+			currentValue = input[j];
+			if (currentValue < 0x80) {
+				output.push(stringFromCharCode(currentValue));
+			}
+		}
+
+		handledCPCount = basicLength = output.length;
+
+		// `handledCPCount` is the number of code points that have been handled;
+		// `basicLength` is the number of basic code points.
+
+		// Finish the basic string - if it is not empty - with a delimiter
+		if (basicLength) {
+			output.push(delimiter);
+		}
+
+		// Main encoding loop:
+		while (handledCPCount < inputLength) {
+
+			// All non-basic code points < n have been handled already. Find the next
+			// larger one:
+			for (m = maxInt, j = 0; j < inputLength; ++j) {
+				currentValue = input[j];
+				if (currentValue >= n && currentValue < m) {
+					m = currentValue;
+				}
+			}
+
+			// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,
+			// but guard against overflow
+			handledCPCountPlusOne = handledCPCount + 1;
+			if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
+				error('overflow');
+			}
+
+			delta += (m - n) * handledCPCountPlusOne;
+			n = m;
+
+			for (j = 0; j < inputLength; ++j) {
+				currentValue = input[j];
+
+				if (currentValue < n && ++delta > maxInt) {
+					error('overflow');
+				}
+
+				if (currentValue == n) {
+					// Represent delta as a generalized variable-length integer
+					for (q = delta, k = base;; /* no condition */k += base) {
+						t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
+						if (q < t) {
+							break;
+						}
+						qMinusT = q - t;
+						baseMinusT = base - t;
+						output.push(stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0)));
+						q = floor(qMinusT / baseMinusT);
+					}
+
+					output.push(stringFromCharCode(digitToBasic(q, 0)));
+					bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);
+					delta = 0;
+					++handledCPCount;
+				}
+			}
+
+			++delta;
+			++n;
+		}
+		return output.join('');
+	}
+
+	/**
+  * Converts a Punycode string representing a domain name or an email address
+  * to Unicode. Only the Punycoded parts of the input will be converted, i.e.
+  * it doesn't matter if you call it on a string that has already been
+  * converted to Unicode.
+  * @memberOf punycode
+  * @param {String} input The Punycoded domain name or email address to
+  * convert to Unicode.
+  * @returns {String} The Unicode representation of the given Punycode
+  * string.
+  */
+	function toUnicode(input) {
+		return mapDomain(input, function (string) {
+			return regexPunycode.test(string) ? decode(string.slice(4).toLowerCase()) : string;
+		});
+	}
+
+	/**
+  * Converts a Unicode string representing a domain name or an email address to
+  * Punycode. Only the non-ASCII parts of the domain name will be converted,
+  * i.e. it doesn't matter if you call it with a domain that's already in
+  * ASCII.
+  * @memberOf punycode
+  * @param {String} input The domain name or email address to convert, as a
+  * Unicode string.
+  * @returns {String} The Punycode representation of the given domain name or
+  * email address.
+  */
+	function toASCII(input) {
+		return mapDomain(input, function (string) {
+			return regexNonASCII.test(string) ? 'xn--' + encode(string) : string;
+		});
+	}
+
+	/*--------------------------------------------------------------------------*/
+
+	/** Define the public API */
+	punycode = {
+		/**
+   * A string representing the current Punycode.js version number.
+   * @memberOf punycode
+   * @type String
+   */
+		'version': '1.4.1',
+		/**
+   * An object of methods to convert from JavaScript's internal character
+   * representation (UCS-2) to Unicode code points, and back.
+   * @see <https://mathiasbynens.be/notes/javascript-encoding>
+   * @memberOf punycode
+   * @type Object
+   */
+		'ucs2': {
+			'decode': ucs2decode,
+			'encode': ucs2encode
+		},
+		'decode': decode,
+		'encode': encode,
+		'toASCII': toASCII,
+		'toUnicode': toUnicode
+	};
+
+	/** Expose `punycode` */
+	// Some AMD build optimizers, like r.js, check for specific condition patterns
+	// like the following:
+	if (typeof define == 'function' && (0, _typeof3.default)(define.amd) == 'object' && define.amd) {
+		define('punycode', function () {
+			return punycode;
+		});
+	} else if (freeExports && freeModule) {
+		if (module.exports == freeExports) {
+			// in Node.js, io.js, or RingoJS v0.8.0+
+			freeModule.exports = punycode;
+		} else {
+			// in Narwhal or RingoJS v0.7.0-
+			for (key in punycode) {
+				punycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]);
+			}
+		}
+	} else {
+		// in Rhino or a web browser
+		root.punycode = punycode;
+	}
+})(undefined);
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"babel-runtime/helpers/typeof":39}],347:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+
+// If obj.hasOwnProperty has been overridden, then calling
+// obj.hasOwnProperty(prop) will break.
+// See: https://github.com/joyent/node/issues/1707
+
+function hasOwnProperty(obj, prop) {
+  return Object.prototype.hasOwnProperty.call(obj, prop);
+}
+
+module.exports = function (qs, sep, eq, options) {
+  sep = sep || '&';
+  eq = eq || '=';
+  var obj = {};
+
+  if (typeof qs !== 'string' || qs.length === 0) {
+    return obj;
+  }
+
+  var regexp = /\+/g;
+  qs = qs.split(sep);
+
+  var maxKeys = 1000;
+  if (options && typeof options.maxKeys === 'number') {
+    maxKeys = options.maxKeys;
+  }
+
+  var len = qs.length;
+  // maxKeys <= 0 means that we should not limit keys count
+  if (maxKeys > 0 && len > maxKeys) {
+    len = maxKeys;
+  }
+
+  for (var i = 0; i < len; ++i) {
+    var x = qs[i].replace(regexp, '%20'),
+        idx = x.indexOf(eq),
+        kstr,
+        vstr,
+        k,
+        v;
+
+    if (idx >= 0) {
+      kstr = x.substr(0, idx);
+      vstr = x.substr(idx + 1);
+    } else {
+      kstr = x;
+      vstr = '';
+    }
+
+    k = decodeURIComponent(kstr);
+    v = decodeURIComponent(vstr);
+
+    if (!hasOwnProperty(obj, k)) {
+      obj[k] = v;
+    } else if (isArray(obj[k])) {
+      obj[k].push(v);
+    } else {
+      obj[k] = [obj[k], v];
+    }
+  }
+
+  return obj;
+};
+
+var isArray = Array.isArray || function (xs) {
+  return Object.prototype.toString.call(xs) === '[object Array]';
+};
+
+},{}],348:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+
+var _keys = require('babel-runtime/core-js/object/keys');
+
+var _keys2 = _interopRequireDefault(_keys);
+
+var _typeof2 = require('babel-runtime/helpers/typeof');
+
+var _typeof3 = _interopRequireDefault(_typeof2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var stringifyPrimitive = function stringifyPrimitive(v) {
+  switch (typeof v === 'undefined' ? 'undefined' : (0, _typeof3.default)(v)) {
+    case 'string':
+      return v;
+
+    case 'boolean':
+      return v ? 'true' : 'false';
+
+    case 'number':
+      return isFinite(v) ? v : '';
+
+    default:
+      return '';
+  }
+};
+
+module.exports = function (obj, sep, eq, name) {
+  sep = sep || '&';
+  eq = eq || '=';
+  if (obj === null) {
+    obj = undefined;
+  }
+
+  if ((typeof obj === 'undefined' ? 'undefined' : (0, _typeof3.default)(obj)) === 'object') {
+    return map(objectKeys(obj), function (k) {
+      var ks = encodeURIComponent(stringifyPrimitive(k)) + eq;
+      if (isArray(obj[k])) {
+        return map(obj[k], function (v) {
+          return ks + encodeURIComponent(stringifyPrimitive(v));
+        }).join(sep);
+      } else {
+        return ks + encodeURIComponent(stringifyPrimitive(obj[k]));
+      }
+    }).join(sep);
+  }
+
+  if (!name) return '';
+  return encodeURIComponent(stringifyPrimitive(name)) + eq + encodeURIComponent(stringifyPrimitive(obj));
+};
+
+var isArray = Array.isArray || function (xs) {
+  return Object.prototype.toString.call(xs) === '[object Array]';
+};
+
+function map(xs, f) {
+  if (xs.map) return xs.map(f);
+  var res = [];
+  for (var i = 0; i < xs.length; i++) {
+    res.push(f(xs[i], i));
+  }
+  return res;
+}
+
+var objectKeys = _keys2.default || function (obj) {
+  var res = [];
+  for (var key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) res.push(key);
+  }
+  return res;
+};
+
+},{"babel-runtime/core-js/object/keys":30,"babel-runtime/helpers/typeof":39}],349:[function(require,module,exports){
+'use strict';
+
+exports.decode = exports.parse = require('./decode');
+exports.encode = exports.stringify = require('./encode');
+
+},{"./decode":347,"./encode":348}],350:[function(require,module,exports){
+"use strict";
+
+module.exports = require("./lib/_stream_duplex.js");
+
+},{"./lib/_stream_duplex.js":351}],351:[function(require,module,exports){
+// a duplex stream is just a stream that is both readable and writable.
+// Since JS doesn't have multiple prototypal inheritance, this class
+// prototypally inherits from Readable, and then parasitically from
+// Writable.
+
+'use strict';
+
+/*<replacement>*/
+
+var _keys = require('babel-runtime/core-js/object/keys');
+
+var _keys2 = _interopRequireDefault(_keys);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var objectKeys = _keys2.default || function (obj) {
+  var keys = [];
+  for (var key in obj) {
+    keys.push(key);
+  }return keys;
+};
+/*</replacement>*/
+
+module.exports = Duplex;
+
+/*<replacement>*/
+var processNextTick = require('process-nextick-args');
+/*</replacement>*/
+
+/*<replacement>*/
+var util = require('core-util-is');
+util.inherits = require('inherits');
+/*</replacement>*/
+
+var Readable = require('./_stream_readable');
+var Writable = require('./_stream_writable');
+
+util.inherits(Duplex, Readable);
+
+var keys = objectKeys(Writable.prototype);
+for (var v = 0; v < keys.length; v++) {
+  var method = keys[v];
+  if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];
+}
+
+function Duplex(options) {
+  if (!(this instanceof Duplex)) return new Duplex(options);
+
+  Readable.call(this, options);
+  Writable.call(this, options);
+
+  if (options && options.readable === false) this.readable = false;
+
+  if (options && options.writable === false) this.writable = false;
+
+  this.allowHalfOpen = true;
+  if (options && options.allowHalfOpen === false) this.allowHalfOpen = false;
+
+  this.once('end', onend);
+}
+
+// the no-half-open enforcer
+function onend() {
+  // if we allow half-open state, or if the writable side ended,
+  // then we're ok.
+  if (this.allowHalfOpen || this._writableState.ended) return;
+
+  // no more data can be written.
+  // But allow more writes to happen in this tick.
+  processNextTick(onEndNT, this);
+}
+
+function onEndNT(self) {
+  self.end();
+}
+
+function forEach(xs, f) {
+  for (var i = 0, l = xs.length; i < l; i++) {
+    f(xs[i], i);
+  }
+}
+
+},{"./_stream_readable":353,"./_stream_writable":355,"babel-runtime/core-js/object/keys":30,"core-util-is":176,"inherits":198,"process-nextick-args":344}],352:[function(require,module,exports){
+// a passthrough stream.
+// basically just the most minimal sort of Transform stream.
+// Every written chunk gets output as-is.
+
+'use strict';
+
+module.exports = PassThrough;
+
+var Transform = require('./_stream_transform');
+
+/*<replacement>*/
+var util = require('core-util-is');
+util.inherits = require('inherits');
+/*</replacement>*/
+
+util.inherits(PassThrough, Transform);
+
+function PassThrough(options) {
+  if (!(this instanceof PassThrough)) return new PassThrough(options);
+
+  Transform.call(this, options);
+}
+
+PassThrough.prototype._transform = function (chunk, encoding, cb) {
+  cb(null, chunk);
+};
+
+},{"./_stream_transform":354,"core-util-is":176,"inherits":198}],353:[function(require,module,exports){
+(function (process){
+'use strict';
+
+module.exports = Readable;
+
+/*<replacement>*/
+var processNextTick = require('process-nextick-args');
+/*</replacement>*/
+
+/*<replacement>*/
+var isArray = require('isarray');
+/*</replacement>*/
+
+Readable.ReadableState = ReadableState;
+
+/*<replacement>*/
+var EE = require('events').EventEmitter;
+
+var EElistenerCount = function EElistenerCount(emitter, type) {
+  return emitter.listeners(type).length;
+};
+/*</replacement>*/
+
+/*<replacement>*/
+var Stream;
+(function () {
+  try {
+    Stream = require('st' + 'ream');
+  } catch (_) {} finally {
+    if (!Stream) Stream = require('events').EventEmitter;
+  }
+})();
+/*</replacement>*/
+
+var Buffer = require('buffer').Buffer;
+/*<replacement>*/
+var bufferShim = require('buffer-shims');
+/*</replacement>*/
+
+/*<replacement>*/
+var util = require('core-util-is');
+util.inherits = require('inherits');
+/*</replacement>*/
+
+/*<replacement>*/
+var debugUtil = require('util');
+var debug = void 0;
+if (debugUtil && debugUtil.debuglog) {
+  debug = debugUtil.debuglog('stream');
+} else {
+  debug = function debug() {};
+}
+/*</replacement>*/
+
+var BufferList = require('./internal/streams/BufferList');
+var StringDecoder;
+
+util.inherits(Readable, Stream);
+
+function prependListener(emitter, event, fn) {
+  if (typeof emitter.prependListener === 'function') {
+    return emitter.prependListener(event, fn);
+  } else {
+    // This is a hack to make sure that our error handler is attached before any
+    // userland ones.  NEVER DO THIS. This is here only because this code needs
+    // to continue to work with older versions of Node.js that do not include
+    // the prependListener() method. The goal is to eventually remove this hack.
+    if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]];
+  }
+}
+
+var Duplex;
+function ReadableState(options, stream) {
+  Duplex = Duplex || require('./_stream_duplex');
+
+  options = options || {};
+
+  // object stream flag. Used to make read(n) ignore n and to
+  // make all the buffer merging and length checks go away
+  this.objectMode = !!options.objectMode;
+
+  if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.readableObjectMode;
+
+  // the point at which it stops calling _read() to fill the buffer
+  // Note: 0 is a valid value, means "don't call _read preemptively ever"
+  var hwm = options.highWaterMark;
+  var defaultHwm = this.objectMode ? 16 : 16 * 1024;
+  this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm;
+
+  // cast to ints.
+  this.highWaterMark = ~~this.highWaterMark;
+
+  // A linked list is used to store data chunks instead of an array because the
+  // linked list can remove elements from the beginning faster than
+  // array.shift()
+  this.buffer = new BufferList();
+  this.length = 0;
+  this.pipes = null;
+  this.pipesCount = 0;
+  this.flowing = null;
+  this.ended = false;
+  this.endEmitted = false;
+  this.reading = false;
+
+  // a flag to be able to tell if the onwrite cb is called immediately,
+  // or on a later tick.  We set this to true at first, because any
+  // actions that shouldn't happen until "later" should generally also
+  // not happen before the first write call.
+  this.sync = true;
+
+  // whenever we return null, then we set a flag to say
+  // that we're awaiting a 'readable' event emission.
+  this.needReadable = false;
+  this.emittedReadable = false;
+  this.readableListening = false;
+  this.resumeScheduled = false;
+
+  // Crypto is kind of old and crusty.  Historically, its default string
+  // encoding is 'binary' so we have to make this configurable.
+  // Everything else in the universe uses 'utf8', though.
+  this.defaultEncoding = options.defaultEncoding || 'utf8';
+
+  // when piping, we only care about 'readable' events that happen
+  // after read()ing all the bytes and not getting any pushback.
+  this.ranOut = false;
+
+  // the number of writers that are awaiting a drain event in .pipe()s
+  this.awaitDrain = 0;
+
+  // if true, a maybeReadMore has been scheduled
+  this.readingMore = false;
+
+  this.decoder = null;
+  this.encoding = null;
+  if (options.encoding) {
+    if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;
+    this.decoder = new StringDecoder(options.encoding);
+    this.encoding = options.encoding;
+  }
+}
+
+var Duplex;
+function Readable(options) {
+  Duplex = Duplex || require('./_stream_duplex');
+
+  if (!(this instanceof Readable)) return new Readable(options);
+
+  this._readableState = new ReadableState(options, this);
+
+  // legacy
+  this.readable = true;
+
+  if (options && typeof options.read === 'function') this._read = options.read;
+
+  Stream.call(this);
+}
+
+// Manually shove something into the read() buffer.
+// This returns true if the highWaterMark has not been hit yet,
+// similar to how Writable.write() returns true if you should
+// write() some more.
+Readable.prototype.push = function (chunk, encoding) {
+  var state = this._readableState;
+
+  if (!state.objectMode && typeof chunk === 'string') {
+    encoding = encoding || state.defaultEncoding;
+    if (encoding !== state.encoding) {
+      chunk = bufferShim.from(chunk, encoding);
+      encoding = '';
+    }
+  }
+
+  return readableAddChunk(this, state, chunk, encoding, false);
+};
+
+// Unshift should *always* be something directly out of read()
+Readable.prototype.unshift = function (chunk) {
+  var state = this._readableState;
+  return readableAddChunk(this, state, chunk, '', true);
+};
+
+Readable.prototype.isPaused = function () {
+  return this._readableState.flowing === false;
+};
+
+function readableAddChunk(stream, state, chunk, encoding, addToFront) {
+  var er = chunkInvalid(state, chunk);
+  if (er) {
+    stream.emit('error', er);
+  } else if (chunk === null) {
+    state.reading = false;
+    onEofChunk(stream, state);
+  } else if (state.objectMode || chunk && chunk.length > 0) {
+    if (state.ended && !addToFront) {
+      var e = new Error('stream.push() after EOF');
+      stream.emit('error', e);
+    } else if (state.endEmitted && addToFront) {
+      var _e = new Error('stream.unshift() after end event');
+      stream.emit('error', _e);
+    } else {
+      var skipAdd;
+      if (state.decoder && !addToFront && !encoding) {
+        chunk = state.decoder.write(chunk);
+        skipAdd = !state.objectMode && chunk.length === 0;
+      }
+
+      if (!addToFront) state.reading = false;
+
+      // Don't add to the buffer if we've decoded to an empty string chunk and
+      // we're not in object mode
+      if (!skipAdd) {
+        // if we want the data now, just emit it.
+        if (state.flowing && state.length === 0 && !state.sync) {
+          stream.emit('data', chunk);
+          stream.read(0);
+        } else {
+          // update the buffer info.
+          state.length += state.objectMode ? 1 : chunk.length;
+          if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);
+
+          if (state.needReadable) emitReadable(stream);
+        }
+      }
+
+      maybeReadMore(stream, state);
+    }
+  } else if (!addToFront) {
+    state.reading = false;
+  }
+
+  return needMoreData(state);
+}
+
+// if it's past the high water mark, we can push in some more.
+// Also, if we have no data yet, we can stand some
+// more bytes.  This is to work around cases where hwm=0,
+// such as the repl.  Also, if the push() triggered a
+// readable event, and the user called read(largeNumber) such that
+// needReadable was set, then we ought to push more, so that another
+// 'readable' event will be triggered.
+function needMoreData(state) {
+  return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0);
+}
+
+// backwards compatibility.
+Readable.prototype.setEncoding = function (enc) {
+  if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;
+  this._readableState.decoder = new StringDecoder(enc);
+  this._readableState.encoding = enc;
+  return this;
+};
+
+// Don't raise the hwm > 8MB
+var MAX_HWM = 0x800000;
+function computeNewHighWaterMark(n) {
+  if (n >= MAX_HWM) {
+    n = MAX_HWM;
+  } else {
+    // Get the next highest power of 2 to prevent increasing hwm excessively in
+    // tiny amounts
+    n--;
+    n |= n >>> 1;
+    n |= n >>> 2;
+    n |= n >>> 4;
+    n |= n >>> 8;
+    n |= n >>> 16;
+    n++;
+  }
+  return n;
+}
+
+// This function is designed to be inlinable, so please take care when making
+// changes to the function body.
+function howMuchToRead(n, state) {
+  if (n <= 0 || state.length === 0 && state.ended) return 0;
+  if (state.objectMode) return 1;
+  if (n !== n) {
+    // Only flow one buffer at a time
+    if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;
+  }
+  // If we're asking for more than the current hwm, then raise the hwm.
+  if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);
+  if (n <= state.length) return n;
+  // Don't have enough
+  if (!state.ended) {
+    state.needReadable = true;
+    return 0;
+  }
+  return state.length;
+}
+
+// you can override either this method, or the async _read(n) below.
+Readable.prototype.read = function (n) {
+  debug('read', n);
+  n = parseInt(n, 10);
+  var state = this._readableState;
+  var nOrig = n;
+
+  if (n !== 0) state.emittedReadable = false;
+
+  // if we're doing read(0) to trigger a readable event, but we
+  // already have a bunch of data in the buffer, then just trigger
+  // the 'readable' event and move on.
+  if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) {
+    debug('read: emitReadable', state.length, state.ended);
+    if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this);
+    return null;
+  }
+
+  n = howMuchToRead(n, state);
+
+  // if we've ended, and we're now clear, then finish it up.
+  if (n === 0 && state.ended) {
+    if (state.length === 0) endReadable(this);
+    return null;
+  }
+
+  // All the actual chunk generation logic needs to be
+  // *below* the call to _read.  The reason is that in certain
+  // synthetic stream cases, such as passthrough streams, _read
+  // may be a completely synchronous operation which may change
+  // the state of the read buffer, providing enough data when
+  // before there was *not* enough.
+  //
+  // So, the steps are:
+  // 1. Figure out what the state of things will be after we do
+  // a read from the buffer.
+  //
+  // 2. If that resulting state will trigger a _read, then call _read.
+  // Note that this may be asynchronous, or synchronous.  Yes, it is
+  // deeply ugly to write APIs this way, but that still doesn't mean
+  // that the Readable class should behave improperly, as streams are
+  // designed to be sync/async agnostic.
+  // Take note if the _read call is sync or async (ie, if the read call
+  // has returned yet), so that we know whether or not it's safe to emit
+  // 'readable' etc.
+  //
+  // 3. Actually pull the requested chunks out of the buffer and return.
+
+  // if we need a readable event, then we need to do some reading.
+  var doRead = state.needReadable;
+  debug('need readable', doRead);
+
+  // if we currently have less than the highWaterMark, then also read some
+  if (state.length === 0 || state.length - n < state.highWaterMark) {
+    doRead = true;
+    debug('length less than watermark', doRead);
+  }
+
+  // however, if we've ended, then there's no point, and if we're already
+  // reading, then it's unnecessary.
+  if (state.ended || state.reading) {
+    doRead = false;
+    debug('reading or ended', doRead);
+  } else if (doRead) {
+    debug('do read');
+    state.reading = true;
+    state.sync = true;
+    // if the length is currently zero, then we *need* a readable event.
+    if (state.length === 0) state.needReadable = true;
+    // call internal read method
+    this._read(state.highWaterMark);
+    state.sync = false;
+    // If _read pushed data synchronously, then `reading` will be false,
+    // and we need to re-evaluate how much data we can return to the user.
+    if (!state.reading) n = howMuchToRead(nOrig, state);
+  }
+
+  var ret;
+  if (n > 0) ret = fromList(n, state);else ret = null;
+
+  if (ret === null) {
+    state.needReadable = true;
+    n = 0;
+  } else {
+    state.length -= n;
+  }
+
+  if (state.length === 0) {
+    // If we have nothing in the buffer, then we want to know
+    // as soon as we *do* get something into the buffer.
+    if (!state.ended) state.needReadable = true;
+
+    // If we tried to read() past the EOF, then emit end on the next tick.
+    if (nOrig !== n && state.ended) endReadable(this);
+  }
+
+  if (ret !== null) this.emit('data', ret);
+
+  return ret;
+};
+
+function chunkInvalid(state, chunk) {
+  var er = null;
+  if (!Buffer.isBuffer(chunk) && typeof chunk !== 'string' && chunk !== null && chunk !== undefined && !state.objectMode) {
+    er = new TypeError('Invalid non-string/buffer chunk');
+  }
+  return er;
+}
+
+function onEofChunk(stream, state) {
+  if (state.ended) return;
+  if (state.decoder) {
+    var chunk = state.decoder.end();
+    if (chunk && chunk.length) {
+      state.buffer.push(chunk);
+      state.length += state.objectMode ? 1 : chunk.length;
+    }
+  }
+  state.ended = true;
+
+  // emit 'readable' now to make sure it gets picked up.
+  emitReadable(stream);
+}
+
+// Don't emit readable right away in sync mode, because this can trigger
+// another read() call => stack overflow.  This way, it might trigger
+// a nextTick recursion warning, but that's not so bad.
+function emitReadable(stream) {
+  var state = stream._readableState;
+  state.needReadable = false;
+  if (!state.emittedReadable) {
+    debug('emitReadable', state.flowing);
+    state.emittedReadable = true;
+    if (state.sync) processNextTick(emitReadable_, stream);else emitReadable_(stream);
+  }
+}
+
+function emitReadable_(stream) {
+  debug('emit readable');
+  stream.emit('readable');
+  flow(stream);
+}
+
+// at this point, the user has presumably seen the 'readable' event,
+// and called read() to consume some data.  that may have triggered
+// in turn another _read(n) call, in which case reading = true if
+// it's in progress.
+// However, if we're not ended, or reading, and the length < hwm,
+// then go ahead and try to read some more preemptively.
+function maybeReadMore(stream, state) {
+  if (!state.readingMore) {
+    state.readingMore = true;
+    processNextTick(maybeReadMore_, stream, state);
+  }
+}
+
+function maybeReadMore_(stream, state) {
+  var len = state.length;
+  while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) {
+    debug('maybeReadMore read 0');
+    stream.read(0);
+    if (len === state.length)
+      // didn't get any data, stop spinning.
+      break;else len = state.length;
+  }
+  state.readingMore = false;
+}
+
+// abstract method.  to be overridden in specific implementation classes.
+// call cb(er, data) where data is <= n in length.
+// for virtual (non-string, non-buffer) streams, "length" is somewhat
+// arbitrary, and perhaps not very meaningful.
+Readable.prototype._read = function (n) {
+  this.emit('error', new Error('not implemented'));
+};
+
+Readable.prototype.pipe = function (dest, pipeOpts) {
+  var src = this;
+  var state = this._readableState;
+
+  switch (state.pipesCount) {
+    case 0:
+      state.pipes = dest;
+      break;
+    case 1:
+      state.pipes = [state.pipes, dest];
+      break;
+    default:
+      state.pipes.push(dest);
+      break;
+  }
+  state.pipesCount += 1;
+  debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);
+
+  var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;
+
+  var endFn = doEnd ? onend : cleanup;
+  if (state.endEmitted) processNextTick(endFn);else src.once('end', endFn);
+
+  dest.on('unpipe', onunpipe);
+  function onunpipe(readable) {
+    debug('onunpipe');
+    if (readable === src) {
+      cleanup();
+    }
+  }
+
+  function onend() {
+    debug('onend');
+    dest.end();
+  }
+
+  // when the dest drains, it reduces the awaitDrain counter
+  // on the source.  This would be more elegant with a .once()
+  // handler in flow(), but adding and removing repeatedly is
+  // too slow.
+  var ondrain = pipeOnDrain(src);
+  dest.on('drain', ondrain);
+
+  var cleanedUp = false;
+  function cleanup() {
+    debug('cleanup');
+    // cleanup event handlers once the pipe is broken
+    dest.removeListener('close', onclose);
+    dest.removeListener('finish', onfinish);
+    dest.removeListener('drain', ondrain);
+    dest.removeListener('error', onerror);
+    dest.removeListener('unpipe', onunpipe);
+    src.removeListener('end', onend);
+    src.removeListener('end', cleanup);
+    src.removeListener('data', ondata);
+
+    cleanedUp = true;
+
+    // if the reader is waiting for a drain event from this
+    // specific writer, then it would cause it to never start
+    // flowing again.
+    // So, if this is awaiting a drain, then we just call it now.
+    // If we don't know, then assume that we are waiting for one.
+    if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();
+  }
+
+  // If the user pushes more data while we're writing to dest then we'll end up
+  // in ondata again. However, we only want to increase awaitDrain once because
+  // dest will only emit one 'drain' event for the multiple writes.
+  // => Introduce a guard on increasing awaitDrain.
+  var increasedAwaitDrain = false;
+  src.on('data', ondata);
+  function ondata(chunk) {
+    debug('ondata');
+    increasedAwaitDrain = false;
+    var ret = dest.write(chunk);
+    if (false === ret && !increasedAwaitDrain) {
+      // If the user unpiped during `dest.write()`, it is possible
+      // to get stuck in a permanently paused state if that write
+      // also returned false.
+      // => Check whether `dest` is still a piping destination.
+      if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {
+        debug('false write response, pause', src._readableState.awaitDrain);
+        src._readableState.awaitDrain++;
+        increasedAwaitDrain = true;
+      }
+      src.pause();
+    }
+  }
+
+  // if the dest has an error, then stop piping into it.
+  // however, don't suppress the throwing behavior for this.
+  function onerror(er) {
+    debug('onerror', er);
+    unpipe();
+    dest.removeListener('error', onerror);
+    if (EElistenerCount(dest, 'error') === 0) dest.emit('error', er);
+  }
+
+  // Make sure our error handler is attached before userland ones.
+  prependListener(dest, 'error', onerror);
+
+  // Both close and finish should trigger unpipe, but only once.
+  function onclose() {
+    dest.removeListener('finish', onfinish);
+    unpipe();
+  }
+  dest.once('close', onclose);
+  function onfinish() {
+    debug('onfinish');
+    dest.removeListener('close', onclose);
+    unpipe();
+  }
+  dest.once('finish', onfinish);
+
+  function unpipe() {
+    debug('unpipe');
+    src.unpipe(dest);
+  }
+
+  // tell the dest that it's being piped to
+  dest.emit('pipe', src);
+
+  // start the flow if it hasn't been started already.
+  if (!state.flowing) {
+    debug('pipe resume');
+    src.resume();
+  }
+
+  return dest;
+};
+
+function pipeOnDrain(src) {
+  return function () {
+    var state = src._readableState;
+    debug('pipeOnDrain', state.awaitDrain);
+    if (state.awaitDrain) state.awaitDrain--;
+    if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {
+      state.flowing = true;
+      flow(src);
+    }
+  };
+}
+
+Readable.prototype.unpipe = function (dest) {
+  var state = this._readableState;
+
+  // if we're not piping anywhere, then do nothing.
+  if (state.pipesCount === 0) return this;
+
+  // just one destination.  most common case.
+  if (state.pipesCount === 1) {
+    // passed in one, but it's not the right one.
+    if (dest && dest !== state.pipes) return this;
+
+    if (!dest) dest = state.pipes;
+
+    // got a match.
+    state.pipes = null;
+    state.pipesCount = 0;
+    state.flowing = false;
+    if (dest) dest.emit('unpipe', this);
+    return this;
+  }
+
+  // slow case. multiple pipe destinations.
+
+  if (!dest) {
+    // remove all.
+    var dests = state.pipes;
+    var len = state.pipesCount;
+    state.pipes = null;
+    state.pipesCount = 0;
+    state.flowing = false;
+
+    for (var _i = 0; _i < len; _i++) {
+      dests[_i].emit('unpipe', this);
+    }return this;
+  }
+
+  // try to find the right one.
+  var i = indexOf(state.pipes, dest);
+  if (i === -1) return this;
+
+  state.pipes.splice(i, 1);
+  state.pipesCount -= 1;
+  if (state.pipesCount === 1) state.pipes = state.pipes[0];
+
+  dest.emit('unpipe', this);
+
+  return this;
+};
+
+// set up data events if they are asked for
+// Ensure readable listeners eventually get something
+Readable.prototype.on = function (ev, fn) {
+  var res = Stream.prototype.on.call(this, ev, fn);
+
+  if (ev === 'data') {
+    // Start flowing on next tick if stream isn't explicitly paused
+    if (this._readableState.flowing !== false) this.resume();
+  } else if (ev === 'readable') {
+    var state = this._readableState;
+    if (!state.endEmitted && !state.readableListening) {
+      state.readableListening = state.needReadable = true;
+      state.emittedReadable = false;
+      if (!state.reading) {
+        processNextTick(nReadingNextTick, this);
+      } else if (state.length) {
+        emitReadable(this, state);
+      }
+    }
+  }
+
+  return res;
+};
+Readable.prototype.addListener = Readable.prototype.on;
+
+function nReadingNextTick(self) {
+  debug('readable nexttick read 0');
+  self.read(0);
+}
+
+// pause() and resume() are remnants of the legacy readable stream API
+// If the user uses them, then switch into old mode.
+Readable.prototype.resume = function () {
+  var state = this._readableState;
+  if (!state.flowing) {
+    debug('resume');
+    state.flowing = true;
+    resume(this, state);
+  }
+  return this;
+};
+
+function resume(stream, state) {
+  if (!state.resumeScheduled) {
+    state.resumeScheduled = true;
+    processNextTick(resume_, stream, state);
+  }
+}
+
+function resume_(stream, state) {
+  if (!state.reading) {
+    debug('resume read 0');
+    stream.read(0);
+  }
+
+  state.resumeScheduled = false;
+  state.awaitDrain = 0;
+  stream.emit('resume');
+  flow(stream);
+  if (state.flowing && !state.reading) stream.read(0);
+}
+
+Readable.prototype.pause = function () {
+  debug('call pause flowing=%j', this._readableState.flowing);
+  if (false !== this._readableState.flowing) {
+    debug('pause');
+    this._readableState.flowing = false;
+    this.emit('pause');
+  }
+  return this;
+};
+
+function flow(stream) {
+  var state = stream._readableState;
+  debug('flow', state.flowing);
+  while (state.flowing && stream.read() !== null) {}
+}
+
+// wrap an old-style stream as the async data source.
+// This is *not* part of the readable stream interface.
+// It is an ugly unfortunate mess of history.
+Readable.prototype.wrap = function (stream) {
+  var state = this._readableState;
+  var paused = false;
+
+  var self = this;
+  stream.on('end', function () {
+    debug('wrapped end');
+    if (state.decoder && !state.ended) {
+      var chunk = state.decoder.end();
+      if (chunk && chunk.length) self.push(chunk);
+    }
+
+    self.push(null);
+  });
+
+  stream.on('data', function (chunk) {
+    debug('wrapped data');
+    if (state.decoder) chunk = state.decoder.write(chunk);
+
+    // don't skip over falsy values in objectMode
+    if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;
+
+    var ret = self.push(chunk);
+    if (!ret) {
+      paused = true;
+      stream.pause();
+    }
+  });
+
+  // proxy all the other methods.
+  // important when wrapping filters and duplexes.
+  for (var i in stream) {
+    if (this[i] === undefined && typeof stream[i] === 'function') {
+      this[i] = function (method) {
+        return function () {
+          return stream[method].apply(stream, arguments);
+        };
+      }(i);
+    }
+  }
+
+  // proxy certain important events.
+  var events = ['error', 'close', 'destroy', 'pause', 'resume'];
+  forEach(events, function (ev) {
+    stream.on(ev, self.emit.bind(self, ev));
+  });
+
+  // when we try to consume some more bytes, simply unpause the
+  // underlying stream.
+  self._read = function (n) {
+    debug('wrapped _read', n);
+    if (paused) {
+      paused = false;
+      stream.resume();
+    }
+  };
+
+  return self;
+};
+
+// exposed for testing purposes only.
+Readable._fromList = fromList;
+
+// Pluck off n bytes from an array of buffers.
+// Length is the combined lengths of all the buffers in the list.
+// This function is designed to be inlinable, so please take care when making
+// changes to the function body.
+function fromList(n, state) {
+  // nothing buffered
+  if (state.length === 0) return null;
+
+  var ret;
+  if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) {
+    // read it all, truncate the list
+    if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.head.data;else ret = state.buffer.concat(state.length);
+    state.buffer.clear();
+  } else {
+    // read part of list
+    ret = fromListPartial(n, state.buffer, state.decoder);
+  }
+
+  return ret;
+}
+
+// Extracts only enough buffered data to satisfy the amount requested.
+// This function is designed to be inlinable, so please take care when making
+// changes to the function body.
+function fromListPartial(n, list, hasStrings) {
+  var ret;
+  if (n < list.head.data.length) {
+    // slice is the same for buffers and strings
+    ret = list.head.data.slice(0, n);
+    list.head.data = list.head.data.slice(n);
+  } else if (n === list.head.data.length) {
+    // first chunk is a perfect match
+    ret = list.shift();
+  } else {
+    // result spans more than one buffer
+    ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list);
+  }
+  return ret;
+}
+
+// Copies a specified amount of characters from the list of buffered data
+// chunks.
+// This function is designed to be inlinable, so please take care when making
+// changes to the function body.
+function copyFromBufferString(n, list) {
+  var p = list.head;
+  var c = 1;
+  var ret = p.data;
+  n -= ret.length;
+  while (p = p.next) {
+    var str = p.data;
+    var nb = n > str.length ? str.length : n;
+    if (nb === str.length) ret += str;else ret += str.slice(0, n);
+    n -= nb;
+    if (n === 0) {
+      if (nb === str.length) {
+        ++c;
+        if (p.next) list.head = p.next;else list.head = list.tail = null;
+      } else {
+        list.head = p;
+        p.data = str.slice(nb);
+      }
+      break;
+    }
+    ++c;
+  }
+  list.length -= c;
+  return ret;
+}
+
+// Copies a specified amount of bytes from the list of buffered data chunks.
+// This function is designed to be inlinable, so please take care when making
+// changes to the function body.
+function copyFromBuffer(n, list) {
+  var ret = bufferShim.allocUnsafe(n);
+  var p = list.head;
+  var c = 1;
+  p.data.copy(ret);
+  n -= p.data.length;
+  while (p = p.next) {
+    var buf = p.data;
+    var nb = n > buf.length ? buf.length : n;
+    buf.copy(ret, ret.length - n, 0, nb);
+    n -= nb;
+    if (n === 0) {
+      if (nb === buf.length) {
+        ++c;
+        if (p.next) list.head = p.next;else list.head = list.tail = null;
+      } else {
+        list.head = p;
+        p.data = buf.slice(nb);
+      }
+      break;
+    }
+    ++c;
+  }
+  list.length -= c;
+  return ret;
+}
+
+function endReadable(stream) {
+  var state = stream._readableState;
+
+  // If we get here before consuming all the bytes, then that is a
+  // bug in node.  Should never happen.
+  if (state.length > 0) throw new Error('"endReadable()" called on non-empty stream');
+
+  if (!state.endEmitted) {
+    state.ended = true;
+    processNextTick(endReadableNT, state, stream);
+  }
+}
+
+function endReadableNT(state, stream) {
+  // Check that we didn't get one last unshift.
+  if (!state.endEmitted && state.length === 0) {
+    state.endEmitted = true;
+    stream.readable = false;
+    stream.emit('end');
+  }
+}
+
+function forEach(xs, f) {
+  for (var i = 0, l = xs.length; i < l; i++) {
+    f(xs[i], i);
+  }
+}
+
+function indexOf(xs, x) {
+  for (var i = 0, l = xs.length; i < l; i++) {
+    if (xs[i] === x) return i;
+  }
+  return -1;
+}
+
+}).call(this,require('_process'))
+},{"./_stream_duplex":351,"./internal/streams/BufferList":356,"_process":345,"buffer":45,"buffer-shims":44,"core-util-is":176,"events":193,"inherits":198,"isarray":357,"process-nextick-args":344,"string_decoder/":374,"util":42}],354:[function(require,module,exports){
+// a transform stream is a readable/writable stream where you do
+// something with the data.  Sometimes it's called a "filter",
+// but that's not a great name for it, since that implies a thing where
+// some bits pass through, and others are simply ignored.  (That would
+// be a valid example of a transform, of course.)
+//
+// While the output is causally related to the input, it's not a
+// necessarily symmetric or synchronous transformation.  For example,
+// a zlib stream might take multiple plain-text writes(), and then
+// emit a single compressed chunk some time in the future.
+//
+// Here's how this works:
+//
+// The Transform stream has all the aspects of the readable and writable
+// stream classes.  When you write(chunk), that calls _write(chunk,cb)
+// internally, and returns false if there's a lot of pending writes
+// buffered up.  When you call read(), that calls _read(n) until
+// there's enough pending readable data buffered up.
+//
+// In a transform stream, the written data is placed in a buffer.  When
+// _read(n) is called, it transforms the queued up data, calling the
+// buffered _write cb's as it consumes chunks.  If consuming a single
+// written chunk would result in multiple output chunks, then the first
+// outputted bit calls the readcb, and subsequent chunks just go into
+// the read buffer, and will cause it to emit 'readable' if necessary.
+//
+// This way, back-pressure is actually determined by the reading side,
+// since _read has to be called to start processing a new chunk.  However,
+// a pathological inflate type of transform can cause excessive buffering
+// here.  For example, imagine a stream where every byte of input is
+// interpreted as an integer from 0-255, and then results in that many
+// bytes of output.  Writing the 4 bytes {ff,ff,ff,ff} would result in
+// 1kb of data being output.  In this case, you could write a very small
+// amount of input, and end up with a very large amount of output.  In
+// such a pathological inflating mechanism, there'd be no way to tell
+// the system to stop doing the transform.  A single 4MB write could
+// cause the system to run out of memory.
+//
+// However, even in such a pathological case, only a single written chunk
+// would be consumed, and then the rest would wait (un-transformed) until
+// the results of the previous transformed chunk were consumed.
+
+'use strict';
+
+module.exports = Transform;
+
+var Duplex = require('./_stream_duplex');
+
+/*<replacement>*/
+var util = require('core-util-is');
+util.inherits = require('inherits');
+/*</replacement>*/
+
+util.inherits(Transform, Duplex);
+
+function TransformState(stream) {
+  this.afterTransform = function (er, data) {
+    return afterTransform(stream, er, data);
+  };
+
+  this.needTransform = false;
+  this.transforming = false;
+  this.writecb = null;
+  this.writechunk = null;
+  this.writeencoding = null;
+}
+
+function afterTransform(stream, er, data) {
+  var ts = stream._transformState;
+  ts.transforming = false;
+
+  var cb = ts.writecb;
+
+  if (!cb) return stream.emit('error', new Error('no writecb in Transform class'));
+
+  ts.writechunk = null;
+  ts.writecb = null;
+
+  if (data !== null && data !== undefined) stream.push(data);
+
+  cb(er);
+
+  var rs = stream._readableState;
+  rs.reading = false;
+  if (rs.needReadable || rs.length < rs.highWaterMark) {
+    stream._read(rs.highWaterMark);
+  }
+}
+
+function Transform(options) {
+  if (!(this instanceof Transform)) return new Transform(options);
+
+  Duplex.call(this, options);
+
+  this._transformState = new TransformState(this);
+
+  // when the writable side finishes, then flush out anything remaining.
+  var stream = this;
+
+  // start out asking for a readable event once data is transformed.
+  this._readableState.needReadable = true;
+
+  // we have implemented the _read method, and done the other things
+  // that Readable wants before the first _read call, so unset the
+  // sync guard flag.
+  this._readableState.sync = false;
+
+  if (options) {
+    if (typeof options.transform === 'function') this._transform = options.transform;
+
+    if (typeof options.flush === 'function') this._flush = options.flush;
+  }
+
+  this.once('prefinish', function () {
+    if (typeof this._flush === 'function') this._flush(function (er) {
+      done(stream, er);
+    });else done(stream);
+  });
+}
+
+Transform.prototype.push = function (chunk, encoding) {
+  this._transformState.needTransform = false;
+  return Duplex.prototype.push.call(this, chunk, encoding);
+};
+
+// This is the part where you do stuff!
+// override this function in implementation classes.
+// 'chunk' is an input chunk.
+//
+// Call `push(newChunk)` to pass along transformed output
+// to the readable side.  You may call 'push' zero or more times.
+//
+// Call `cb(err)` when you are done with this chunk.  If you pass
+// an error, then that'll put the hurt on the whole operation.  If you
+// never call cb(), then you'll never get another chunk.
+Transform.prototype._transform = function (chunk, encoding, cb) {
+  throw new Error('Not implemented');
+};
+
+Transform.prototype._write = function (chunk, encoding, cb) {
+  var ts = this._transformState;
+  ts.writecb = cb;
+  ts.writechunk = chunk;
+  ts.writeencoding = encoding;
+  if (!ts.transforming) {
+    var rs = this._readableState;
+    if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);
+  }
+};
+
+// Doesn't matter what the args are here.
+// _transform does all the work.
+// That we got here means that the readable side wants more data.
+Transform.prototype._read = function (n) {
+  var ts = this._transformState;
+
+  if (ts.writechunk !== null && ts.writecb && !ts.transforming) {
+    ts.transforming = true;
+    this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
+  } else {
+    // mark that we need a transform, so that any data that comes in
+    // will get processed, now that we've asked for it.
+    ts.needTransform = true;
+  }
+};
+
+function done(stream, er) {
+  if (er) return stream.emit('error', er);
+
+  // if there's nothing in the write buffer, then that means
+  // that nothing more will ever be provided
+  var ws = stream._writableState;
+  var ts = stream._transformState;
+
+  if (ws.length) throw new Error('Calling transform done when ws.length != 0');
+
+  if (ts.transforming) throw new Error('Calling transform done when still transforming');
+
+  return stream.push(null);
+}
+
+},{"./_stream_duplex":351,"core-util-is":176,"inherits":198}],355:[function(require,module,exports){
+(function (process){
+// A bit simpler than readable streams.
+// Implement an async ._write(chunk, encoding, cb), and it'll handle all
+// the drain event emission and buffering.
+
+'use strict';
+
+var _setImmediate2 = require('babel-runtime/core-js/set-immediate');
+
+var _setImmediate3 = _interopRequireDefault(_setImmediate2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+module.exports = Writable;
+
+/*<replacement>*/
+var processNextTick = require('process-nextick-args');
+/*</replacement>*/
+
+/*<replacement>*/
+var asyncWrite = !process.browser && ['v0.10', 'v0.9.'].indexOf(process.version.slice(0, 5)) > -1 ? _setImmediate3.default : processNextTick;
+/*</replacement>*/
+
+Writable.WritableState = WritableState;
+
+/*<replacement>*/
+var util = require('core-util-is');
+util.inherits = require('inherits');
+/*</replacement>*/
+
+/*<replacement>*/
+var internalUtil = {
+  deprecate: require('util-deprecate')
+};
+/*</replacement>*/
+
+/*<replacement>*/
+var Stream;
+(function () {
+  try {
+    Stream = require('st' + 'ream');
+  } catch (_) {} finally {
+    if (!Stream) Stream = require('events').EventEmitter;
+  }
+})();
+/*</replacement>*/
+
+var Buffer = require('buffer').Buffer;
+/*<replacement>*/
+var bufferShim = require('buffer-shims');
+/*</replacement>*/
+
+util.inherits(Writable, Stream);
+
+function nop() {}
+
+function WriteReq(chunk, encoding, cb) {
+  this.chunk = chunk;
+  this.encoding = encoding;
+  this.callback = cb;
+  this.next = null;
+}
+
+var Duplex;
+function WritableState(options, stream) {
+  Duplex = Duplex || require('./_stream_duplex');
+
+  options = options || {};
+
+  // object stream flag to indicate whether or not this stream
+  // contains buffers or objects.
+  this.objectMode = !!options.objectMode;
+
+  if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.writableObjectMode;
+
+  // the point at which write() starts returning false
+  // Note: 0 is a valid value, means that we always return false if
+  // the entire buffer is not flushed immediately on write()
+  var hwm = options.highWaterMark;
+  var defaultHwm = this.objectMode ? 16 : 16 * 1024;
+  this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm;
+
+  // cast to ints.
+  this.highWaterMark = ~~this.highWaterMark;
+
+  this.needDrain = false;
+  // at the start of calling end()
+  this.ending = false;
+  // when end() has been called, and returned
+  this.ended = false;
+  // when 'finish' is emitted
+  this.finished = false;
+
+  // should we decode strings into buffers before passing to _write?
+  // this is here so that some node-core streams can optimize string
+  // handling at a lower level.
+  var noDecode = options.decodeStrings === false;
+  this.decodeStrings = !noDecode;
+
+  // Crypto is kind of old and crusty.  Historically, its default string
+  // encoding is 'binary' so we have to make this configurable.
+  // Everything else in the universe uses 'utf8', though.
+  this.defaultEncoding = options.defaultEncoding || 'utf8';
+
+  // not an actual buffer we keep track of, but a measurement
+  // of how much we're waiting to get pushed to some underlying
+  // socket or file.
+  this.length = 0;
+
+  // a flag to see when we're in the middle of a write.
+  this.writing = false;
+
+  // when true all writes will be buffered until .uncork() call
+  this.corked = 0;
+
+  // a flag to be able to tell if the onwrite cb is called immediately,
+  // or on a later tick.  We set this to true at first, because any
+  // actions that shouldn't happen until "later" should generally also
+  // not happen before the first write call.
+  this.sync = true;
+
+  // a flag to know if we're processing previously buffered items, which
+  // may call the _write() callback in the same tick, so that we don't
+  // end up in an overlapped onwrite situation.
+  this.bufferProcessing = false;
+
+  // the callback that's passed to _write(chunk,cb)
+  this.onwrite = function (er) {
+    onwrite(stream, er);
+  };
+
+  // the callback that the user supplies to write(chunk,encoding,cb)
+  this.writecb = null;
+
+  // the amount that is being written when _write is called.
+  this.writelen = 0;
+
+  this.bufferedRequest = null;
+  this.lastBufferedRequest = null;
+
+  // number of pending user-supplied write callbacks
+  // this must be 0 before 'finish' can be emitted
+  this.pendingcb = 0;
+
+  // emit prefinish if the only thing we're waiting for is _write cbs
+  // This is relevant for synchronous Transform streams
+  this.prefinished = false;
+
+  // True if the error was already emitted and should not be thrown again
+  this.errorEmitted = false;
+
+  // count buffered requests
+  this.bufferedRequestCount = 0;
+
+  // allocate the first CorkedRequest, there is always
+  // one allocated and free to use, and we maintain at most two
+  this.corkedRequestsFree = new CorkedRequest(this);
+}
+
+WritableState.prototype.getBuffer = function writableStateGetBuffer() {
+  var current = this.bufferedRequest;
+  var out = [];
+  while (current) {
+    out.push(current);
+    current = current.next;
+  }
+  return out;
+};
+
+(function () {
+  try {
+    Object.defineProperty(WritableState.prototype, 'buffer', {
+      get: internalUtil.deprecate(function () {
+        return this.getBuffer();
+      }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.')
+    });
+  } catch (_) {}
+})();
+
+var Duplex;
+function Writable(options) {
+  Duplex = Duplex || require('./_stream_duplex');
+
+  // Writable ctor is applied to Duplexes, though they're not
+  // instanceof Writable, they're instanceof Readable.
+  if (!(this instanceof Writable) && !(this instanceof Duplex)) return new Writable(options);
+
+  this._writableState = new WritableState(options, this);
+
+  // legacy.
+  this.writable = true;
+
+  if (options) {
+    if (typeof options.write === 'function') this._write = options.write;
+
+    if (typeof options.writev === 'function') this._writev = options.writev;
+  }
+
+  Stream.call(this);
+}
+
+// Otherwise people can pipe Writable streams, which is just wrong.
+Writable.prototype.pipe = function () {
+  this.emit('error', new Error('Cannot pipe, not readable'));
+};
+
+function writeAfterEnd(stream, cb) {
+  var er = new Error('write after end');
+  // TODO: defer error events consistently everywhere, not just the cb
+  stream.emit('error', er);
+  processNextTick(cb, er);
+}
+
+// If we get something that is not a buffer, string, null, or undefined,
+// and we're not in objectMode, then that's an error.
+// Otherwise stream chunks are all considered to be of length=1, and the
+// watermarks determine how many objects to keep in the buffer, rather than
+// how many bytes or characters.
+function validChunk(stream, state, chunk, cb) {
+  var valid = true;
+  var er = false;
+  // Always throw error if a null is written
+  // if we are not in object mode then throw
+  // if it is not a buffer, string, or undefined.
+  if (chunk === null) {
+    er = new TypeError('May not write null values to stream');
+  } else if (!Buffer.isBuffer(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {
+    er = new TypeError('Invalid non-string/buffer chunk');
+  }
+  if (er) {
+    stream.emit('error', er);
+    processNextTick(cb, er);
+    valid = false;
+  }
+  return valid;
+}
+
+Writable.prototype.write = function (chunk, encoding, cb) {
+  var state = this._writableState;
+  var ret = false;
+
+  if (typeof encoding === 'function') {
+    cb = encoding;
+    encoding = null;
+  }
+
+  if (Buffer.isBuffer(chunk)) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;
+
+  if (typeof cb !== 'function') cb = nop;
+
+  if (state.ended) writeAfterEnd(this, cb);else if (validChunk(this, state, chunk, cb)) {
+    state.pendingcb++;
+    ret = writeOrBuffer(this, state, chunk, encoding, cb);
+  }
+
+  return ret;
+};
+
+Writable.prototype.cork = function () {
+  var state = this._writableState;
+
+  state.corked++;
+};
+
+Writable.prototype.uncork = function () {
+  var state = this._writableState;
+
+  if (state.corked) {
+    state.corked--;
+
+    if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);
+  }
+};
+
+Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
+  // node::ParseEncoding() requires lower case.
+  if (typeof encoding === 'string') encoding = encoding.toLowerCase();
+  if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new TypeError('Unknown encoding: ' + encoding);
+  this._writableState.defaultEncoding = encoding;
+  return this;
+};
+
+function decodeChunk(state, chunk, encoding) {
+  if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {
+    chunk = bufferShim.from(chunk, encoding);
+  }
+  return chunk;
+}
+
+// if we're already writing something, then just put this
+// in the queue, and wait our turn.  Otherwise, call _write
+// If we return false, then we need a drain event, so set that flag.
+function writeOrBuffer(stream, state, chunk, encoding, cb) {
+  chunk = decodeChunk(state, chunk, encoding);
+
+  if (Buffer.isBuffer(chunk)) encoding = 'buffer';
+  var len = state.objectMode ? 1 : chunk.length;
+
+  state.length += len;
+
+  var ret = state.length < state.highWaterMark;
+  // we must ensure that previous needDrain will not be reset to false.
+  if (!ret) state.needDrain = true;
+
+  if (state.writing || state.corked) {
+    var last = state.lastBufferedRequest;
+    state.lastBufferedRequest = new WriteReq(chunk, encoding, cb);
+    if (last) {
+      last.next = state.lastBufferedRequest;
+    } else {
+      state.bufferedRequest = state.lastBufferedRequest;
+    }
+    state.bufferedRequestCount += 1;
+  } else {
+    doWrite(stream, state, false, len, chunk, encoding, cb);
+  }
+
+  return ret;
+}
+
+function doWrite(stream, state, writev, len, chunk, encoding, cb) {
+  state.writelen = len;
+  state.writecb = cb;
+  state.writing = true;
+  state.sync = true;
+  if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);
+  state.sync = false;
+}
+
+function onwriteError(stream, state, sync, er, cb) {
+  --state.pendingcb;
+  if (sync) processNextTick(cb, er);else cb(er);
+
+  stream._writableState.errorEmitted = true;
+  stream.emit('error', er);
+}
+
+function onwriteStateUpdate(state) {
+  state.writing = false;
+  state.writecb = null;
+  state.length -= state.writelen;
+  state.writelen = 0;
+}
+
+function onwrite(stream, er) {
+  var state = stream._writableState;
+  var sync = state.sync;
+  var cb = state.writecb;
+
+  onwriteStateUpdate(state);
+
+  if (er) onwriteError(stream, state, sync, er, cb);else {
+    // Check if we're actually ready to finish, but don't emit yet
+    var finished = needFinish(state);
+
+    if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {
+      clearBuffer(stream, state);
+    }
+
+    if (sync) {
+      /*<replacement>*/
+      asyncWrite(afterWrite, stream, state, finished, cb);
+      /*</replacement>*/
+    } else {
+      afterWrite(stream, state, finished, cb);
+    }
+  }
+}
+
+function afterWrite(stream, state, finished, cb) {
+  if (!finished) onwriteDrain(stream, state);
+  state.pendingcb--;
+  cb();
+  finishMaybe(stream, state);
+}
+
+// Must force callback to be called on nextTick, so that we don't
+// emit 'drain' before the write() consumer gets the 'false' return
+// value, and has a chance to attach a 'drain' listener.
+function onwriteDrain(stream, state) {
+  if (state.length === 0 && state.needDrain) {
+    state.needDrain = false;
+    stream.emit('drain');
+  }
+}
+
+// if there's something in the buffer waiting, then process it
+function clearBuffer(stream, state) {
+  state.bufferProcessing = true;
+  var entry = state.bufferedRequest;
+
+  if (stream._writev && entry && entry.next) {
+    // Fast case, write everything using _writev()
+    var l = state.bufferedRequestCount;
+    var buffer = new Array(l);
+    var holder = state.corkedRequestsFree;
+    holder.entry = entry;
+
+    var count = 0;
+    while (entry) {
+      buffer[count] = entry;
+      entry = entry.next;
+      count += 1;
+    }
+
+    doWrite(stream, state, true, state.length, buffer, '', holder.finish);
+
+    // doWrite is almost always async, defer these to save a bit of time
+    // as the hot path ends with doWrite
+    state.pendingcb++;
+    state.lastBufferedRequest = null;
+    if (holder.next) {
+      state.corkedRequestsFree = holder.next;
+      holder.next = null;
+    } else {
+      state.corkedRequestsFree = new CorkedRequest(state);
+    }
+  } else {
+    // Slow case, write chunks one-by-one
+    while (entry) {
+      var chunk = entry.chunk;
+      var encoding = entry.encoding;
+      var cb = entry.callback;
+      var len = state.objectMode ? 1 : chunk.length;
+
+      doWrite(stream, state, false, len, chunk, encoding, cb);
+      entry = entry.next;
+      // if we didn't call the onwrite immediately, then
+      // it means that we need to wait until it does.
+      // also, that means that the chunk and cb are currently
+      // being processed, so move the buffer counter past them.
+      if (state.writing) {
+        break;
+      }
+    }
+
+    if (entry === null) state.lastBufferedRequest = null;
+  }
+
+  state.bufferedRequestCount = 0;
+  state.bufferedRequest = entry;
+  state.bufferProcessing = false;
+}
+
+Writable.prototype._write = function (chunk, encoding, cb) {
+  cb(new Error('not implemented'));
+};
+
+Writable.prototype._writev = null;
+
+Writable.prototype.end = function (chunk, encoding, cb) {
+  var state = this._writableState;
+
+  if (typeof chunk === 'function') {
+    cb = chunk;
+    chunk = null;
+    encoding = null;
+  } else if (typeof encoding === 'function') {
+    cb = encoding;
+    encoding = null;
+  }
+
+  if (chunk !== null && chunk !== undefined) this.write(chunk, encoding);
+
+  // .end() fully uncorks
+  if (state.corked) {
+    state.corked = 1;
+    this.uncork();
+  }
+
+  // ignore unnecessary end() calls.
+  if (!state.ending && !state.finished) endWritable(this, state, cb);
+};
+
+function needFinish(state) {
+  return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;
+}
+
+function prefinish(stream, state) {
+  if (!state.prefinished) {
+    state.prefinished = true;
+    stream.emit('prefinish');
+  }
+}
+
+function finishMaybe(stream, state) {
+  var need = needFinish(state);
+  if (need) {
+    if (state.pendingcb === 0) {
+      prefinish(stream, state);
+      state.finished = true;
+      stream.emit('finish');
+    } else {
+      prefinish(stream, state);
+    }
+  }
+  return need;
+}
+
+function endWritable(stream, state, cb) {
+  state.ending = true;
+  finishMaybe(stream, state);
+  if (cb) {
+    if (state.finished) processNextTick(cb);else stream.once('finish', cb);
+  }
+  state.ended = true;
+  stream.writable = false;
+}
+
+// It seems a linked list but it is not
+// there will be only 2 of these for each stream
+function CorkedRequest(state) {
+  var _this = this;
+
+  this.next = null;
+  this.entry = null;
+
+  this.finish = function (err) {
+    var entry = _this.entry;
+    _this.entry = null;
+    while (entry) {
+      var cb = entry.callback;
+      state.pendingcb--;
+      cb(err);
+      entry = entry.next;
+    }
+    if (state.corkedRequestsFree) {
+      state.corkedRequestsFree.next = _this;
+    } else {
+      state.corkedRequestsFree = _this;
+    }
+  };
+}
+
+}).call(this,require('_process'))
+},{"./_stream_duplex":351,"_process":345,"babel-runtime/core-js/set-immediate":34,"buffer":45,"buffer-shims":44,"core-util-is":176,"events":193,"inherits":198,"process-nextick-args":344,"util-deprecate":381}],356:[function(require,module,exports){
+'use strict';
+
+var Buffer = require('buffer').Buffer;
+/*<replacement>*/
+var bufferShim = require('buffer-shims');
+/*</replacement>*/
+
+module.exports = BufferList;
+
+function BufferList() {
+  this.head = null;
+  this.tail = null;
+  this.length = 0;
+}
+
+BufferList.prototype.push = function (v) {
+  var entry = { data: v, next: null };
+  if (this.length > 0) this.tail.next = entry;else this.head = entry;
+  this.tail = entry;
+  ++this.length;
+};
+
+BufferList.prototype.unshift = function (v) {
+  var entry = { data: v, next: this.head };
+  if (this.length === 0) this.tail = entry;
+  this.head = entry;
+  ++this.length;
+};
+
+BufferList.prototype.shift = function () {
+  if (this.length === 0) return;
+  var ret = this.head.data;
+  if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next;
+  --this.length;
+  return ret;
+};
+
+BufferList.prototype.clear = function () {
+  this.head = this.tail = null;
+  this.length = 0;
+};
+
+BufferList.prototype.join = function (s) {
+  if (this.length === 0) return '';
+  var p = this.head;
+  var ret = '' + p.data;
+  while (p = p.next) {
+    ret += s + p.data;
+  }return ret;
+};
+
+BufferList.prototype.concat = function (n) {
+  if (this.length === 0) return bufferShim.alloc(0);
+  if (this.length === 1) return this.head.data;
+  var ret = bufferShim.allocUnsafe(n >>> 0);
+  var p = this.head;
+  var i = 0;
+  while (p) {
+    p.data.copy(ret, i);
+    i += p.data.length;
+    p = p.next;
+  }
+  return ret;
+};
+
+},{"buffer":45,"buffer-shims":44}],357:[function(require,module,exports){
+arguments[4][46][0].apply(exports,arguments)
+},{"dup":46}],358:[function(require,module,exports){
+"use strict";
+
+module.exports = require("./lib/_stream_passthrough.js");
+
+},{"./lib/_stream_passthrough.js":352}],359:[function(require,module,exports){
+(function (process){
+'use strict';
+
+var Stream = function () {
+  try {
+    return require('st' + 'ream'); // hack to fix a circular dependency issue when used with browserify
+  } catch (_) {}
+}();
+exports = module.exports = require('./lib/_stream_readable.js');
+exports.Stream = Stream || exports;
+exports.Readable = exports;
+exports.Writable = require('./lib/_stream_writable.js');
+exports.Duplex = require('./lib/_stream_duplex.js');
+exports.Transform = require('./lib/_stream_transform.js');
+exports.PassThrough = require('./lib/_stream_passthrough.js');
+
+if (!process.browser && process.env.READABLE_STREAM === 'disable' && Stream) {
+  module.exports = Stream;
+}
+
+}).call(this,require('_process'))
+},{"./lib/_stream_duplex.js":351,"./lib/_stream_passthrough.js":352,"./lib/_stream_readable.js":353,"./lib/_stream_transform.js":354,"./lib/_stream_writable.js":355,"_process":345}],360:[function(require,module,exports){
+"use strict";
+
+module.exports = require("./lib/_stream_transform.js");
+
+},{"./lib/_stream_transform.js":354}],361:[function(require,module,exports){
+"use strict";
+
+module.exports = require("./lib/_stream_writable.js");
+
+},{"./lib/_stream_writable.js":355}],362:[function(require,module,exports){
+(function (global){
+"use strict";
+
+var _getOwnPropertyNames = require("babel-runtime/core-js/object/get-own-property-names");
+
+var _getOwnPropertyNames2 = _interopRequireDefault(_getOwnPropertyNames);
+
+var _typeof2 = require("babel-runtime/helpers/typeof");
+
+var _typeof3 = _interopRequireDefault(_typeof2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// This method of obtaining a reference to the global object needs to be
+// kept identical to the way it is obtained in runtime.js
+var g = (typeof global === "undefined" ? "undefined" : (0, _typeof3.default)(global)) === "object" ? global : (typeof window === "undefined" ? "undefined" : (0, _typeof3.default)(window)) === "object" ? window : (typeof self === "undefined" ? "undefined" : (0, _typeof3.default)(self)) === "object" ? self : undefined;
+
+// Use `getOwnPropertyNames` because not all browsers support calling
+// `hasOwnProperty` on the global `self` object in a worker. See #183.
+var hadRuntime = g.regeneratorRuntime && (0, _getOwnPropertyNames2.default)(g).indexOf("regeneratorRuntime") >= 0;
+
+// Save the old regeneratorRuntime in case it needs to be restored later.
+var oldRuntime = hadRuntime && g.regeneratorRuntime;
+
+// Force reevalutation of runtime.js.
+g.regeneratorRuntime = undefined;
+
+module.exports = require("./runtime");
+
+if (hadRuntime) {
+  // Restore the original runtime.
+  g.regeneratorRuntime = oldRuntime;
+} else {
+  // Remove the global property added by runtime.js.
+  try {
+    delete g.regeneratorRuntime;
+  } catch (e) {
+    g.regeneratorRuntime = undefined;
+  }
+}
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"./runtime":363,"babel-runtime/core-js/object/get-own-property-names":26,"babel-runtime/helpers/typeof":39}],363:[function(require,module,exports){
+(function (process,global){
+"use strict";
+
+var _promise = require("babel-runtime/core-js/promise");
+
+var _promise2 = _interopRequireDefault(_promise);
+
+var _setPrototypeOf = require("babel-runtime/core-js/object/set-prototype-of");
+
+var _setPrototypeOf2 = _interopRequireDefault(_setPrototypeOf);
+
+var _create = require("babel-runtime/core-js/object/create");
+
+var _create2 = _interopRequireDefault(_create);
+
+var _typeof2 = require("babel-runtime/helpers/typeof");
+
+var _typeof3 = _interopRequireDefault(_typeof2);
+
+var _symbol = require("babel-runtime/core-js/symbol");
+
+var _symbol2 = _interopRequireDefault(_symbol);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * Copyright (c) 2014, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * https://raw.github.com/facebook/regenerator/master/LICENSE file. An
+ * additional grant of patent rights can be found in the PATENTS file in
+ * the same directory.
+ */
+
+!function (global) {
+  "use strict";
+
+  var hasOwn = Object.prototype.hasOwnProperty;
+  var undefined; // More compressible than void 0.
+  var $Symbol = typeof _symbol2.default === "function" ? _symbol2.default : {};
+  var iteratorSymbol = $Symbol.iterator || "@@iterator";
+  var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
+
+  var inModule = (typeof module === "undefined" ? "undefined" : (0, _typeof3.default)(module)) === "object";
+  var runtime = global.regeneratorRuntime;
+  if (runtime) {
+    if (inModule) {
+      // If regeneratorRuntime is defined globally and we're in a module,
+      // make the exports object identical to regeneratorRuntime.
+      module.exports = runtime;
+    }
+    // Don't bother evaluating the rest of this file if the runtime was
+    // already defined globally.
+    return;
+  }
+
+  // Define the runtime globally (as expected by generated code) as either
+  // module.exports (if we're in a module) or a new, empty object.
+  runtime = global.regeneratorRuntime = inModule ? module.exports : {};
+
+  function wrap(innerFn, outerFn, self, tryLocsList) {
+    // If outerFn provided, then outerFn.prototype instanceof Generator.
+    var generator = (0, _create2.default)((outerFn || Generator).prototype);
+    var context = new Context(tryLocsList || []);
+
+    // The ._invoke method unifies the implementations of the .next,
+    // .throw, and .return methods.
+    generator._invoke = makeInvokeMethod(innerFn, self, context);
+
+    return generator;
+  }
+  runtime.wrap = wrap;
+
+  // Try/catch helper to minimize deoptimizations. Returns a completion
+  // record like context.tryEntries[i].completion. This interface could
+  // have been (and was previously) designed to take a closure to be
+  // invoked without arguments, but in all the cases we care about we
+  // already have an existing method we want to call, so there's no need
+  // to create a new function object. We can even get away with assuming
+  // the method takes exactly one argument, since that happens to be true
+  // in every case, so we don't have to touch the arguments object. The
+  // only additional allocation required is the completion record, which
+  // has a stable shape and so hopefully should be cheap to allocate.
+  function tryCatch(fn, obj, arg) {
+    try {
+      return { type: "normal", arg: fn.call(obj, arg) };
+    } catch (err) {
+      return { type: "throw", arg: err };
+    }
+  }
+
+  var GenStateSuspendedStart = "suspendedStart";
+  var GenStateSuspendedYield = "suspendedYield";
+  var GenStateExecuting = "executing";
+  var GenStateCompleted = "completed";
+
+  // Returning this object from the innerFn has the same effect as
+  // breaking out of the dispatch switch statement.
+  var ContinueSentinel = {};
+
+  // Dummy constructor functions that we use as the .constructor and
+  // .constructor.prototype properties for functions that return Generator
+  // objects. For full spec compliance, you may wish to configure your
+  // minifier not to mangle the names of these two functions.
+  function Generator() {}
+  function GeneratorFunction() {}
+  function GeneratorFunctionPrototype() {}
+
+  var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype;
+  GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;
+  GeneratorFunctionPrototype.constructor = GeneratorFunction;
+  GeneratorFunctionPrototype[toStringTagSymbol] = GeneratorFunction.displayName = "GeneratorFunction";
+
+  // Helper for defining the .next, .throw, and .return methods of the
+  // Iterator interface in terms of a single ._invoke method.
+  function defineIteratorMethods(prototype) {
+    ["next", "throw", "return"].forEach(function (method) {
+      prototype[method] = function (arg) {
+        return this._invoke(method, arg);
+      };
+    });
+  }
+
+  runtime.isGeneratorFunction = function (genFun) {
+    var ctor = typeof genFun === "function" && genFun.constructor;
+    return ctor ? ctor === GeneratorFunction ||
+    // For the native GeneratorFunction constructor, the best we can
+    // do is to check its .name property.
+    (ctor.displayName || ctor.name) === "GeneratorFunction" : false;
+  };
+
+  runtime.mark = function (genFun) {
+    if (_setPrototypeOf2.default) {
+      (0, _setPrototypeOf2.default)(genFun, GeneratorFunctionPrototype);
+    } else {
+      genFun.__proto__ = GeneratorFunctionPrototype;
+      if (!(toStringTagSymbol in genFun)) {
+        genFun[toStringTagSymbol] = "GeneratorFunction";
+      }
+    }
+    genFun.prototype = (0, _create2.default)(Gp);
+    return genFun;
+  };
+
+  // Within the body of any async function, `await x` is transformed to
+  // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test
+  // `value instanceof AwaitArgument` to determine if the yielded value is
+  // meant to be awaited. Some may consider the name of this method too
+  // cutesy, but they are curmudgeons.
+  runtime.awrap = function (arg) {
+    return new AwaitArgument(arg);
+  };
+
+  function AwaitArgument(arg) {
+    this.arg = arg;
+  }
+
+  function AsyncIterator(generator) {
+    function invoke(method, arg, resolve, reject) {
+      var record = tryCatch(generator[method], generator, arg);
+      if (record.type === "throw") {
+        reject(record.arg);
+      } else {
+        var result = record.arg;
+        var value = result.value;
+        if (value instanceof AwaitArgument) {
+          return _promise2.default.resolve(value.arg).then(function (value) {
+            invoke("next", value, resolve, reject);
+          }, function (err) {
+            invoke("throw", err, resolve, reject);
+          });
+        }
+
+        return _promise2.default.resolve(value).then(function (unwrapped) {
+          // When a yielded Promise is resolved, its final value becomes
+          // the .value of the Promise<{value,done}> result for the
+          // current iteration. If the Promise is rejected, however, the
+          // result for this iteration will be rejected with the same
+          // reason. Note that rejections of yielded Promises are not
+          // thrown back into the generator function, as is the case
+          // when an awaited Promise is rejected. This difference in
+          // behavior between yield and await is important, because it
+          // allows the consumer to decide what to do with the yielded
+          // rejection (swallow it and continue, manually .throw it back
+          // into the generator, abandon iteration, whatever). With
+          // await, by contrast, there is no opportunity to examine the
+          // rejection reason outside the generator function, so the
+          // only option is to throw it from the await expression, and
+          // let the generator function handle the exception.
+          result.value = unwrapped;
+          resolve(result);
+        }, reject);
+      }
+    }
+
+    if ((typeof process === "undefined" ? "undefined" : (0, _typeof3.default)(process)) === "object" && process.domain) {
+      invoke = process.domain.bind(invoke);
+    }
+
+    var previousPromise;
+
+    function enqueue(method, arg) {
+      function callInvokeWithMethodAndArg() {
+        return new _promise2.default(function (resolve, reject) {
+          invoke(method, arg, resolve, reject);
+        });
+      }
+
+      return previousPromise =
+      // If enqueue has been called before, then we want to wait until
+      // all previous Promises have been resolved before calling invoke,
+      // so that results are always delivered in the correct order. If
+      // enqueue has not been called before, then it is important to
+      // call invoke immediately, without waiting on a callback to fire,
+      // so that the async generator function has the opportunity to do
+      // any necessary setup in a predictable way. This predictability
+      // is why the Promise constructor synchronously invokes its
+      // executor callback, and why async functions synchronously
+      // execute code before the first await. Since we implement simple
+      // async functions in terms of async generators, it is especially
+      // important to get this right, even though it requires care.
+      previousPromise ? previousPromise.then(callInvokeWithMethodAndArg,
+      // Avoid propagating failures to Promises returned by later
+      // invocations of the iterator.
+      callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
+    }
+
+    // Define the unified helper method that is used to implement .next,
+    // .throw, and .return (see defineIteratorMethods).
+    this._invoke = enqueue;
+  }
+
+  defineIteratorMethods(AsyncIterator.prototype);
+
+  // Note that simple async functions are implemented on top of
+  // AsyncIterator objects; they just return a Promise for the value of
+  // the final result produced by the iterator.
+  runtime.async = function (innerFn, outerFn, self, tryLocsList) {
+    var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList));
+
+    return runtime.isGeneratorFunction(outerFn) ? iter // If outerFn is a generator, return the full iterator.
+    : iter.next().then(function (result) {
+      return result.done ? result.value : iter.next();
+    });
+  };
+
+  function makeInvokeMethod(innerFn, self, context) {
+    var state = GenStateSuspendedStart;
+
+    return function invoke(method, arg) {
+      if (state === GenStateExecuting) {
+        throw new Error("Generator is already running");
+      }
+
+      if (state === GenStateCompleted) {
+        if (method === "throw") {
+          throw arg;
+        }
+
+        // Be forgiving, per 25.3.3.3.3 of the spec:
+        // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume
+        return doneResult();
+      }
+
+      while (true) {
+        var delegate = context.delegate;
+        if (delegate) {
+          if (method === "return" || method === "throw" && delegate.iterator[method] === undefined) {
+            // A return or throw (when the delegate iterator has no throw
+            // method) always terminates the yield* loop.
+            context.delegate = null;
+
+            // If the delegate iterator has a return method, give it a
+            // chance to clean up.
+            var returnMethod = delegate.iterator["return"];
+            if (returnMethod) {
+              var record = tryCatch(returnMethod, delegate.iterator, arg);
+              if (record.type === "throw") {
+                // If the return method threw an exception, let that
+                // exception prevail over the original return or throw.
+                method = "throw";
+                arg = record.arg;
+                continue;
+              }
+            }
+
+            if (method === "return") {
+              // Continue with the outer return, now that the delegate
+              // iterator has been terminated.
+              continue;
+            }
+          }
+
+          var record = tryCatch(delegate.iterator[method], delegate.iterator, arg);
+
+          if (record.type === "throw") {
+            context.delegate = null;
+
+            // Like returning generator.throw(uncaught), but without the
+            // overhead of an extra function call.
+            method = "throw";
+            arg = record.arg;
+            continue;
+          }
+
+          // Delegate generator ran and handled its own exceptions so
+          // regardless of what the method was, we continue as if it is
+          // "next" with an undefined arg.
+          method = "next";
+          arg = undefined;
+
+          var info = record.arg;
+          if (info.done) {
+            context[delegate.resultName] = info.value;
+            context.next = delegate.nextLoc;
+          } else {
+            state = GenStateSuspendedYield;
+            return info;
+          }
+
+          context.delegate = null;
+        }
+
+        if (method === "next") {
+          // Setting context._sent for legacy support of Babel's
+          // function.sent implementation.
+          context.sent = context._sent = arg;
+        } else if (method === "throw") {
+          if (state === GenStateSuspendedStart) {
+            state = GenStateCompleted;
+            throw arg;
+          }
+
+          if (context.dispatchException(arg)) {
+            // If the dispatched exception was caught by a catch block,
+            // then let that catch block handle the exception normally.
+            method = "next";
+            arg = undefined;
+          }
+        } else if (method === "return") {
+          context.abrupt("return", arg);
+        }
+
+        state = GenStateExecuting;
+
+        var record = tryCatch(innerFn, self, context);
+        if (record.type === "normal") {
+          // If an exception is thrown from innerFn, we leave state ===
+          // GenStateExecuting and loop back for another invocation.
+          state = context.done ? GenStateCompleted : GenStateSuspendedYield;
+
+          var info = {
+            value: record.arg,
+            done: context.done
+          };
+
+          if (record.arg === ContinueSentinel) {
+            if (context.delegate && method === "next") {
+              // Deliberately forget the last sent value so that we don't
+              // accidentally pass it on to the delegate.
+              arg = undefined;
+            }
+          } else {
+            return info;
+          }
+        } else if (record.type === "throw") {
+          state = GenStateCompleted;
+          // Dispatch the exception by looping back around to the
+          // context.dispatchException(arg) call above.
+          method = "throw";
+          arg = record.arg;
+        }
+      }
+    };
+  }
+
+  // Define Generator.prototype.{next,throw,return} in terms of the
+  // unified ._invoke helper method.
+  defineIteratorMethods(Gp);
+
+  Gp[iteratorSymbol] = function () {
+    return this;
+  };
+
+  Gp[toStringTagSymbol] = "Generator";
+
+  Gp.toString = function () {
+    return "[object Generator]";
+  };
+
+  function pushTryEntry(locs) {
+    var entry = { tryLoc: locs[0] };
+
+    if (1 in locs) {
+      entry.catchLoc = locs[1];
+    }
+
+    if (2 in locs) {
+      entry.finallyLoc = locs[2];
+      entry.afterLoc = locs[3];
+    }
+
+    this.tryEntries.push(entry);
+  }
+
+  function resetTryEntry(entry) {
+    var record = entry.completion || {};
+    record.type = "normal";
+    delete record.arg;
+    entry.completion = record;
+  }
+
+  function Context(tryLocsList) {
+    // The root entry object (effectively a try statement without a catch
+    // or a finally block) gives us a place to store values thrown from
+    // locations where there is no enclosing try statement.
+    this.tryEntries = [{ tryLoc: "root" }];
+    tryLocsList.forEach(pushTryEntry, this);
+    this.reset(true);
+  }
+
+  runtime.keys = function (object) {
+    var keys = [];
+    for (var key in object) {
+      keys.push(key);
+    }
+    keys.reverse();
+
+    // Rather than returning an object with a next method, we keep
+    // things simple and return the next function itself.
+    return function next() {
+      while (keys.length) {
+        var key = keys.pop();
+        if (key in object) {
+          next.value = key;
+          next.done = false;
+          return next;
+        }
+      }
+
+      // To avoid creating an additional object, we just hang the .value
+      // and .done properties off the next function object itself. This
+      // also ensures that the minifier will not anonymize the function.
+      next.done = true;
+      return next;
+    };
+  };
+
+  function values(iterable) {
+    if (iterable) {
+      var iteratorMethod = iterable[iteratorSymbol];
+      if (iteratorMethod) {
+        return iteratorMethod.call(iterable);
+      }
+
+      if (typeof iterable.next === "function") {
+        return iterable;
+      }
+
+      if (!isNaN(iterable.length)) {
+        var i = -1,
+            next = function next() {
+          while (++i < iterable.length) {
+            if (hasOwn.call(iterable, i)) {
+              next.value = iterable[i];
+              next.done = false;
+              return next;
+            }
+          }
+
+          next.value = undefined;
+          next.done = true;
+
+          return next;
+        };
+
+        return next.next = next;
+      }
+    }
+
+    // Return an iterator with no values.
+    return { next: doneResult };
+  }
+  runtime.values = values;
+
+  function doneResult() {
+    return { value: undefined, done: true };
+  }
+
+  Context.prototype = {
+    constructor: Context,
+
+    reset: function reset(skipTempReset) {
+      this.prev = 0;
+      this.next = 0;
+      // Resetting context._sent for legacy support of Babel's
+      // function.sent implementation.
+      this.sent = this._sent = undefined;
+      this.done = false;
+      this.delegate = null;
+
+      this.tryEntries.forEach(resetTryEntry);
+
+      if (!skipTempReset) {
+        for (var name in this) {
+          // Not sure about the optimal order of these conditions:
+          if (name.charAt(0) === "t" && hasOwn.call(this, name) && !isNaN(+name.slice(1))) {
+            this[name] = undefined;
+          }
+        }
+      }
+    },
+
+    stop: function stop() {
+      this.done = true;
+
+      var rootEntry = this.tryEntries[0];
+      var rootRecord = rootEntry.completion;
+      if (rootRecord.type === "throw") {
+        throw rootRecord.arg;
+      }
+
+      return this.rval;
+    },
+
+    dispatchException: function dispatchException(exception) {
+      if (this.done) {
+        throw exception;
+      }
+
+      var context = this;
+      function handle(loc, caught) {
+        record.type = "throw";
+        record.arg = exception;
+        context.next = loc;
+        return !!caught;
+      }
+
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+        var record = entry.completion;
+
+        if (entry.tryLoc === "root") {
+          // Exception thrown outside of any try block that could handle
+          // it, so set the completion value of the entire function to
+          // throw the exception.
+          return handle("end");
+        }
+
+        if (entry.tryLoc <= this.prev) {
+          var hasCatch = hasOwn.call(entry, "catchLoc");
+          var hasFinally = hasOwn.call(entry, "finallyLoc");
+
+          if (hasCatch && hasFinally) {
+            if (this.prev < entry.catchLoc) {
+              return handle(entry.catchLoc, true);
+            } else if (this.prev < entry.finallyLoc) {
+              return handle(entry.finallyLoc);
+            }
+          } else if (hasCatch) {
+            if (this.prev < entry.catchLoc) {
+              return handle(entry.catchLoc, true);
+            }
+          } else if (hasFinally) {
+            if (this.prev < entry.finallyLoc) {
+              return handle(entry.finallyLoc);
+            }
+          } else {
+            throw new Error("try statement without catch or finally");
+          }
+        }
+      }
+    },
+
+    abrupt: function abrupt(type, arg) {
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+        if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
+          var finallyEntry = entry;
+          break;
+        }
+      }
+
+      if (finallyEntry && (type === "break" || type === "continue") && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc) {
+        // Ignore the finally entry if control is not jumping to a
+        // location outside the try/catch block.
+        finallyEntry = null;
+      }
+
+      var record = finallyEntry ? finallyEntry.completion : {};
+      record.type = type;
+      record.arg = arg;
+
+      if (finallyEntry) {
+        this.next = finallyEntry.finallyLoc;
+      } else {
+        this.complete(record);
+      }
+
+      return ContinueSentinel;
+    },
+
+    complete: function complete(record, afterLoc) {
+      if (record.type === "throw") {
+        throw record.arg;
+      }
+
+      if (record.type === "break" || record.type === "continue") {
+        this.next = record.arg;
+      } else if (record.type === "return") {
+        this.rval = record.arg;
+        this.next = "end";
+      } else if (record.type === "normal" && afterLoc) {
+        this.next = afterLoc;
+      }
+    },
+
+    finish: function finish(finallyLoc) {
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+        if (entry.finallyLoc === finallyLoc) {
+          this.complete(entry.completion, entry.afterLoc);
+          resetTryEntry(entry);
+          return ContinueSentinel;
+        }
+      }
+    },
+
+    "catch": function _catch(tryLoc) {
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+        if (entry.tryLoc === tryLoc) {
+          var record = entry.completion;
+          if (record.type === "throw") {
+            var thrown = record.arg;
+            resetTryEntry(entry);
+          }
+          return thrown;
+        }
+      }
+
+      // The context.catch method must only be called with a location
+      // argument that corresponds to a known catch block.
+      throw new Error("illegal catch attempt");
+    },
+
+    delegateYield: function delegateYield(iterable, resultName, nextLoc) {
+      this.delegate = {
+        iterator: values(iterable),
+        resultName: resultName,
+        nextLoc: nextLoc
+      };
+
+      return ContinueSentinel;
+    }
+  };
+}(
+// Among the various tricks for obtaining a reference to the global
+// object, this seems to be the most reliable technique that does not
+// use indirect eval (which violates Content Security Policy).
+(typeof global === "undefined" ? "undefined" : (0, _typeof3.default)(global)) === "object" ? global : (typeof window === "undefined" ? "undefined" : (0, _typeof3.default)(window)) === "object" ? window : (typeof self === "undefined" ? "undefined" : (0, _typeof3.default)(self)) === "object" ? self : undefined);
+
+}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"_process":345,"babel-runtime/core-js/object/create":22,"babel-runtime/core-js/object/set-prototype-of":32,"babel-runtime/core-js/promise":33,"babel-runtime/core-js/symbol":36,"babel-runtime/helpers/typeof":39}],364:[function(require,module,exports){
+(function (Buffer){
+'use strict';
+
+var _fromCodePoint = require('babel-runtime/core-js/string/from-code-point');
+
+var _fromCodePoint2 = _interopRequireDefault(_fromCodePoint);
+
+var _stringify = require('babel-runtime/core-js/json/stringify');
+
+var _stringify2 = _interopRequireDefault(_stringify);
+
+var _typeof2 = require('babel-runtime/helpers/typeof');
+
+var _typeof3 = _interopRequireDefault(_typeof2);
+
+var _defineProperty = require('babel-runtime/core-js/object/define-property');
+
+var _defineProperty2 = _interopRequireDefault(_defineProperty);
+
+var _keys = require('babel-runtime/core-js/object/keys');
+
+var _keys2 = _interopRequireDefault(_keys);
+
+var _create = require('babel-runtime/core-js/object/create');
+
+var _create2 = _interopRequireDefault(_create);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+;(function (sax) {
+  // wrapper for non-node envs
+  sax.parser = function (strict, opt) {
+    return new SAXParser(strict, opt);
+  };
+  sax.SAXParser = SAXParser;
+  sax.SAXStream = SAXStream;
+  sax.createStream = createStream;
+
+  // When we pass the MAX_BUFFER_LENGTH position, start checking for buffer overruns.
+  // When we check, schedule the next check for MAX_BUFFER_LENGTH - (max(buffer lengths)),
+  // since that's the earliest that a buffer overrun could occur.  This way, checks are
+  // as rare as required, but as often as necessary to ensure never crossing this bound.
+  // Furthermore, buffers are only tested at most once per write(), so passing a very
+  // large string into write() might have undesirable effects, but this is manageable by
+  // the caller, so it is assumed to be safe.  Thus, a call to write() may, in the extreme
+  // edge case, result in creating at most one complete copy of the string passed in.
+  // Set to Infinity to have unlimited buffers.
+  sax.MAX_BUFFER_LENGTH = 64 * 1024;
+
+  var buffers = ['comment', 'sgmlDecl', 'textNode', 'tagName', 'doctype', 'procInstName', 'procInstBody', 'entity', 'attribName', 'attribValue', 'cdata', 'script'];
+
+  sax.EVENTS = ['text', 'processinginstruction', 'sgmldeclaration', 'doctype', 'comment', 'opentagstart', 'attribute', 'opentag', 'closetag', 'opencdata', 'cdata', 'closecdata', 'error', 'end', 'ready', 'script', 'opennamespace', 'closenamespace'];
+
+  function SAXParser(strict, opt) {
+    if (!(this instanceof SAXParser)) {
+      return new SAXParser(strict, opt);
+    }
+
+    var parser = this;
+    clearBuffers(parser);
+    parser.q = parser.c = '';
+    parser.bufferCheckPosition = sax.MAX_BUFFER_LENGTH;
+    parser.opt = opt || {};
+    parser.opt.lowercase = parser.opt.lowercase || parser.opt.lowercasetags;
+    parser.looseCase = parser.opt.lowercase ? 'toLowerCase' : 'toUpperCase';
+    parser.tags = [];
+    parser.closed = parser.closedRoot = parser.sawRoot = false;
+    parser.tag = parser.error = null;
+    parser.strict = !!strict;
+    parser.noscript = !!(strict || parser.opt.noscript);
+    parser.state = S.BEGIN;
+    parser.strictEntities = parser.opt.strictEntities;
+    parser.ENTITIES = parser.strictEntities ? (0, _create2.default)(sax.XML_ENTITIES) : (0, _create2.default)(sax.ENTITIES);
+    parser.attribList = [];
+
+    // namespaces form a prototype chain.
+    // it always points at the current tag,
+    // which protos to its parent tag.
+    if (parser.opt.xmlns) {
+      parser.ns = (0, _create2.default)(rootNS);
+    }
+
+    // mostly just for error reporting
+    parser.trackPosition = parser.opt.position !== false;
+    if (parser.trackPosition) {
+      parser.position = parser.line = parser.column = 0;
+    }
+    emit(parser, 'onready');
+  }
+
+  if (!_create2.default) {
+    Object.create = function (o) {
+      function F() {}
+      F.prototype = o;
+      var newf = new F();
+      return newf;
+    };
+  }
+
+  if (!_keys2.default) {
+    Object.keys = function (o) {
+      var a = [];
+      for (var i in o) {
+        if (o.hasOwnProperty(i)) a.push(i);
+      }return a;
+    };
+  }
+
+  function checkBufferLength(parser) {
+    var maxAllowed = Math.max(sax.MAX_BUFFER_LENGTH, 10);
+    var maxActual = 0;
+    for (var i = 0, l = buffers.length; i < l; i++) {
+      var len = parser[buffers[i]].length;
+      if (len > maxAllowed) {
+        // Text/cdata nodes can get big, and since they're buffered,
+        // we can get here under normal conditions.
+        // Avoid issues by emitting the text node now,
+        // so at least it won't get any bigger.
+        switch (buffers[i]) {
+          case 'textNode':
+            closeText(parser);
+            break;
+
+          case 'cdata':
+            emitNode(parser, 'oncdata', parser.cdata);
+            parser.cdata = '';
+            break;
+
+          case 'script':
+            emitNode(parser, 'onscript', parser.script);
+            parser.script = '';
+            break;
+
+          default:
+            error(parser, 'Max buffer length exceeded: ' + buffers[i]);
+        }
+      }
+      maxActual = Math.max(maxActual, len);
+    }
+    // schedule the next check for the earliest possible buffer overrun.
+    var m = sax.MAX_BUFFER_LENGTH - maxActual;
+    parser.bufferCheckPosition = m + parser.position;
+  }
+
+  function clearBuffers(parser) {
+    for (var i = 0, l = buffers.length; i < l; i++) {
+      parser[buffers[i]] = '';
+    }
+  }
+
+  function flushBuffers(parser) {
+    closeText(parser);
+    if (parser.cdata !== '') {
+      emitNode(parser, 'oncdata', parser.cdata);
+      parser.cdata = '';
+    }
+    if (parser.script !== '') {
+      emitNode(parser, 'onscript', parser.script);
+      parser.script = '';
+    }
+  }
+
+  SAXParser.prototype = {
+    end: function end() {
+      _end(this);
+    },
+    write: write,
+    resume: function resume() {
+      this.error = null;return this;
+    },
+    close: function close() {
+      return this.write(null);
+    },
+    flush: function flush() {
+      flushBuffers(this);
+    }
+  };
+
+  var Stream;
+  try {
+    Stream = require('stream').Stream;
+  } catch (ex) {
+    Stream = function Stream() {};
+  }
+
+  var streamWraps = sax.EVENTS.filter(function (ev) {
+    return ev !== 'error' && ev !== 'end';
+  });
+
+  function createStream(strict, opt) {
+    return new SAXStream(strict, opt);
+  }
+
+  function SAXStream(strict, opt) {
+    if (!(this instanceof SAXStream)) {
+      return new SAXStream(strict, opt);
+    }
+
+    Stream.apply(this);
+
+    this._parser = new SAXParser(strict, opt);
+    this.writable = true;
+    this.readable = true;
+
+    var me = this;
+
+    this._parser.onend = function () {
+      me.emit('end');
+    };
+
+    this._parser.onerror = function (er) {
+      me.emit('error', er);
+
+      // if didn't throw, then means error was handled.
+      // go ahead and clear error, so we can write again.
+      me._parser.error = null;
+    };
+
+    this._decoder = null;
+
+    streamWraps.forEach(function (ev) {
+      (0, _defineProperty2.default)(me, 'on' + ev, {
+        get: function get() {
+          return me._parser['on' + ev];
+        },
+        set: function set(h) {
+          if (!h) {
+            me.removeAllListeners(ev);
+            me._parser['on' + ev] = h;
+            return h;
+          }
+          me.on(ev, h);
+        },
+        enumerable: true,
+        configurable: false
+      });
+    });
+  }
+
+  SAXStream.prototype = (0, _create2.default)(Stream.prototype, {
+    constructor: {
+      value: SAXStream
+    }
+  });
+
+  SAXStream.prototype.write = function (data) {
+    if (typeof Buffer === 'function' && typeof Buffer.isBuffer === 'function' && Buffer.isBuffer(data)) {
+      if (!this._decoder) {
+        var SD = require('string_decoder').StringDecoder;
+        this._decoder = new SD('utf8');
+      }
+      data = this._decoder.write(data);
+    }
+
+    this._parser.write(data.toString());
+    this.emit('data', data);
+    return true;
+  };
+
+  SAXStream.prototype.end = function (chunk) {
+    if (chunk && chunk.length) {
+      this.write(chunk);
+    }
+    this._parser.end();
+    return true;
+  };
+
+  SAXStream.prototype.on = function (ev, handler) {
+    var me = this;
+    if (!me._parser['on' + ev] && streamWraps.indexOf(ev) !== -1) {
+      me._parser['on' + ev] = function () {
+        var args = arguments.length === 1 ? [arguments[0]] : Array.apply(null, arguments);
+        args.splice(0, 0, ev);
+        me.emit.apply(me, args);
+      };
+    }
+
+    return Stream.prototype.on.call(me, ev, handler);
+  };
+
+  // character classes and tokens
+  var whitespace = '\r\n\t ';
+
+  // this really needs to be replaced with character classes.
+  // XML allows all manner of ridiculous numbers and digits.
+  var number = '0124356789';
+  var letter = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
+
+  // (Letter | "_" | ":")
+  var quote = '\'"';
+  var attribEnd = whitespace + '>';
+  var CDATA = '[CDATA[';
+  var DOCTYPE = 'DOCTYPE';
+  var XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
+  var XMLNS_NAMESPACE = 'http://www.w3.org/2000/xmlns/';
+  var rootNS = { xml: XML_NAMESPACE, xmlns: XMLNS_NAMESPACE };
+
+  // turn all the string character sets into character class objects.
+  whitespace = charClass(whitespace);
+  number = charClass(number);
+  letter = charClass(letter);
+
+  // http://www.w3.org/TR/REC-xml/#NT-NameStartChar
+  // This implementation works on strings, a single character at a time
+  // as such, it cannot ever support astral-plane characters (10000-EFFFF)
+  // without a significant breaking change to either this  parser, or the
+  // JavaScript language.  Implementation of an emoji-capable xml parser
+  // is left as an exercise for the reader.
+  var nameStart = /[:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/;
+
+  var nameBody = /[:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u00B7\u0300-\u036F\u203F-\u2040\.\d-]/;
+
+  var entityStart = /[#:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/;
+  var entityBody = /[#:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u00B7\u0300-\u036F\u203F-\u2040\.\d-]/;
+
+  quote = charClass(quote);
+  attribEnd = charClass(attribEnd);
+
+  function charClass(str) {
+    return str.split('').reduce(function (s, c) {
+      s[c] = true;
+      return s;
+    }, {});
+  }
+
+  function isRegExp(c) {
+    return Object.prototype.toString.call(c) === '[object RegExp]';
+  }
+
+  function is(charclass, c) {
+    return isRegExp(charclass) ? !!c.match(charclass) : charclass[c];
+  }
+
+  function not(charclass, c) {
+    return !is(charclass, c);
+  }
+
+  var S = 0;
+  sax.STATE = {
+    BEGIN: S++, // leading byte order mark or whitespace
+    BEGIN_WHITESPACE: S++, // leading whitespace
+    TEXT: S++, // general stuff
+    TEXT_ENTITY: S++, // &amp and such.
+    OPEN_WAKA: S++, // <
+    SGML_DECL: S++, // <!BLARG
+    SGML_DECL_QUOTED: S++, // <!BLARG foo "bar
+    DOCTYPE: S++, // <!DOCTYPE
+    DOCTYPE_QUOTED: S++, // <!DOCTYPE "//blah
+    DOCTYPE_DTD: S++, // <!DOCTYPE "//blah" [ ...
+    DOCTYPE_DTD_QUOTED: S++, // <!DOCTYPE "//blah" [ "foo
+    COMMENT_STARTING: S++, // <!-
+    COMMENT: S++, // <!--
+    COMMENT_ENDING: S++, // <!-- blah -
+    COMMENT_ENDED: S++, // <!-- blah --
+    CDATA: S++, // <![CDATA[ something
+    CDATA_ENDING: S++, // ]
+    CDATA_ENDING_2: S++, // ]]
+    PROC_INST: S++, // <?hi
+    PROC_INST_BODY: S++, // <?hi there
+    PROC_INST_ENDING: S++, // <?hi "there" ?
+    OPEN_TAG: S++, // <strong
+    OPEN_TAG_SLASH: S++, // <strong /
+    ATTRIB: S++, // <a
+    ATTRIB_NAME: S++, // <a foo
+    ATTRIB_NAME_SAW_WHITE: S++, // <a foo _
+    ATTRIB_VALUE: S++, // <a foo=
+    ATTRIB_VALUE_QUOTED: S++, // <a foo="bar
+    ATTRIB_VALUE_CLOSED: S++, // <a foo="bar"
+    ATTRIB_VALUE_UNQUOTED: S++, // <a foo=bar
+    ATTRIB_VALUE_ENTITY_Q: S++, // <foo bar="&quot;"
+    ATTRIB_VALUE_ENTITY_U: S++, // <foo bar=&quot
+    CLOSE_TAG: S++, // </a
+    CLOSE_TAG_SAW_WHITE: S++, // </a   >
+    SCRIPT: S++, // <script> ...
+    SCRIPT_ENDING: S++ // <script> ... <
+  };
+
+  sax.XML_ENTITIES = {
+    'amp': '&',
+    'gt': '>',
+    'lt': '<',
+    'quot': '"',
+    'apos': "'"
+  };
+
+  sax.ENTITIES = {
+    'amp': '&',
+    'gt': '>',
+    'lt': '<',
+    'quot': '"',
+    'apos': "'",
+    'AElig': 198,
+    'Aacute': 193,
+    'Acirc': 194,
+    'Agrave': 192,
+    'Aring': 197,
+    'Atilde': 195,
+    'Auml': 196,
+    'Ccedil': 199,
+    'ETH': 208,
+    'Eacute': 201,
+    'Ecirc': 202,
+    'Egrave': 200,
+    'Euml': 203,
+    'Iacute': 205,
+    'Icirc': 206,
+    'Igrave': 204,
+    'Iuml': 207,
+    'Ntilde': 209,
+    'Oacute': 211,
+    'Ocirc': 212,
+    'Ograve': 210,
+    'Oslash': 216,
+    'Otilde': 213,
+    'Ouml': 214,
+    'THORN': 222,
+    'Uacute': 218,
+    'Ucirc': 219,
+    'Ugrave': 217,
+    'Uuml': 220,
+    'Yacute': 221,
+    'aacute': 225,
+    'acirc': 226,
+    'aelig': 230,
+    'agrave': 224,
+    'aring': 229,
+    'atilde': 227,
+    'auml': 228,
+    'ccedil': 231,
+    'eacute': 233,
+    'ecirc': 234,
+    'egrave': 232,
+    'eth': 240,
+    'euml': 235,
+    'iacute': 237,
+    'icirc': 238,
+    'igrave': 236,
+    'iuml': 239,
+    'ntilde': 241,
+    'oacute': 243,
+    'ocirc': 244,
+    'ograve': 242,
+    'oslash': 248,
+    'otilde': 245,
+    'ouml': 246,
+    'szlig': 223,
+    'thorn': 254,
+    'uacute': 250,
+    'ucirc': 251,
+    'ugrave': 249,
+    'uuml': 252,
+    'yacute': 253,
+    'yuml': 255,
+    'copy': 169,
+    'reg': 174,
+    'nbsp': 160,
+    'iexcl': 161,
+    'cent': 162,
+    'pound': 163,
+    'curren': 164,
+    'yen': 165,
+    'brvbar': 166,
+    'sect': 167,
+    'uml': 168,
+    'ordf': 170,
+    'laquo': 171,
+    'not': 172,
+    'shy': 173,
+    'macr': 175,
+    'deg': 176,
+    'plusmn': 177,
+    'sup1': 185,
+    'sup2': 178,
+    'sup3': 179,
+    'acute': 180,
+    'micro': 181,
+    'para': 182,
+    'middot': 183,
+    'cedil': 184,
+    'ordm': 186,
+    'raquo': 187,
+    'frac14': 188,
+    'frac12': 189,
+    'frac34': 190,
+    'iquest': 191,
+    'times': 215,
+    'divide': 247,
+    'OElig': 338,
+    'oelig': 339,
+    'Scaron': 352,
+    'scaron': 353,
+    'Yuml': 376,
+    'fnof': 402,
+    'circ': 710,
+    'tilde': 732,
+    'Alpha': 913,
+    'Beta': 914,
+    'Gamma': 915,
+    'Delta': 916,
+    'Epsilon': 917,
+    'Zeta': 918,
+    'Eta': 919,
+    'Theta': 920,
+    'Iota': 921,
+    'Kappa': 922,
+    'Lambda': 923,
+    'Mu': 924,
+    'Nu': 925,
+    'Xi': 926,
+    'Omicron': 927,
+    'Pi': 928,
+    'Rho': 929,
+    'Sigma': 931,
+    'Tau': 932,
+    'Upsilon': 933,
+    'Phi': 934,
+    'Chi': 935,
+    'Psi': 936,
+    'Omega': 937,
+    'alpha': 945,
+    'beta': 946,
+    'gamma': 947,
+    'delta': 948,
+    'epsilon': 949,
+    'zeta': 950,
+    'eta': 951,
+    'theta': 952,
+    'iota': 953,
+    'kappa': 954,
+    'lambda': 955,
+    'mu': 956,
+    'nu': 957,
+    'xi': 958,
+    'omicron': 959,
+    'pi': 960,
+    'rho': 961,
+    'sigmaf': 962,
+    'sigma': 963,
+    'tau': 964,
+    'upsilon': 965,
+    'phi': 966,
+    'chi': 967,
+    'psi': 968,
+    'omega': 969,
+    'thetasym': 977,
+    'upsih': 978,
+    'piv': 982,
+    'ensp': 8194,
+    'emsp': 8195,
+    'thinsp': 8201,
+    'zwnj': 8204,
+    'zwj': 8205,
+    'lrm': 8206,
+    'rlm': 8207,
+    'ndash': 8211,
+    'mdash': 8212,
+    'lsquo': 8216,
+    'rsquo': 8217,
+    'sbquo': 8218,
+    'ldquo': 8220,
+    'rdquo': 8221,
+    'bdquo': 8222,
+    'dagger': 8224,
+    'Dagger': 8225,
+    'bull': 8226,
+    'hellip': 8230,
+    'permil': 8240,
+    'prime': 8242,
+    'Prime': 8243,
+    'lsaquo': 8249,
+    'rsaquo': 8250,
+    'oline': 8254,
+    'frasl': 8260,
+    'euro': 8364,
+    'image': 8465,
+    'weierp': 8472,
+    'real': 8476,
+    'trade': 8482,
+    'alefsym': 8501,
+    'larr': 8592,
+    'uarr': 8593,
+    'rarr': 8594,
+    'darr': 8595,
+    'harr': 8596,
+    'crarr': 8629,
+    'lArr': 8656,
+    'uArr': 8657,
+    'rArr': 8658,
+    'dArr': 8659,
+    'hArr': 8660,
+    'forall': 8704,
+    'part': 8706,
+    'exist': 8707,
+    'empty': 8709,
+    'nabla': 8711,
+    'isin': 8712,
+    'notin': 8713,
+    'ni': 8715,
+    'prod': 8719,
+    'sum': 8721,
+    'minus': 8722,
+    'lowast': 8727,
+    'radic': 8730,
+    'prop': 8733,
+    'infin': 8734,
+    'ang': 8736,
+    'and': 8743,
+    'or': 8744,
+    'cap': 8745,
+    'cup': 8746,
+    'int': 8747,
+    'there4': 8756,
+    'sim': 8764,
+    'cong': 8773,
+    'asymp': 8776,
+    'ne': 8800,
+    'equiv': 8801,
+    'le': 8804,
+    'ge': 8805,
+    'sub': 8834,
+    'sup': 8835,
+    'nsub': 8836,
+    'sube': 8838,
+    'supe': 8839,
+    'oplus': 8853,
+    'otimes': 8855,
+    'perp': 8869,
+    'sdot': 8901,
+    'lceil': 8968,
+    'rceil': 8969,
+    'lfloor': 8970,
+    'rfloor': 8971,
+    'lang': 9001,
+    'rang': 9002,
+    'loz': 9674,
+    'spades': 9824,
+    'clubs': 9827,
+    'hearts': 9829,
+    'diams': 9830
+  };
+
+  (0, _keys2.default)(sax.ENTITIES).forEach(function (key) {
+    var e = sax.ENTITIES[key];
+    var s = typeof e === 'number' ? String.fromCharCode(e) : e;
+    sax.ENTITIES[key] = s;
+  });
+
+  for (var s in sax.STATE) {
+    sax.STATE[sax.STATE[s]] = s;
+  }
+
+  // shorthand
+  S = sax.STATE;
+
+  function emit(parser, event, data) {
+    parser[event] && parser[event](data);
+  }
+
+  function emitNode(parser, nodeType, data) {
+    if (parser.textNode) closeText(parser);
+    emit(parser, nodeType, data);
+  }
+
+  function closeText(parser) {
+    parser.textNode = textopts(parser.opt, parser.textNode);
+    if (parser.textNode) emit(parser, 'ontext', parser.textNode);
+    parser.textNode = '';
+  }
+
+  function textopts(opt, text) {
+    if (opt.trim) text = text.trim();
+    if (opt.normalize) text = text.replace(/\s+/g, ' ');
+    return text;
+  }
+
+  function error(parser, er) {
+    closeText(parser);
+    if (parser.trackPosition) {
+      er += '\nLine: ' + parser.line + '\nColumn: ' + parser.column + '\nChar: ' + parser.c;
+    }
+    er = new Error(er);
+    parser.error = er;
+    emit(parser, 'onerror', er);
+    return parser;
+  }
+
+  function _end(parser) {
+    if (parser.sawRoot && !parser.closedRoot) strictFail(parser, 'Unclosed root tag');
+    if (parser.state !== S.BEGIN && parser.state !== S.BEGIN_WHITESPACE && parser.state !== S.TEXT) {
+      error(parser, 'Unexpected end');
+    }
+    closeText(parser);
+    parser.c = '';
+    parser.closed = true;
+    emit(parser, 'onend');
+    SAXParser.call(parser, parser.strict, parser.opt);
+    return parser;
+  }
+
+  function strictFail(parser, message) {
+    if ((typeof parser === 'undefined' ? 'undefined' : (0, _typeof3.default)(parser)) !== 'object' || !(parser instanceof SAXParser)) {
+      throw new Error('bad call to strictFail');
+    }
+    if (parser.strict) {
+      error(parser, message);
+    }
+  }
+
+  function newTag(parser) {
+    if (!parser.strict) parser.tagName = parser.tagName[parser.looseCase]();
+    var parent = parser.tags[parser.tags.length - 1] || parser;
+    var tag = parser.tag = { name: parser.tagName, attributes: {} };
+
+    // will be overridden if tag contails an xmlns="foo" or xmlns:foo="bar"
+    if (parser.opt.xmlns) {
+      tag.ns = parent.ns;
+    }
+    parser.attribList.length = 0;
+    emitNode(parser, 'onopentagstart', tag);
+  }
+
+  function qname(name, attribute) {
+    var i = name.indexOf(':');
+    var qualName = i < 0 ? ['', name] : name.split(':');
+    var prefix = qualName[0];
+    var local = qualName[1];
+
+    // <x "xmlns"="http://foo">
+    if (attribute && name === 'xmlns') {
+      prefix = 'xmlns';
+      local = '';
+    }
+
+    return { prefix: prefix, local: local };
+  }
+
+  function attrib(parser) {
+    if (!parser.strict) {
+      parser.attribName = parser.attribName[parser.looseCase]();
+    }
+
+    if (parser.attribList.indexOf(parser.attribName) !== -1 || parser.tag.attributes.hasOwnProperty(parser.attribName)) {
+      parser.attribName = parser.attribValue = '';
+      return;
+    }
+
+    if (parser.opt.xmlns) {
+      var qn = qname(parser.attribName, true);
+      var prefix = qn.prefix;
+      var local = qn.local;
+
+      if (prefix === 'xmlns') {
+        // namespace binding attribute. push the binding into scope
+        if (local === 'xml' && parser.attribValue !== XML_NAMESPACE) {
+          strictFail(parser, 'xml: prefix must be bound to ' + XML_NAMESPACE + '\n' + 'Actual: ' + parser.attribValue);
+        } else if (local === 'xmlns' && parser.attribValue !== XMLNS_NAMESPACE) {
+          strictFail(parser, 'xmlns: prefix must be bound to ' + XMLNS_NAMESPACE + '\n' + 'Actual: ' + parser.attribValue);
+        } else {
+          var tag = parser.tag;
+          var parent = parser.tags[parser.tags.length - 1] || parser;
+          if (tag.ns === parent.ns) {
+            tag.ns = (0, _create2.default)(parent.ns);
+          }
+          tag.ns[local] = parser.attribValue;
+        }
+      }
+
+      // defer onattribute events until all attributes have been seen
+      // so any new bindings can take effect. preserve attribute order
+      // so deferred events can be emitted in document order
+      parser.attribList.push([parser.attribName, parser.attribValue]);
+    } else {
+      // in non-xmlns mode, we can emit the event right away
+      parser.tag.attributes[parser.attribName] = parser.attribValue;
+      emitNode(parser, 'onattribute', {
+        name: parser.attribName,
+        value: parser.attribValue
+      });
+    }
+
+    parser.attribName = parser.attribValue = '';
+  }
+
+  function openTag(parser, selfClosing) {
+    if (parser.opt.xmlns) {
+      // emit namespace binding events
+      var tag = parser.tag;
+
+      // add namespace info to tag
+      var qn = qname(parser.tagName);
+      tag.prefix = qn.prefix;
+      tag.local = qn.local;
+      tag.uri = tag.ns[qn.prefix] || '';
+
+      if (tag.prefix && !tag.uri) {
+        strictFail(parser, 'Unbound namespace prefix: ' + (0, _stringify2.default)(parser.tagName));
+        tag.uri = qn.prefix;
+      }
+
+      var parent = parser.tags[parser.tags.length - 1] || parser;
+      if (tag.ns && parent.ns !== tag.ns) {
+        (0, _keys2.default)(tag.ns).forEach(function (p) {
+          emitNode(parser, 'onopennamespace', {
+            prefix: p,
+            uri: tag.ns[p]
+          });
+        });
+      }
+
+      // handle deferred onattribute events
+      // Note: do not apply default ns to attributes:
+      //   http://www.w3.org/TR/REC-xml-names/#defaulting
+      for (var i = 0, l = parser.attribList.length; i < l; i++) {
+        var nv = parser.attribList[i];
+        var name = nv[0];
+        var value = nv[1];
+        var qualName = qname(name, true);
+        var prefix = qualName.prefix;
+        var local = qualName.local;
+        var uri = prefix === '' ? '' : tag.ns[prefix] || '';
+        var a = {
+          name: name,
+          value: value,
+          prefix: prefix,
+          local: local,
+          uri: uri
+        };
+
+        // if there's any attributes with an undefined namespace,
+        // then fail on them now.
+        if (prefix && prefix !== 'xmlns' && !uri) {
+          strictFail(parser, 'Unbound namespace prefix: ' + (0, _stringify2.default)(prefix));
+          a.uri = prefix;
+        }
+        parser.tag.attributes[name] = a;
+        emitNode(parser, 'onattribute', a);
+      }
+      parser.attribList.length = 0;
+    }
+
+    parser.tag.isSelfClosing = !!selfClosing;
+
+    // process the tag
+    parser.sawRoot = true;
+    parser.tags.push(parser.tag);
+    emitNode(parser, 'onopentag', parser.tag);
+    if (!selfClosing) {
+      // special case for <script> in non-strict mode.
+      if (!parser.noscript && parser.tagName.toLowerCase() === 'script') {
+        parser.state = S.SCRIPT;
+      } else {
+        parser.state = S.TEXT;
+      }
+      parser.tag = null;
+      parser.tagName = '';
+    }
+    parser.attribName = parser.attribValue = '';
+    parser.attribList.length = 0;
+  }
+
+  function closeTag(parser) {
+    if (!parser.tagName) {
+      strictFail(parser, 'Weird empty close tag.');
+      parser.textNode += '</>';
+      parser.state = S.TEXT;
+      return;
+    }
+
+    if (parser.script) {
+      if (parser.tagName !== 'script') {
+        parser.script += '</' + parser.tagName + '>';
+        parser.tagName = '';
+        parser.state = S.SCRIPT;
+        return;
+      }
+      emitNode(parser, 'onscript', parser.script);
+      parser.script = '';
+    }
+
+    // first make sure that the closing tag actually exists.
+    // <a><b></c></b></a> will close everything, otherwise.
+    var t = parser.tags.length;
+    var tagName = parser.tagName;
+    if (!parser.strict) {
+      tagName = tagName[parser.looseCase]();
+    }
+    var closeTo = tagName;
+    while (t--) {
+      var close = parser.tags[t];
+      if (close.name !== closeTo) {
+        // fail the first time in strict mode
+        strictFail(parser, 'Unexpected close tag');
+      } else {
+        break;
+      }
+    }
+
+    // didn't find it.  we already failed for strict, so just abort.
+    if (t < 0) {
+      strictFail(parser, 'Unmatched closing tag: ' + parser.tagName);
+      parser.textNode += '</' + parser.tagName + '>';
+      parser.state = S.TEXT;
+      return;
+    }
+    parser.tagName = tagName;
+    var s = parser.tags.length;
+    while (s-- > t) {
+      var tag = parser.tag = parser.tags.pop();
+      parser.tagName = parser.tag.name;
+      emitNode(parser, 'onclosetag', parser.tagName);
+
+      var x = {};
+      for (var i in tag.ns) {
+        x[i] = tag.ns[i];
+      }
+
+      var parent = parser.tags[parser.tags.length - 1] || parser;
+      if (parser.opt.xmlns && tag.ns !== parent.ns) {
+        // remove namespace bindings introduced by tag
+        (0, _keys2.default)(tag.ns).forEach(function (p) {
+          var n = tag.ns[p];
+          emitNode(parser, 'onclosenamespace', { prefix: p, uri: n });
+        });
+      }
+    }
+    if (t === 0) parser.closedRoot = true;
+    parser.tagName = parser.attribValue = parser.attribName = '';
+    parser.attribList.length = 0;
+    parser.state = S.TEXT;
+  }
+
+  function parseEntity(parser) {
+    var entity = parser.entity;
+    var entityLC = entity.toLowerCase();
+    var num;
+    var numStr = '';
+
+    if (parser.ENTITIES[entity]) {
+      return parser.ENTITIES[entity];
+    }
+    if (parser.ENTITIES[entityLC]) {
+      return parser.ENTITIES[entityLC];
+    }
+    entity = entityLC;
+    if (entity.charAt(0) === '#') {
+      if (entity.charAt(1) === 'x') {
+        entity = entity.slice(2);
+        num = parseInt(entity, 16);
+        numStr = num.toString(16);
+      } else {
+        entity = entity.slice(1);
+        num = parseInt(entity, 10);
+        numStr = num.toString(10);
+      }
+    }
+    entity = entity.replace(/^0+/, '');
+    if (numStr.toLowerCase() !== entity) {
+      strictFail(parser, 'Invalid character entity');
+      return '&' + parser.entity + ';';
+    }
+
+    return (0, _fromCodePoint2.default)(num);
+  }
+
+  function beginWhiteSpace(parser, c) {
+    if (c === '<') {
+      parser.state = S.OPEN_WAKA;
+      parser.startTagPosition = parser.position;
+    } else if (not(whitespace, c)) {
+      // have to process this as a text node.
+      // weird, but happens.
+      strictFail(parser, 'Non-whitespace before first tag.');
+      parser.textNode = c;
+      parser.state = S.TEXT;
+    }
+  }
+
+  function charAt(chunk, i) {
+    var result = '';
+    if (i < chunk.length) {
+      result = chunk.charAt(i);
+    }
+    return result;
+  }
+
+  function write(chunk) {
+    var parser = this;
+    if (this.error) {
+      throw this.error;
+    }
+    if (parser.closed) {
+      return error(parser, 'Cannot write after close. Assign an onready handler.');
+    }
+    if (chunk === null) {
+      return _end(parser);
+    }
+    if ((typeof chunk === 'undefined' ? 'undefined' : (0, _typeof3.default)(chunk)) === 'object') {
+      chunk = chunk.toString();
+    }
+    var i = 0;
+    var c = '';
+    while (true) {
+      c = charAt(chunk, i++);
+      parser.c = c;
+      if (!c) {
+        break;
+      }
+      if (parser.trackPosition) {
+        parser.position++;
+        if (c === '\n') {
+          parser.line++;
+          parser.column = 0;
+        } else {
+          parser.column++;
+        }
+      }
+      switch (parser.state) {
+        case S.BEGIN:
+          parser.state = S.BEGIN_WHITESPACE;
+          if (c === '\uFEFF') {
+            continue;
+          }
+          beginWhiteSpace(parser, c);
+          continue;
+
+        case S.BEGIN_WHITESPACE:
+          beginWhiteSpace(parser, c);
+          continue;
+
+        case S.TEXT:
+          if (parser.sawRoot && !parser.closedRoot) {
+            var starti = i - 1;
+            while (c && c !== '<' && c !== '&') {
+              c = charAt(chunk, i++);
+              if (c && parser.trackPosition) {
+                parser.position++;
+                if (c === '\n') {
+                  parser.line++;
+                  parser.column = 0;
+                } else {
+                  parser.column++;
+                }
+              }
+            }
+            parser.textNode += chunk.substring(starti, i - 1);
+          }
+          if (c === '<' && !(parser.sawRoot && parser.closedRoot && !parser.strict)) {
+            parser.state = S.OPEN_WAKA;
+            parser.startTagPosition = parser.position;
+          } else {
+            if (not(whitespace, c) && (!parser.sawRoot || parser.closedRoot)) {
+              strictFail(parser, 'Text data outside of root node.');
+            }
+            if (c === '&') {
+              parser.state = S.TEXT_ENTITY;
+            } else {
+              parser.textNode += c;
+            }
+          }
+          continue;
+
+        case S.SCRIPT:
+          // only non-strict
+          if (c === '<') {
+            parser.state = S.SCRIPT_ENDING;
+          } else {
+            parser.script += c;
+          }
+          continue;
+
+        case S.SCRIPT_ENDING:
+          if (c === '/') {
+            parser.state = S.CLOSE_TAG;
+          } else {
+            parser.script += '<' + c;
+            parser.state = S.SCRIPT;
+          }
+          continue;
+
+        case S.OPEN_WAKA:
+          // either a /, ?, !, or text is coming next.
+          if (c === '!') {
+            parser.state = S.SGML_DECL;
+            parser.sgmlDecl = '';
+          } else if (is(whitespace, c)) {
+            // wait for it...
+          } else if (is(nameStart, c)) {
+            parser.state = S.OPEN_TAG;
+            parser.tagName = c;
+          } else if (c === '/') {
+            parser.state = S.CLOSE_TAG;
+            parser.tagName = '';
+          } else if (c === '?') {
+            parser.state = S.PROC_INST;
+            parser.procInstName = parser.procInstBody = '';
+          } else {
+            strictFail(parser, 'Unencoded <');
+            // if there was some whitespace, then add that in.
+            if (parser.startTagPosition + 1 < parser.position) {
+              var pad = parser.position - parser.startTagPosition;
+              c = new Array(pad).join(' ') + c;
+            }
+            parser.textNode += '<' + c;
+            parser.state = S.TEXT;
+          }
+          continue;
+
+        case S.SGML_DECL:
+          if ((parser.sgmlDecl + c).toUpperCase() === CDATA) {
+            emitNode(parser, 'onopencdata');
+            parser.state = S.CDATA;
+            parser.sgmlDecl = '';
+            parser.cdata = '';
+          } else if (parser.sgmlDecl + c === '--') {
+            parser.state = S.COMMENT;
+            parser.comment = '';
+            parser.sgmlDecl = '';
+          } else if ((parser.sgmlDecl + c).toUpperCase() === DOCTYPE) {
+            parser.state = S.DOCTYPE;
+            if (parser.doctype || parser.sawRoot) {
+              strictFail(parser, 'Inappropriately located doctype declaration');
+            }
+            parser.doctype = '';
+            parser.sgmlDecl = '';
+          } else if (c === '>') {
+            emitNode(parser, 'onsgmldeclaration', parser.sgmlDecl);
+            parser.sgmlDecl = '';
+            parser.state = S.TEXT;
+          } else if (is(quote, c)) {
+            parser.state = S.SGML_DECL_QUOTED;
+            parser.sgmlDecl += c;
+          } else {
+            parser.sgmlDecl += c;
+          }
+          continue;
+
+        case S.SGML_DECL_QUOTED:
+          if (c === parser.q) {
+            parser.state = S.SGML_DECL;
+            parser.q = '';
+          }
+          parser.sgmlDecl += c;
+          continue;
+
+        case S.DOCTYPE:
+          if (c === '>') {
+            parser.state = S.TEXT;
+            emitNode(parser, 'ondoctype', parser.doctype);
+            parser.doctype = true; // just remember that we saw it.
+          } else {
+            parser.doctype += c;
+            if (c === '[') {
+              parser.state = S.DOCTYPE_DTD;
+            } else if (is(quote, c)) {
+              parser.state = S.DOCTYPE_QUOTED;
+              parser.q = c;
+            }
+          }
+          continue;
+
+        case S.DOCTYPE_QUOTED:
+          parser.doctype += c;
+          if (c === parser.q) {
+            parser.q = '';
+            parser.state = S.DOCTYPE;
+          }
+          continue;
+
+        case S.DOCTYPE_DTD:
+          parser.doctype += c;
+          if (c === ']') {
+            parser.state = S.DOCTYPE;
+          } else if (is(quote, c)) {
+            parser.state = S.DOCTYPE_DTD_QUOTED;
+            parser.q = c;
+          }
+          continue;
+
+        case S.DOCTYPE_DTD_QUOTED:
+          parser.doctype += c;
+          if (c === parser.q) {
+            parser.state = S.DOCTYPE_DTD;
+            parser.q = '';
+          }
+          continue;
+
+        case S.COMMENT:
+          if (c === '-') {
+            parser.state = S.COMMENT_ENDING;
+          } else {
+            parser.comment += c;
+          }
+          continue;
+
+        case S.COMMENT_ENDING:
+          if (c === '-') {
+            parser.state = S.COMMENT_ENDED;
+            parser.comment = textopts(parser.opt, parser.comment);
+            if (parser.comment) {
+              emitNode(parser, 'oncomment', parser.comment);
+            }
+            parser.comment = '';
+          } else {
+            parser.comment += '-' + c;
+            parser.state = S.COMMENT;
+          }
+          continue;
+
+        case S.COMMENT_ENDED:
+          if (c !== '>') {
+            strictFail(parser, 'Malformed comment');
+            // allow <!-- blah -- bloo --> in non-strict mode,
+            // which is a comment of " blah -- bloo "
+            parser.comment += '--' + c;
+            parser.state = S.COMMENT;
+          } else {
+            parser.state = S.TEXT;
+          }
+          continue;
+
+        case S.CDATA:
+          if (c === ']') {
+            parser.state = S.CDATA_ENDING;
+          } else {
+            parser.cdata += c;
+          }
+          continue;
+
+        case S.CDATA_ENDING:
+          if (c === ']') {
+            parser.state = S.CDATA_ENDING_2;
+          } else {
+            parser.cdata += ']' + c;
+            parser.state = S.CDATA;
+          }
+          continue;
+
+        case S.CDATA_ENDING_2:
+          if (c === '>') {
+            if (parser.cdata) {
+              emitNode(parser, 'oncdata', parser.cdata);
+            }
+            emitNode(parser, 'onclosecdata');
+            parser.cdata = '';
+            parser.state = S.TEXT;
+          } else if (c === ']') {
+            parser.cdata += ']';
+          } else {
+            parser.cdata += ']]' + c;
+            parser.state = S.CDATA;
+          }
+          continue;
+
+        case S.PROC_INST:
+          if (c === '?') {
+            parser.state = S.PROC_INST_ENDING;
+          } else if (is(whitespace, c)) {
+            parser.state = S.PROC_INST_BODY;
+          } else {
+            parser.procInstName += c;
+          }
+          continue;
+
+        case S.PROC_INST_BODY:
+          if (!parser.procInstBody && is(whitespace, c)) {
+            continue;
+          } else if (c === '?') {
+            parser.state = S.PROC_INST_ENDING;
+          } else {
+            parser.procInstBody += c;
+          }
+          continue;
+
+        case S.PROC_INST_ENDING:
+          if (c === '>') {
+            emitNode(parser, 'onprocessinginstruction', {
+              name: parser.procInstName,
+              body: parser.procInstBody
+            });
+            parser.procInstName = parser.procInstBody = '';
+            parser.state = S.TEXT;
+          } else {
+            parser.procInstBody += '?' + c;
+            parser.state = S.PROC_INST_BODY;
+          }
+          continue;
+
+        case S.OPEN_TAG:
+          if (is(nameBody, c)) {
+            parser.tagName += c;
+          } else {
+            newTag(parser);
+            if (c === '>') {
+              openTag(parser);
+            } else if (c === '/') {
+              parser.state = S.OPEN_TAG_SLASH;
+            } else {
+              if (not(whitespace, c)) {
+                strictFail(parser, 'Invalid character in tag name');
+              }
+              parser.state = S.ATTRIB;
+            }
+          }
+          continue;
+
+        case S.OPEN_TAG_SLASH:
+          if (c === '>') {
+            openTag(parser, true);
+            closeTag(parser);
+          } else {
+            strictFail(parser, 'Forward-slash in opening tag not followed by >');
+            parser.state = S.ATTRIB;
+          }
+          continue;
+
+        case S.ATTRIB:
+          // haven't read the attribute name yet.
+          if (is(whitespace, c)) {
+            continue;
+          } else if (c === '>') {
+            openTag(parser);
+          } else if (c === '/') {
+            parser.state = S.OPEN_TAG_SLASH;
+          } else if (is(nameStart, c)) {
+            parser.attribName = c;
+            parser.attribValue = '';
+            parser.state = S.ATTRIB_NAME;
+          } else {
+            strictFail(parser, 'Invalid attribute name');
+          }
+          continue;
+
+        case S.ATTRIB_NAME:
+          if (c === '=') {
+            parser.state = S.ATTRIB_VALUE;
+          } else if (c === '>') {
+            strictFail(parser, 'Attribute without value');
+            parser.attribValue = parser.attribName;
+            attrib(parser);
+            openTag(parser);
+          } else if (is(whitespace, c)) {
+            parser.state = S.ATTRIB_NAME_SAW_WHITE;
+          } else if (is(nameBody, c)) {
+            parser.attribName += c;
+          } else {
+            strictFail(parser, 'Invalid attribute name');
+          }
+          continue;
+
+        case S.ATTRIB_NAME_SAW_WHITE:
+          if (c === '=') {
+            parser.state = S.ATTRIB_VALUE;
+          } else if (is(whitespace, c)) {
+            continue;
+          } else {
+            strictFail(parser, 'Attribute without value');
+            parser.tag.attributes[parser.attribName] = '';
+            parser.attribValue = '';
+            emitNode(parser, 'onattribute', {
+              name: parser.attribName,
+              value: ''
+            });
+            parser.attribName = '';
+            if (c === '>') {
+              openTag(parser);
+            } else if (is(nameStart, c)) {
+              parser.attribName = c;
+              parser.state = S.ATTRIB_NAME;
+            } else {
+              strictFail(parser, 'Invalid attribute name');
+              parser.state = S.ATTRIB;
+            }
+          }
+          continue;
+
+        case S.ATTRIB_VALUE:
+          if (is(whitespace, c)) {
+            continue;
+          } else if (is(quote, c)) {
+            parser.q = c;
+            parser.state = S.ATTRIB_VALUE_QUOTED;
+          } else {
+            strictFail(parser, 'Unquoted attribute value');
+            parser.state = S.ATTRIB_VALUE_UNQUOTED;
+            parser.attribValue = c;
+          }
+          continue;
+
+        case S.ATTRIB_VALUE_QUOTED:
+          if (c !== parser.q) {
+            if (c === '&') {
+              parser.state = S.ATTRIB_VALUE_ENTITY_Q;
+            } else {
+              parser.attribValue += c;
+            }
+            continue;
+          }
+          attrib(parser);
+          parser.q = '';
+          parser.state = S.ATTRIB_VALUE_CLOSED;
+          continue;
+
+        case S.ATTRIB_VALUE_CLOSED:
+          if (is(whitespace, c)) {
+            parser.state = S.ATTRIB;
+          } else if (c === '>') {
+            openTag(parser);
+          } else if (c === '/') {
+            parser.state = S.OPEN_TAG_SLASH;
+          } else if (is(nameStart, c)) {
+            strictFail(parser, 'No whitespace between attributes');
+            parser.attribName = c;
+            parser.attribValue = '';
+            parser.state = S.ATTRIB_NAME;
+          } else {
+            strictFail(parser, 'Invalid attribute name');
+          }
+          continue;
+
+        case S.ATTRIB_VALUE_UNQUOTED:
+          if (not(attribEnd, c)) {
+            if (c === '&') {
+              parser.state = S.ATTRIB_VALUE_ENTITY_U;
+            } else {
+              parser.attribValue += c;
+            }
+            continue;
+          }
+          attrib(parser);
+          if (c === '>') {
+            openTag(parser);
+          } else {
+            parser.state = S.ATTRIB;
+          }
+          continue;
+
+        case S.CLOSE_TAG:
+          if (!parser.tagName) {
+            if (is(whitespace, c)) {
+              continue;
+            } else if (not(nameStart, c)) {
+              if (parser.script) {
+                parser.script += '</' + c;
+                parser.state = S.SCRIPT;
+              } else {
+                strictFail(parser, 'Invalid tagname in closing tag.');
+              }
+            } else {
+              parser.tagName = c;
+            }
+          } else if (c === '>') {
+            closeTag(parser);
+          } else if (is(nameBody, c)) {
+            parser.tagName += c;
+          } else if (parser.script) {
+            parser.script += '</' + parser.tagName;
+            parser.tagName = '';
+            parser.state = S.SCRIPT;
+          } else {
+            if (not(whitespace, c)) {
+              strictFail(parser, 'Invalid tagname in closing tag');
+            }
+            parser.state = S.CLOSE_TAG_SAW_WHITE;
+          }
+          continue;
+
+        case S.CLOSE_TAG_SAW_WHITE:
+          if (is(whitespace, c)) {
+            continue;
+          }
+          if (c === '>') {
+            closeTag(parser);
+          } else {
+            strictFail(parser, 'Invalid characters in closing tag');
+          }
+          continue;
+
+        case S.TEXT_ENTITY:
+        case S.ATTRIB_VALUE_ENTITY_Q:
+        case S.ATTRIB_VALUE_ENTITY_U:
+          var returnState;
+          var buffer;
+          switch (parser.state) {
+            case S.TEXT_ENTITY:
+              returnState = S.TEXT;
+              buffer = 'textNode';
+              break;
+
+            case S.ATTRIB_VALUE_ENTITY_Q:
+              returnState = S.ATTRIB_VALUE_QUOTED;
+              buffer = 'attribValue';
+              break;
+
+            case S.ATTRIB_VALUE_ENTITY_U:
+              returnState = S.ATTRIB_VALUE_UNQUOTED;
+              buffer = 'attribValue';
+              break;
+          }
+
+          if (c === ';') {
+            parser[buffer] += parseEntity(parser);
+            parser.entity = '';
+            parser.state = returnState;
+          } else if (is(parser.entity.length ? entityBody : entityStart, c)) {
+            parser.entity += c;
+          } else {
+            strictFail(parser, 'Invalid character in entity name');
+            parser[buffer] += '&' + parser.entity + c;
+            parser.entity = '';
+            parser.state = returnState;
+          }
+
+          continue;
+
+        default:
+          throw new Error(parser, 'Unknown state: ' + parser.state);
+      }
+    } // while
+
+    if (parser.position >= parser.bufferCheckPosition) {
+      checkBufferLength(parser);
+    }
+    return parser;
+  }
+
+  /*! http://mths.be/fromcodepoint v0.1.0 by @mathias */
+  if (!_fromCodePoint2.default) {
+    (function () {
+      var stringFromCharCode = String.fromCharCode;
+      var floor = Math.floor;
+      var fromCodePoint = function fromCodePoint() {
+        var MAX_SIZE = 0x4000;
+        var codeUnits = [];
+        var highSurrogate;
+        var lowSurrogate;
+        var index = -1;
+        var length = arguments.length;
+        if (!length) {
+          return '';
+        }
+        var result = '';
+        while (++index < length) {
+          var codePoint = Number(arguments[index]);
+          if (!isFinite(codePoint) || // `NaN`, `+Infinity`, or `-Infinity`
+          codePoint < 0 || // not a valid Unicode code point
+          codePoint > 0x10FFFF || // not a valid Unicode code point
+          floor(codePoint) !== codePoint // not an integer
+          ) {
+              throw RangeError('Invalid code point: ' + codePoint);
+            }
+          if (codePoint <= 0xFFFF) {
+            // BMP code point
+            codeUnits.push(codePoint);
+          } else {
+            // Astral code point; split in surrogate halves
+            // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+            codePoint -= 0x10000;
+            highSurrogate = (codePoint >> 10) + 0xD800;
+            lowSurrogate = codePoint % 0x400 + 0xDC00;
+            codeUnits.push(highSurrogate, lowSurrogate);
+          }
+          if (index + 1 === length || codeUnits.length > MAX_SIZE) {
+            result += stringFromCharCode.apply(null, codeUnits);
+            codeUnits.length = 0;
+          }
+        }
+        return result;
+      };
+      if (_defineProperty2.default) {
+        Object.defineProperty(String, 'fromCodePoint', {
+          value: fromCodePoint,
+          configurable: true,
+          writable: true
+        });
+      } else {
+        String.fromCodePoint = fromCodePoint;
+      }
+    })();
+  }
+})(typeof exports === 'undefined' ? undefined.sax = {} : exports);
+
+}).call(this,require("buffer").Buffer)
+},{"babel-runtime/core-js/json/stringify":18,"babel-runtime/core-js/object/create":22,"babel-runtime/core-js/object/define-property":24,"babel-runtime/core-js/object/keys":30,"babel-runtime/core-js/string/from-code-point":35,"babel-runtime/helpers/typeof":39,"buffer":45,"stream":369,"string_decoder":374}],365:[function(require,module,exports){
+(function (process,__filename){
+/**
+ * Copyright(c) dead_horse and other contributors.
+ * MIT Licensed
+ *
+ * Authors:
+ * 	 dead_horse <dead_horse@qq.com>
+ *   fengmk2 <fengmk2@gmail.com> (http://fengmk2.com)
+ */
+
+'use strict';
+
+/**
+ * Module dependencies.
+ */
+
+var ready = require('get-ready');
+var EventEmitter = require('events').EventEmitter;
+var util = require('util');
+
+module.exports = Base;
+
+function Base() {
+  EventEmitter.call(this);
+  this.on('error', this.defaultErrorHandler.bind(this));
+}
+
+/**
+ * inherits from EventEmitter
+ */
+
+util.inherits(Base, EventEmitter);
+
+ready.mixin(Base.prototype);
+
+Base.prototype.defaultErrorHandler = function (err) {
+  if (this.listeners('error').length > 1) {
+    // ignore defaultErrorHandler
+    return;
+  }
+  console.error('\n[%s][pid: %s][%s][%s] %s: %s \nError Stack:\n  %s', Date(), process.pid, this.constructor.name, __filename, err.name, err.message, err.stack);
+
+  // try to show addition property on the error object
+  // e.g.: `err.data = {url: '/foo'};`
+  var additions = [];
+  for (var key in err) {
+    if (key === 'name' || key === 'message') {
+      continue;
+    }
+
+    additions.push(util.format('  %s: %j', key, err[key]));
+  }
+  if (additions.length) {
+    console.error('Error Additions:\n%s', additions.join('\n'));
+  }
+  console.error();
+};
+
+}).call(this,require('_process'),"/node_modules/sdk-base/index.js")
+},{"_process":345,"events":193,"get-ready":194,"util":384}],366:[function(require,module,exports){
+(function (process){
+'use strict';
+
+var _maxSafeInteger = require('babel-runtime/core-js/number/max-safe-integer');
+
+var _maxSafeInteger2 = _interopRequireDefault(_maxSafeInteger);
+
+var _typeof2 = require('babel-runtime/helpers/typeof');
+
+var _typeof3 = _interopRequireDefault(_typeof2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports = module.exports = SemVer;
+
+// The debug function is excluded entirely from the minified version.
+/* nomin */var debug;
+/* nomin */if ((typeof process === 'undefined' ? 'undefined' : (0, _typeof3.default)(process)) === 'object' &&
+/* nomin */process.env &&
+/* nomin */process.env.NODE_DEBUG &&
+/* nomin *//\bsemver\b/i.test(process.env.NODE_DEBUG))
+  /* nomin */debug = function debug() {
+    /* nomin */var args = Array.prototype.slice.call(arguments, 0);
+    /* nomin */args.unshift('SEMVER');
+    /* nomin */console.log.apply(console, args);
+    /* nomin */
+  };
+  /* nomin */else
+  /* nomin */debug = function debug() {};
+
+// Note: this is the semver.org version of the spec that it implements
+// Not necessarily the package version of this code.
+exports.SEMVER_SPEC_VERSION = '2.0.0';
+
+var MAX_LENGTH = 256;
+var MAX_SAFE_INTEGER = _maxSafeInteger2.default || 9007199254740991;
+
+// The actual regexps go on exports.re
+var re = exports.re = [];
+var src = exports.src = [];
+var R = 0;
+
+// The following Regular Expressions can be used for tokenizing,
+// validating, and parsing SemVer version strings.
+
+// ## Numeric Identifier
+// A single `0`, or a non-zero digit followed by zero or more digits.
+
+var NUMERICIDENTIFIER = R++;
+src[NUMERICIDENTIFIER] = '0|[1-9]\\d*';
+var NUMERICIDENTIFIERLOOSE = R++;
+src[NUMERICIDENTIFIERLOOSE] = '[0-9]+';
+
+// ## Non-numeric Identifier
+// Zero or more digits, followed by a letter or hyphen, and then zero or
+// more letters, digits, or hyphens.
+
+var NONNUMERICIDENTIFIER = R++;
+src[NONNUMERICIDENTIFIER] = '\\d*[a-zA-Z-][a-zA-Z0-9-]*';
+
+// ## Main Version
+// Three dot-separated numeric identifiers.
+
+var MAINVERSION = R++;
+src[MAINVERSION] = '(' + src[NUMERICIDENTIFIER] + ')\\.' + '(' + src[NUMERICIDENTIFIER] + ')\\.' + '(' + src[NUMERICIDENTIFIER] + ')';
+
+var MAINVERSIONLOOSE = R++;
+src[MAINVERSIONLOOSE] = '(' + src[NUMERICIDENTIFIERLOOSE] + ')\\.' + '(' + src[NUMERICIDENTIFIERLOOSE] + ')\\.' + '(' + src[NUMERICIDENTIFIERLOOSE] + ')';
+
+// ## Pre-release Version Identifier
+// A numeric identifier, or a non-numeric identifier.
+
+var PRERELEASEIDENTIFIER = R++;
+src[PRERELEASEIDENTIFIER] = '(?:' + src[NUMERICIDENTIFIER] + '|' + src[NONNUMERICIDENTIFIER] + ')';
+
+var PRERELEASEIDENTIFIERLOOSE = R++;
+src[PRERELEASEIDENTIFIERLOOSE] = '(?:' + src[NUMERICIDENTIFIERLOOSE] + '|' + src[NONNUMERICIDENTIFIER] + ')';
+
+// ## Pre-release Version
+// Hyphen, followed by one or more dot-separated pre-release version
+// identifiers.
+
+var PRERELEASE = R++;
+src[PRERELEASE] = '(?:-(' + src[PRERELEASEIDENTIFIER] + '(?:\\.' + src[PRERELEASEIDENTIFIER] + ')*))';
+
+var PRERELEASELOOSE = R++;
+src[PRERELEASELOOSE] = '(?:-?(' + src[PRERELEASEIDENTIFIERLOOSE] + '(?:\\.' + src[PRERELEASEIDENTIFIERLOOSE] + ')*))';
+
+// ## Build Metadata Identifier
+// Any combination of digits, letters, or hyphens.
+
+var BUILDIDENTIFIER = R++;
+src[BUILDIDENTIFIER] = '[0-9A-Za-z-]+';
+
+// ## Build Metadata
+// Plus sign, followed by one or more period-separated build metadata
+// identifiers.
+
+var BUILD = R++;
+src[BUILD] = '(?:\\+(' + src[BUILDIDENTIFIER] + '(?:\\.' + src[BUILDIDENTIFIER] + ')*))';
+
+// ## Full Version String
+// A main version, followed optionally by a pre-release version and
+// build metadata.
+
+// Note that the only major, minor, patch, and pre-release sections of
+// the version string are capturing groups.  The build metadata is not a
+// capturing group, because it should not ever be used in version
+// comparison.
+
+var FULL = R++;
+var FULLPLAIN = 'v?' + src[MAINVERSION] + src[PRERELEASE] + '?' + src[BUILD] + '?';
+
+src[FULL] = '^' + FULLPLAIN + '$';
+
+// like full, but allows v1.2.3 and =1.2.3, which people do sometimes.
+// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty
+// common in the npm registry.
+var LOOSEPLAIN = '[v=\\s]*' + src[MAINVERSIONLOOSE] + src[PRERELEASELOOSE] + '?' + src[BUILD] + '?';
+
+var LOOSE = R++;
+src[LOOSE] = '^' + LOOSEPLAIN + '$';
+
+var GTLT = R++;
+src[GTLT] = '((?:<|>)?=?)';
+
+// Something like "2.*" or "1.2.x".
+// Note that "x.x" is a valid xRange identifer, meaning "any version"
+// Only the first item is strictly required.
+var XRANGEIDENTIFIERLOOSE = R++;
+src[XRANGEIDENTIFIERLOOSE] = src[NUMERICIDENTIFIERLOOSE] + '|x|X|\\*';
+var XRANGEIDENTIFIER = R++;
+src[XRANGEIDENTIFIER] = src[NUMERICIDENTIFIER] + '|x|X|\\*';
+
+var XRANGEPLAIN = R++;
+src[XRANGEPLAIN] = '[v=\\s]*(' + src[XRANGEIDENTIFIER] + ')' + '(?:\\.(' + src[XRANGEIDENTIFIER] + ')' + '(?:\\.(' + src[XRANGEIDENTIFIER] + ')' + '(?:' + src[PRERELEASE] + ')?' + src[BUILD] + '?' + ')?)?';
+
+var XRANGEPLAINLOOSE = R++;
+src[XRANGEPLAINLOOSE] = '[v=\\s]*(' + src[XRANGEIDENTIFIERLOOSE] + ')' + '(?:\\.(' + src[XRANGEIDENTIFIERLOOSE] + ')' + '(?:\\.(' + src[XRANGEIDENTIFIERLOOSE] + ')' + '(?:' + src[PRERELEASELOOSE] + ')?' + src[BUILD] + '?' + ')?)?';
+
+var XRANGE = R++;
+src[XRANGE] = '^' + src[GTLT] + '\\s*' + src[XRANGEPLAIN] + '$';
+var XRANGELOOSE = R++;
+src[XRANGELOOSE] = '^' + src[GTLT] + '\\s*' + src[XRANGEPLAINLOOSE] + '$';
+
+// Tilde ranges.
+// Meaning is "reasonably at or greater than"
+var LONETILDE = R++;
+src[LONETILDE] = '(?:~>?)';
+
+var TILDETRIM = R++;
+src[TILDETRIM] = '(\\s*)' + src[LONETILDE] + '\\s+';
+re[TILDETRIM] = new RegExp(src[TILDETRIM], 'g');
+var tildeTrimReplace = '$1~';
+
+var TILDE = R++;
+src[TILDE] = '^' + src[LONETILDE] + src[XRANGEPLAIN] + '$';
+var TILDELOOSE = R++;
+src[TILDELOOSE] = '^' + src[LONETILDE] + src[XRANGEPLAINLOOSE] + '$';
+
+// Caret ranges.
+// Meaning is "at least and backwards compatible with"
+var LONECARET = R++;
+src[LONECARET] = '(?:\\^)';
+
+var CARETTRIM = R++;
+src[CARETTRIM] = '(\\s*)' + src[LONECARET] + '\\s+';
+re[CARETTRIM] = new RegExp(src[CARETTRIM], 'g');
+var caretTrimReplace = '$1^';
+
+var CARET = R++;
+src[CARET] = '^' + src[LONECARET] + src[XRANGEPLAIN] + '$';
+var CARETLOOSE = R++;
+src[CARETLOOSE] = '^' + src[LONECARET] + src[XRANGEPLAINLOOSE] + '$';
+
+// A simple gt/lt/eq thing, or just "" to indicate "any version"
+var COMPARATORLOOSE = R++;
+src[COMPARATORLOOSE] = '^' + src[GTLT] + '\\s*(' + LOOSEPLAIN + ')$|^$';
+var COMPARATOR = R++;
+src[COMPARATOR] = '^' + src[GTLT] + '\\s*(' + FULLPLAIN + ')$|^$';
+
+// An expression to strip any whitespace between the gtlt and the thing
+// it modifies, so that `> 1.2.3` ==> `>1.2.3`
+var COMPARATORTRIM = R++;
+src[COMPARATORTRIM] = '(\\s*)' + src[GTLT] + '\\s*(' + LOOSEPLAIN + '|' + src[XRANGEPLAIN] + ')';
+
+// this one has to use the /g flag
+re[COMPARATORTRIM] = new RegExp(src[COMPARATORTRIM], 'g');
+var comparatorTrimReplace = '$1$2$3';
+
+// Something like `1.2.3 - 1.2.4`
+// Note that these all use the loose form, because they'll be
+// checked against either the strict or loose comparator form
+// later.
+var HYPHENRANGE = R++;
+src[HYPHENRANGE] = '^\\s*(' + src[XRANGEPLAIN] + ')' + '\\s+-\\s+' + '(' + src[XRANGEPLAIN] + ')' + '\\s*$';
+
+var HYPHENRANGELOOSE = R++;
+src[HYPHENRANGELOOSE] = '^\\s*(' + src[XRANGEPLAINLOOSE] + ')' + '\\s+-\\s+' + '(' + src[XRANGEPLAINLOOSE] + ')' + '\\s*$';
+
+// Star ranges basically just allow anything at all.
+var STAR = R++;
+src[STAR] = '(<|>)?=?\\s*\\*';
+
+// Compile to actual regexp objects.
+// All are flag-free, unless they were created above with a flag.
+for (var i = 0; i < R; i++) {
+  debug(i, src[i]);
+  if (!re[i]) re[i] = new RegExp(src[i]);
+}
+
+exports.parse = parse;
+function parse(version, loose) {
+  if (version instanceof SemVer) return version;
+
+  if (typeof version !== 'string') return null;
+
+  if (version.length > MAX_LENGTH) return null;
+
+  var r = loose ? re[LOOSE] : re[FULL];
+  if (!r.test(version)) return null;
+
+  try {
+    return new SemVer(version, loose);
+  } catch (er) {
+    return null;
+  }
+}
+
+exports.valid = valid;
+function valid(version, loose) {
+  var v = parse(version, loose);
+  return v ? v.version : null;
+}
+
+exports.clean = clean;
+function clean(version, loose) {
+  var s = parse(version.trim().replace(/^[=v]+/, ''), loose);
+  return s ? s.version : null;
+}
+
+exports.SemVer = SemVer;
+
+function SemVer(version, loose) {
+  if (version instanceof SemVer) {
+    if (version.loose === loose) return version;else version = version.version;
+  } else if (typeof version !== 'string') {
+    throw new TypeError('Invalid Version: ' + version);
+  }
+
+  if (version.length > MAX_LENGTH) throw new TypeError('version is longer than ' + MAX_LENGTH + ' characters');
+
+  if (!(this instanceof SemVer)) return new SemVer(version, loose);
+
+  debug('SemVer', version, loose);
+  this.loose = loose;
+  var m = version.trim().match(loose ? re[LOOSE] : re[FULL]);
+
+  if (!m) throw new TypeError('Invalid Version: ' + version);
+
+  this.raw = version;
+
+  // these are actually numbers
+  this.major = +m[1];
+  this.minor = +m[2];
+  this.patch = +m[3];
+
+  if (this.major > MAX_SAFE_INTEGER || this.major < 0) throw new TypeError('Invalid major version');
+
+  if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) throw new TypeError('Invalid minor version');
+
+  if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) throw new TypeError('Invalid patch version');
+
+  // numberify any prerelease numeric ids
+  if (!m[4]) this.prerelease = [];else this.prerelease = m[4].split('.').map(function (id) {
+    if (/^[0-9]+$/.test(id)) {
+      var num = +id;
+      if (num >= 0 && num < MAX_SAFE_INTEGER) return num;
+    }
+    return id;
+  });
+
+  this.build = m[5] ? m[5].split('.') : [];
+  this.format();
+}
+
+SemVer.prototype.format = function () {
+  this.version = this.major + '.' + this.minor + '.' + this.patch;
+  if (this.prerelease.length) this.version += '-' + this.prerelease.join('.');
+  return this.version;
+};
+
+SemVer.prototype.toString = function () {
+  return this.version;
+};
+
+SemVer.prototype.compare = function (other) {
+  debug('SemVer.compare', this.version, this.loose, other);
+  if (!(other instanceof SemVer)) other = new SemVer(other, this.loose);
+
+  return this.compareMain(other) || this.comparePre(other);
+};
+
+SemVer.prototype.compareMain = function (other) {
+  if (!(other instanceof SemVer)) other = new SemVer(other, this.loose);
+
+  return compareIdentifiers(this.major, other.major) || compareIdentifiers(this.minor, other.minor) || compareIdentifiers(this.patch, other.patch);
+};
+
+SemVer.prototype.comparePre = function (other) {
+  if (!(other instanceof SemVer)) other = new SemVer(other, this.loose);
+
+  // NOT having a prerelease is > having one
+  if (this.prerelease.length && !other.prerelease.length) return -1;else if (!this.prerelease.length && other.prerelease.length) return 1;else if (!this.prerelease.length && !other.prerelease.length) return 0;
+
+  var i = 0;
+  do {
+    var a = this.prerelease[i];
+    var b = other.prerelease[i];
+    debug('prerelease compare', i, a, b);
+    if (a === undefined && b === undefined) return 0;else if (b === undefined) return 1;else if (a === undefined) return -1;else if (a === b) continue;else return compareIdentifiers(a, b);
+  } while (++i);
+};
+
+// preminor will bump the version up to the next minor release, and immediately
+// down to pre-release. premajor and prepatch work the same way.
+SemVer.prototype.inc = function (release, identifier) {
+  switch (release) {
+    case 'premajor':
+      this.prerelease.length = 0;
+      this.patch = 0;
+      this.minor = 0;
+      this.major++;
+      this.inc('pre', identifier);
+      break;
+    case 'preminor':
+      this.prerelease.length = 0;
+      this.patch = 0;
+      this.minor++;
+      this.inc('pre', identifier);
+      break;
+    case 'prepatch':
+      // If this is already a prerelease, it will bump to the next version
+      // drop any prereleases that might already exist, since they are not
+      // relevant at this point.
+      this.prerelease.length = 0;
+      this.inc('patch', identifier);
+      this.inc('pre', identifier);
+      break;
+    // If the input is a non-prerelease version, this acts the same as
+    // prepatch.
+    case 'prerelease':
+      if (this.prerelease.length === 0) this.inc('patch', identifier);
+      this.inc('pre', identifier);
+      break;
+
+    case 'major':
+      // If this is a pre-major version, bump up to the same major version.
+      // Otherwise increment major.
+      // 1.0.0-5 bumps to 1.0.0
+      // 1.1.0 bumps to 2.0.0
+      if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) this.major++;
+      this.minor = 0;
+      this.patch = 0;
+      this.prerelease = [];
+      break;
+    case 'minor':
+      // If this is a pre-minor version, bump up to the same minor version.
+      // Otherwise increment minor.
+      // 1.2.0-5 bumps to 1.2.0
+      // 1.2.1 bumps to 1.3.0
+      if (this.patch !== 0 || this.prerelease.length === 0) this.minor++;
+      this.patch = 0;
+      this.prerelease = [];
+      break;
+    case 'patch':
+      // If this is not a pre-release version, it will increment the patch.
+      // If it is a pre-release it will bump up to the same patch version.
+      // 1.2.0-5 patches to 1.2.0
+      // 1.2.0 patches to 1.2.1
+      if (this.prerelease.length === 0) this.patch++;
+      this.prerelease = [];
+      break;
+    // This probably shouldn't be used publicly.
+    // 1.0.0 "pre" would become 1.0.0-0 which is the wrong direction.
+    case 'pre':
+      if (this.prerelease.length === 0) this.prerelease = [0];else {
+        var i = this.prerelease.length;
+        while (--i >= 0) {
+          if (typeof this.prerelease[i] === 'number') {
+            this.prerelease[i]++;
+            i = -2;
+          }
+        }
+        if (i === -1) // didn't increment anything
+          this.prerelease.push(0);
+      }
+      if (identifier) {
+        // 1.2.0-beta.1 bumps to 1.2.0-beta.2,
+        // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0
+        if (this.prerelease[0] === identifier) {
+          if (isNaN(this.prerelease[1])) this.prerelease = [identifier, 0];
+        } else this.prerelease = [identifier, 0];
+      }
+      break;
+
+    default:
+      throw new Error('invalid increment argument: ' + release);
+  }
+  this.format();
+  this.raw = this.version;
+  return this;
+};
+
+exports.inc = inc;
+function inc(version, release, loose, identifier) {
+  if (typeof loose === 'string') {
+    identifier = loose;
+    loose = undefined;
+  }
+
+  try {
+    return new SemVer(version, loose).inc(release, identifier).version;
+  } catch (er) {
+    return null;
+  }
+}
+
+exports.diff = diff;
+function diff(version1, version2) {
+  if (eq(version1, version2)) {
+    return null;
+  } else {
+    var v1 = parse(version1);
+    var v2 = parse(version2);
+    if (v1.prerelease.length || v2.prerelease.length) {
+      for (var key in v1) {
+        if (key === 'major' || key === 'minor' || key === 'patch') {
+          if (v1[key] !== v2[key]) {
+            return 'pre' + key;
+          }
+        }
+      }
+      return 'prerelease';
+    }
+    for (var key in v1) {
+      if (key === 'major' || key === 'minor' || key === 'patch') {
+        if (v1[key] !== v2[key]) {
+          return key;
+        }
+      }
+    }
+  }
+}
+
+exports.compareIdentifiers = compareIdentifiers;
+
+var numeric = /^[0-9]+$/;
+function compareIdentifiers(a, b) {
+  var anum = numeric.test(a);
+  var bnum = numeric.test(b);
+
+  if (anum && bnum) {
+    a = +a;
+    b = +b;
+  }
+
+  return anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : a > b ? 1 : 0;
+}
+
+exports.rcompareIdentifiers = rcompareIdentifiers;
+function rcompareIdentifiers(a, b) {
+  return compareIdentifiers(b, a);
+}
+
+exports.major = major;
+function major(a, loose) {
+  return new SemVer(a, loose).major;
+}
+
+exports.minor = minor;
+function minor(a, loose) {
+  return new SemVer(a, loose).minor;
+}
+
+exports.patch = patch;
+function patch(a, loose) {
+  return new SemVer(a, loose).patch;
+}
+
+exports.compare = compare;
+function compare(a, b, loose) {
+  return new SemVer(a, loose).compare(b);
+}
+
+exports.compareLoose = compareLoose;
+function compareLoose(a, b) {
+  return compare(a, b, true);
+}
+
+exports.rcompare = rcompare;
+function rcompare(a, b, loose) {
+  return compare(b, a, loose);
+}
+
+exports.sort = sort;
+function sort(list, loose) {
+  return list.sort(function (a, b) {
+    return exports.compare(a, b, loose);
+  });
+}
+
+exports.rsort = rsort;
+function rsort(list, loose) {
+  return list.sort(function (a, b) {
+    return exports.rcompare(a, b, loose);
+  });
+}
+
+exports.gt = gt;
+function gt(a, b, loose) {
+  return compare(a, b, loose) > 0;
+}
+
+exports.lt = lt;
+function lt(a, b, loose) {
+  return compare(a, b, loose) < 0;
+}
+
+exports.eq = eq;
+function eq(a, b, loose) {
+  return compare(a, b, loose) === 0;
+}
+
+exports.neq = neq;
+function neq(a, b, loose) {
+  return compare(a, b, loose) !== 0;
+}
+
+exports.gte = gte;
+function gte(a, b, loose) {
+  return compare(a, b, loose) >= 0;
+}
+
+exports.lte = lte;
+function lte(a, b, loose) {
+  return compare(a, b, loose) <= 0;
+}
+
+exports.cmp = cmp;
+function cmp(a, op, b, loose) {
+  var ret;
+  switch (op) {
+    case '===':
+      if ((typeof a === 'undefined' ? 'undefined' : (0, _typeof3.default)(a)) === 'object') a = a.version;
+      if ((typeof b === 'undefined' ? 'undefined' : (0, _typeof3.default)(b)) === 'object') b = b.version;
+      ret = a === b;
+      break;
+    case '!==':
+      if ((typeof a === 'undefined' ? 'undefined' : (0, _typeof3.default)(a)) === 'object') a = a.version;
+      if ((typeof b === 'undefined' ? 'undefined' : (0, _typeof3.default)(b)) === 'object') b = b.version;
+      ret = a !== b;
+      break;
+    case '':case '=':case '==':
+      ret = eq(a, b, loose);break;
+    case '!=':
+      ret = neq(a, b, loose);break;
+    case '>':
+      ret = gt(a, b, loose);break;
+    case '>=':
+      ret = gte(a, b, loose);break;
+    case '<':
+      ret = lt(a, b, loose);break;
+    case '<=':
+      ret = lte(a, b, loose);break;
+    default:
+      throw new TypeError('Invalid operator: ' + op);
+  }
+  return ret;
+}
+
+exports.Comparator = Comparator;
+function Comparator(comp, loose) {
+  if (comp instanceof Comparator) {
+    if (comp.loose === loose) return comp;else comp = comp.value;
+  }
+
+  if (!(this instanceof Comparator)) return new Comparator(comp, loose);
+
+  debug('comparator', comp, loose);
+  this.loose = loose;
+  this.parse(comp);
+
+  if (this.semver === ANY) this.value = '';else this.value = this.operator + this.semver.version;
+
+  debug('comp', this);
+}
+
+var ANY = {};
+Comparator.prototype.parse = function (comp) {
+  var r = this.loose ? re[COMPARATORLOOSE] : re[COMPARATOR];
+  var m = comp.match(r);
+
+  if (!m) throw new TypeError('Invalid comparator: ' + comp);
+
+  this.operator = m[1];
+  if (this.operator === '=') this.operator = '';
+
+  // if it literally is just '>' or '' then allow anything.
+  if (!m[2]) this.semver = ANY;else this.semver = new SemVer(m[2], this.loose);
+};
+
+Comparator.prototype.toString = function () {
+  return this.value;
+};
+
+Comparator.prototype.test = function (version) {
+  debug('Comparator.test', version, this.loose);
+
+  if (this.semver === ANY) return true;
+
+  if (typeof version === 'string') version = new SemVer(version, this.loose);
+
+  return cmp(version, this.operator, this.semver, this.loose);
+};
+
+exports.Range = Range;
+function Range(range, loose) {
+  if (range instanceof Range && range.loose === loose) return range;
+
+  if (!(this instanceof Range)) return new Range(range, loose);
+
+  this.loose = loose;
+
+  // First, split based on boolean or ||
+  this.raw = range;
+  this.set = range.split(/\s*\|\|\s*/).map(function (range) {
+    return this.parseRange(range.trim());
+  }, this).filter(function (c) {
+    // throw out any that are not relevant for whatever reason
+    return c.length;
+  });
+
+  if (!this.set.length) {
+    throw new TypeError('Invalid SemVer Range: ' + range);
+  }
+
+  this.format();
+}
+
+Range.prototype.format = function () {
+  this.range = this.set.map(function (comps) {
+    return comps.join(' ').trim();
+  }).join('||').trim();
+  return this.range;
+};
+
+Range.prototype.toString = function () {
+  return this.range;
+};
+
+Range.prototype.parseRange = function (range) {
+  var loose = this.loose;
+  range = range.trim();
+  debug('range', range, loose);
+  // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`
+  var hr = loose ? re[HYPHENRANGELOOSE] : re[HYPHENRANGE];
+  range = range.replace(hr, hyphenReplace);
+  debug('hyphen replace', range);
+  // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`
+  range = range.replace(re[COMPARATORTRIM], comparatorTrimReplace);
+  debug('comparator trim', range, re[COMPARATORTRIM]);
+
+  // `~ 1.2.3` => `~1.2.3`
+  range = range.replace(re[TILDETRIM], tildeTrimReplace);
+
+  // `^ 1.2.3` => `^1.2.3`
+  range = range.replace(re[CARETTRIM], caretTrimReplace);
+
+  // normalize spaces
+  range = range.split(/\s+/).join(' ');
+
+  // At this point, the range is completely trimmed and
+  // ready to be split into comparators.
+
+  var compRe = loose ? re[COMPARATORLOOSE] : re[COMPARATOR];
+  var set = range.split(' ').map(function (comp) {
+    return parseComparator(comp, loose);
+  }).join(' ').split(/\s+/);
+  if (this.loose) {
+    // in loose mode, throw out any that are not valid comparators
+    set = set.filter(function (comp) {
+      return !!comp.match(compRe);
+    });
+  }
+  set = set.map(function (comp) {
+    return new Comparator(comp, loose);
+  });
+
+  return set;
+};
+
+// Mostly just for testing and legacy API reasons
+exports.toComparators = toComparators;
+function toComparators(range, loose) {
+  return new Range(range, loose).set.map(function (comp) {
+    return comp.map(function (c) {
+      return c.value;
+    }).join(' ').trim().split(' ');
+  });
+}
+
+// comprised of xranges, tildes, stars, and gtlt's at this point.
+// already replaced the hyphen ranges
+// turn into a set of JUST comparators.
+function parseComparator(comp, loose) {
+  debug('comp', comp);
+  comp = replaceCarets(comp, loose);
+  debug('caret', comp);
+  comp = replaceTildes(comp, loose);
+  debug('tildes', comp);
+  comp = replaceXRanges(comp, loose);
+  debug('xrange', comp);
+  comp = replaceStars(comp, loose);
+  debug('stars', comp);
+  return comp;
+}
+
+function isX(id) {
+  return !id || id.toLowerCase() === 'x' || id === '*';
+}
+
+// ~, ~> --> * (any, kinda silly)
+// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0
+// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0
+// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0
+// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0
+// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0
+function replaceTildes(comp, loose) {
+  return comp.trim().split(/\s+/).map(function (comp) {
+    return replaceTilde(comp, loose);
+  }).join(' ');
+}
+
+function replaceTilde(comp, loose) {
+  var r = loose ? re[TILDELOOSE] : re[TILDE];
+  return comp.replace(r, function (_, M, m, p, pr) {
+    debug('tilde', comp, _, M, m, p, pr);
+    var ret;
+
+    if (isX(M)) ret = '';else if (isX(m)) ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0';else if (isX(p))
+      // ~1.2 == >=1.2.0 <1.3.0
+      ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0';else if (pr) {
+      debug('replaceTilde pr', pr);
+      if (pr.charAt(0) !== '-') pr = '-' + pr;
+      ret = '>=' + M + '.' + m + '.' + p + pr + ' <' + M + '.' + (+m + 1) + '.0';
+    } else
+      // ~1.2.3 == >=1.2.3 <1.3.0
+      ret = '>=' + M + '.' + m + '.' + p + ' <' + M + '.' + (+m + 1) + '.0';
+
+    debug('tilde return', ret);
+    return ret;
+  });
+}
+
+// ^ --> * (any, kinda silly)
+// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0
+// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0
+// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0
+// ^1.2.3 --> >=1.2.3 <2.0.0
+// ^1.2.0 --> >=1.2.0 <2.0.0
+function replaceCarets(comp, loose) {
+  return comp.trim().split(/\s+/).map(function (comp) {
+    return replaceCaret(comp, loose);
+  }).join(' ');
+}
+
+function replaceCaret(comp, loose) {
+  debug('caret', comp, loose);
+  var r = loose ? re[CARETLOOSE] : re[CARET];
+  return comp.replace(r, function (_, M, m, p, pr) {
+    debug('caret', comp, _, M, m, p, pr);
+    var ret;
+
+    if (isX(M)) ret = '';else if (isX(m)) ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0';else if (isX(p)) {
+      if (M === '0') ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0';else ret = '>=' + M + '.' + m + '.0 <' + (+M + 1) + '.0.0';
+    } else if (pr) {
+      debug('replaceCaret pr', pr);
+      if (pr.charAt(0) !== '-') pr = '-' + pr;
+      if (M === '0') {
+        if (m === '0') ret = '>=' + M + '.' + m + '.' + p + pr + ' <' + M + '.' + m + '.' + (+p + 1);else ret = '>=' + M + '.' + m + '.' + p + pr + ' <' + M + '.' + (+m + 1) + '.0';
+      } else ret = '>=' + M + '.' + m + '.' + p + pr + ' <' + (+M + 1) + '.0.0';
+    } else {
+      debug('no pr');
+      if (M === '0') {
+        if (m === '0') ret = '>=' + M + '.' + m + '.' + p + ' <' + M + '.' + m + '.' + (+p + 1);else ret = '>=' + M + '.' + m + '.' + p + ' <' + M + '.' + (+m + 1) + '.0';
+      } else ret = '>=' + M + '.' + m + '.' + p + ' <' + (+M + 1) + '.0.0';
+    }
+
+    debug('caret return', ret);
+    return ret;
+  });
+}
+
+function replaceXRanges(comp, loose) {
+  debug('replaceXRanges', comp, loose);
+  return comp.split(/\s+/).map(function (comp) {
+    return replaceXRange(comp, loose);
+  }).join(' ');
+}
+
+function replaceXRange(comp, loose) {
+  comp = comp.trim();
+  var r = loose ? re[XRANGELOOSE] : re[XRANGE];
+  return comp.replace(r, function (ret, gtlt, M, m, p, pr) {
+    debug('xRange', comp, ret, gtlt, M, m, p, pr);
+    var xM = isX(M);
+    var xm = xM || isX(m);
+    var xp = xm || isX(p);
+    var anyX = xp;
+
+    if (gtlt === '=' && anyX) gtlt = '';
+
+    if (xM) {
+      if (gtlt === '>' || gtlt === '<') {
+        // nothing is allowed
+        ret = '<0.0.0';
+      } else {
+        // nothing is forbidden
+        ret = '*';
+      }
+    } else if (gtlt && anyX) {
+      // replace X with 0
+      if (xm) m = 0;
+      if (xp) p = 0;
+
+      if (gtlt === '>') {
+        // >1 => >=2.0.0
+        // >1.2 => >=1.3.0
+        // >1.2.3 => >= 1.2.4
+        gtlt = '>=';
+        if (xm) {
+          M = +M + 1;
+          m = 0;
+          p = 0;
+        } else if (xp) {
+          m = +m + 1;
+          p = 0;
+        }
+      } else if (gtlt === '<=') {
+        // <=0.7.x is actually <0.8.0, since any 0.7.x should
+        // pass.  Similarly, <=7.x is actually <8.0.0, etc.
+        gtlt = '<';
+        if (xm) M = +M + 1;else m = +m + 1;
+      }
+
+      ret = gtlt + M + '.' + m + '.' + p;
+    } else if (xm) {
+      ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0';
+    } else if (xp) {
+      ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0';
+    }
+
+    debug('xRange return', ret);
+
+    return ret;
+  });
+}
+
+// Because * is AND-ed with everything else in the comparator,
+// and '' means "any version", just remove the *s entirely.
+function replaceStars(comp, loose) {
+  debug('replaceStars', comp, loose);
+  // Looseness is ignored here.  star is always as loose as it gets!
+  return comp.trim().replace(re[STAR], '');
+}
+
+// This function is passed to string.replace(re[HYPHENRANGE])
+// M, m, patch, prerelease, build
+// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5
+// 1.2.3 - 3.4 => >=1.2.0 <3.5.0 Any 3.4.x will do
+// 1.2 - 3.4 => >=1.2.0 <3.5.0
+function hyphenReplace($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr, tb) {
+
+  if (isX(fM)) from = '';else if (isX(fm)) from = '>=' + fM + '.0.0';else if (isX(fp)) from = '>=' + fM + '.' + fm + '.0';else from = '>=' + from;
+
+  if (isX(tM)) to = '';else if (isX(tm)) to = '<' + (+tM + 1) + '.0.0';else if (isX(tp)) to = '<' + tM + '.' + (+tm + 1) + '.0';else if (tpr) to = '<=' + tM + '.' + tm + '.' + tp + '-' + tpr;else to = '<=' + to;
+
+  return (from + ' ' + to).trim();
+}
+
+// if ANY of the sets match ALL of its comparators, then pass
+Range.prototype.test = function (version) {
+  if (!version) return false;
+
+  if (typeof version === 'string') version = new SemVer(version, this.loose);
+
+  for (var i = 0; i < this.set.length; i++) {
+    if (testSet(this.set[i], version)) return true;
+  }
+  return false;
+};
+
+function testSet(set, version) {
+  for (var i = 0; i < set.length; i++) {
+    if (!set[i].test(version)) return false;
+  }
+
+  if (version.prerelease.length) {
+    // Find the set of versions that are allowed to have prereleases
+    // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0
+    // That should allow `1.2.3-pr.2` to pass.
+    // However, `1.2.4-alpha.notready` should NOT be allowed,
+    // even though it's within the range set by the comparators.
+    for (var i = 0; i < set.length; i++) {
+      debug(set[i].semver);
+      if (set[i].semver === ANY) continue;
+
+      if (set[i].semver.prerelease.length > 0) {
+        var allowed = set[i].semver;
+        if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) return true;
+      }
+    }
+
+    // Version has a -pre, but it's not one of the ones we like.
+    return false;
+  }
+
+  return true;
+}
+
+exports.satisfies = satisfies;
+function satisfies(version, range, loose) {
+  try {
+    range = new Range(range, loose);
+  } catch (er) {
+    return false;
+  }
+  return range.test(version);
+}
+
+exports.maxSatisfying = maxSatisfying;
+function maxSatisfying(versions, range, loose) {
+  return versions.filter(function (version) {
+    return satisfies(version, range, loose);
+  }).sort(function (a, b) {
+    return rcompare(a, b, loose);
+  })[0] || null;
+}
+
+exports.minSatisfying = minSatisfying;
+function minSatisfying(versions, range, loose) {
+  return versions.filter(function (version) {
+    return satisfies(version, range, loose);
+  }).sort(function (a, b) {
+    return compare(a, b, loose);
+  })[0] || null;
+}
+
+exports.validRange = validRange;
+function validRange(range, loose) {
+  try {
+    // Return '*' instead of '' so that truthiness works.
+    // This will throw if it's invalid anyway
+    return new Range(range, loose).range || '*';
+  } catch (er) {
+    return null;
+  }
+}
+
+// Determine if version is less than all the versions possible in the range
+exports.ltr = ltr;
+function ltr(version, range, loose) {
+  return outside(version, range, '<', loose);
+}
+
+// Determine if version is greater than all the versions possible in the range.
+exports.gtr = gtr;
+function gtr(version, range, loose) {
+  return outside(version, range, '>', loose);
+}
+
+exports.outside = outside;
+function outside(version, range, hilo, loose) {
+  version = new SemVer(version, loose);
+  range = new Range(range, loose);
+
+  var gtfn, ltefn, ltfn, comp, ecomp;
+  switch (hilo) {
+    case '>':
+      gtfn = gt;
+      ltefn = lte;
+      ltfn = lt;
+      comp = '>';
+      ecomp = '>=';
+      break;
+    case '<':
+      gtfn = lt;
+      ltefn = gte;
+      ltfn = gt;
+      comp = '<';
+      ecomp = '<=';
+      break;
+    default:
+      throw new TypeError('Must provide a hilo val of "<" or ">"');
+  }
+
+  // If it satisifes the range it is not outside
+  if (satisfies(version, range, loose)) {
+    return false;
+  }
+
+  // From now on, variable terms are as if we're in "gtr" mode.
+  // but note that everything is flipped for the "ltr" function.
+
+  for (var i = 0; i < range.set.length; ++i) {
+    var comparators = range.set[i];
+
+    var high = null;
+    var low = null;
+
+    comparators.forEach(function (comparator) {
+      if (comparator.semver === ANY) {
+        comparator = new Comparator('>=0.0.0');
+      }
+      high = high || comparator;
+      low = low || comparator;
+      if (gtfn(comparator.semver, high.semver, loose)) {
+        high = comparator;
+      } else if (ltfn(comparator.semver, low.semver, loose)) {
+        low = comparator;
+      }
+    });
+
+    // If the edge version comparator has a operator then our version
+    // isn't outside it
+    if (high.operator === comp || high.operator === ecomp) {
+      return false;
+    }
+
+    // If the lowest version comparator has an operator and our version
+    // is less than it then it isn't higher than the range
+    if ((!low.operator || low.operator === comp) && ltefn(version, low.semver)) {
+      return false;
+    } else if (low.operator === ecomp && ltfn(version, low.semver)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+exports.prerelease = prerelease;
+function prerelease(version, loose) {
+  var parsed = parse(version, loose);
+  return parsed && parsed.prerelease.length ? parsed.prerelease : null;
+}
+
+}).call(this,require('_process'))
+},{"_process":345,"babel-runtime/core-js/number/max-safe-integer":21,"babel-runtime/helpers/typeof":39}],367:[function(require,module,exports){
+module.exports={
+  "100": "Continue",
+  "101": "Switching Protocols",
+  "102": "Processing",
+  "200": "OK",
+  "201": "Created",
+  "202": "Accepted",
+  "203": "Non-Authoritative Information",
+  "204": "No Content",
+  "205": "Reset Content",
+  "206": "Partial Content",
+  "207": "Multi-Status",
+  "208": "Already Reported",
+  "226": "IM Used",
+  "300": "Multiple Choices",
+  "301": "Moved Permanently",
+  "302": "Found",
+  "303": "See Other",
+  "304": "Not Modified",
+  "305": "Use Proxy",
+  "306": "(Unused)",
+  "307": "Temporary Redirect",
+  "308": "Permanent Redirect",
+  "400": "Bad Request",
+  "401": "Unauthorized",
+  "402": "Payment Required",
+  "403": "Forbidden",
+  "404": "Not Found",
+  "405": "Method Not Allowed",
+  "406": "Not Acceptable",
+  "407": "Proxy Authentication Required",
+  "408": "Request Timeout",
+  "409": "Conflict",
+  "410": "Gone",
+  "411": "Length Required",
+  "412": "Precondition Failed",
+  "413": "Payload Too Large",
+  "414": "URI Too Long",
+  "415": "Unsupported Media Type",
+  "416": "Range Not Satisfiable",
+  "417": "Expectation Failed",
+  "418": "I'm a teapot",
+  "421": "Misdirected Request",
+  "422": "Unprocessable Entity",
+  "423": "Locked",
+  "424": "Failed Dependency",
+  "425": "Unordered Collection",
+  "426": "Upgrade Required",
+  "428": "Precondition Required",
+  "429": "Too Many Requests",
+  "431": "Request Header Fields Too Large",
+  "451": "Unavailable For Legal Reasons",
+  "500": "Internal Server Error",
+  "501": "Not Implemented",
+  "502": "Bad Gateway",
+  "503": "Service Unavailable",
+  "504": "Gateway Timeout",
+  "505": "HTTP Version Not Supported",
+  "506": "Variant Also Negotiates",
+  "507": "Insufficient Storage",
+  "508": "Loop Detected",
+  "509": "Bandwidth Limit Exceeded",
+  "510": "Not Extended",
+  "511": "Network Authentication Required"
+}
+},{}],368:[function(require,module,exports){
+/*!
+ * statuses
+ * Copyright(c) 2014 Jonathan Ong
+ * Copyright(c) 2016 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+'use strict';
+
+/**
+ * Module dependencies.
+ * @private
+ */
+
+var _keys = require('babel-runtime/core-js/object/keys');
+
+var _keys2 = _interopRequireDefault(_keys);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var codes = require('./codes.json');
+
+/**
+ * Module exports.
+ * @public
+ */
+
+module.exports = status;
+
+// array of status codes
+status.codes = populateStatusesMap(status, codes);
+
+// status codes for redirects
+status.redirect = {
+  300: true,
+  301: true,
+  302: true,
+  303: true,
+  305: true,
+  307: true,
+  308: true
+};
+
+// status codes for empty bodies
+status.empty = {
+  204: true,
+  205: true,
+  304: true
+};
+
+// status codes for when you should retry the request
+status.retry = {
+  502: true,
+  503: true,
+  504: true
+};
+
+/**
+ * Populate the statuses map for given codes.
+ * @private
+ */
+
+function populateStatusesMap(statuses, codes) {
+  var arr = [];
+
+  (0, _keys2.default)(codes).forEach(function forEachCode(code) {
+    var message = codes[code];
+    var status = Number(code);
+
+    // Populate properties
+    statuses[status] = message;
+    statuses[message] = status;
+    statuses[message.toLowerCase()] = status;
+
+    // Add to array
+    arr.push(status);
+  });
+
+  return arr;
+}
+
+/**
+ * Get the status code.
+ *
+ * Given a number, this will throw if it is not a known status
+ * code, otherwise the code will be returned. Given a string,
+ * the string will be parsed for a number and return the code
+ * if valid, otherwise will lookup the code assuming this is
+ * the status message.
+ *
+ * @param {string|number} code
+ * @returns {string}
+ * @public
+ */
+
+function status(code) {
+  if (typeof code === 'number') {
+    if (!status[code]) throw new Error('invalid status code: ' + code);
+    return code;
+  }
+
+  if (typeof code !== 'string') {
+    throw new TypeError('code must be a number or string');
+  }
+
+  // '403'
+  var n = parseInt(code, 10);
+  if (!isNaN(n)) {
+    if (!status[n]) throw new Error('invalid status code: ' + n);
+    return n;
+  }
+
+  n = status[code.toLowerCase()];
+  if (!n) throw new Error('invalid status message: "' + code + '"');
+  return n;
+}
+
+},{"./codes.json":367,"babel-runtime/core-js/object/keys":30}],369:[function(require,module,exports){
+'use strict';
+
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+module.exports = Stream;
+
+var EE = require('events').EventEmitter;
+var inherits = require('inherits');
+
+inherits(Stream, EE);
+Stream.Readable = require('readable-stream/readable.js');
+Stream.Writable = require('readable-stream/writable.js');
+Stream.Duplex = require('readable-stream/duplex.js');
+Stream.Transform = require('readable-stream/transform.js');
+Stream.PassThrough = require('readable-stream/passthrough.js');
+
+// Backwards-compat with node 0.4.x
+Stream.Stream = Stream;
+
+// old-style streams.  Note that the pipe method (the only relevant
+// part of this class) is overridden in the Readable class.
+
+function Stream() {
+  EE.call(this);
+}
+
+Stream.prototype.pipe = function (dest, options) {
+  var source = this;
+
+  function ondata(chunk) {
+    if (dest.writable) {
+      if (false === dest.write(chunk) && source.pause) {
+        source.pause();
+      }
+    }
+  }
+
+  source.on('data', ondata);
+
+  function ondrain() {
+    if (source.readable && source.resume) {
+      source.resume();
+    }
+  }
+
+  dest.on('drain', ondrain);
+
+  // If the 'end' option is not supplied, dest.end() will be called when
+  // source gets the 'end' or 'close' events.  Only dest.end() once.
+  if (!dest._isStdio && (!options || options.end !== false)) {
+    source.on('end', onend);
+    source.on('close', onclose);
+  }
+
+  var didOnEnd = false;
+  function onend() {
+    if (didOnEnd) return;
+    didOnEnd = true;
+
+    dest.end();
+  }
+
+  function onclose() {
+    if (didOnEnd) return;
+    didOnEnd = true;
+
+    if (typeof dest.destroy === 'function') dest.destroy();
+  }
+
+  // don't leave dangling pipes when there are errors.
+  function onerror(er) {
+    cleanup();
+    if (EE.listenerCount(this, 'error') === 0) {
+      throw er; // Unhandled stream error in pipe.
+    }
+  }
+
+  source.on('error', onerror);
+  dest.on('error', onerror);
+
+  // remove all the event listeners that were added.
+  function cleanup() {
+    source.removeListener('data', ondata);
+    dest.removeListener('drain', ondrain);
+
+    source.removeListener('end', onend);
+    source.removeListener('close', onclose);
+
+    source.removeListener('error', onerror);
+    dest.removeListener('error', onerror);
+
+    source.removeListener('end', cleanup);
+    source.removeListener('close', cleanup);
+
+    dest.removeListener('close', cleanup);
+  }
+
+  source.on('end', cleanup);
+  source.on('close', cleanup);
+
+  dest.on('close', cleanup);
+
+  dest.emit('pipe', source);
+
+  // Allow for unix-like usage: A.pipe(B).pipe(C)
+  return dest;
+};
+
+},{"events":193,"inherits":198,"readable-stream/duplex.js":350,"readable-stream/passthrough.js":358,"readable-stream/readable.js":359,"readable-stream/transform.js":360,"readable-stream/writable.js":361}],370:[function(require,module,exports){
+(function (global){
+'use strict';
+
+var ClientRequest = require('./lib/request');
+var extend = require('xtend');
+var statusCodes = require('builtin-status-codes');
+var url = require('url');
+
+var http = exports;
+
+http.request = function (opts, cb) {
+	if (typeof opts === 'string') opts = url.parse(opts);else opts = extend(opts);
+
+	// Normally, the page is loaded from http or https, so not specifying a protocol
+	// will result in a (valid) protocol-relative url. However, this won't work if
+	// the protocol is something else, like 'file:'
+	var defaultProtocol = global.location.protocol.search(/^https?:$/) === -1 ? 'http:' : '';
+
+	var protocol = opts.protocol || defaultProtocol;
+	var host = opts.hostname || opts.host;
+	var port = opts.port;
+	var path = opts.path || '/';
+
+	// Necessary for IPv6 addresses
+	if (host && host.indexOf(':') !== -1) host = '[' + host + ']';
+
+	// This may be a relative url. The browser should always be able to interpret it correctly.
+	opts.url = (host ? protocol + '//' + host : '') + (port ? ':' + port : '') + path;
+	opts.method = (opts.method || 'GET').toUpperCase();
+	opts.headers = opts.headers || {};
+
+	// Also valid opts.auth, opts.mode
+
+	var req = new ClientRequest(opts);
+	if (cb) req.on('response', cb);
+	return req;
+};
+
+http.get = function get(opts, cb) {
+	var req = http.request(opts, cb);
+	req.end();
+	return req;
+};
+
+http.Agent = function () {};
+http.Agent.defaultMaxSockets = 4;
+
+http.STATUS_CODES = statusCodes;
+
+http.METHODS = ['CHECKOUT', 'CONNECT', 'COPY', 'DELETE', 'GET', 'HEAD', 'LOCK', 'M-SEARCH', 'MERGE', 'MKACTIVITY', 'MKCOL', 'MOVE', 'NOTIFY', 'OPTIONS', 'PATCH', 'POST', 'PROPFIND', 'PROPPATCH', 'PURGE', 'PUT', 'REPORT', 'SEARCH', 'SUBSCRIBE', 'TRACE', 'UNLOCK', 'UNSUBSCRIBE'];
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"./lib/request":372,"builtin-status-codes":47,"url":377,"xtend":418}],371:[function(require,module,exports){
+(function (global){
+'use strict';
+
+exports.fetch = isFunction(global.fetch) && isFunction(global.ReadableStream);
+
+exports.blobConstructor = false;
+try {
+	new Blob([new ArrayBuffer(1)]);
+	exports.blobConstructor = true;
+} catch (e) {}
+
+var xhr = new global.XMLHttpRequest();
+// If location.host is empty, e.g. if this page/worker was loaded
+// from a Blob, then use example.com to avoid an error
+xhr.open('GET', global.location.host ? '/' : 'https://example.com');
+
+function checkTypeSupport(type) {
+	try {
+		xhr.responseType = type;
+		return xhr.responseType === type;
+	} catch (e) {}
+	return false;
+}
+
+// For some strange reason, Safari 7.0 reports typeof global.ArrayBuffer === 'object'.
+// Safari 7.1 appears to have fixed this bug.
+var haveArrayBuffer = typeof global.ArrayBuffer !== 'undefined';
+var haveSlice = haveArrayBuffer && isFunction(global.ArrayBuffer.prototype.slice);
+
+exports.arraybuffer = haveArrayBuffer && checkTypeSupport('arraybuffer');
+// These next two tests unavoidably show warnings in Chrome. Since fetch will always
+// be used if it's available, just return false for these to avoid the warnings.
+exports.msstream = !exports.fetch && haveSlice && checkTypeSupport('ms-stream');
+exports.mozchunkedarraybuffer = !exports.fetch && haveArrayBuffer && checkTypeSupport('moz-chunked-arraybuffer');
+exports.overrideMimeType = isFunction(xhr.overrideMimeType);
+exports.vbArray = isFunction(global.VBArray);
+
+function isFunction(value) {
+	return typeof value === 'function';
+}
+
+xhr = null; // Help gc
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{}],372:[function(require,module,exports){
+(function (process,global,Buffer){
+'use strict';
+
+var _keys = require('babel-runtime/core-js/object/keys');
+
+var _keys2 = _interopRequireDefault(_keys);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var capability = require('./capability');
+var inherits = require('inherits');
+var response = require('./response');
+var stream = require('readable-stream');
+var toArrayBuffer = require('to-arraybuffer');
+
+var IncomingMessage = response.IncomingMessage;
+var rStates = response.readyStates;
+
+function decideMode(preferBinary, useFetch) {
+	if (capability.fetch && useFetch) {
+		return 'fetch';
+	} else if (capability.mozchunkedarraybuffer) {
+		return 'moz-chunked-arraybuffer';
+	} else if (capability.msstream) {
+		return 'ms-stream';
+	} else if (capability.arraybuffer && preferBinary) {
+		return 'arraybuffer';
+	} else if (capability.vbArray && preferBinary) {
+		return 'text:vbarray';
+	} else {
+		return 'text';
+	}
+}
+
+var ClientRequest = module.exports = function (opts) {
+	var self = this;
+	stream.Writable.call(self);
+
+	self._opts = opts;
+	self._body = [];
+	self._headers = {};
+	if (opts.auth) self.setHeader('Authorization', 'Basic ' + new Buffer(opts.auth).toString('base64'));
+	(0, _keys2.default)(opts.headers).forEach(function (name) {
+		self.setHeader(name, opts.headers[name]);
+	});
+
+	var preferBinary;
+	var useFetch = true;
+	if (opts.mode === 'disable-fetch') {
+		// If the use of XHR should be preferred and includes preserving the 'content-type' header
+		useFetch = false;
+		preferBinary = true;
+	} else if (opts.mode === 'prefer-streaming') {
+		// If streaming is a high priority but binary compatibility and
+		// the accuracy of the 'content-type' header aren't
+		preferBinary = false;
+	} else if (opts.mode === 'allow-wrong-content-type') {
+		// If streaming is more important than preserving the 'content-type' header
+		preferBinary = !capability.overrideMimeType;
+	} else if (!opts.mode || opts.mode === 'default' || opts.mode === 'prefer-fast') {
+		// Use binary if text streaming may corrupt data or the content-type header, or for speed
+		preferBinary = true;
+	} else {
+		throw new Error('Invalid value for opts.mode');
+	}
+	self._mode = decideMode(preferBinary, useFetch);
+
+	self.on('finish', function () {
+		self._onFinish();
+	});
+};
+
+inherits(ClientRequest, stream.Writable);
+
+ClientRequest.prototype.setHeader = function (name, value) {
+	var self = this;
+	var lowerName = name.toLowerCase();
+	// This check is not necessary, but it prevents warnings from browsers about setting unsafe
+	// headers. To be honest I'm not entirely sure hiding these warnings is a good thing, but
+	// http-browserify did it, so I will too.
+	if (unsafeHeaders.indexOf(lowerName) !== -1) return;
+
+	self._headers[lowerName] = {
+		name: name,
+		value: value
+	};
+};
+
+ClientRequest.prototype.getHeader = function (name) {
+	var self = this;
+	return self._headers[name.toLowerCase()].value;
+};
+
+ClientRequest.prototype.removeHeader = function (name) {
+	var self = this;
+	delete self._headers[name.toLowerCase()];
+};
+
+ClientRequest.prototype._onFinish = function () {
+	var self = this;
+
+	if (self._destroyed) return;
+	var opts = self._opts;
+
+	var headersObj = self._headers;
+	var body;
+	if (opts.method === 'POST' || opts.method === 'PUT' || opts.method === 'PATCH') {
+		if (capability.blobConstructor) {
+			body = new global.Blob(self._body.map(function (buffer) {
+				return toArrayBuffer(buffer);
+			}), {
+				type: (headersObj['content-type'] || {}).value || ''
+			});
+		} else {
+			// get utf8 string
+			body = Buffer.concat(self._body).toString();
+		}
+	}
+
+	if (self._mode === 'fetch') {
+		var headers = (0, _keys2.default)(headersObj).map(function (name) {
+			return [headersObj[name].name, headersObj[name].value];
+		});
+
+		global.fetch(self._opts.url, {
+			method: self._opts.method,
+			headers: headers,
+			body: body,
+			mode: 'cors',
+			credentials: opts.withCredentials ? 'include' : 'same-origin'
+		}).then(function (response) {
+			self._fetchResponse = response;
+			self._connect();
+		}, function (reason) {
+			self.emit('error', reason);
+		});
+	} else {
+		var xhr = self._xhr = new global.XMLHttpRequest();
+		try {
+			xhr.open(self._opts.method, self._opts.url, true);
+		} catch (err) {
+			process.nextTick(function () {
+				self.emit('error', err);
+			});
+			return;
+		}
+
+		// Can't set responseType on really old browsers
+		if ('responseType' in xhr) xhr.responseType = self._mode.split(':')[0];
+
+		if ('withCredentials' in xhr) xhr.withCredentials = !!opts.withCredentials;
+
+		if (self._mode === 'text' && 'overrideMimeType' in xhr) xhr.overrideMimeType('text/plain; charset=x-user-defined');
+
+		(0, _keys2.default)(headersObj).forEach(function (name) {
+			xhr.setRequestHeader(headersObj[name].name, headersObj[name].value);
+		});
+
+		self._response = null;
+		xhr.onreadystatechange = function () {
+			switch (xhr.readyState) {
+				case rStates.LOADING:
+				case rStates.DONE:
+					self._onXHRProgress();
+					break;
+			}
+		};
+		// Necessary for streaming in Firefox, since xhr.response is ONLY defined
+		// in onprogress, not in onreadystatechange with xhr.readyState = 3
+		if (self._mode === 'moz-chunked-arraybuffer') {
+			xhr.onprogress = function () {
+				self._onXHRProgress();
+			};
+		}
+
+		xhr.onerror = function () {
+			if (self._destroyed) return;
+			self.emit('error', new Error('XHR error'));
+		};
+
+		try {
+			xhr.send(body);
+		} catch (err) {
+			process.nextTick(function () {
+				self.emit('error', err);
+			});
+			return;
+		}
+	}
+};
+
+/**
+ * Checks if xhr.status is readable and non-zero, indicating no error.
+ * Even though the spec says it should be available in readyState 3,
+ * accessing it throws an exception in IE8
+ */
+function statusValid(xhr) {
+	try {
+		var status = xhr.status;
+		return status !== null && status !== 0;
+	} catch (e) {
+		return false;
+	}
+}
+
+ClientRequest.prototype._onXHRProgress = function () {
+	var self = this;
+
+	if (!statusValid(self._xhr) || self._destroyed) return;
+
+	if (!self._response) self._connect();
+
+	self._response._onXHRProgress();
+};
+
+ClientRequest.prototype._connect = function () {
+	var self = this;
+
+	if (self._destroyed) return;
+
+	self._response = new IncomingMessage(self._xhr, self._fetchResponse, self._mode);
+	self.emit('response', self._response);
+};
+
+ClientRequest.prototype._write = function (chunk, encoding, cb) {
+	var self = this;
+
+	self._body.push(chunk);
+	cb();
+};
+
+ClientRequest.prototype.abort = ClientRequest.prototype.destroy = function () {
+	var self = this;
+	self._destroyed = true;
+	if (self._response) self._response._destroyed = true;
+	if (self._xhr) self._xhr.abort();
+	// Currently, there isn't a way to truly abort a fetch.
+	// If you like bikeshedding, see https://github.com/whatwg/fetch/issues/27
+};
+
+ClientRequest.prototype.end = function (data, encoding, cb) {
+	var self = this;
+	if (typeof data === 'function') {
+		cb = data;
+		data = undefined;
+	}
+
+	stream.Writable.prototype.end.call(self, data, encoding, cb);
+};
+
+ClientRequest.prototype.flushHeaders = function () {};
+ClientRequest.prototype.setTimeout = function () {};
+ClientRequest.prototype.setNoDelay = function () {};
+ClientRequest.prototype.setSocketKeepAlive = function () {};
+
+// Taken from http://www.w3.org/TR/XMLHttpRequest/#the-setrequestheader%28%29-method
+var unsafeHeaders = ['accept-charset', 'accept-encoding', 'access-control-request-headers', 'access-control-request-method', 'connection', 'content-length', 'cookie', 'cookie2', 'date', 'dnt', 'expect', 'host', 'keep-alive', 'origin', 'referer', 'te', 'trailer', 'transfer-encoding', 'upgrade', 'user-agent', 'via'];
+
+}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {},require("buffer").Buffer)
+},{"./capability":371,"./response":373,"_process":345,"babel-runtime/core-js/object/keys":30,"buffer":45,"inherits":198,"readable-stream":359,"to-arraybuffer":376}],373:[function(require,module,exports){
+(function (process,global,Buffer){
+'use strict';
+
+var _getIterator2 = require('babel-runtime/core-js/get-iterator');
+
+var _getIterator3 = _interopRequireDefault(_getIterator2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var capability = require('./capability');
+var inherits = require('inherits');
+var stream = require('readable-stream');
+
+var rStates = exports.readyStates = {
+	UNSENT: 0,
+	OPENED: 1,
+	HEADERS_RECEIVED: 2,
+	LOADING: 3,
+	DONE: 4
+};
+
+var IncomingMessage = exports.IncomingMessage = function (xhr, response, mode) {
+	var self = this;
+	stream.Readable.call(self);
+
+	self._mode = mode;
+	self.headers = {};
+	self.rawHeaders = [];
+	self.trailers = {};
+	self.rawTrailers = [];
+
+	// Fake the 'close' event, but only once 'end' fires
+	self.on('end', function () {
+		// The nextTick is necessary to prevent the 'request' module from causing an infinite loop
+		process.nextTick(function () {
+			self.emit('close');
+		});
+	});
+
+	if (mode === 'fetch') {
+		var header, _i, _it;
+
+		var reader;
+
+		(function () {
+			var read = function read() {
+				reader.read().then(function (result) {
+					if (self._destroyed) return;
+					if (result.done) {
+						self.push(null);
+						return;
+					}
+					self.push(new Buffer(result.value));
+					read();
+				});
+			};
+
+			self._fetchResponse = response;
+
+			self.url = response.url;
+			self.statusCode = response.status;
+			self.statusMessage = response.statusText;
+			// backwards compatible version of for (<item> of <iterable>):
+			// for (var <item>,_i,_it = <iterable>[Symbol.iterator](); <item> = (_i = _it.next()).value,!_i.done;)
+			for (_it = (0, _getIterator3.default)(response.headers); header = (_i = _it.next()).value, !_i.done;) {
+				self.headers[header[0].toLowerCase()] = header[1];
+				self.rawHeaders.push(header[0], header[1]);
+			}
+
+			// TODO: this doesn't respect backpressure. Once WritableStream is available, this can be fixed
+			reader = response.body.getReader();
+
+			read();
+		})();
+	} else {
+		self._xhr = xhr;
+		self._pos = 0;
+
+		self.url = xhr.responseURL;
+		self.statusCode = xhr.status;
+		self.statusMessage = xhr.statusText;
+		var headers = xhr.getAllResponseHeaders().split(/\r?\n/);
+		headers.forEach(function (header) {
+			var matches = header.match(/^([^:]+):\s*(.*)/);
+			if (matches) {
+				var key = matches[1].toLowerCase();
+				if (key === 'set-cookie') {
+					if (self.headers[key] === undefined) {
+						self.headers[key] = [];
+					}
+					self.headers[key].push(matches[2]);
+				} else if (self.headers[key] !== undefined) {
+					self.headers[key] += ', ' + matches[2];
+				} else {
+					self.headers[key] = matches[2];
+				}
+				self.rawHeaders.push(matches[1], matches[2]);
+			}
+		});
+
+		self._charset = 'x-user-defined';
+		if (!capability.overrideMimeType) {
+			var mimeType = self.rawHeaders['mime-type'];
+			if (mimeType) {
+				var charsetMatch = mimeType.match(/;\s*charset=([^;])(;|$)/);
+				if (charsetMatch) {
+					self._charset = charsetMatch[1].toLowerCase();
+				}
+			}
+			if (!self._charset) self._charset = 'utf-8'; // best guess
+		}
+	}
+};
+
+inherits(IncomingMessage, stream.Readable);
+
+IncomingMessage.prototype._read = function () {};
+
+IncomingMessage.prototype._onXHRProgress = function () {
+	var self = this;
+
+	var xhr = self._xhr;
+
+	var response = null;
+	switch (self._mode) {
+		case 'text:vbarray':
+			// For IE9
+			if (xhr.readyState !== rStates.DONE) break;
+			try {
+				// This fails in IE8
+				response = new global.VBArray(xhr.responseBody).toArray();
+			} catch (e) {}
+			if (response !== null) {
+				self.push(new Buffer(response));
+				break;
+			}
+		// Falls through in IE8	
+		case 'text':
+			try {
+				// This will fail when readyState = 3 in IE9. Switch mode and wait for readyState = 4
+				response = xhr.responseText;
+			} catch (e) {
+				self._mode = 'text:vbarray';
+				break;
+			}
+			if (response.length > self._pos) {
+				var newData = response.substr(self._pos);
+				if (self._charset === 'x-user-defined') {
+					var buffer = new Buffer(newData.length);
+					for (var i = 0; i < newData.length; i++) {
+						buffer[i] = newData.charCodeAt(i) & 0xff;
+					}self.push(buffer);
+				} else {
+					self.push(newData, self._charset);
+				}
+				self._pos = response.length;
+			}
+			break;
+		case 'arraybuffer':
+			if (xhr.readyState !== rStates.DONE || !xhr.response) break;
+			response = xhr.response;
+			self.push(new Buffer(new Uint8Array(response)));
+			break;
+		case 'moz-chunked-arraybuffer':
+			// take whole
+			response = xhr.response;
+			if (xhr.readyState !== rStates.LOADING || !response) break;
+			self.push(new Buffer(new Uint8Array(response)));
+			break;
+		case 'ms-stream':
+			response = xhr.response;
+			if (xhr.readyState !== rStates.LOADING) break;
+			var reader = new global.MSStreamReader();
+			reader.onprogress = function () {
+				if (reader.result.byteLength > self._pos) {
+					self.push(new Buffer(new Uint8Array(reader.result.slice(self._pos))));
+					self._pos = reader.result.byteLength;
+				}
+			};
+			reader.onload = function () {
+				self.push(null);
+			};
+			// reader.onerror = ??? // TODO: this
+			reader.readAsArrayBuffer(response);
+			break;
+	}
+
+	// The ms-stream case handles end separately in reader.onload()
+	if (self._xhr.readyState === rStates.DONE && self._mode !== 'ms-stream') {
+		self.push(null);
+	}
+};
+
+}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {},require("buffer").Buffer)
+},{"./capability":371,"_process":345,"babel-runtime/core-js/get-iterator":17,"buffer":45,"inherits":198,"readable-stream":359}],374:[function(require,module,exports){
+'use strict';
+
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+var Buffer = require('buffer').Buffer;
+
+var isBufferEncoding = Buffer.isEncoding || function (encoding) {
+  switch (encoding && encoding.toLowerCase()) {
+    case 'hex':case 'utf8':case 'utf-8':case 'ascii':case 'binary':case 'base64':case 'ucs2':case 'ucs-2':case 'utf16le':case 'utf-16le':case 'raw':
+      return true;
+    default:
+      return false;
+  }
+};
+
+function assertEncoding(encoding) {
+  if (encoding && !isBufferEncoding(encoding)) {
+    throw new Error('Unknown encoding: ' + encoding);
+  }
+}
+
+// StringDecoder provides an interface for efficiently splitting a series of
+// buffers into a series of JS strings without breaking apart multi-byte
+// characters. CESU-8 is handled as part of the UTF-8 encoding.
+//
+// @TODO Handling all encodings inside a single object makes it very difficult
+// to reason about this code, so it should be split up in the future.
+// @TODO There should be a utf8-strict encoding that rejects invalid UTF-8 code
+// points as used by CESU-8.
+var StringDecoder = exports.StringDecoder = function (encoding) {
+  this.encoding = (encoding || 'utf8').toLowerCase().replace(/[-_]/, '');
+  assertEncoding(encoding);
+  switch (this.encoding) {
+    case 'utf8':
+      // CESU-8 represents each of Surrogate Pair by 3-bytes
+      this.surrogateSize = 3;
+      break;
+    case 'ucs2':
+    case 'utf16le':
+      // UTF-16 represents each of Surrogate Pair by 2-bytes
+      this.surrogateSize = 2;
+      this.detectIncompleteChar = utf16DetectIncompleteChar;
+      break;
+    case 'base64':
+      // Base-64 stores 3 bytes in 4 chars, and pads the remainder.
+      this.surrogateSize = 3;
+      this.detectIncompleteChar = base64DetectIncompleteChar;
+      break;
+    default:
+      this.write = passThroughWrite;
+      return;
+  }
+
+  // Enough space to store all bytes of a single character. UTF-8 needs 4
+  // bytes, but CESU-8 may require up to 6 (3 bytes per surrogate).
+  this.charBuffer = new Buffer(6);
+  // Number of bytes received for the current incomplete multi-byte character.
+  this.charReceived = 0;
+  // Number of bytes expected for the current incomplete multi-byte character.
+  this.charLength = 0;
+};
+
+// write decodes the given buffer and returns it as JS string that is
+// guaranteed to not contain any partial multi-byte characters. Any partial
+// character found at the end of the buffer is buffered up, and will be
+// returned when calling write again with the remaining bytes.
+//
+// Note: Converting a Buffer containing an orphan surrogate to a String
+// currently works, but converting a String to a Buffer (via `new Buffer`, or
+// Buffer#write) will replace incomplete surrogates with the unicode
+// replacement character. See https://codereview.chromium.org/121173009/ .
+StringDecoder.prototype.write = function (buffer) {
+  var charStr = '';
+  // if our last write ended with an incomplete multibyte character
+  while (this.charLength) {
+    // determine how many remaining bytes this buffer has to offer for this char
+    var available = buffer.length >= this.charLength - this.charReceived ? this.charLength - this.charReceived : buffer.length;
+
+    // add the new bytes to the char buffer
+    buffer.copy(this.charBuffer, this.charReceived, 0, available);
+    this.charReceived += available;
+
+    if (this.charReceived < this.charLength) {
+      // still not enough chars in this buffer? wait for more ...
+      return '';
+    }
+
+    // remove bytes belonging to the current character from the buffer
+    buffer = buffer.slice(available, buffer.length);
+
+    // get the character that was split
+    charStr = this.charBuffer.slice(0, this.charLength).toString(this.encoding);
+
+    // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character
+    var charCode = charStr.charCodeAt(charStr.length - 1);
+    if (charCode >= 0xD800 && charCode <= 0xDBFF) {
+      this.charLength += this.surrogateSize;
+      charStr = '';
+      continue;
+    }
+    this.charReceived = this.charLength = 0;
+
+    // if there are no more bytes in this buffer, just emit our char
+    if (buffer.length === 0) {
+      return charStr;
+    }
+    break;
+  }
+
+  // determine and set charLength / charReceived
+  this.detectIncompleteChar(buffer);
+
+  var end = buffer.length;
+  if (this.charLength) {
+    // buffer the incomplete character bytes we got
+    buffer.copy(this.charBuffer, 0, buffer.length - this.charReceived, end);
+    end -= this.charReceived;
+  }
+
+  charStr += buffer.toString(this.encoding, 0, end);
+
+  var end = charStr.length - 1;
+  var charCode = charStr.charCodeAt(end);
+  // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character
+  if (charCode >= 0xD800 && charCode <= 0xDBFF) {
+    var size = this.surrogateSize;
+    this.charLength += size;
+    this.charReceived += size;
+    this.charBuffer.copy(this.charBuffer, size, 0, size);
+    buffer.copy(this.charBuffer, 0, 0, size);
+    return charStr.substring(0, end);
+  }
+
+  // or just emit the charStr
+  return charStr;
+};
+
+// detectIncompleteChar determines if there is an incomplete UTF-8 character at
+// the end of the given buffer. If so, it sets this.charLength to the byte
+// length that character, and sets this.charReceived to the number of bytes
+// that are available for this character.
+StringDecoder.prototype.detectIncompleteChar = function (buffer) {
+  // determine how many bytes we have to check at the end of this buffer
+  var i = buffer.length >= 3 ? 3 : buffer.length;
+
+  // Figure out if one of the last i bytes of our buffer announces an
+  // incomplete char.
+  for (; i > 0; i--) {
+    var c = buffer[buffer.length - i];
+
+    // See http://en.wikipedia.org/wiki/UTF-8#Description
+
+    // 110XXXXX
+    if (i == 1 && c >> 5 == 0x06) {
+      this.charLength = 2;
+      break;
+    }
+
+    // 1110XXXX
+    if (i <= 2 && c >> 4 == 0x0E) {
+      this.charLength = 3;
+      break;
+    }
+
+    // 11110XXX
+    if (i <= 3 && c >> 3 == 0x1E) {
+      this.charLength = 4;
+      break;
+    }
+  }
+  this.charReceived = i;
+};
+
+StringDecoder.prototype.end = function (buffer) {
+  var res = '';
+  if (buffer && buffer.length) res = this.write(buffer);
+
+  if (this.charReceived) {
+    var cr = this.charReceived;
+    var buf = this.charBuffer;
+    var enc = this.encoding;
+    res += buf.slice(0, cr).toString(enc);
+  }
+
+  return res;
+};
+
+function passThroughWrite(buffer) {
+  return buffer.toString(this.encoding);
+}
+
+function utf16DetectIncompleteChar(buffer) {
+  this.charReceived = buffer.length % 2;
+  this.charLength = this.charReceived ? 2 : 0;
+}
+
+function base64DetectIncompleteChar(buffer) {
+  this.charReceived = buffer.length % 3;
+  this.charLength = this.charReceived ? 3 : 0;
+}
+
+},{"buffer":45}],375:[function(require,module,exports){
+"use strict";
+
+var _clearImmediate2 = require("babel-runtime/core-js/clear-immediate");
+
+var _clearImmediate3 = _interopRequireDefault(_clearImmediate2);
+
+var _setImmediate2 = require("babel-runtime/core-js/set-immediate");
+
+var _setImmediate3 = _interopRequireDefault(_setImmediate2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var nextTick = require('process/browser.js').nextTick;
+var apply = Function.prototype.apply;
+var slice = Array.prototype.slice;
+var immediateIds = {};
+var nextImmediateId = 0;
+
+// DOM APIs, for completeness
+
+exports.setTimeout = function () {
+  return new Timeout(apply.call(setTimeout, window, arguments), clearTimeout);
+};
+exports.setInterval = function () {
+  return new Timeout(apply.call(setInterval, window, arguments), clearInterval);
+};
+exports.clearTimeout = exports.clearInterval = function (timeout) {
+  timeout.close();
+};
+
+function Timeout(id, clearFn) {
+  this._id = id;
+  this._clearFn = clearFn;
+}
+Timeout.prototype.unref = Timeout.prototype.ref = function () {};
+Timeout.prototype.close = function () {
+  this._clearFn.call(window, this._id);
+};
+
+// Does not start the time, just sets up the members needed.
+exports.enroll = function (item, msecs) {
+  clearTimeout(item._idleTimeoutId);
+  item._idleTimeout = msecs;
+};
+
+exports.unenroll = function (item) {
+  clearTimeout(item._idleTimeoutId);
+  item._idleTimeout = -1;
+};
+
+exports._unrefActive = exports.active = function (item) {
+  clearTimeout(item._idleTimeoutId);
+
+  var msecs = item._idleTimeout;
+  if (msecs >= 0) {
+    item._idleTimeoutId = setTimeout(function onTimeout() {
+      if (item._onTimeout) item._onTimeout();
+    }, msecs);
+  }
+};
+
+// That's not how node.js implements it but the exposed api is the same.
+exports.setImmediate = typeof _setImmediate3.default === "function" ? _setImmediate3.default : function (fn) {
+  var id = nextImmediateId++;
+  var args = arguments.length < 2 ? false : slice.call(arguments, 1);
+
+  immediateIds[id] = true;
+
+  nextTick(function onNextTick() {
+    if (immediateIds[id]) {
+      // fn.call() is faster so we optimize for the common use-case
+      // @see http://jsperf.com/call-apply-segu
+      if (args) {
+        fn.apply(null, args);
+      } else {
+        fn.call(null);
+      }
+      // Prevent ids from leaking
+      exports.clearImmediate(id);
+    }
+  });
+
+  return id;
+};
+
+exports.clearImmediate = typeof _clearImmediate3.default === "function" ? _clearImmediate3.default : function (id) {
+  delete immediateIds[id];
+};
+
+},{"babel-runtime/core-js/clear-immediate":16,"babel-runtime/core-js/set-immediate":34,"process/browser.js":345}],376:[function(require,module,exports){
+'use strict';
+
+var Buffer = require('buffer').Buffer;
+
+module.exports = function (buf) {
+	// If the buffer is backed by a Uint8Array, a faster version will work
+	if (buf instanceof Uint8Array) {
+		// If the buffer isn't a subarray, return the underlying ArrayBuffer
+		if (buf.byteOffset === 0 && buf.byteLength === buf.buffer.byteLength) {
+			return buf.buffer;
+		} else if (typeof buf.buffer.slice === 'function') {
+			// Otherwise we need to get a proper copy
+			return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+		}
+	}
+
+	if (Buffer.isBuffer(buf)) {
+		// This is the slow version that will work with any Buffer
+		// implementation (even in old browsers)
+		var arrayCopy = new Uint8Array(buf.length);
+		var len = buf.length;
+		for (var i = 0; i < len; i++) {
+			arrayCopy[i] = buf[i];
+		}
+		return arrayCopy.buffer;
+	} else {
+		throw new Error('Argument must be a Buffer');
+	}
+};
+
+},{"buffer":45}],377:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+
+var _keys = require('babel-runtime/core-js/object/keys');
+
+var _keys2 = _interopRequireDefault(_keys);
+
+var _typeof2 = require('babel-runtime/helpers/typeof');
+
+var _typeof3 = _interopRequireDefault(_typeof2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var punycode = require('punycode');
+var util = require('./util');
+
+exports.parse = urlParse;
+exports.resolve = urlResolve;
+exports.resolveObject = urlResolveObject;
+exports.format = urlFormat;
+
+exports.Url = Url;
+
+function Url() {
+  this.protocol = null;
+  this.slashes = null;
+  this.auth = null;
+  this.host = null;
+  this.port = null;
+  this.hostname = null;
+  this.hash = null;
+  this.search = null;
+  this.query = null;
+  this.pathname = null;
+  this.path = null;
+  this.href = null;
+}
+
+// Reference: RFC 3986, RFC 1808, RFC 2396
+
+// define these here so at least they only have to be
+// compiled once on the first module load.
+var protocolPattern = /^([a-z0-9.+-]+:)/i,
+    portPattern = /:[0-9]*$/,
+
+
+// Special case for a simple path URL
+simplePathPattern = /^(\/\/?(?!\/)[^\?\s]*)(\?[^\s]*)?$/,
+
+
+// RFC 2396: characters reserved for delimiting URLs.
+// We actually just auto-escape these.
+delims = ['<', '>', '"', '`', ' ', '\r', '\n', '\t'],
+
+
+// RFC 2396: characters not allowed for various reasons.
+unwise = ['{', '}', '|', '\\', '^', '`'].concat(delims),
+
+
+// Allowed by RFCs, but cause of XSS attacks.  Always escape these.
+autoEscape = ['\''].concat(unwise),
+
+// Characters that are never ever allowed in a hostname.
+// Note that any invalid chars are also handled, but these
+// are the ones that are *expected* to be seen, so we fast-path
+// them.
+nonHostChars = ['%', '/', '?', ';', '#'].concat(autoEscape),
+    hostEndingChars = ['/', '?', '#'],
+    hostnameMaxLen = 255,
+    hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/,
+    hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/,
+
+// protocols that can allow "unsafe" and "unwise" chars.
+unsafeProtocol = {
+  'javascript': true,
+  'javascript:': true
+},
+
+// protocols that never have a hostname.
+hostlessProtocol = {
+  'javascript': true,
+  'javascript:': true
+},
+
+// protocols that always contain a // bit.
+slashedProtocol = {
+  'http': true,
+  'https': true,
+  'ftp': true,
+  'gopher': true,
+  'file': true,
+  'http:': true,
+  'https:': true,
+  'ftp:': true,
+  'gopher:': true,
+  'file:': true
+},
+    querystring = require('querystring');
+
+function urlParse(url, parseQueryString, slashesDenoteHost) {
+  if (url && util.isObject(url) && url instanceof Url) return url;
+
+  var u = new Url();
+  u.parse(url, parseQueryString, slashesDenoteHost);
+  return u;
+}
+
+Url.prototype.parse = function (url, parseQueryString, slashesDenoteHost) {
+  if (!util.isString(url)) {
+    throw new TypeError("Parameter 'url' must be a string, not " + (typeof url === 'undefined' ? 'undefined' : (0, _typeof3.default)(url)));
+  }
+
+  // Copy chrome, IE, opera backslash-handling behavior.
+  // Back slashes before the query string get converted to forward slashes
+  // See: https://code.google.com/p/chromium/issues/detail?id=25916
+  var queryIndex = url.indexOf('?'),
+      splitter = queryIndex !== -1 && queryIndex < url.indexOf('#') ? '?' : '#',
+      uSplit = url.split(splitter),
+      slashRegex = /\\/g;
+  uSplit[0] = uSplit[0].replace(slashRegex, '/');
+  url = uSplit.join(splitter);
+
+  var rest = url;
+
+  // trim before proceeding.
+  // This is to support parse stuff like "  http://foo.com  \n"
+  rest = rest.trim();
+
+  if (!slashesDenoteHost && url.split('#').length === 1) {
+    // Try fast path regexp
+    var simplePath = simplePathPattern.exec(rest);
+    if (simplePath) {
+      this.path = rest;
+      this.href = rest;
+      this.pathname = simplePath[1];
+      if (simplePath[2]) {
+        this.search = simplePath[2];
+        if (parseQueryString) {
+          this.query = querystring.parse(this.search.substr(1));
+        } else {
+          this.query = this.search.substr(1);
+        }
+      } else if (parseQueryString) {
+        this.search = '';
+        this.query = {};
+      }
+      return this;
+    }
+  }
+
+  var proto = protocolPattern.exec(rest);
+  if (proto) {
+    proto = proto[0];
+    var lowerProto = proto.toLowerCase();
+    this.protocol = lowerProto;
+    rest = rest.substr(proto.length);
+  }
+
+  // figure out if it's got a host
+  // user@server is *always* interpreted as a hostname, and url
+  // resolution will treat //foo/bar as host=foo,path=bar because that's
+  // how the browser resolves relative URLs.
+  if (slashesDenoteHost || proto || rest.match(/^\/\/[^@\/]+@[^@\/]+/)) {
+    var slashes = rest.substr(0, 2) === '//';
+    if (slashes && !(proto && hostlessProtocol[proto])) {
+      rest = rest.substr(2);
+      this.slashes = true;
+    }
+  }
+
+  if (!hostlessProtocol[proto] && (slashes || proto && !slashedProtocol[proto])) {
+
+    // there's a hostname.
+    // the first instance of /, ?, ;, or # ends the host.
+    //
+    // If there is an @ in the hostname, then non-host chars *are* allowed
+    // to the left of the last @ sign, unless some host-ending character
+    // comes *before* the @-sign.
+    // URLs are obnoxious.
+    //
+    // ex:
+    // http://a@b@c/ => user:a@b host:c
+    // http://a@b?@c => user:a host:c path:/?@c
+
+    // v0.12 TODO(isaacs): This is not quite how Chrome does things.
+    // Review our test case against browsers more comprehensively.
+
+    // find the first instance of any hostEndingChars
+    var hostEnd = -1;
+    for (var i = 0; i < hostEndingChars.length; i++) {
+      var hec = rest.indexOf(hostEndingChars[i]);
+      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) hostEnd = hec;
+    }
+
+    // at this point, either we have an explicit point where the
+    // auth portion cannot go past, or the last @ char is the decider.
+    var auth, atSign;
+    if (hostEnd === -1) {
+      // atSign can be anywhere.
+      atSign = rest.lastIndexOf('@');
+    } else {
+      // atSign must be in auth portion.
+      // http://a@b/c@d => host:b auth:a path:/c@d
+      atSign = rest.lastIndexOf('@', hostEnd);
+    }
+
+    // Now we have a portion which is definitely the auth.
+    // Pull that off.
+    if (atSign !== -1) {
+      auth = rest.slice(0, atSign);
+      rest = rest.slice(atSign + 1);
+      this.auth = decodeURIComponent(auth);
+    }
+
+    // the host is the remaining to the left of the first non-host char
+    hostEnd = -1;
+    for (var i = 0; i < nonHostChars.length; i++) {
+      var hec = rest.indexOf(nonHostChars[i]);
+      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) hostEnd = hec;
+    }
+    // if we still have not hit it, then the entire thing is a host.
+    if (hostEnd === -1) hostEnd = rest.length;
+
+    this.host = rest.slice(0, hostEnd);
+    rest = rest.slice(hostEnd);
+
+    // pull out port.
+    this.parseHost();
+
+    // we've indicated that there is a hostname,
+    // so even if it's empty, it has to be present.
+    this.hostname = this.hostname || '';
+
+    // if hostname begins with [ and ends with ]
+    // assume that it's an IPv6 address.
+    var ipv6Hostname = this.hostname[0] === '[' && this.hostname[this.hostname.length - 1] === ']';
+
+    // validate a little.
+    if (!ipv6Hostname) {
+      var hostparts = this.hostname.split(/\./);
+      for (var i = 0, l = hostparts.length; i < l; i++) {
+        var part = hostparts[i];
+        if (!part) continue;
+        if (!part.match(hostnamePartPattern)) {
+          var newpart = '';
+          for (var j = 0, k = part.length; j < k; j++) {
+            if (part.charCodeAt(j) > 127) {
+              // we replace non-ASCII char with a temporary placeholder
+              // we need this to make sure size of hostname is not
+              // broken by replacing non-ASCII by nothing
+              newpart += 'x';
+            } else {
+              newpart += part[j];
+            }
+          }
+          // we test again with ASCII char only
+          if (!newpart.match(hostnamePartPattern)) {
+            var validParts = hostparts.slice(0, i);
+            var notHost = hostparts.slice(i + 1);
+            var bit = part.match(hostnamePartStart);
+            if (bit) {
+              validParts.push(bit[1]);
+              notHost.unshift(bit[2]);
+            }
+            if (notHost.length) {
+              rest = '/' + notHost.join('.') + rest;
+            }
+            this.hostname = validParts.join('.');
+            break;
+          }
+        }
+      }
+    }
+
+    if (this.hostname.length > hostnameMaxLen) {
+      this.hostname = '';
+    } else {
+      // hostnames are always lower case.
+      this.hostname = this.hostname.toLowerCase();
+    }
+
+    if (!ipv6Hostname) {
+      // IDNA Support: Returns a punycoded representation of "domain".
+      // It only converts parts of the domain name that
+      // have non-ASCII characters, i.e. it doesn't matter if
+      // you call it with a domain that already is ASCII-only.
+      this.hostname = punycode.toASCII(this.hostname);
+    }
+
+    var p = this.port ? ':' + this.port : '';
+    var h = this.hostname || '';
+    this.host = h + p;
+    this.href += this.host;
+
+    // strip [ and ] from the hostname
+    // the host field still retains them, though
+    if (ipv6Hostname) {
+      this.hostname = this.hostname.substr(1, this.hostname.length - 2);
+      if (rest[0] !== '/') {
+        rest = '/' + rest;
+      }
+    }
+  }
+
+  // now rest is set to the post-host stuff.
+  // chop off any delim chars.
+  if (!unsafeProtocol[lowerProto]) {
+
+    // First, make 100% sure that any "autoEscape" chars get
+    // escaped, even if encodeURIComponent doesn't think they
+    // need to be.
+    for (var i = 0, l = autoEscape.length; i < l; i++) {
+      var ae = autoEscape[i];
+      if (rest.indexOf(ae) === -1) continue;
+      var esc = encodeURIComponent(ae);
+      if (esc === ae) {
+        esc = escape(ae);
+      }
+      rest = rest.split(ae).join(esc);
+    }
+  }
+
+  // chop off from the tail first.
+  var hash = rest.indexOf('#');
+  if (hash !== -1) {
+    // got a fragment string.
+    this.hash = rest.substr(hash);
+    rest = rest.slice(0, hash);
+  }
+  var qm = rest.indexOf('?');
+  if (qm !== -1) {
+    this.search = rest.substr(qm);
+    this.query = rest.substr(qm + 1);
+    if (parseQueryString) {
+      this.query = querystring.parse(this.query);
+    }
+    rest = rest.slice(0, qm);
+  } else if (parseQueryString) {
+    // no query string, but parseQueryString still requested
+    this.search = '';
+    this.query = {};
+  }
+  if (rest) this.pathname = rest;
+  if (slashedProtocol[lowerProto] && this.hostname && !this.pathname) {
+    this.pathname = '/';
+  }
+
+  //to support http.request
+  if (this.pathname || this.search) {
+    var p = this.pathname || '';
+    var s = this.search || '';
+    this.path = p + s;
+  }
+
+  // finally, reconstruct the href based on what has been validated.
+  this.href = this.format();
+  return this;
+};
+
+// format a parsed object into a url string
+function urlFormat(obj) {
+  // ensure it's an object, and not a string url.
+  // If it's an obj, this is a no-op.
+  // this way, you can call url_format() on strings
+  // to clean up potentially wonky urls.
+  if (util.isString(obj)) obj = urlParse(obj);
+  if (!(obj instanceof Url)) return Url.prototype.format.call(obj);
+  return obj.format();
+}
+
+Url.prototype.format = function () {
+  var auth = this.auth || '';
+  if (auth) {
+    auth = encodeURIComponent(auth);
+    auth = auth.replace(/%3A/i, ':');
+    auth += '@';
+  }
+
+  var protocol = this.protocol || '',
+      pathname = this.pathname || '',
+      hash = this.hash || '',
+      host = false,
+      query = '';
+
+  if (this.host) {
+    host = auth + this.host;
+  } else if (this.hostname) {
+    host = auth + (this.hostname.indexOf(':') === -1 ? this.hostname : '[' + this.hostname + ']');
+    if (this.port) {
+      host += ':' + this.port;
+    }
+  }
+
+  if (this.query && util.isObject(this.query) && (0, _keys2.default)(this.query).length) {
+    query = querystring.stringify(this.query);
+  }
+
+  var search = this.search || query && '?' + query || '';
+
+  if (protocol && protocol.substr(-1) !== ':') protocol += ':';
+
+  // only the slashedProtocols get the //.  Not mailto:, xmpp:, etc.
+  // unless they had them to begin with.
+  if (this.slashes || (!protocol || slashedProtocol[protocol]) && host !== false) {
+    host = '//' + (host || '');
+    if (pathname && pathname.charAt(0) !== '/') pathname = '/' + pathname;
+  } else if (!host) {
+    host = '';
+  }
+
+  if (hash && hash.charAt(0) !== '#') hash = '#' + hash;
+  if (search && search.charAt(0) !== '?') search = '?' + search;
+
+  pathname = pathname.replace(/[?#]/g, function (match) {
+    return encodeURIComponent(match);
+  });
+  search = search.replace('#', '%23');
+
+  return protocol + host + pathname + search + hash;
+};
+
+function urlResolve(source, relative) {
+  return urlParse(source, false, true).resolve(relative);
+}
+
+Url.prototype.resolve = function (relative) {
+  return this.resolveObject(urlParse(relative, false, true)).format();
+};
+
+function urlResolveObject(source, relative) {
+  if (!source) return relative;
+  return urlParse(source, false, true).resolveObject(relative);
+}
+
+Url.prototype.resolveObject = function (relative) {
+  if (util.isString(relative)) {
+    var rel = new Url();
+    rel.parse(relative, false, true);
+    relative = rel;
+  }
+
+  var result = new Url();
+  var tkeys = (0, _keys2.default)(this);
+  for (var tk = 0; tk < tkeys.length; tk++) {
+    var tkey = tkeys[tk];
+    result[tkey] = this[tkey];
+  }
+
+  // hash is always overridden, no matter what.
+  // even href="" will remove it.
+  result.hash = relative.hash;
+
+  // if the relative url is empty, then there's nothing left to do here.
+  if (relative.href === '') {
+    result.href = result.format();
+    return result;
+  }
+
+  // hrefs like //foo/bar always cut to the protocol.
+  if (relative.slashes && !relative.protocol) {
+    // take everything except the protocol from relative
+    var rkeys = (0, _keys2.default)(relative);
+    for (var rk = 0; rk < rkeys.length; rk++) {
+      var rkey = rkeys[rk];
+      if (rkey !== 'protocol') result[rkey] = relative[rkey];
+    }
+
+    //urlParse appends trailing / to urls like http://www.example.com
+    if (slashedProtocol[result.protocol] && result.hostname && !result.pathname) {
+      result.path = result.pathname = '/';
+    }
+
+    result.href = result.format();
+    return result;
+  }
+
+  if (relative.protocol && relative.protocol !== result.protocol) {
+    // if it's a known url protocol, then changing
+    // the protocol does weird things
+    // first, if it's not file:, then we MUST have a host,
+    // and if there was a path
+    // to begin with, then we MUST have a path.
+    // if it is file:, then the host is dropped,
+    // because that's known to be hostless.
+    // anything else is assumed to be absolute.
+    if (!slashedProtocol[relative.protocol]) {
+      var keys = (0, _keys2.default)(relative);
+      for (var v = 0; v < keys.length; v++) {
+        var k = keys[v];
+        result[k] = relative[k];
+      }
+      result.href = result.format();
+      return result;
+    }
+
+    result.protocol = relative.protocol;
+    if (!relative.host && !hostlessProtocol[relative.protocol]) {
+      var relPath = (relative.pathname || '').split('/');
+      while (relPath.length && !(relative.host = relPath.shift())) {}
+      if (!relative.host) relative.host = '';
+      if (!relative.hostname) relative.hostname = '';
+      if (relPath[0] !== '') relPath.unshift('');
+      if (relPath.length < 2) relPath.unshift('');
+      result.pathname = relPath.join('/');
+    } else {
+      result.pathname = relative.pathname;
+    }
+    result.search = relative.search;
+    result.query = relative.query;
+    result.host = relative.host || '';
+    result.auth = relative.auth;
+    result.hostname = relative.hostname || relative.host;
+    result.port = relative.port;
+    // to support http.request
+    if (result.pathname || result.search) {
+      var p = result.pathname || '';
+      var s = result.search || '';
+      result.path = p + s;
+    }
+    result.slashes = result.slashes || relative.slashes;
+    result.href = result.format();
+    return result;
+  }
+
+  var isSourceAbs = result.pathname && result.pathname.charAt(0) === '/',
+      isRelAbs = relative.host || relative.pathname && relative.pathname.charAt(0) === '/',
+      mustEndAbs = isRelAbs || isSourceAbs || result.host && relative.pathname,
+      removeAllDots = mustEndAbs,
+      srcPath = result.pathname && result.pathname.split('/') || [],
+      relPath = relative.pathname && relative.pathname.split('/') || [],
+      psychotic = result.protocol && !slashedProtocol[result.protocol];
+
+  // if the url is a non-slashed url, then relative
+  // links like ../.. should be able
+  // to crawl up to the hostname, as well.  This is strange.
+  // result.protocol has already been set by now.
+  // Later on, put the first path part into the host field.
+  if (psychotic) {
+    result.hostname = '';
+    result.port = null;
+    if (result.host) {
+      if (srcPath[0] === '') srcPath[0] = result.host;else srcPath.unshift(result.host);
+    }
+    result.host = '';
+    if (relative.protocol) {
+      relative.hostname = null;
+      relative.port = null;
+      if (relative.host) {
+        if (relPath[0] === '') relPath[0] = relative.host;else relPath.unshift(relative.host);
+      }
+      relative.host = null;
+    }
+    mustEndAbs = mustEndAbs && (relPath[0] === '' || srcPath[0] === '');
+  }
+
+  if (isRelAbs) {
+    // it's absolute.
+    result.host = relative.host || relative.host === '' ? relative.host : result.host;
+    result.hostname = relative.hostname || relative.hostname === '' ? relative.hostname : result.hostname;
+    result.search = relative.search;
+    result.query = relative.query;
+    srcPath = relPath;
+    // fall through to the dot-handling below.
+  } else if (relPath.length) {
+    // it's relative
+    // throw away the existing file, and take the new path instead.
+    if (!srcPath) srcPath = [];
+    srcPath.pop();
+    srcPath = srcPath.concat(relPath);
+    result.search = relative.search;
+    result.query = relative.query;
+  } else if (!util.isNullOrUndefined(relative.search)) {
+    // just pull out the search.
+    // like href='?foo'.
+    // Put this after the other two cases because it simplifies the booleans
+    if (psychotic) {
+      result.hostname = result.host = srcPath.shift();
+      //occationaly the auth can get stuck only in host
+      //this especially happens in cases like
+      //url.resolveObject('mailto:local1@domain1', 'local2@domain2')
+      var authInHost = result.host && result.host.indexOf('@') > 0 ? result.host.split('@') : false;
+      if (authInHost) {
+        result.auth = authInHost.shift();
+        result.host = result.hostname = authInHost.shift();
+      }
+    }
+    result.search = relative.search;
+    result.query = relative.query;
+    //to support http.request
+    if (!util.isNull(result.pathname) || !util.isNull(result.search)) {
+      result.path = (result.pathname ? result.pathname : '') + (result.search ? result.search : '');
+    }
+    result.href = result.format();
+    return result;
+  }
+
+  if (!srcPath.length) {
+    // no path at all.  easy.
+    // we've already handled the other stuff above.
+    result.pathname = null;
+    //to support http.request
+    if (result.search) {
+      result.path = '/' + result.search;
+    } else {
+      result.path = null;
+    }
+    result.href = result.format();
+    return result;
+  }
+
+  // if a url ENDs in . or .., then it must get a trailing slash.
+  // however, if it ends in anything else non-slashy,
+  // then it must NOT get a trailing slash.
+  var last = srcPath.slice(-1)[0];
+  var hasTrailingSlash = (result.host || relative.host || srcPath.length > 1) && (last === '.' || last === '..') || last === '';
+
+  // strip single dots, resolve double dots to parent dir
+  // if the path tries to go above the root, `up` ends up > 0
+  var up = 0;
+  for (var i = srcPath.length; i >= 0; i--) {
+    last = srcPath[i];
+    if (last === '.') {
+      srcPath.splice(i, 1);
+    } else if (last === '..') {
+      srcPath.splice(i, 1);
+      up++;
+    } else if (up) {
+      srcPath.splice(i, 1);
+      up--;
+    }
+  }
+
+  // if the path is allowed to go above the root, restore leading ..s
+  if (!mustEndAbs && !removeAllDots) {
+    for (; up--; up) {
+      srcPath.unshift('..');
+    }
+  }
+
+  if (mustEndAbs && srcPath[0] !== '' && (!srcPath[0] || srcPath[0].charAt(0) !== '/')) {
+    srcPath.unshift('');
+  }
+
+  if (hasTrailingSlash && srcPath.join('/').substr(-1) !== '/') {
+    srcPath.push('');
+  }
+
+  var isAbsolute = srcPath[0] === '' || srcPath[0] && srcPath[0].charAt(0) === '/';
+
+  // put the host back
+  if (psychotic) {
+    result.hostname = result.host = isAbsolute ? '' : srcPath.length ? srcPath.shift() : '';
+    //occationaly the auth can get stuck only in host
+    //this especially happens in cases like
+    //url.resolveObject('mailto:local1@domain1', 'local2@domain2')
+    var authInHost = result.host && result.host.indexOf('@') > 0 ? result.host.split('@') : false;
+    if (authInHost) {
+      result.auth = authInHost.shift();
+      result.host = result.hostname = authInHost.shift();
+    }
+  }
+
+  mustEndAbs = mustEndAbs || result.host && srcPath.length;
+
+  if (mustEndAbs && !isAbsolute) {
+    srcPath.unshift('');
+  }
+
+  if (!srcPath.length) {
+    result.pathname = null;
+    result.path = null;
+  } else {
+    result.pathname = srcPath.join('/');
+  }
+
+  //to support request.http
+  if (!util.isNull(result.pathname) || !util.isNull(result.search)) {
+    result.path = (result.pathname ? result.pathname : '') + (result.search ? result.search : '');
+  }
+  result.auth = relative.auth || result.auth;
+  result.slashes = result.slashes || relative.slashes;
+  result.href = result.format();
+  return result;
+};
+
+Url.prototype.parseHost = function () {
+  var host = this.host;
+  var port = portPattern.exec(host);
+  if (port) {
+    port = port[0];
+    if (port !== ':') {
+      this.port = port.substr(1);
+    }
+    host = host.substr(0, host.length - port.length);
+  }
+  if (host) this.hostname = host;
+};
+
+},{"./util":378,"babel-runtime/core-js/object/keys":30,"babel-runtime/helpers/typeof":39,"punycode":346,"querystring":349}],378:[function(require,module,exports){
+'use strict';
+
+var _typeof2 = require('babel-runtime/helpers/typeof');
+
+var _typeof3 = _interopRequireDefault(_typeof2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+module.exports = {
+  isString: function isString(arg) {
+    return typeof arg === 'string';
+  },
+  isObject: function isObject(arg) {
+    return (typeof arg === 'undefined' ? 'undefined' : (0, _typeof3.default)(arg)) === 'object' && arg !== null;
+  },
+  isNull: function isNull(arg) {
+    return arg === null;
+  },
+  isNullOrUndefined: function isNullOrUndefined(arg) {
+    return arg == null;
+  }
+};
+
+},{"babel-runtime/helpers/typeof":39}],379:[function(require,module,exports){
+(function (process,Buffer){
+'use strict';
+
+var _stringify = require('babel-runtime/core-js/json/stringify');
+
+var _stringify2 = _interopRequireDefault(_stringify);
+
+var _typeof2 = require('babel-runtime/helpers/typeof');
+
+var _typeof3 = _interopRequireDefault(_typeof2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var debug = require('debug')('urllib');
+var http = require('http');
+var https = require('https');
+var urlutil = require('url');
+var util = require('util');
+var qs = require('querystring');
+var zlib = {};
+var ua = require('default-user-agent');
+var digestAuthHeader = require('digest-header');
+var util = require('util');
+var EventEmitter = require('events').EventEmitter;
+var ms = require('humanize-ms');
+var statuses = require('statuses');
+var contentTypeParser = require('content-type');
+
+var _Promise;
+var _iconv;
+
+var pkg = require('../package.json');
+
+var USER_AGENT = exports.USER_AGENT = ua('node-urllib', pkg.version);
+
+// change Agent.maxSockets to 1000
+exports.agent = new http.Agent();
+exports.agent.maxSockets = 1000;
+
+exports.httpsAgent = new https.Agent();
+exports.httpsAgent.maxSockets = 1000;
+
+/**
+ * The default request timeout(in milliseconds).
+ * @type {Number}
+ * @const
+ */
+
+exports.TIMEOUT = ms('5s');
+exports.TIMEOUTS = [ms('5s'), ms('5s')];
+
+var REQUEST_ID = 0;
+var MAX_VALUE = Math.pow(2, 31) - 10;
+var isOldVersionNode = /^v0\.10\.\d+$/.test(process.version);
+
+/**
+ * support data types
+ * will auto decode response body
+ * @type {Array}
+ */
+var TEXT_DATA_TYPES = ['json', 'text'];
+
+var PROTO_RE = /^https?:\/\//i;
+
+/**
+ * Handle all http request, both http and https support well.
+ *
+ * @example
+ *
+ * // GET http://httptest.cnodejs.net
+ * urllib.request('http://httptest.cnodejs.net/test/get', function(err, data, res) {});
+ * // POST http://httptest.cnodejs.net
+ * var args = { type: 'post', data: { foo: 'bar' } };
+ * urllib.request('http://httptest.cnodejs.net/test/post', args, function(err, data, res) {});
+ *
+ * @param {String|Object} url
+ * @param {Object} [args], optional
+ *   - {Object} [data]: request data, will auto be query stringify.
+ *   - {String|Buffer} [content]: optional, if set content, `data` will ignore.
+ *   - {ReadStream} [stream]: read stream to sent.
+ *   - {WriteStream} [writeStream]: writable stream to save response data.
+ *       If you use this, callback's data should be null.
+ *       We will just `pipe(ws, {end: true})`.
+ *   - {consumeWriteStream} [true]: consume the writeStream, invoke the callback after writeStream close.
+ *   - {String} [method]: optional, could be GET | POST | DELETE | PUT, default is GET
+ *   - {String} [contentType]: optional, request data type, could be `json`, default is undefined
+ *   - {String} [dataType]: optional, response data type, could be `text` or `json`, default is buffer
+ *   - {Boolean} [fixJSONCtlChars]: optional, fix the control characters (U+0000 through U+001F)
+ *       before JSON parse response. Default is `false`
+ *   - {Object} [headers]: optional, request headers
+ *   - {Number|Array} [timeout]: request timeout(in milliseconds), default is `exports.TIMEOUTS containing connect timeout and response timeout`
+ *   - {Agent} [agent]: optional, http agent. Set `false` if you does not use agent.
+ *   - {Agent} [httpsAgent]: optional, https agent. Set `false` if you does not use agent.
+ *   - {String} [auth]: Basic authentication i.e. 'user:password' to compute an Authorization header.
+ *   - {String} [digestAuth]: Digest authentication i.e. 'user:password' to compute an Authorization header.
+ *   - {String|Buffer|Array} [ca]: An array of strings or Buffers of trusted certificates.
+ *       If this is omitted several well known "root" CAs will be used, like VeriSign.
+ *       These are used to authorize connections.
+ *       Notes: This is necessary only if the server uses the self-signed certificate
+ *   - {Boolean} [rejectUnauthorized]: If true, the server certificate is verified against the list of supplied CAs.
+ *       An 'error' event is emitted if verification fails. Default: true.
+ *   - {String|Buffer} [pfx]: A string or Buffer containing the private key,
+ *       certificate and CA certs of the server in PFX or PKCS12 format.
+ *   - {String|Buffer} [key]: A string or Buffer containing the private key of the client in PEM format.
+ *       Notes: This is necessary only if using the client certificate authentication
+ *   - {String|Buffer} [cert]: A string or Buffer containing the certificate key of the client in PEM format.
+ *       Notes: This is necessary only if using the client certificate authentication
+ *   - {String} [passphrase]: A string of passphrase for the private key or pfx.
+ *   - {String} [ciphers]: A string describing the ciphers to use or exclude.
+ *   - {String} [secureProtocol]: The SSL method to use, e.g. SSLv3_method to force SSL version 3.
+ *       The possible values depend on your installation of OpenSSL and are defined in the constant SSL_METHODS.
+ *   - {Boolean} [followRedirect]: Follow HTTP 3xx responses as redirects. defaults to false.
+ *   - {Number} [maxRedirects]: The maximum number of redirects to follow, defaults to 10.
+ *   - {Function(from, to)} [formatRedirectUrl]: Format the redirect url by your self. Default is `url.resolve(from, to)`
+ *   - {Function(options)} [beforeRequest]: Before request hook, you can change every thing here.
+ *   - {Boolean} [streaming]: let you get the res object when request connected, default is `false`. alias `customResponse`
+ *   - {Boolean} [gzip]: Accept gzip response content and auto decode it, default is `false`.
+ *   - {Boolean} [timing]: Enable timing or not, default is `false`.
+ *   - {Function} [lookup]: Custom DNS lookup function, default is `dns.lookup`.
+ *       Require node >= 4.0.0 and only work on `http` protocol.
+ * @param {Function} [callback], callback(error, data, res). If missing callback, will return a promise object.
+ * @return {HttpRequest} req object.
+ * @api public
+ */
+exports.request = function request(url, args, callback) {
+  // request(url, callback)
+  if (arguments.length === 2 && typeof args === 'function') {
+    callback = args;
+    args = null;
+  }
+  if (typeof callback === 'function') {
+    return exports.requestWithCallback(url, args, callback);
+  }
+
+  // Promise
+  if (!_Promise) {
+    _Promise = require('any-promise');
+  }
+  return new _Promise(function (resolve, reject) {
+    exports.requestWithCallback(url, args, makeCallback(resolve, reject));
+  });
+};
+
+// alias to curl
+exports.curl = exports.request;
+
+function makeCallback(resolve, reject) {
+  return function (err, data, res) {
+    if (err) {
+      return reject(err);
+    }
+    resolve({
+      data: data,
+      status: res.statusCode,
+      headers: res.headers,
+      res: res
+    });
+  };
+}
+
+// yield urllib.requestThunk(url, args)
+exports.requestThunk = function requestThunk(url, args) {
+  return function (callback) {
+    exports.requestWithCallback(url, args, function (err, data, res) {
+      if (err) {
+        return callback(err);
+      }
+      callback(null, {
+        data: data,
+        status: res.statusCode,
+        headers: res.headers,
+        res: res
+      });
+    });
+  };
+};
+
+exports.requestWithCallback = function requestWithCallback(url, args, callback) {
+  // requestWithCallback(url, callback)
+  if (!url || typeof url !== 'string' && (typeof url === 'undefined' ? 'undefined' : (0, _typeof3.default)(url)) !== 'object') {
+    var msg = util.format('expect request url to be a string or a http request options, but got %j', url);
+    throw new Error(msg);
+  }
+
+  if (arguments.length === 2 && typeof args === 'function') {
+    callback = args;
+    args = null;
+  }
+
+  args = args || {};
+  if (REQUEST_ID >= MAX_VALUE) {
+    REQUEST_ID = 0;
+  }
+  var reqId = ++REQUEST_ID;
+
+  args.requestUrls = args.requestUrls || [];
+
+  if (args.emitter) {
+    args.emitter.emit('request', {
+      requestId: reqId,
+      url: url,
+      args: args,
+      ctx: args.ctx
+    });
+  }
+
+  args.timeout = args.timeout || exports.TIMEOUTS;
+  args.maxRedirects = args.maxRedirects || 10;
+  args.streaming = args.streaming || args.customResponse;
+  var requestStartTime = Date.now();
+  var parsedUrl;
+
+  if (typeof url === 'string') {
+    if (!PROTO_RE.test(url)) {
+      // Support `request('www.server.com')`
+      url = 'http://' + url;
+    }
+    parsedUrl = urlutil.parse(url);
+  } else {
+    parsedUrl = url;
+  }
+
+  var method = (args.type || args.method || parsedUrl.method || 'GET').toUpperCase();
+  var port = parsedUrl.port || 80;
+  var httplib = http;
+  var agent = getAgent(args.agent, exports.agent);
+  var fixJSONCtlChars = !!args.fixJSONCtlChars;
+
+  if (parsedUrl.protocol === 'https:') {
+    httplib = https;
+    agent = getAgent(args.httpsAgent, exports.httpsAgent);
+
+    if (!parsedUrl.port) {
+      port = 443;
+    }
+  }
+
+  var options = {
+    host: parsedUrl.hostname || parsedUrl.host || 'localhost',
+    path: parsedUrl.path || '/',
+    method: method,
+    port: port,
+    agent: agent,
+    headers: args.headers || {},
+    // default is dns.lookup
+    // https://github.com/nodejs/node/blob/master/lib/net.js#L986
+    // custom dnslookup require node >= 4.0.0
+    // https://github.com/nodejs/node/blob/archived-io.js-v0.12/lib/net.js#L952
+    lookup: args.lookup
+  };
+
+  var sslNames = ['pfx', 'key', 'passphrase', 'cert', 'ca', 'ciphers', 'rejectUnauthorized', 'secureProtocol', 'secureOptions'];
+  for (var i = 0; i < sslNames.length; i++) {
+    var name = sslNames[i];
+    if (args.hasOwnProperty(name)) {
+      options[name] = args[name];
+    }
+  }
+
+  // don't check ssl
+  if (options.rejectUnauthorized === false && !options.hasOwnProperty('secureOptions')) {
+    options.secureOptions = require('constants').SSL_OP_NO_TLSv1_2;
+  }
+
+  var auth = args.auth || parsedUrl.auth;
+  if (auth) {
+    options.auth = auth;
+  }
+
+  var body = args.content || args.data;
+  var isReadAction = method === 'GET' || method === 'HEAD';
+  if (!args.content) {
+    if (body && !(typeof body === 'string' || Buffer.isBuffer(body))) {
+      if (isReadAction) {
+        // read: GET, HEAD, use query string
+        body = qs.stringify(body);
+      } else {
+        var contentType = options.headers['Content-Type'] || options.headers['content-type'];
+        // auto add application/x-www-form-urlencoded when using urlencode form request
+        if (!contentType) {
+          if (args.contentType === 'json') {
+            contentType = 'application/json';
+          } else {
+            contentType = 'application/x-www-form-urlencoded';
+          }
+          options.headers['Content-Type'] = contentType;
+        }
+
+        if (parseContentType(contentType).type === 'application/json') {
+          body = (0, _stringify2.default)(body);
+        } else {
+          // 'application/x-www-form-urlencoded'
+          body = qs.stringify(body);
+        }
+      }
+    }
+  }
+
+  // if it's a GET or HEAD request, data should be sent as query string
+  if (isReadAction && body) {
+    options.path += (parsedUrl.query ? '&' : '?') + body;
+    body = null;
+  }
+
+  var requestSize = 0;
+  if (body) {
+    var length = body.length;
+    if (!Buffer.isBuffer(body)) {
+      length = Buffer.byteLength(body);
+    }
+    requestSize = options.headers['Content-Length'] = length;
+  }
+
+  if (args.dataType === 'json') {
+    options.headers.Accept = 'application/json';
+  }
+
+  if (typeof args.beforeRequest === 'function') {
+    // you can use this hook to change every thing.
+    args.beforeRequest(options);
+  }
+  var connectTimer = null;
+  var responseTimer = null;
+  var __err = null;
+  var connected = false; // socket connected or not
+  var keepAliveSocket = false; // request with keepalive socket
+  var responseSize = 0;
+  var statusCode = -1;
+  var responseAborted = false;
+  var remoteAddress = '';
+  var remotePort = '';
+  var timing = null;
+  if (args.timing) {
+    timing = {
+      // socket assigned
+      queuing: 0,
+      // dns lookup time
+      dnslookup: 0,
+      // socket connected
+      connected: 0,
+      // request sent
+      requestSent: 0,
+      // Time to first byte (TTFB)
+      waiting: 0,
+      contentDownload: 0
+    };
+  }
+
+  function cancelConnectTimer() {
+    if (connectTimer) {
+      clearTimeout(connectTimer);
+      connectTimer = null;
+    }
+  }
+  function cancelResponseTimer() {
+    if (responseTimer) {
+      clearTimeout(responseTimer);
+      responseTimer = null;
+    }
+  }
+
+  function done(err, data, res) {
+    cancelResponseTimer();
+    if (!callback) {
+      console.warn('[urllib:warn] [%s] [worker:%s] %s %s callback twice!!!', Date(), process.pid, options.method, url);
+      // https://github.com/node-modules/urllib/pull/30
+      if (err) {
+        console.warn('[urllib:warn] [%s] [worker:%s] %s: %s\nstack: %s', Date(), process.pid, err.name, err.message, err.stack);
+      }
+      return;
+    }
+    var cb = callback;
+    callback = null;
+    var headers = {};
+    if (res) {
+      statusCode = res.statusCode;
+      headers = res.headers;
+    }
+
+    // handle digest auth
+    if (statusCode === 401 && headers['www-authenticate'] && (!args.headers || !args.headers.Authorization) && args.digestAuth) {
+      var authenticate = headers['www-authenticate'];
+      if (authenticate.indexOf('Digest ') >= 0) {
+        debug('Request#%d %s: got digest auth header WWW-Authenticate: %s', reqId, url, authenticate);
+        args.headers = args.headers || {};
+        args.headers.Authorization = digestAuthHeader(options.method, options.path, authenticate, args.digestAuth);
+        debug('Request#%d %s: auth with digest header: %s', reqId, url, args.headers.Authorization);
+        if (res.headers['set-cookie']) {
+          args.headers.Cookie = res.headers['set-cookie'].join(';');
+        }
+        return exports.requestWithCallback(url, args, cb);
+      }
+    }
+
+    var requestUseTime = Date.now() - requestStartTime;
+    if (timing) {
+      timing.contentDownload = requestUseTime;
+    }
+
+    debug('[%sms] done, %s bytes HTTP %s %s %s %s, keepAliveSocket: %s, timing: %j', requestUseTime, responseSize, statusCode, options.method, options.host, options.path, keepAliveSocket, timing);
+
+    var response = {
+      status: statusCode,
+      statusCode: statusCode,
+      headers: headers,
+      size: responseSize,
+      aborted: responseAborted,
+      rt: requestUseTime,
+      keepAliveSocket: keepAliveSocket,
+      data: data,
+      requestUrls: args.requestUrls,
+      timing: timing,
+      remoteAddress: remoteAddress,
+      remotePort: remotePort
+    };
+
+    if (err) {
+      var agentStatus = '';
+      if (agent && typeof agent.getCurrentStatus === 'function') {
+        // add current agent status to error message for logging and debug
+        agentStatus = ', agent status: ' + (0, _stringify2.default)(agent.getCurrentStatus());
+      }
+      err.message += ', ' + options.method + ' ' + url + ' ' + statusCode + ' (connected: ' + connected + ', keepalive socket: ' + keepAliveSocket + agentStatus + ')' + '\nheaders: ' + (0, _stringify2.default)(headers);
+      err.data = data;
+      err.path = options.path;
+      err.status = statusCode;
+      err.headers = headers;
+      err.res = response;
+    }
+
+    cb(err, data, args.streaming ? res : response);
+
+    if (args.emitter) {
+      args.emitter.emit('response', {
+        requestId: reqId,
+        error: err,
+        ctx: args.ctx,
+        req: {
+          url: url,
+          socket: req && req.connection,
+          options: options,
+          size: requestSize
+        },
+        res: response
+      });
+    }
+  }
+
+  function handleRedirect(res) {
+    var err = null;
+    if (args.followRedirect && statuses.redirect[res.statusCode]) {
+      // handle redirect
+      args._followRedirectCount = (args._followRedirectCount || 0) + 1;
+      var location = res.headers.location;
+      if (!location) {
+        err = new Error('Got statusCode ' + res.statusCode + ' but cannot resolve next location from headers');
+        err.name = 'FollowRedirectError';
+      } else if (args._followRedirectCount > args.maxRedirects) {
+        err = new Error('Exceeded maxRedirects. Probably stuck in a redirect loop ' + url);
+        err.name = 'MaxRedirectError';
+      } else {
+        var newUrl = args.formatRedirectUrl ? args.formatRedirectUrl(url, location) : urlutil.resolve(url, location);
+        debug('Request#%d %s: `redirected` from %s to %s', reqId, options.path, url, newUrl);
+        // make sure timer stop
+        cancelResponseTimer();
+        // should clean up headers.Host on `location: http://other-domain/url`
+        if (args.headers && args.headers.Host && PROTO_RE.test(location)) {
+          args.headers.Host = null;
+        }
+        // avoid done will be execute in the future change.
+        var cb = callback;
+        callback = null;
+        exports.requestWithCallback(newUrl, args, cb);
+        return {
+          redirect: true,
+          error: null
+        };
+      }
+    }
+    return {
+      redirect: false,
+      error: err
+    };
+  }
+
+  // set user-agent
+  if (!options.headers['User-Agent'] && !options.headers['user-agent']) {
+    options.headers['User-Agent'] = USER_AGENT;
+  }
+
+  if (args.gzip) {
+    if (!options.headers['Accept-Encoding'] && !options.headers['accept-encoding']) {
+      options.headers['Accept-Encoding'] = 'gzip';
+    }
+  }
+
+  function decodeContent(res, body, cb) {
+    var encoding = res.headers['content-encoding'];
+    if (body.length === 0) {
+      return cb(null, body, encoding);
+    }
+
+    if (!encoding || encoding.toLowerCase() !== 'gzip') {
+      return cb(null, body, encoding);
+    }
+
+    debug('gunzip %d length body', body.length);
+    zlib.gunzip(body, cb);
+  }
+
+  var writeStream = args.writeStream;
+
+  debug('Request#%d %s %s with headers %j, options.path: %s', reqId, method, url, options.headers, options.path);
+
+  args.requestUrls.push(url);
+
+  function onResponse(res) {
+    if (timing) {
+      timing.waiting = Date.now() - requestStartTime;
+    }
+    debug('Request#%d %s `req response` event emit: status %d, headers: %j', reqId, url, res.statusCode, res.headers);
+
+    if (args.streaming) {
+      var result = handleRedirect(res);
+      if (result.redirect) {
+        res.resume();
+        return;
+      }
+      if (result.error) {
+        res.resume();
+        return done(result.error, null, res);
+      }
+
+      return done(null, null, res);
+    }
+
+    if (writeStream) {
+      // If there's a writable stream to recieve the response data, just pipe the
+      // response stream to that writable stream and call the callback when it has
+      // finished writing.
+      //
+      // NOTE that when the response stream `res` emits an 'end' event it just
+      // means that it has finished piping data to another stream. In the
+      // meanwhile that writable stream may still writing data to the disk until
+      // it emits a 'close' event.
+      //
+      // That means that we should not apply callback until the 'close' of the
+      // writable stream is emited.
+      //
+      // See also:
+      // - https://github.com/TBEDP/urllib/commit/959ac3365821e0e028c231a5e8efca6af410eabb
+      // - http://nodejs.org/api/stream.html#stream_event_end
+      // - http://nodejs.org/api/stream.html#stream_event_close_1
+      var result = handleRedirect(res);
+      if (result.redirect) {
+        res.resume();
+        return;
+      }
+      if (result.error) {
+        res.resume();
+        // end ths stream first
+        writeStream.end();
+        return done(result.error, null, res);
+      }
+      // you can set consumeWriteStream false that only wait response end
+      if (args.consumeWriteStream === false) {
+        res.on('end', done.bind(null, null, null, res));
+      } else {
+        writeStream.on('close', done.bind(null, null, null, res));
+      }
+      return res.pipe(writeStream);
+    }
+
+    // Otherwise, just concat those buffers.
+    //
+    // NOTE that the `chunk` is not a String but a Buffer. It means that if
+    // you simply concat two chunk with `+` you're actually converting both
+    // Buffers into Strings before concating them. It'll cause problems when
+    // dealing with multi-byte characters.
+    //
+    // The solution is to store each chunk in an array and concat them with
+    // 'buffer-concat' when all chunks is recieved.
+    //
+    // See also:
+    // http://cnodejs.org/topic/4faf65852e8fb5bc65113403
+
+    var chunks = [];
+
+    res.on('data', function (chunk) {
+      debug('Request#%d %s: `res data` event emit, size %d', reqId, url, chunk.length);
+      responseSize += chunk.length;
+      chunks.push(chunk);
+    });
+
+    // res.on('close', function () {
+    //   debug('Request#%d %s: `res close` event emit, total size %d',
+    //     reqId, url, responseSize);
+    // });
+
+    // res.on('error', function () {
+    //   debug('Request#%d %s: `res error` event emit, total size %d',
+    //     reqId, url, responseSize);
+    // });
+
+    res.on('aborted', function () {
+      responseAborted = true;
+      debug('Request#%d %s: `res aborted` event emit, total size %d', reqId, url, responseSize);
+    });
+
+    res.on('end', function () {
+      var body = Buffer.concat(chunks, responseSize);
+      debug('Request#%d %s: `res end` event emit, total size %d, _dumped: %s', reqId, url, responseSize, res._dumped);
+
+      if (__err) {
+        // req.abort() after `res data` event emit.
+        return done(__err, body, res);
+      }
+
+      var result = handleRedirect(res);
+      if (result.error) {
+        return done(result.error, body, res);
+      }
+      if (result.redirect) {
+        return;
+      }
+
+      decodeContent(res, body, function (err, data, encoding) {
+        if (err) {
+          return done(err, body, res);
+        }
+        // if body not decode, dont touch it
+        if (!encoding && TEXT_DATA_TYPES.indexOf(args.dataType) >= 0) {
+          // try to decode charset
+          try {
+            data = decodeBodyByCharset(data, res);
+          } catch (e) {
+            debug('decodeBodyByCharset error: %s', e);
+            // if error, dont touch it
+            return done(null, data, res);
+          }
+
+          if (args.dataType === 'json') {
+            if (responseSize === 0) {
+              data = null;
+            } else {
+              var r = parseJSON(data, fixJSONCtlChars);
+              if (r.error) {
+                err = r.error;
+              } else {
+                data = r.data;
+              }
+            }
+          }
+        }
+
+        if (responseAborted) {
+          // err = new Error('Remote socket was terminated before `response.end()` was called');
+          // err.name = 'RemoteSocketClosedError';
+          debug('Request#%d %s: Remote socket was terminated before `response.end()` was called', reqId, url);
+        }
+
+        done(err, data, res);
+      });
+    });
+  }
+
+  var connectTimeout, responseTimeout;
+  if (Array.isArray(args.timeout)) {
+    connectTimeout = ms(args.timeout[0]);
+    responseTimeout = ms(args.timeout[1]);
+  } else {
+    // set both timeout equal
+    connectTimeout = responseTimeout = ms(args.timeout);
+  }
+  debug('ConnectTimeout: %d, ResponseTimeout: %d', connectTimeout, responseTimeout);
+
+  function startConnectTimer() {
+    debug('Connect timer ticking, timeout: %d', connectTimeout);
+    connectTimer = setTimeout(function () {
+      connectTimer = null;
+      if (statusCode === -1) {
+        statusCode = -2;
+      }
+      var msg = 'Connect timeout for ' + connectTimeout + 'ms';
+      var errorName = 'ConnectionTimeoutError';
+      if (!req.socket) {
+        errorName = 'SocketAssignTimeoutError';
+        msg += ', working sockets is full';
+      }
+      __err = new Error(msg);
+      __err.name = errorName;
+      __err.requestId = reqId;
+      debug('ConnectTimeout: Request#%d %s %s: %s, connected: %s', reqId, url, __err.name, msg, connected);
+      abortRequest();
+    }, connectTimeout);
+  }
+
+  function startResposneTimer() {
+    debug('Response timer ticking, timeout: %d', responseTimeout);
+    responseTimer = setTimeout(function () {
+      responseTimer = null;
+      var msg = 'Response timeout for ' + responseTimeout + 'ms';
+      var errorName = 'ResponseTimeoutError';
+      __err = new Error(msg);
+      __err.name = errorName;
+      __err.requestId = reqId;
+      debug('ResponseTimeout: Request#%d %s %s: %s, connected: %s', reqId, url, __err.name, msg, connected);
+      abortRequest();
+    }, responseTimeout);
+  }
+
+  var req;
+  // request headers checker will throw error
+  try {
+    req = httplib.request(options, onResponse);
+  } catch (err) {
+    return done(err);
+  }
+  // start connect timer just after `request` return
+  startConnectTimer();
+
+  function abortRequest() {
+    debug('Request#%d %s abort, connected: %s', reqId, url, connected);
+    // it wont case error event when req haven't been assigned a socket yet.
+    if (!req.socket) {
+      __err.noSocket = true;
+      done(__err);
+    }
+    req.abort();
+  }
+
+  if (timing) {
+    // request sent
+    req.on('finish', function () {
+      timing.requestSent = Date.now() - requestStartTime;
+    });
+  }
+
+  req.once('socket', function (socket) {
+    if (timing) {
+      // socket queuing time
+      timing.queuing = Date.now() - requestStartTime;
+    }
+
+    // https://github.com/nodejs/node/blob/master/lib/net.js#L377
+    // https://github.com/nodejs/node/blob/v0.10.40-release/lib/net.js#L352
+    // should use socket.socket on 0.10.x
+    if (isOldVersionNode && socket.socket) {
+      socket = socket.socket;
+    }
+
+    var readyState = socket.readyState;
+    if (readyState === 'opening') {
+      socket.once('lookup', function (err, ip, addressType) {
+        debug('Request#%d %s lookup: %s, %s, %s', reqId, url, err, ip, addressType);
+        if (timing) {
+          timing.dnslookup = Date.now() - requestStartTime;
+        }
+        if (ip) {
+          remoteAddress = ip;
+        }
+      });
+      socket.once('connect', function () {
+        if (timing) {
+          // socket connected
+          timing.connected = Date.now() - requestStartTime;
+        }
+
+        // cancel socket timer at first and start tick for TTFB
+        cancelConnectTimer();
+        startResposneTimer();
+
+        debug('Request#%d %s new socket connected', reqId, url);
+        connected = true;
+        if (!remoteAddress) {
+          remoteAddress = socket.remoteAddress;
+        }
+        remotePort = socket.remotePort;
+      });
+      return;
+    }
+
+    debug('Request#%d %s reuse socket connected, readyState: %s', reqId, url, readyState);
+    connected = true;
+    keepAliveSocket = true;
+    if (!remoteAddress) {
+      remoteAddress = socket.remoteAddress;
+    }
+    remotePort = socket.remotePort;
+
+    // reuse socket, timer should be canceled.
+    cancelConnectTimer();
+    startResposneTimer();
+  });
+
+  req.on('error', function (err) {
+    if (err.name === 'Error') {
+      err.name = connected ? 'ResponseError' : 'RequestError';
+    }
+    err.message += ' (req "error")';
+    debug('Request#%d %s `req error` event emit, %s: %s', reqId, url, err.name, err.message);
+    done(__err || err);
+  });
+
+  if (writeStream) {
+    writeStream.once('error', function (err) {
+      err.message += ' (writeStream "error")';
+      __err = err;
+      debug('Request#%d %s `writeStream error` event emit, %s: %s', reqId, url, err.name, err.message);
+      abortRequest();
+    });
+  }
+
+  if (args.stream) {
+    args.stream.pipe(req);
+    args.stream.once('error', function (err) {
+      err.message += ' (stream "error")';
+      __err = err;
+      debug('Request#%d %s `readStream error` event emit, %s: %s', reqId, url, err.name, err.message);
+      abortRequest();
+    });
+  } else {
+    req.end(body);
+  }
+
+  req.requestId = reqId;
+  return req;
+};
+
+var JSONCtlCharsMap = {
+  '"': '\\"', // \u0022
+  '\\': '\\\\', // \u005c
+  '\b': '\\b', // \u0008
+  '\f': '\\f', // \u000c
+  '\n': '\\n', // \u000a
+  '\r': '\\r', // \u000d
+  '\t': '\\t' // \u0009
+};
+var JSONCtlCharsRE = /[\u0000-\u001F\u005C]/g;
+
+function _replaceOneChar(c) {
+  return JSONCtlCharsMap[c] || '\\u' + (c.charCodeAt(0) + 0x10000).toString(16).substr(1);
+}
+
+function replaceJSONCtlChars(str) {
+  return str.replace(JSONCtlCharsRE, _replaceOneChar);
+}
+
+function parseJSON(data, fixJSONCtlChars) {
+  var result = {
+    error: null,
+    data: null
+  };
+  if (fixJSONCtlChars) {
+    // https://github.com/node-modules/urllib/pull/77
+    // remote the control characters (U+0000 through U+001F)
+    data = replaceJSONCtlChars(data);
+  }
+  try {
+    result.data = JSON.parse(data);
+  } catch (err) {
+    if (err.name === 'SyntaxError') {
+      err.name = 'JSONResponseFormatError';
+    }
+    if (data.length > 1024) {
+      // show 0~512 ... -512~end data
+      err.message += ' (data json format: ' + (0, _stringify2.default)(data.slice(0, 512)) + ' ...skip... ' + (0, _stringify2.default)(data.slice(data.length - 512)) + ')';
+    } else {
+      err.message += ' (data json format: ' + (0, _stringify2.default)(data) + ')';
+    }
+    result.error = err;
+  }
+  return result;
+}
+
+function HttpClient(options) {
+  EventEmitter.call(this);
+  options = options || {};
+
+  if (options.agent !== undefined) {
+    this.agent = options.agent;
+    this.hasCustomAgent = true;
+  } else {
+    this.agent = exports.agent;
+    this.hasCustomAgent = false;
+  }
+
+  if (options.httpsAgent !== undefined) {
+    this.httpsAgent = options.httpsAgent;
+    this.hasCustomHttpsAgent = true;
+  } else {
+    this.httpsAgent = exports.httpsAgent;
+    this.hasCustomHttpsAgent = false;
+  }
+}
+util.inherits(HttpClient, EventEmitter);
+
+HttpClient.prototype.request = HttpClient.prototype.curl = function (url, args, callback) {
+  if (typeof args === 'function') {
+    callback = args;
+    args = null;
+  }
+  args = args || {};
+  args.emitter = this;
+  args.agent = getAgent(args.agent, this.agent);
+  args.httpsAgent = getAgent(args.httpsAgent, this.httpsAgent);
+  return exports.request(url, args, callback);
+};
+
+HttpClient.prototype.requestThunk = function (url, args) {
+  args = args || {};
+  args.emitter = this;
+  args.agent = getAgent(args.agent, this.agent);
+  args.httpsAgent = getAgent(args.httpsAgent, this.httpsAgent);
+  return exports.requestThunk(url, args);
+};
+
+exports.HttpClient = HttpClient;
+
+exports.create = function (options) {
+  return new HttpClient(options);
+};
+
+/**
+ * decode response body by parse `content-type`'s charset
+ * @param {Buffer} data
+ * @param {Http(s)Response} res
+ * @return {String}
+ */
+function decodeBodyByCharset(data, res) {
+  var type = res.headers['content-type'];
+  if (!type) {
+    return data.toString();
+  }
+
+  var type = parseContentType(type);
+  var charset = type.parameters.charset || 'utf-8';
+
+  if (!Buffer.isEncoding(charset)) {
+    if (!_iconv) {
+      _iconv = {};
+    }
+    return _iconv.decode(data, charset);
+  }
+
+  return data.toString(charset);
+}
+
+function getAgent(agent, defaultAgent) {
+  return agent === undefined ? defaultAgent : agent;
+}
+
+function parseContentType(str) {
+  try {
+    return contentTypeParser.parse(str);
+  } catch (err) {
+    // ignore content-type error, tread as default
+    return { parameters: {} };
+  }
+}
+
+}).call(this,require('_process'),require("buffer").Buffer)
+},{"../package.json":380,"_process":345,"any-promise":12,"babel-runtime/core-js/json/stringify":18,"babel-runtime/helpers/typeof":39,"buffer":45,"constants":52,"content-type":53,"debug":184,"default-user-agent":186,"digest-header":188,"events":193,"http":370,"https":195,"humanize-ms":196,"querystring":349,"statuses":368,"url":377,"util":384}],380:[function(require,module,exports){
+module.exports={
+  "_args": [
+    [
+      {
+        "raw": "urllib@^2.16.1",
+        "scope": null,
+        "escapedName": "urllib",
+        "name": "urllib",
+        "rawSpec": "^2.16.1",
+        "spec": ">=2.16.1 <3.0.0",
+        "type": "range"
+      },
+      "/Users/deadhorse/git/ali-oss"
+    ]
+  ],
+  "_cnpm_publish_time": 1476348058960,
+  "_from": "urllib@>=2.16.1 <3.0.0",
+  "_id": "urllib@2.17.0",
+  "_inCache": true,
+  "_location": "/urllib",
+  "_nodeVersion": "4.4.7",
+  "_npmOperationalInternal": {
+    "host": "packages-16-east.internal.npmjs.com",
+    "tmp": "tmp/urllib-2.17.0.tgz_1476348057935_0.42674178583547473"
+  },
+  "_npmUser": {
+    "name": "dead_horse",
+    "email": "dead_horse@qq.com"
+  },
+  "_npmVersion": "3.10.3",
+  "_phantomChildren": {},
+  "_requested": {
+    "raw": "urllib@^2.16.1",
+    "scope": null,
+    "escapedName": "urllib",
+    "name": "urllib",
+    "rawSpec": "^2.16.1",
+    "spec": ">=2.16.1 <3.0.0",
+    "type": "range"
+  },
+  "_requiredBy": [
+    "/",
+    "/autod"
+  ],
+  "_resolved": "http://registry.npm.taobao.org/urllib/download/urllib-2.17.0.tgz",
+  "_shasum": "062264d52f1713deddecc7dd8e0e9000864099a9",
+  "_shrinkwrap": null,
+  "_spec": "urllib@^2.16.1",
+  "_where": "/Users/deadhorse/git/ali-oss",
+  "author": {
+    "name": "fengmk2",
+    "email": "m@fengmk2.com",
+    "url": "http://fengmk2.com"
+  },
+  "bugs": {
+    "url": "https://github.com/node-modules/urllib/issues"
+  },
+  "contributors": [
+    {
+      "name": "fengmk2",
+      "email": "fengmk2@gmail.com",
+      "url": "http://fengmk2.com"
+    },
+    {
+      "name": "aleafs",
+      "email": "zhangxc83@gmail.com",
+      "url": "https://github.com/aleafs"
+    },
+    {
+      "name": "Jackson Tian",
+      "email": "shyvo1987@gmail.com",
+      "url": "https://github.com/JacksonTian"
+    },
+    {
+      "name": "ibigbug",
+      "email": "x1aoba@icloud.com",
+      "url": "https://github.com/ibigbug"
+    },
+    {
+      "name": "XiNGRZ",
+      "email": "chenxingyu92@gmail.com",
+      "url": "https://github.com/XiNGRZ"
+    },
+    {
+      "name": "dead_horse",
+      "email": "dead_horse@qq.com",
+      "url": "http://deadhorse.me/"
+    },
+    {
+      "name": "coderhaoxin",
+      "email": "coderhaoxin@outlook.com",
+      "url": "https://github.com/coderhaoxin"
+    },
+    {
+      "name": "alsotang",
+      "email": "alsotang@gmail.com",
+      "url": "https://github.com/alsotang"
+    },
+    {
+      "name": "Jonathan Dahan",
+      "email": "jonathan@jedahan.com",
+      "url": "https://github.com/jedahan"
+    },
+    {
+      "name": "popomore",
+      "email": "sakura9515@gmail.com",
+      "url": "https://github.com/popomore"
+    },
+    {
+      "name": "fishbar",
+      "email": "zhengxinlin@gmail.com",
+      "url": "https://github.com/fishbar"
+    },
+    {
+      "name": "coolme200",
+      "email": "tangyao@taobao.com",
+      "url": "https://github.com/coolme200"
+    },
+    {
+      "name": "amunu",
+      "email": "panyilinlove@qq.com",
+      "url": "https://github.com/Amunu"
+    },
+    {
+      "name": "Yuwei Ba",
+      "email": "xiaobayuwei@gmail.com",
+      "url": "https://github.com/ibigbug"
+    }
+  ],
+  "dependencies": {
+    "any-promise": "^1.2.0",
+    "content-type": "^1.0.2",
+    "debug": "^2.2.0",
+    "default-user-agent": "^1.0.0",
+    "digest-header": "^0.0.1",
+    "humanize-ms": "^1.2.0",
+    "iconv-lite": "^0.4.13",
+    "statuses": "^1.3.0"
+  },
+  "description": "Help in opening URLs (mostly HTTP) in a complex world — basic and digest authentication, redirections, cookies and more.",
+  "devDependencies": {
+    "agentkeepalive": "2",
+    "autod": "*",
+    "bluebird": "*",
+    "co": "*",
+    "coffee": "1",
+    "formstream": "1",
+    "intelli-espower-loader": "^1.0.1",
+    "istanbul": "*",
+    "jshint": "*",
+    "mocha": "*",
+    "pedding": "1",
+    "power-assert": "^1.4.1",
+    "semver": "5",
+    "should": "8",
+    "should-http": "*",
+    "tar": "2",
+    "through2": "2"
+  },
+  "directories": {},
+  "dist": {
+    "shasum": "062264d52f1713deddecc7dd8e0e9000864099a9",
+    "size": 16235,
+    "noattachment": false,
+    "tarball": "http://registry.npm.taobao.org/urllib/download/urllib-2.17.0.tgz"
+  },
+  "engines": {
+    "node": ">= 0.10.0"
+  },
+  "files": [
+    "lib"
+  ],
+  "gitHead": "13662ea1367bc7fac6bff9950c638f53a6d9207b",
+  "homepage": "http://github.com/node-modules/urllib",
+  "keywords": [
+    "urllib",
+    "http",
+    "urlopen",
+    "curl",
+    "wget",
+    "request",
+    "https"
+  ],
+  "license": "MIT",
+  "main": "lib/urllib.js",
+  "maintainers": [
+    {
+      "name": "dead_horse",
+      "email": "dead_horse@qq.com"
+    },
+    {
+      "name": "fengmk2",
+      "email": "fengmk2@gmail.com"
+    }
+  ],
+  "name": "urllib",
+  "optionalDependencies": {},
+  "publish_time": 1476348058960,
+  "readme": "ERROR: No README data found!",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/node-modules/urllib.git"
+  },
+  "scripts": {
+    "autod": "autod -w --prefix '^' -t test -e examples",
+    "ci": "npm run lint && npm run test-cov",
+    "lint": "jshint .",
+    "test": "mocha -R spec -t 30000 -r should -r should-http -r intelli-espower-loader test/*.test.js",
+    "test-cov": "istanbul cover node_modules/mocha/bin/_mocha -- -t 30000 -r should -r should-http -r intelli-espower-loader test/*.test.js"
+  },
+  "version": "2.17.0"
+}
+
+},{}],381:[function(require,module,exports){
+(function (global){
+'use strict';
+
+/**
+ * Module exports.
+ */
+
+module.exports = deprecate;
+
+/**
+ * Mark that a method should not be used.
+ * Returns a modified function which warns once by default.
+ *
+ * If `localStorage.noDeprecation = true` is set, then it is a no-op.
+ *
+ * If `localStorage.throwDeprecation = true` is set, then deprecated functions
+ * will throw an Error when invoked.
+ *
+ * If `localStorage.traceDeprecation = true` is set, then deprecated functions
+ * will invoke `console.trace()` instead of `console.error()`.
+ *
+ * @param {Function} fn - the function to deprecate
+ * @param {String} msg - the string to print to the console when `fn` is invoked
+ * @returns {Function} a new "deprecated" version of `fn`
+ * @api public
+ */
+
+function deprecate(fn, msg) {
+  if (config('noDeprecation')) {
+    return fn;
+  }
+
+  var warned = false;
+  function deprecated() {
+    if (!warned) {
+      if (config('throwDeprecation')) {
+        throw new Error(msg);
+      } else if (config('traceDeprecation')) {
+        console.trace(msg);
+      } else {
+        console.warn(msg);
+      }
+      warned = true;
+    }
+    return fn.apply(this, arguments);
+  }
+
+  return deprecated;
+}
+
+/**
+ * Checks `localStorage` for boolean values for the given `name`.
+ *
+ * @param {String} name
+ * @returns {Boolean}
+ * @api private
+ */
+
+function config(name) {
+  // accessing global.localStorage can trigger a DOMException in sandboxed iframes
+  try {
+    if (!global.localStorage) return false;
+  } catch (_) {
+    return false;
+  }
+  var val = global.localStorage[name];
+  if (null == val) return false;
+  return String(val).toLowerCase() === 'true';
+}
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{}],382:[function(require,module,exports){
+arguments[4][198][0].apply(exports,arguments)
+},{"babel-runtime/core-js/object/create":22,"dup":198}],383:[function(require,module,exports){
+'use strict';
+
+var _typeof2 = require('babel-runtime/helpers/typeof');
+
+var _typeof3 = _interopRequireDefault(_typeof2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+module.exports = function isBuffer(arg) {
+  return arg && (typeof arg === 'undefined' ? 'undefined' : (0, _typeof3.default)(arg)) === 'object' && typeof arg.copy === 'function' && typeof arg.fill === 'function' && typeof arg.readUInt8 === 'function';
+};
+
+},{"babel-runtime/helpers/typeof":39}],384:[function(require,module,exports){
+(function (process,global){
+'use strict';
+
+var _typeof2 = require('babel-runtime/helpers/typeof');
+
+var _typeof3 = _interopRequireDefault(_typeof2);
+
+var _getOwnPropertyDescriptor = require('babel-runtime/core-js/object/get-own-property-descriptor');
+
+var _getOwnPropertyDescriptor2 = _interopRequireDefault(_getOwnPropertyDescriptor);
+
+var _getOwnPropertyNames = require('babel-runtime/core-js/object/get-own-property-names');
+
+var _getOwnPropertyNames2 = _interopRequireDefault(_getOwnPropertyNames);
+
+var _keys = require('babel-runtime/core-js/object/keys');
+
+var _keys2 = _interopRequireDefault(_keys);
+
+var _stringify = require('babel-runtime/core-js/json/stringify');
+
+var _stringify2 = _interopRequireDefault(_stringify);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+var formatRegExp = /%[sdj%]/g;
+exports.format = function (f) {
+  if (!isString(f)) {
+    var objects = [];
+    for (var i = 0; i < arguments.length; i++) {
+      objects.push(inspect(arguments[i]));
+    }
+    return objects.join(' ');
+  }
+
+  var i = 1;
+  var args = arguments;
+  var len = args.length;
+  var str = String(f).replace(formatRegExp, function (x) {
+    if (x === '%%') return '%';
+    if (i >= len) return x;
+    switch (x) {
+      case '%s':
+        return String(args[i++]);
+      case '%d':
+        return Number(args[i++]);
+      case '%j':
+        try {
+          return (0, _stringify2.default)(args[i++]);
+        } catch (_) {
+          return '[Circular]';
+        }
+      default:
+        return x;
+    }
+  });
+  for (var x = args[i]; i < len; x = args[++i]) {
+    if (isNull(x) || !isObject(x)) {
+      str += ' ' + x;
+    } else {
+      str += ' ' + inspect(x);
+    }
+  }
+  return str;
+};
+
+// Mark that a method should not be used.
+// Returns a modified function which warns once by default.
+// If --no-deprecation is set, then it is a no-op.
+exports.deprecate = function (fn, msg) {
+  // Allow for deprecating things in the process of starting up.
+  if (isUndefined(global.process)) {
+    return function () {
+      return exports.deprecate(fn, msg).apply(this, arguments);
+    };
+  }
+
+  if (process.noDeprecation === true) {
+    return fn;
+  }
+
+  var warned = false;
+  function deprecated() {
+    if (!warned) {
+      if (process.throwDeprecation) {
+        throw new Error(msg);
+      } else if (process.traceDeprecation) {
+        console.trace(msg);
+      } else {
+        console.error(msg);
+      }
+      warned = true;
+    }
+    return fn.apply(this, arguments);
+  }
+
+  return deprecated;
+};
+
+var debugs = {};
+var debugEnviron;
+exports.debuglog = function (set) {
+  if (isUndefined(debugEnviron)) debugEnviron = process.env.NODE_DEBUG || '';
+  set = set.toUpperCase();
+  if (!debugs[set]) {
+    if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) {
+      var pid = process.pid;
+      debugs[set] = function () {
+        var msg = exports.format.apply(exports, arguments);
+        console.error('%s %d: %s', set, pid, msg);
+      };
+    } else {
+      debugs[set] = function () {};
+    }
+  }
+  return debugs[set];
+};
+
+/**
+ * Echos the value of a value. Trys to print the value out
+ * in the best way possible given the different types.
+ *
+ * @param {Object} obj The object to print out.
+ * @param {Object} opts Optional options object that alters the output.
+ */
+/* legacy: obj, showHidden, depth, colors*/
+function inspect(obj, opts) {
+  // default options
+  var ctx = {
+    seen: [],
+    stylize: stylizeNoColor
+  };
+  // legacy...
+  if (arguments.length >= 3) ctx.depth = arguments[2];
+  if (arguments.length >= 4) ctx.colors = arguments[3];
+  if (isBoolean(opts)) {
+    // legacy...
+    ctx.showHidden = opts;
+  } else if (opts) {
+    // got an "options" object
+    exports._extend(ctx, opts);
+  }
+  // set default options
+  if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
+  if (isUndefined(ctx.depth)) ctx.depth = 2;
+  if (isUndefined(ctx.colors)) ctx.colors = false;
+  if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
+  if (ctx.colors) ctx.stylize = stylizeWithColor;
+  return formatValue(ctx, obj, ctx.depth);
+}
+exports.inspect = inspect;
+
+// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
+inspect.colors = {
+  'bold': [1, 22],
+  'italic': [3, 23],
+  'underline': [4, 24],
+  'inverse': [7, 27],
+  'white': [37, 39],
+  'grey': [90, 39],
+  'black': [30, 39],
+  'blue': [34, 39],
+  'cyan': [36, 39],
+  'green': [32, 39],
+  'magenta': [35, 39],
+  'red': [31, 39],
+  'yellow': [33, 39]
+};
+
+// Don't use 'blue' not visible on cmd.exe
+inspect.styles = {
+  'special': 'cyan',
+  'number': 'yellow',
+  'boolean': 'yellow',
+  'undefined': 'grey',
+  'null': 'bold',
+  'string': 'green',
+  'date': 'magenta',
+  // "name": intentionally not styling
+  'regexp': 'red'
+};
+
+function stylizeWithColor(str, styleType) {
+  var style = inspect.styles[styleType];
+
+  if (style) {
+    return '\x1B[' + inspect.colors[style][0] + 'm' + str + '\x1B[' + inspect.colors[style][1] + 'm';
+  } else {
+    return str;
+  }
+}
+
+function stylizeNoColor(str, styleType) {
+  return str;
+}
+
+function arrayToHash(array) {
+  var hash = {};
+
+  array.forEach(function (val, idx) {
+    hash[val] = true;
+  });
+
+  return hash;
+}
+
+function formatValue(ctx, value, recurseTimes) {
+  // Provide a hook for user-specified inspect functions.
+  // Check that value is an object with an inspect function on it
+  if (ctx.customInspect && value && isFunction(value.inspect) &&
+  // Filter out the util module, it's inspect function is special
+  value.inspect !== exports.inspect &&
+  // Also filter out any prototype objects using the circular check.
+  !(value.constructor && value.constructor.prototype === value)) {
+    var ret = value.inspect(recurseTimes, ctx);
+    if (!isString(ret)) {
+      ret = formatValue(ctx, ret, recurseTimes);
+    }
+    return ret;
+  }
+
+  // Primitive types cannot have properties
+  var primitive = formatPrimitive(ctx, value);
+  if (primitive) {
+    return primitive;
+  }
+
+  // Look up the keys of the object.
+  var keys = (0, _keys2.default)(value);
+  var visibleKeys = arrayToHash(keys);
+
+  if (ctx.showHidden) {
+    keys = (0, _getOwnPropertyNames2.default)(value);
+  }
+
+  // IE doesn't make error fields non-enumerable
+  // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
+  if (isError(value) && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
+    return formatError(value);
+  }
+
+  // Some type of object without properties can be shortcutted.
+  if (keys.length === 0) {
+    if (isFunction(value)) {
+      var name = value.name ? ': ' + value.name : '';
+      return ctx.stylize('[Function' + name + ']', 'special');
+    }
+    if (isRegExp(value)) {
+      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
+    }
+    if (isDate(value)) {
+      return ctx.stylize(Date.prototype.toString.call(value), 'date');
+    }
+    if (isError(value)) {
+      return formatError(value);
+    }
+  }
+
+  var base = '',
+      array = false,
+      braces = ['{', '}'];
+
+  // Make Array say that they are Array
+  if (isArray(value)) {
+    array = true;
+    braces = ['[', ']'];
+  }
+
+  // Make functions say that they are functions
+  if (isFunction(value)) {
+    var n = value.name ? ': ' + value.name : '';
+    base = ' [Function' + n + ']';
+  }
+
+  // Make RegExps say that they are RegExps
+  if (isRegExp(value)) {
+    base = ' ' + RegExp.prototype.toString.call(value);
+  }
+
+  // Make dates with properties first say the date
+  if (isDate(value)) {
+    base = ' ' + Date.prototype.toUTCString.call(value);
+  }
+
+  // Make error with message first say the error
+  if (isError(value)) {
+    base = ' ' + formatError(value);
+  }
+
+  if (keys.length === 0 && (!array || value.length == 0)) {
+    return braces[0] + base + braces[1];
+  }
+
+  if (recurseTimes < 0) {
+    if (isRegExp(value)) {
+      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
+    } else {
+      return ctx.stylize('[Object]', 'special');
+    }
+  }
+
+  ctx.seen.push(value);
+
+  var output;
+  if (array) {
+    output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
+  } else {
+    output = keys.map(function (key) {
+      return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
+    });
+  }
+
+  ctx.seen.pop();
+
+  return reduceToSingleString(output, base, braces);
+}
+
+function formatPrimitive(ctx, value) {
+  if (isUndefined(value)) return ctx.stylize('undefined', 'undefined');
+  if (isString(value)) {
+    var simple = '\'' + (0, _stringify2.default)(value).replace(/^"|"$/g, '').replace(/'/g, "\\'").replace(/\\"/g, '"') + '\'';
+    return ctx.stylize(simple, 'string');
+  }
+  if (isNumber(value)) return ctx.stylize('' + value, 'number');
+  if (isBoolean(value)) return ctx.stylize('' + value, 'boolean');
+  // For some reason typeof null is "object", so special case here.
+  if (isNull(value)) return ctx.stylize('null', 'null');
+}
+
+function formatError(value) {
+  return '[' + Error.prototype.toString.call(value) + ']';
+}
+
+function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
+  var output = [];
+  for (var i = 0, l = value.length; i < l; ++i) {
+    if (hasOwnProperty(value, String(i))) {
+      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, String(i), true));
+    } else {
+      output.push('');
+    }
+  }
+  keys.forEach(function (key) {
+    if (!key.match(/^\d+$/)) {
+      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, key, true));
+    }
+  });
+  return output;
+}
+
+function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
+  var name, str, desc;
+  desc = (0, _getOwnPropertyDescriptor2.default)(value, key) || { value: value[key] };
+  if (desc.get) {
+    if (desc.set) {
+      str = ctx.stylize('[Getter/Setter]', 'special');
+    } else {
+      str = ctx.stylize('[Getter]', 'special');
+    }
+  } else {
+    if (desc.set) {
+      str = ctx.stylize('[Setter]', 'special');
+    }
+  }
+  if (!hasOwnProperty(visibleKeys, key)) {
+    name = '[' + key + ']';
+  }
+  if (!str) {
+    if (ctx.seen.indexOf(desc.value) < 0) {
+      if (isNull(recurseTimes)) {
+        str = formatValue(ctx, desc.value, null);
+      } else {
+        str = formatValue(ctx, desc.value, recurseTimes - 1);
+      }
+      if (str.indexOf('\n') > -1) {
+        if (array) {
+          str = str.split('\n').map(function (line) {
+            return '  ' + line;
+          }).join('\n').substr(2);
+        } else {
+          str = '\n' + str.split('\n').map(function (line) {
+            return '   ' + line;
+          }).join('\n');
+        }
+      }
+    } else {
+      str = ctx.stylize('[Circular]', 'special');
+    }
+  }
+  if (isUndefined(name)) {
+    if (array && key.match(/^\d+$/)) {
+      return str;
+    }
+    name = (0, _stringify2.default)('' + key);
+    if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
+      name = name.substr(1, name.length - 2);
+      name = ctx.stylize(name, 'name');
+    } else {
+      name = name.replace(/'/g, "\\'").replace(/\\"/g, '"').replace(/(^"|"$)/g, "'");
+      name = ctx.stylize(name, 'string');
+    }
+  }
+
+  return name + ': ' + str;
+}
+
+function reduceToSingleString(output, base, braces) {
+  var numLinesEst = 0;
+  var length = output.reduce(function (prev, cur) {
+    numLinesEst++;
+    if (cur.indexOf('\n') >= 0) numLinesEst++;
+    return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
+  }, 0);
+
+  if (length > 60) {
+    return braces[0] + (base === '' ? '' : base + '\n ') + ' ' + output.join(',\n  ') + ' ' + braces[1];
+  }
+
+  return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
+}
+
+// NOTE: These type checking functions intentionally don't use `instanceof`
+// because it is fragile and can be easily faked with `Object.create()`.
+function isArray(ar) {
+  return Array.isArray(ar);
+}
+exports.isArray = isArray;
+
+function isBoolean(arg) {
+  return typeof arg === 'boolean';
+}
+exports.isBoolean = isBoolean;
+
+function isNull(arg) {
+  return arg === null;
+}
+exports.isNull = isNull;
+
+function isNullOrUndefined(arg) {
+  return arg == null;
+}
+exports.isNullOrUndefined = isNullOrUndefined;
+
+function isNumber(arg) {
+  return typeof arg === 'number';
+}
+exports.isNumber = isNumber;
+
+function isString(arg) {
+  return typeof arg === 'string';
+}
+exports.isString = isString;
+
+function isSymbol(arg) {
+  return (typeof arg === 'undefined' ? 'undefined' : (0, _typeof3.default)(arg)) === 'symbol';
+}
+exports.isSymbol = isSymbol;
+
+function isUndefined(arg) {
+  return arg === void 0;
+}
+exports.isUndefined = isUndefined;
+
+function isRegExp(re) {
+  return isObject(re) && objectToString(re) === '[object RegExp]';
+}
+exports.isRegExp = isRegExp;
+
+function isObject(arg) {
+  return (typeof arg === 'undefined' ? 'undefined' : (0, _typeof3.default)(arg)) === 'object' && arg !== null;
+}
+exports.isObject = isObject;
+
+function isDate(d) {
+  return isObject(d) && objectToString(d) === '[object Date]';
+}
+exports.isDate = isDate;
+
+function isError(e) {
+  return isObject(e) && (objectToString(e) === '[object Error]' || e instanceof Error);
+}
+exports.isError = isError;
+
+function isFunction(arg) {
+  return typeof arg === 'function';
+}
+exports.isFunction = isFunction;
+
+function isPrimitive(arg) {
+  return arg === null || typeof arg === 'boolean' || typeof arg === 'number' || typeof arg === 'string' || (typeof arg === 'undefined' ? 'undefined' : (0, _typeof3.default)(arg)) === 'symbol' || // ES6 symbol
+  typeof arg === 'undefined';
+}
+exports.isPrimitive = isPrimitive;
+
+exports.isBuffer = require('./support/isBuffer');
+
+function objectToString(o) {
+  return Object.prototype.toString.call(o);
+}
+
+function pad(n) {
+  return n < 10 ? '0' + n.toString(10) : n.toString(10);
+}
+
+var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+
+// 26 Feb 16:19:34
+function timestamp() {
+  var d = new Date();
+  var time = [pad(d.getHours()), pad(d.getMinutes()), pad(d.getSeconds())].join(':');
+  return [d.getDate(), months[d.getMonth()], time].join(' ');
+}
+
+// log is just a thin wrapper to console.log that prepends a timestamp
+exports.log = function () {
+  console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));
+};
+
+/**
+ * Inherit the prototype methods from one constructor into another.
+ *
+ * The Function.prototype.inherits from lang.js rewritten as a standalone
+ * function (not on Function.prototype). NOTE: If this file is to be loaded
+ * during bootstrapping this function needs to be rewritten using some native
+ * functions as prototype setup using normal JavaScript does not work as
+ * expected during bootstrapping (see mirror.js in r114903).
+ *
+ * @param {function} ctor Constructor function which needs to inherit the
+ *     prototype.
+ * @param {function} superCtor Constructor function to inherit prototype from.
+ */
+exports.inherits = require('inherits');
+
+exports._extend = function (origin, add) {
+  // Don't do anything if add isn't an object
+  if (!add || !isObject(add)) return origin;
+
+  var keys = (0, _keys2.default)(add);
+  var i = keys.length;
+  while (i--) {
+    origin[keys[i]] = add[keys[i]];
+  }
+  return origin;
+};
+
+function hasOwnProperty(obj, prop) {
+  return Object.prototype.hasOwnProperty.call(obj, prop);
+}
+
+}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"./support/isBuffer":383,"_process":345,"babel-runtime/core-js/json/stringify":18,"babel-runtime/core-js/object/get-own-property-descriptor":25,"babel-runtime/core-js/object/get-own-property-names":26,"babel-runtime/core-js/object/keys":30,"babel-runtime/helpers/typeof":39,"inherits":382}],385:[function(require,module,exports){
+/**
+ * Copyright(c) node-modules and other contributors.
+ * MIT Licensed
+ *
+ * Authors:
+ *   fengmk2 <fengmk2@gmail.com> (http://fengmk2.com)
+ */
+
+"use strict";
+
+/**
+ * Array random slice with items count.
+ * @param {Array} arr
+ * @param {Number} num, number of sub items.
+ * @return {Array}
+ */
+
+exports.randomSlice = function randomSlice(arr, num) {
+  if (!num || num >= arr.length) {
+    return arr.slice();
+  }
+  var index = Math.floor(Math.random() * arr.length);
+  var a = [];
+  for (var i = 0, j = index; i < num; i++) {
+    a.push(arr[j++]);
+    if (j === arr.length) {
+      j = 0;
+    }
+  }
+  return a;
+};
+
+/**
+ * Remove one exists element from an array
+ * @param {Array} arr
+ * @param  {Number} index - remove element index
+ * @return {Array} the array instance
+ */
+exports.spliceOne = function spliceOne(arr, index) {
+  if (index < 0) {
+    index = arr.length + index;
+    // still negative, not found element
+    if (index < 0) {
+      return arr;
+    }
+  }
+
+  // don't touch
+  if (index >= arr.length) {
+    return arr;
+  }
+
+  for (var i = index, k = i + 1, n = arr.length; k < n; i += 1, k += 1) {
+    arr[i] = arr[k];
+  }
+  arr.pop();
+  return arr;
+};
+
+},{}],386:[function(require,module,exports){
+(function (Buffer){
+/*!
+ * utility - lib/crypto.js
+ *
+ * Copyright(c) 2012 - 2014 fengmk2 <fengmk2@gmail.com>
+ * MIT Licensed
+ */
+
+"use strict";
+
+/**
+ * Module dependencies.
+ */
+
+var _keys = require('babel-runtime/core-js/object/keys');
+
+var _keys2 = _interopRequireDefault(_keys);
+
+var _stringify = require('babel-runtime/core-js/json/stringify');
+
+var _stringify2 = _interopRequireDefault(_stringify);
+
+var _typeof2 = require('babel-runtime/helpers/typeof');
+
+var _typeof3 = _interopRequireDefault(_typeof2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var crypto = require('./../../../shims/crypto.js');
+
+/**
+ * hash
+ *
+ * @param {String} method hash method, e.g.: 'md5', 'sha1'
+ * @param {String|Buffer} s
+ * @param {String} [format] output string format, could be 'hex' or 'base64'. default is 'hex'.
+ * @return {String} md5 hash string
+ * @public
+ */
+exports.hash = function hash(method, s, format) {
+  var sum = crypto.createHash(method);
+  var isBuffer = Buffer.isBuffer(s);
+  if (!isBuffer && (typeof s === 'undefined' ? 'undefined' : (0, _typeof3.default)(s)) === 'object') {
+    s = (0, _stringify2.default)(sortObject(s));
+  }
+  sum.update(s, isBuffer ? 'binary' : 'utf8');
+  return sum.digest(format || 'hex');
+};
+
+/**
+ * md5 hash
+ *
+ * @param {String|Buffer} s
+ * @param {String} [format] output string format, could be 'hex' or 'base64'. default is 'hex'.
+ * @return {String} md5 hash string
+ * @public
+ */
+exports.md5 = function md5(s, format) {
+  return exports.hash('md5', s, format);
+};
+
+/**
+ * sha1 hash
+ *
+ * @param {String|Buffer} s
+ * @param {String} [format] output string format, could be 'hex' or 'base64'. default is 'hex'.
+ * @return {String} sha1 hash string
+ * @public
+ */
+exports.sha1 = function sha1(s, format) {
+  return exports.hash('sha1', s, format);
+};
+
+/**
+ * sha256 hash
+ *
+ * @param {String|Buffer} s
+ * @param {String} [format] output string format, could be 'hex' or 'base64'. default is 'hex'.
+ * @return {String} sha256 hash string
+ * @public
+ */
+exports.sha256 = function sha1(s, format) {
+  return exports.hash('sha256', s, format);
+};
+
+/**
+ * HMAC algorithm.
+ *
+ * Equal bash:
+ *
+ * ```bash
+ * $ echo -n "$data" | openssl dgst -binary -$algorithm -hmac "$key" | openssl $encoding
+ * ```
+ *
+ * @param {String} algorithm, dependent on the available algorithms supported by the version of OpenSSL on the platform.
+ *   Examples are 'sha1', 'md5', 'sha256', 'sha512', etc.
+ *   On recent releases, `openssl list-message-digest-algorithms` will display the available digest algorithms.
+ * @param {String} key, the hmac key to be used.
+ * @param {String|Buffer} data, content string.
+ * @param {String} [encoding='base64']
+ * @return {String} digest string.
+ */
+exports.hmac = function hmac(algorithm, key, data, encoding) {
+  encoding = encoding || 'base64';
+  var hmac = crypto.createHmac(algorithm, key);
+  hmac.update(data, Buffer.isBuffer(data) ? 'binary' : 'utf8');
+  return hmac.digest(encoding);
+};
+
+/**
+ * Base64 encode string.
+ *
+ * @param {String|Buffer} s
+ * @param {Boolean} [urlsafe=false] Encode string s using a URL-safe alphabet,
+ *   which substitutes - instead of + and _ instead of / in the standard Base64 alphabet.
+ * @return {String} base64 encode format string.
+ */
+exports.base64encode = function base64encode(s, urlsafe) {
+  if (!Buffer.isBuffer(s)) {
+    s = new Buffer(s);
+  }
+  var encode = s.toString('base64');
+  if (urlsafe) {
+    encode = encode.replace(/\+/g, '-').replace(/\//g, '_');
+  }
+  return encode;
+};
+
+/**
+ * Base64 string decode.
+ *
+ * @param {String} encode, base64 encoding string.
+ * @param {Boolean} [urlsafe=false] Decode string s using a URL-safe alphabet,
+ *   which substitutes - instead of + and _ instead of / in the standard Base64 alphabet.
+ * @param {encoding} [encoding=utf8] if encoding = buffer, will return Buffer instance
+ * @return {String|Buffer} plain text.
+ */
+exports.base64decode = function base64decode(encodeStr, urlsafe, encoding) {
+  if (urlsafe) {
+    encodeStr = encodeStr.replace(/\-/g, '+').replace(/_/g, '/');
+  }
+  var buf = new Buffer(encodeStr, 'base64');
+  if (encoding === 'buffer') {
+    return buf;
+  }
+  return buf.toString(encoding || 'utf8');
+};
+
+function sortObject(o) {
+  if (!o || Array.isArray(o) || (typeof o === 'undefined' ? 'undefined' : (0, _typeof3.default)(o)) !== 'object') {
+    return o;
+  }
+  var keys = (0, _keys2.default)(o);
+  keys.sort();
+  var values = [];
+  for (var i = 0; i < keys.length; i++) {
+    var k = keys[i];
+    values.push([k, sortObject(o[k])]);
+  }
+  return values;
+}
+
+}).call(this,require("buffer").Buffer)
+},{"./../../../shims/crypto.js":420,"babel-runtime/core-js/json/stringify":18,"babel-runtime/core-js/object/keys":30,"babel-runtime/helpers/typeof":39,"buffer":45}],387:[function(require,module,exports){
+/*!
+ * utility - lib/date.js
+ *
+ * Copyright(c) 2012 - 2014 fengmk2 <fengmk2@gmail.com>
+ * MIT Licensed
+ */
+
+"use strict";
+
+var MONTHS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+
+// only set once.
+var TIMEZONE = ' ';
+var _hourOffset = parseInt(-new Date().getTimezoneOffset() / 60, 10);
+if (_hourOffset >= 0) {
+  TIMEZONE += '+';
+} else {
+  TIMEZONE += '-';
+}
+_hourOffset = Math.abs(_hourOffset);
+if (_hourOffset < 10) {
+  _hourOffset = '0' + _hourOffset;
+}
+TIMEZONE += _hourOffset + '00';
+
+/**
+ * Access log format date. format: `moment().format('DD/MMM/YYYY:HH:mm:ss ZZ')`
+ *
+ * @return {String}
+ */
+exports.accessLogDate = function (d) {
+  // 16/Apr/2013:16:40:09 +0800
+  d = d || new Date();
+  var date = d.getDate();
+  if (date < 10) {
+    date = '0' + date;
+  }
+  var hours = d.getHours();
+  if (hours < 10) {
+    hours = '0' + hours;
+  }
+  var mintues = d.getMinutes();
+  if (mintues < 10) {
+    mintues = '0' + mintues;
+  }
+  var seconds = d.getSeconds();
+  if (seconds < 10) {
+    seconds = '0' + seconds;
+  }
+  return date + '/' + MONTHS[d.getMonth()] + '/' + d.getFullYear() + ':' + hours + ':' + mintues + ':' + seconds + TIMEZONE;
+};
+
+/**
+ * Normal log format date. format: `moment().format('YYYY-MM-DD HH:mm:ss.SSS')`
+ *
+ * @return {String}
+ */
+exports.logDate = exports.YYYYMMDDHHmmssSSS = function (d, msSep) {
+  if (typeof d === 'string') {
+    // logDate(msSep)
+    msSep = d;
+    d = new Date();
+  } else {
+    // logDate(d, msSep)
+    d = d || new Date();
+  }
+  var date = d.getDate();
+  if (date < 10) {
+    date = '0' + date;
+  }
+  var month = d.getMonth() + 1;
+  if (month < 10) {
+    month = '0' + month;
+  }
+  var hours = d.getHours();
+  if (hours < 10) {
+    hours = '0' + hours;
+  }
+  var mintues = d.getMinutes();
+  if (mintues < 10) {
+    mintues = '0' + mintues;
+  }
+  var seconds = d.getSeconds();
+  if (seconds < 10) {
+    seconds = '0' + seconds;
+  }
+  var milliseconds = d.getMilliseconds();
+  if (milliseconds < 10) {
+    milliseconds = '00' + milliseconds;
+  } else if (milliseconds < 100) {
+    milliseconds = '0' + milliseconds;
+  }
+  return d.getFullYear() + '-' + month + '-' + date + ' ' + hours + ':' + mintues + ':' + seconds + (msSep || '.') + milliseconds;
+};
+
+/**
+ * `moment().format('YYYY-MM-DD HH:mm:ss')` format date string.
+ *
+ * @return {String}
+ */
+exports.YYYYMMDDHHmmss = function (d, options) {
+  d = d || new Date();
+  if (!(d instanceof Date)) {
+    d = new Date(d);
+  }
+
+  var dateSep = '-';
+  var timeSep = ':';
+  if (options) {
+    if (options.dateSep) {
+      dateSep = options.dateSep;
+    }
+    if (options.timeSep) {
+      timeSep = options.timeSep;
+    }
+  }
+  var date = d.getDate();
+  if (date < 10) {
+    date = '0' + date;
+  }
+  var month = d.getMonth() + 1;
+  if (month < 10) {
+    month = '0' + month;
+  }
+  var hours = d.getHours();
+  if (hours < 10) {
+    hours = '0' + hours;
+  }
+  var mintues = d.getMinutes();
+  if (mintues < 10) {
+    mintues = '0' + mintues;
+  }
+  var seconds = d.getSeconds();
+  if (seconds < 10) {
+    seconds = '0' + seconds;
+  }
+  return d.getFullYear() + dateSep + month + dateSep + date + ' ' + hours + timeSep + mintues + timeSep + seconds;
+};
+
+/**
+ * `moment().format('YYYY-MM-DD')` format date string.
+ *
+ * @return {String}
+ */
+exports.YYYYMMDD = function YYYYMMDD(d, sep) {
+  if (typeof d === 'string') {
+    // YYYYMMDD(sep)
+    sep = d;
+    d = new Date();
+  } else {
+    // YYYYMMDD(d, sep)
+    d = d || new Date();
+    if (typeof sep !== 'string') {
+      sep = '-';
+    }
+  }
+  var date = d.getDate();
+  if (date < 10) {
+    date = '0' + date;
+  }
+  var month = d.getMonth() + 1;
+  if (month < 10) {
+    month = '0' + month;
+  }
+  return d.getFullYear() + sep + month + sep + date;
+};
+
+/**
+ * return datetime struct.
+ *
+ * @return {Object} date
+ *  - {Number} YYYYMMDD, 20130401
+ *  - {Number} H, 0, 1, 9, 12, 23
+ */
+exports.datestruct = function (now) {
+  now = now || new Date();
+  return {
+    YYYYMMDD: now.getFullYear() * 10000 + (now.getMonth() + 1) * 100 + now.getDate(),
+    H: now.getHours()
+  };
+};
+
+/**
+ * Get Unix's timestamp in seconds.
+ * @return {Number}
+ */
+exports.timestamp = function timestamp(t) {
+  if (t) {
+    var v = t;
+    if (typeof v === 'string') {
+      v = Number(v);
+    }
+    if (String(t).length === 10) {
+      v *= 1000;
+    }
+    return new Date(v);
+  }
+  return Math.round(Date.now() / 1000);
+};
+
+},{}],388:[function(require,module,exports){
+/*!
+ * utility - lib/function.js
+ *
+ * Copyright(c) 2012 - 2014 fengmk2 <fengmk2@gmail.com>
+ * MIT Licensed
+ */
+
+"use strict";
+
+/**
+ * A empty function.
+ *
+ * @return {Function}
+ * @public
+ */
+
+exports.noop = function noop() {};
+
+/**
+ * Get a function parameter's names.
+ *
+ * @param {Function} func
+ * @param {Boolean} [useCache], default is true
+ * @return {Array} names
+ */
+exports.getParamNames = function getParamNames(func, cache) {
+  cache = cache !== false;
+  if (cache && func.__cache_names) {
+    return func.__cache_names;
+  }
+  var str = func.toString();
+  var names = str.slice(str.indexOf('(') + 1, str.indexOf(')')).match(/([^\s,]+)/g) || [];
+  func.__cache_names = names;
+  return names;
+};
+
+},{}],389:[function(require,module,exports){
+/*!
+ * utility - lib/crypto.js
+ *
+ * MIT Licensed
+ */
+
+"use strict";
+
+/**
+ * Module dependencies.
+ */
+
+var _typeof2 = require('babel-runtime/helpers/typeof');
+
+var _typeof3 = _interopRequireDefault(_typeof2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.strictJSONParse = function (str) {
+  var obj = JSON.parse(str);
+  if (!obj || (typeof obj === 'undefined' ? 'undefined' : (0, _typeof3.default)(obj)) !== 'object') {
+    throw new Error('JSON string is not object');
+  }
+  return obj;
+};
+
+},{"babel-runtime/helpers/typeof":39}],390:[function(require,module,exports){
+/**
+ * Copyright(c) node-modules and other contributors.
+ * MIT Licensed
+ *
+ * Authors:
+ *   fengmk2 <fengmk2@gmail.com> (http://fengmk2.com)
+ */
+
+'use strict';
+
+/**
+ * Module dependencies.
+ */
+
+var _create = require('babel-runtime/core-js/object/create');
+
+var _create2 = _interopRequireDefault(_create);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.has = function has(obj, prop) {
+  return Object.prototype.hasOwnProperty.call(obj, prop);
+};
+
+/**
+ * generate a real map object(clean object), no constructor, no __proto__
+ * @param {Object} [obj] - init object, optional
+ * @return {Object}
+ */
+exports.map = function map(obj) {
+  var map = new EmptyObject();
+  if (!obj) {
+    return map;
+  }
+
+  for (var key in obj) {
+    map[key] = obj[key];
+  }
+  return map;
+};
+
+// faster way like `Object.create(null)` to get a 'clean' empty object
+// https://github.com/nodejs/node/blob/master/lib/events.js#L5
+// https://cnodejs.org/topic/571e0c445a26c4a841ecbcf1
+function EmptyObject() {}
+EmptyObject.prototype = (0, _create2.default)(null);
+
+},{"babel-runtime/core-js/object/create":22}],391:[function(require,module,exports){
+/*!
+ * utility - lib/number.js
+ *
+ * Copyright(c) 2012 - 2014 fengmk2 <fengmk2@gmail.com>
+ * MIT Licensed
+ */
+
+"use strict";
+
+// http://www.2ality.com/2013/10/safe-integers.html
+// http://es6.ruanyifeng.com/#docs/number
+
+var _maxSafeInteger = require('babel-runtime/core-js/number/max-safe-integer');
+
+var _maxSafeInteger2 = _interopRequireDefault(_maxSafeInteger);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.MAX_SAFE_INTEGER = _maxSafeInteger2.default || Math.pow(2, 53) - 1;
+exports.MIN_SAFE_INTEGER = -exports.MAX_SAFE_INTEGER;
+var MAX_SAFE_INTEGER_STR = exports.MAX_SAFE_INTEGER_STR = String(exports.MAX_SAFE_INTEGER);
+var MAX_SAFE_INTEGER_STR_LENGTH = MAX_SAFE_INTEGER_STR.length;
+
+/**
+ * Detect a number string can safe convert to Javascript Number.
+ *
+ * @param {String} s number format string, like `"123"`, `"-1000123123123123123123"`
+ * @return {Boolean}
+ */
+exports.isSafeNumberString = function isSafeNumberString(s) {
+  if (s[0] === '-') {
+    s = s.substring(1);
+  }
+  if (s.length < MAX_SAFE_INTEGER_STR_LENGTH || s.length === MAX_SAFE_INTEGER_STR_LENGTH && s <= MAX_SAFE_INTEGER_STR) {
+    return true;
+  }
+  return false;
+};
+
+/**
+ * Convert string to Number if string in safe Number scope.
+ *
+ * @param {String} s number format string.
+ * @return {Number|String} success will return Number, otherise return the original string.
+ */
+exports.toSafeNumber = function toSafeNumber(s) {
+  if (typeof s === 'number') {
+    return s;
+  }
+
+  return exports.isSafeNumberString(s) ? Number(s) : s;
+};
+
+},{"babel-runtime/core-js/number/max-safe-integer":21}],392:[function(require,module,exports){
+/*!
+ * utility - lib/optimize.js
+ *
+ * Copyright(c) 2012 - 2014 fengmk2 <fengmk2@gmail.com>
+ * MIT Licensed
+ */
+
+"use strict";
+
+/**
+ * optimize try catch
+ * @param {Function} fn
+ * @return {Object}
+ *   - {Error} error
+ *   - {Mix} value
+ */
+
+exports.try = function (fn) {
+  var res = {
+    error: undefined,
+    value: undefined
+  };
+
+  try {
+    res.value = fn();
+  } catch (err) {
+    res.error = err instanceof Error ? err : new Error(err);
+  }
+
+  return res;
+};
+
+/**
+ * avoid if (a && a.b && a.b.c)
+ * @param {Object} obj
+ * @param {...String} keys
+ * @return {Object}
+ */
+exports.dig = function (obj) {
+  if (!obj) {
+    return;
+  }
+  if (arguments.length <= 1) {
+    return obj;
+  }
+
+  var value = obj[arguments[1]];
+  for (var i = 2; i < arguments.length; i++) {
+    if (!value) {
+      break;
+    }
+    value = value[arguments[i]];
+  }
+
+  return value;
+};
+
+/**
+ * optimize arguments to array
+ * @param {Arguments} args
+ * @return {Array}
+ */
+exports.argumentsToArray = function (args) {
+  var res = new Array(args.length);
+  for (var i = 0; i < args.length; i++) {
+    res[i] = args[i];
+  }
+  return res;
+};
+
+},{}],393:[function(require,module,exports){
+(function (process){
+/*!
+ * utility - lib/polyfill.js
+ *
+ * Copyright(c) 2012 - 2014 fengmk2 <fengmk2@gmail.com>
+ * MIT Licensed
+ */
+
+"use strict";
+
+var _setImmediate2 = require("babel-runtime/core-js/set-immediate");
+
+var _setImmediate3 = _interopRequireDefault(_setImmediate2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.setImmediate = typeof _setImmediate3.default === 'function' ? _setImmediate3.default : function (fn) {
+  process.nextTick(fn.bind.apply(fn, arguments));
+};
+
+}).call(this,require('_process'))
+},{"_process":345,"babel-runtime/core-js/set-immediate":34}],394:[function(require,module,exports){
+/*!
+ * utility - lib/string.js
+ *
+ * Copyright(c) 2012 - 2014 fengmk2 <fengmk2@gmail.com>
+ * MIT Licensed
+ */
+
+"use strict";
+
+exports.randomString = function randomString(length, charSet) {
+  var result = [];
+  length = length || 16;
+  charSet = charSet || 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+
+  while (length--) {
+    result.push(charSet[Math.floor(Math.random() * charSet.length)]);
+  }
+  return result.join('');
+};
+
+/**
+ * split string to array
+ * @param  {String} str
+ * @param  {String} [sep] default is ','
+ * @return {Array}
+ */
+exports.split = function split(str, sep) {
+  str = str || '';
+  sep = sep || ',';
+  var items = str.split(sep);
+  var needs = [];
+  for (var i = 0; i < items.length; i++) {
+    var s = items[i].trim();
+    if (s.length > 0) {
+      needs.push(s);
+    }
+  }
+  return needs;
+};
+
+// always optimized
+exports.splitAlwaysOptimized = function splitAlwaysOptimized() {
+  var str = '';
+  var sep = ',';
+  if (arguments.length === 1) {
+    str = arguments[0] || '';
+  } else if (arguments.length === 2) {
+    str = arguments[0] || '';
+    sep = arguments[1] || ',';
+  }
+  var items = str.split(sep);
+  var needs = [];
+  for (var i = 0; i < items.length; i++) {
+    var s = items[i].trim();
+    if (s.length > 0) {
+      needs.push(s);
+    }
+  }
+  return needs;
+};
+
+/**
+ * Replace string
+ *
+ * @param  {String} str
+ * @param  {String|RegExp} substr
+ * @param  {String|Function} newSubstr
+ * @return {String}
+ */
+exports.replace = function replace(str, substr, newSubstr) {
+  var replaceFunction = newSubstr;
+  if (typeof replaceFunction !== 'function') {
+    replaceFunction = function replaceFunction() {
+      return newSubstr;
+    };
+  }
+  return str.replace(substr, replaceFunction);
+};
+
+},{}],395:[function(require,module,exports){
+/*!
+ * utility - lib/utility.js
+ *
+ * Copyright(c) 2012 - 2014 fengmk2 <fengmk2@gmail.com>
+ * MIT Licensed
+ */
+
+"use strict";
+
+/**
+ * Module dependencies.
+ */
+
+var copy = require('copy-to');
+
+copy(require('./function')).and(require('./polyfill')).and(require('./optimize')).and(require('./crypto')).and(require('./number')).and(require('./string')).and(require('./array')).and(require('./json')).and(require('./date')).and(require('./map')).and(require('./web')).to(module.exports);
+
+},{"./array":385,"./crypto":386,"./date":387,"./function":388,"./json":389,"./map":390,"./number":391,"./optimize":392,"./polyfill":393,"./string":394,"./web":396,"copy-to":54}],396:[function(require,module,exports){
+/*!
+ * utility - lib/web.js
+ *
+ * Copyright(c) 2012 - 2014 fengmk2 <fengmk2@gmail.com>
+ * MIT Licensed
+ */
+
+"use strict";
+
+/**
+ * Escape the given string of `html`.
+ *
+ * @param {String} html
+ * @return {String}
+ * @public
+ */
+
+exports.escape = require('escape-html');
+
+/**
+ * Safe encodeURIComponent, won't throw any error.
+ * If `encodeURIComponent` error happen, just return the original value.
+ *
+ * @param {String} text
+ * @return {String} URL encode string.
+ */
+exports.encodeURIComponent = function encodeURIComponent_(text) {
+  try {
+    return encodeURIComponent(text);
+  } catch (e) {
+    return text;
+  }
+};
+
+/**
+ * Safe decodeURIComponent, won't throw any error.
+ * If `decodeURIComponent` error happen, just return the original value.
+ *
+ * @param {String} encodeText
+ * @return {String} URL decode original string.
+ */
+exports.decodeURIComponent = function decodeURIComponent_(encodeText) {
+  try {
+    return decodeURIComponent(encodeText);
+  } catch (e) {
+    return encodeText;
+  }
+};
+
+},{"escape-html":192}],397:[function(require,module,exports){
+(function (process){
+'use strict';
+
+var os = require('os');
+var semver = require('semver');
+
+var nameMap = {
+	'10.0': '10',
+	'6.3': '8.1',
+	'6.2': '8',
+	'6.1': '7',
+	'6.0': 'Vista',
+	'5.1': 'XP',
+	'5.0': '2000',
+	'4.9': 'ME',
+	'4.1': '98',
+	'4.0': '95'
+};
+
+module.exports = function (release) {
+	var verRe = /\d+\.\d+/;
+	var version = verRe.exec(release || os.release());
+
+	// workaround for Windows 10 on node < 3.1.0
+	if (!release && process.platform === 'win32' && semver.satisfies(process.version, '>=0.12.0 <3.1.0')) {
+		try {
+			version = verRe.exec(String(require('child_process').execSync('ver.exe', { timeout: 2000 })));
+		} catch (err) {}
+	}
+
+	if (release && !version) {
+		throw new Error('`release` argument doesn\'t match `n.n`');
+	}
+
+	return nameMap[(version || [])[0]];
+};
+
+}).call(this,require('_process'))
+},{"_process":345,"child_process":43,"os":339,"semver":366}],398:[function(require,module,exports){
+"use strict";
+
+// Generated by CoffeeScript 1.10.0
+(function () {
+  "use strict";
+
+  exports.stripBOM = function (str) {
+    if (str[0] === "\uFEFF") {
+      return str.substring(1);
+    } else {
+      return str;
+    }
+  };
+}).call(undefined);
+
+},{}],399:[function(require,module,exports){
+'use strict';
+
+// Generated by CoffeeScript 1.10.0
+(function () {
+  "use strict";
+
+  var prefixMatch;
+
+  prefixMatch = new RegExp(/(?!xmlns)^.*:/);
+
+  exports.normalize = function (str) {
+    return str.toLowerCase();
+  };
+
+  exports.firstCharLowerCase = function (str) {
+    return str.charAt(0).toLowerCase() + str.slice(1);
+  };
+
+  exports.stripPrefix = function (str) {
+    return str.replace(prefixMatch, '');
+  };
+
+  exports.parseNumbers = function (str) {
+    if (!isNaN(str)) {
+      str = str % 1 === 0 ? parseInt(str, 10) : parseFloat(str);
+    }
+    return str;
+  };
+
+  exports.parseBooleans = function (str) {
+    if (/^(?:true|false)$/i.test(str)) {
+      str = str.toLowerCase() === 'true';
+    }
+    return str;
+  };
+}).call(undefined);
+
+},{}],400:[function(require,module,exports){
+'use strict';
+
+var _getOwnPropertyNames = require('babel-runtime/core-js/object/get-own-property-names');
+
+var _getOwnPropertyNames2 = _interopRequireDefault(_getOwnPropertyNames);
+
+var _keys = require('babel-runtime/core-js/object/keys');
+
+var _keys2 = _interopRequireDefault(_keys);
+
+var _typeof2 = require('babel-runtime/helpers/typeof');
+
+var _typeof3 = _interopRequireDefault(_typeof2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// Generated by CoffeeScript 1.10.0
+(function () {
+  "use strict";
+
+  var bom,
+      builder,
+      escapeCDATA,
+      events,
+      isEmpty,
+      processName,
+      processors,
+      requiresCDATA,
+      sax,
+      setImmediate,
+      wrapCDATA,
+      extend = function extend(child, parent) {
+    for (var key in parent) {
+      if (hasProp.call(parent, key)) child[key] = parent[key];
+    }function ctor() {
+      this.constructor = child;
+    }ctor.prototype = parent.prototype;child.prototype = new ctor();child.__super__ = parent.prototype;return child;
+  },
+      hasProp = {}.hasOwnProperty,
+      bind = function bind(fn, me) {
+    return function () {
+      return fn.apply(me, arguments);
+    };
+  };
+
+  sax = require('sax');
+
+  events = require('events');
+
+  builder = require('xmlbuilder');
+
+  bom = require('./bom');
+
+  processors = require('./processors');
+
+  setImmediate = require('timers').setImmediate;
+
+  isEmpty = function isEmpty(thing) {
+    return (typeof thing === 'undefined' ? 'undefined' : (0, _typeof3.default)(thing)) === "object" && thing != null && (0, _keys2.default)(thing).length === 0;
+  };
+
+  processName = function processName(processors, processedName) {
+    var i, len, process;
+    for (i = 0, len = processors.length; i < len; i++) {
+      process = processors[i];
+      processedName = process(processedName);
+    }
+    return processedName;
+  };
+
+  requiresCDATA = function requiresCDATA(entry) {
+    return entry.indexOf('&') >= 0 || entry.indexOf('>') >= 0 || entry.indexOf('<') >= 0;
+  };
+
+  wrapCDATA = function wrapCDATA(entry) {
+    return "<![CDATA[" + escapeCDATA(entry) + "]]>";
+  };
+
+  escapeCDATA = function escapeCDATA(entry) {
+    return entry.replace(']]>', ']]]]><![CDATA[>');
+  };
+
+  exports.processors = processors;
+
+  exports.defaults = {
+    "0.1": {
+      explicitCharkey: false,
+      trim: true,
+      normalize: true,
+      normalizeTags: false,
+      attrkey: "@",
+      charkey: "#",
+      explicitArray: false,
+      ignoreAttrs: false,
+      mergeAttrs: false,
+      explicitRoot: false,
+      validator: null,
+      xmlns: false,
+      explicitChildren: false,
+      childkey: '@@',
+      charsAsChildren: false,
+      includeWhiteChars: false,
+      async: false,
+      strict: true,
+      attrNameProcessors: null,
+      attrValueProcessors: null,
+      tagNameProcessors: null,
+      valueProcessors: null,
+      emptyTag: ''
+    },
+    "0.2": {
+      explicitCharkey: false,
+      trim: false,
+      normalize: false,
+      normalizeTags: false,
+      attrkey: "$",
+      charkey: "_",
+      explicitArray: true,
+      ignoreAttrs: false,
+      mergeAttrs: false,
+      explicitRoot: true,
+      validator: null,
+      xmlns: false,
+      explicitChildren: false,
+      preserveChildrenOrder: false,
+      childkey: '$$',
+      charsAsChildren: false,
+      includeWhiteChars: false,
+      async: false,
+      strict: true,
+      attrNameProcessors: null,
+      attrValueProcessors: null,
+      tagNameProcessors: null,
+      valueProcessors: null,
+      rootName: 'root',
+      xmldec: {
+        'version': '1.0',
+        'encoding': 'UTF-8',
+        'standalone': true
+      },
+      doctype: null,
+      renderOpts: {
+        'pretty': true,
+        'indent': '  ',
+        'newline': '\n'
+      },
+      headless: false,
+      chunkSize: 10000,
+      emptyTag: '',
+      cdata: false
+    }
+  };
+
+  exports.ValidationError = function (superClass) {
+    extend(ValidationError, superClass);
+
+    function ValidationError(message) {
+      this.message = message;
+    }
+
+    return ValidationError;
+  }(Error);
+
+  exports.Builder = function () {
+    function Builder(opts) {
+      var key, ref, value;
+      this.options = {};
+      ref = exports.defaults["0.2"];
+      for (key in ref) {
+        if (!hasProp.call(ref, key)) continue;
+        value = ref[key];
+        this.options[key] = value;
+      }
+      for (key in opts) {
+        if (!hasProp.call(opts, key)) continue;
+        value = opts[key];
+        this.options[key] = value;
+      }
+    }
+
+    Builder.prototype.buildObject = function (rootObj) {
+      var attrkey, charkey, render, rootElement, rootName;
+      attrkey = this.options.attrkey;
+      charkey = this.options.charkey;
+      if ((0, _keys2.default)(rootObj).length === 1 && this.options.rootName === exports.defaults['0.2'].rootName) {
+        rootName = (0, _keys2.default)(rootObj)[0];
+        rootObj = rootObj[rootName];
+      } else {
+        rootName = this.options.rootName;
+      }
+      render = function (_this) {
+        return function (element, obj) {
+          var attr, child, entry, index, key, value;
+          if ((typeof obj === 'undefined' ? 'undefined' : (0, _typeof3.default)(obj)) !== 'object') {
+            if (_this.options.cdata && requiresCDATA(obj)) {
+              element.raw(wrapCDATA(obj));
+            } else {
+              element.txt(obj);
+            }
+          } else {
+            for (key in obj) {
+              if (!hasProp.call(obj, key)) continue;
+              child = obj[key];
+              if (key === attrkey) {
+                if ((typeof child === 'undefined' ? 'undefined' : (0, _typeof3.default)(child)) === "object") {
+                  for (attr in child) {
+                    value = child[attr];
+                    element = element.att(attr, value);
+                  }
+                }
+              } else if (key === charkey) {
+                if (_this.options.cdata && requiresCDATA(child)) {
+                  element = element.raw(wrapCDATA(child));
+                } else {
+                  element = element.txt(child);
+                }
+              } else if (Array.isArray(child)) {
+                for (index in child) {
+                  if (!hasProp.call(child, index)) continue;
+                  entry = child[index];
+                  if (typeof entry === 'string') {
+                    if (_this.options.cdata && requiresCDATA(entry)) {
+                      element = element.ele(key).raw(wrapCDATA(entry)).up();
+                    } else {
+                      element = element.ele(key, entry).up();
+                    }
+                  } else {
+                    element = render(element.ele(key), entry).up();
+                  }
+                }
+              } else if ((typeof child === 'undefined' ? 'undefined' : (0, _typeof3.default)(child)) === "object") {
+                element = render(element.ele(key), child).up();
+              } else {
+                if (typeof child === 'string' && _this.options.cdata && requiresCDATA(child)) {
+                  element = element.ele(key).raw(wrapCDATA(child)).up();
+                } else {
+                  if (child == null) {
+                    child = '';
+                  }
+                  element = element.ele(key, child.toString()).up();
+                }
+              }
+            }
+          }
+          return element;
+        };
+      }(this);
+      rootElement = builder.create(rootName, this.options.xmldec, this.options.doctype, {
+        headless: this.options.headless,
+        allowSurrogateChars: this.options.allowSurrogateChars
+      });
+      return render(rootElement, rootObj).end(this.options.renderOpts);
+    };
+
+    return Builder;
+  }();
+
+  exports.Parser = function (superClass) {
+    extend(Parser, superClass);
+
+    function Parser(opts) {
+      this.parseString = bind(this.parseString, this);
+      this.reset = bind(this.reset, this);
+      this.assignOrPush = bind(this.assignOrPush, this);
+      this.processAsync = bind(this.processAsync, this);
+      var key, ref, value;
+      if (!(this instanceof exports.Parser)) {
+        return new exports.Parser(opts);
+      }
+      this.options = {};
+      ref = exports.defaults["0.2"];
+      for (key in ref) {
+        if (!hasProp.call(ref, key)) continue;
+        value = ref[key];
+        this.options[key] = value;
+      }
+      for (key in opts) {
+        if (!hasProp.call(opts, key)) continue;
+        value = opts[key];
+        this.options[key] = value;
+      }
+      if (this.options.xmlns) {
+        this.options.xmlnskey = this.options.attrkey + "ns";
+      }
+      if (this.options.normalizeTags) {
+        if (!this.options.tagNameProcessors) {
+          this.options.tagNameProcessors = [];
+        }
+        this.options.tagNameProcessors.unshift(processors.normalize);
+      }
+      this.reset();
+    }
+
+    Parser.prototype.processAsync = function () {
+      var chunk, err, error1;
+      try {
+        if (this.remaining.length <= this.options.chunkSize) {
+          chunk = this.remaining;
+          this.remaining = '';
+          this.saxParser = this.saxParser.write(chunk);
+          return this.saxParser.close();
+        } else {
+          chunk = this.remaining.substr(0, this.options.chunkSize);
+          this.remaining = this.remaining.substr(this.options.chunkSize, this.remaining.length);
+          this.saxParser = this.saxParser.write(chunk);
+          return setImmediate(this.processAsync);
+        }
+      } catch (error1) {
+        err = error1;
+        if (!this.saxParser.errThrown) {
+          this.saxParser.errThrown = true;
+          return this.emit(err);
+        }
+      }
+    };
+
+    Parser.prototype.assignOrPush = function (obj, key, newValue) {
+      if (!(key in obj)) {
+        if (!this.options.explicitArray) {
+          return obj[key] = newValue;
+        } else {
+          return obj[key] = [newValue];
+        }
+      } else {
+        if (!(obj[key] instanceof Array)) {
+          obj[key] = [obj[key]];
+        }
+        return obj[key].push(newValue);
+      }
+    };
+
+    Parser.prototype.reset = function () {
+      var attrkey, charkey, ontext, stack;
+      this.removeAllListeners();
+      this.saxParser = sax.parser(this.options.strict, {
+        trim: false,
+        normalize: false,
+        xmlns: this.options.xmlns
+      });
+      this.saxParser.errThrown = false;
+      this.saxParser.onerror = function (_this) {
+        return function (error) {
+          _this.saxParser.resume();
+          if (!_this.saxParser.errThrown) {
+            _this.saxParser.errThrown = true;
+            return _this.emit("error", error);
+          }
+        };
+      }(this);
+      this.saxParser.onend = function (_this) {
+        return function () {
+          if (!_this.saxParser.ended) {
+            _this.saxParser.ended = true;
+            return _this.emit("end", _this.resultObject);
+          }
+        };
+      }(this);
+      this.saxParser.ended = false;
+      this.EXPLICIT_CHARKEY = this.options.explicitCharkey;
+      this.resultObject = null;
+      stack = [];
+      attrkey = this.options.attrkey;
+      charkey = this.options.charkey;
+      this.saxParser.onopentag = function (_this) {
+        return function (node) {
+          var key, newValue, obj, processedKey, ref;
+          obj = {};
+          obj[charkey] = "";
+          if (!_this.options.ignoreAttrs) {
+            ref = node.attributes;
+            for (key in ref) {
+              if (!hasProp.call(ref, key)) continue;
+              if (!(attrkey in obj) && !_this.options.mergeAttrs) {
+                obj[attrkey] = {};
+              }
+              newValue = _this.options.attrValueProcessors ? processName(_this.options.attrValueProcessors, node.attributes[key]) : node.attributes[key];
+              processedKey = _this.options.attrNameProcessors ? processName(_this.options.attrNameProcessors, key) : key;
+              if (_this.options.mergeAttrs) {
+                _this.assignOrPush(obj, processedKey, newValue);
+              } else {
+                obj[attrkey][processedKey] = newValue;
+              }
+            }
+          }
+          obj["#name"] = _this.options.tagNameProcessors ? processName(_this.options.tagNameProcessors, node.name) : node.name;
+          if (_this.options.xmlns) {
+            obj[_this.options.xmlnskey] = {
+              uri: node.uri,
+              local: node.local
+            };
+          }
+          return stack.push(obj);
+        };
+      }(this);
+      this.saxParser.onclosetag = function (_this) {
+        return function () {
+          var cdata, emptyStr, err, error1, key, node, nodeName, obj, objClone, old, s, xpath;
+          obj = stack.pop();
+          nodeName = obj["#name"];
+          if (!_this.options.explicitChildren || !_this.options.preserveChildrenOrder) {
+            delete obj["#name"];
+          }
+          if (obj.cdata === true) {
+            cdata = obj.cdata;
+            delete obj.cdata;
+          }
+          s = stack[stack.length - 1];
+          if (obj[charkey].match(/^\s*$/) && !cdata) {
+            emptyStr = obj[charkey];
+            delete obj[charkey];
+          } else {
+            if (_this.options.trim) {
+              obj[charkey] = obj[charkey].trim();
+            }
+            if (_this.options.normalize) {
+              obj[charkey] = obj[charkey].replace(/\s{2,}/g, " ").trim();
+            }
+            obj[charkey] = _this.options.valueProcessors ? processName(_this.options.valueProcessors, obj[charkey]) : obj[charkey];
+            if ((0, _keys2.default)(obj).length === 1 && charkey in obj && !_this.EXPLICIT_CHARKEY) {
+              obj = obj[charkey];
+            }
+          }
+          if (isEmpty(obj)) {
+            obj = _this.options.emptyTag !== '' ? _this.options.emptyTag : emptyStr;
+          }
+          if (_this.options.validator != null) {
+            xpath = "/" + function () {
+              var i, len, results;
+              results = [];
+              for (i = 0, len = stack.length; i < len; i++) {
+                node = stack[i];
+                results.push(node["#name"]);
+              }
+              return results;
+            }().concat(nodeName).join("/");
+            try {
+              obj = _this.options.validator(xpath, s && s[nodeName], obj);
+            } catch (error1) {
+              err = error1;
+              _this.emit("error", err);
+            }
+          }
+          if (_this.options.explicitChildren && !_this.options.mergeAttrs && (typeof obj === 'undefined' ? 'undefined' : (0, _typeof3.default)(obj)) === 'object') {
+            if (!_this.options.preserveChildrenOrder) {
+              node = {};
+              if (_this.options.attrkey in obj) {
+                node[_this.options.attrkey] = obj[_this.options.attrkey];
+                delete obj[_this.options.attrkey];
+              }
+              if (!_this.options.charsAsChildren && _this.options.charkey in obj) {
+                node[_this.options.charkey] = obj[_this.options.charkey];
+                delete obj[_this.options.charkey];
+              }
+              if ((0, _getOwnPropertyNames2.default)(obj).length > 0) {
+                node[_this.options.childkey] = obj;
+              }
+              obj = node;
+            } else if (s) {
+              s[_this.options.childkey] = s[_this.options.childkey] || [];
+              objClone = {};
+              for (key in obj) {
+                if (!hasProp.call(obj, key)) continue;
+                objClone[key] = obj[key];
+              }
+              s[_this.options.childkey].push(objClone);
+              delete obj["#name"];
+              if ((0, _keys2.default)(obj).length === 1 && charkey in obj && !_this.EXPLICIT_CHARKEY) {
+                obj = obj[charkey];
+              }
+            }
+          }
+          if (stack.length > 0) {
+            return _this.assignOrPush(s, nodeName, obj);
+          } else {
+            if (_this.options.explicitRoot) {
+              old = obj;
+              obj = {};
+              obj[nodeName] = old;
+            }
+            _this.resultObject = obj;
+            _this.saxParser.ended = true;
+            return _this.emit("end", _this.resultObject);
+          }
+        };
+      }(this);
+      ontext = function (_this) {
+        return function (text) {
+          var charChild, s;
+          s = stack[stack.length - 1];
+          if (s) {
+            s[charkey] += text;
+            if (_this.options.explicitChildren && _this.options.preserveChildrenOrder && _this.options.charsAsChildren && (_this.options.includeWhiteChars || text.replace(/\\n/g, '').trim() !== '')) {
+              s[_this.options.childkey] = s[_this.options.childkey] || [];
+              charChild = {
+                '#name': '__text__'
+              };
+              charChild[charkey] = text;
+              if (_this.options.normalize) {
+                charChild[charkey] = charChild[charkey].replace(/\s{2,}/g, " ").trim();
+              }
+              s[_this.options.childkey].push(charChild);
+            }
+            return s;
+          }
+        };
+      }(this);
+      this.saxParser.ontext = ontext;
+      return this.saxParser.oncdata = function (_this) {
+        return function (text) {
+          var s;
+          s = ontext(text);
+          if (s) {
+            return s.cdata = true;
+          }
+        };
+      }(this);
+    };
+
+    Parser.prototype.parseString = function (str, cb) {
+      var err, error1;
+      if (cb != null && typeof cb === "function") {
+        this.on("end", function (result) {
+          this.reset();
+          return cb(null, result);
+        });
+        this.on("error", function (err) {
+          this.reset();
+          return cb(err);
+        });
+      }
+      try {
+        str = str.toString();
+        if (str.trim() === '') {
+          this.emit("end", null);
+          return true;
+        }
+        str = bom.stripBOM(str);
+        if (this.options.async) {
+          this.remaining = str;
+          setImmediate(this.processAsync);
+          return this.saxParser;
+        }
+        return this.saxParser.write(str).close();
+      } catch (error1) {
+        err = error1;
+        if (!(this.saxParser.errThrown || this.saxParser.ended)) {
+          this.emit('error', err);
+          return this.saxParser.errThrown = true;
+        } else if (this.saxParser.ended) {
+          throw err;
+        }
+      }
+    };
+
+    return Parser;
+  }(events.EventEmitter);
+
+  exports.parseString = function (str, a, b) {
+    var cb, options, parser;
+    if (b != null) {
+      if (typeof b === 'function') {
+        cb = b;
+      }
+      if ((typeof a === 'undefined' ? 'undefined' : (0, _typeof3.default)(a)) === 'object') {
+        options = a;
+      }
+    } else {
+      if (typeof a === 'function') {
+        cb = a;
+      }
+      options = {};
+    }
+    parser = new exports.Parser(options);
+    return parser.parseString(str, cb);
+  };
+}).call(undefined);
+
+},{"./bom":398,"./processors":399,"babel-runtime/core-js/object/get-own-property-names":26,"babel-runtime/core-js/object/keys":30,"babel-runtime/helpers/typeof":39,"events":193,"sax":364,"timers":375,"xmlbuilder":417}],401:[function(require,module,exports){
+"use strict";
+
+// Generated by CoffeeScript 1.9.1
+(function () {
+  var XMLAttribute, create;
+
+  create = require('lodash/create');
+
+  module.exports = XMLAttribute = function () {
+    function XMLAttribute(parent, name, value) {
+      this.stringify = parent.stringify;
+      if (name == null) {
+        throw new Error("Missing attribute name of element " + parent.name);
+      }
+      if (value == null) {
+        throw new Error("Missing attribute value for attribute " + name + " of element " + parent.name);
+      }
+      this.name = this.stringify.attName(name);
+      this.value = this.stringify.attValue(value);
+    }
+
+    XMLAttribute.prototype.clone = function () {
+      return create(XMLAttribute.prototype, this);
+    };
+
+    XMLAttribute.prototype.toString = function (options, level) {
+      return ' ' + this.name + '="' + this.value + '"';
+    };
+
+    return XMLAttribute;
+  }();
+}).call(undefined);
+
+},{"lodash/create":313}],402:[function(require,module,exports){
+'use strict';
+
+// Generated by CoffeeScript 1.9.1
+(function () {
+  var XMLBuilder, XMLDeclaration, XMLDocType, XMLElement, XMLStringifier;
+
+  XMLStringifier = require('./XMLStringifier');
+
+  XMLDeclaration = require('./XMLDeclaration');
+
+  XMLDocType = require('./XMLDocType');
+
+  XMLElement = require('./XMLElement');
+
+  module.exports = XMLBuilder = function () {
+    function XMLBuilder(name, options) {
+      var root, temp;
+      if (name == null) {
+        throw new Error("Root element needs a name");
+      }
+      if (options == null) {
+        options = {};
+      }
+      this.options = options;
+      this.stringify = new XMLStringifier(options);
+      temp = new XMLElement(this, 'doc');
+      root = temp.element(name);
+      root.isRoot = true;
+      root.documentObject = this;
+      this.rootObject = root;
+      if (!options.headless) {
+        root.declaration(options);
+        if (options.pubID != null || options.sysID != null) {
+          root.doctype(options);
+        }
+      }
+    }
+
+    XMLBuilder.prototype.root = function () {
+      return this.rootObject;
+    };
+
+    XMLBuilder.prototype.end = function (options) {
+      return this.toString(options);
+    };
+
+    XMLBuilder.prototype.toString = function (options) {
+      var indent, newline, offset, pretty, r, ref, ref1, ref2;
+      pretty = (options != null ? options.pretty : void 0) || false;
+      indent = (ref = options != null ? options.indent : void 0) != null ? ref : '  ';
+      offset = (ref1 = options != null ? options.offset : void 0) != null ? ref1 : 0;
+      newline = (ref2 = options != null ? options.newline : void 0) != null ? ref2 : '\n';
+      r = '';
+      if (this.xmldec != null) {
+        r += this.xmldec.toString(options);
+      }
+      if (this.doctype != null) {
+        r += this.doctype.toString(options);
+      }
+      r += this.rootObject.toString(options);
+      if (pretty && r.slice(-newline.length) === newline) {
+        r = r.slice(0, -newline.length);
+      }
+      return r;
+    };
+
+    return XMLBuilder;
+  }();
+}).call(undefined);
+
+},{"./XMLDeclaration":409,"./XMLDocType":410,"./XMLElement":411,"./XMLStringifier":415}],403:[function(require,module,exports){
+'use strict';
+
+// Generated by CoffeeScript 1.9.1
+(function () {
+  var XMLCData,
+      XMLNode,
+      create,
+      extend = function extend(child, parent) {
+    for (var key in parent) {
+      if (hasProp.call(parent, key)) child[key] = parent[key];
+    }function ctor() {
+      this.constructor = child;
+    }ctor.prototype = parent.prototype;child.prototype = new ctor();child.__super__ = parent.prototype;return child;
+  },
+      hasProp = {}.hasOwnProperty;
+
+  create = require('lodash/create');
+
+  XMLNode = require('./XMLNode');
+
+  module.exports = XMLCData = function (superClass) {
+    extend(XMLCData, superClass);
+
+    function XMLCData(parent, text) {
+      XMLCData.__super__.constructor.call(this, parent);
+      if (text == null) {
+        throw new Error("Missing CDATA text");
+      }
+      this.text = this.stringify.cdata(text);
+    }
+
+    XMLCData.prototype.clone = function () {
+      return create(XMLCData.prototype, this);
+    };
+
+    XMLCData.prototype.toString = function (options, level) {
+      var indent, newline, offset, pretty, r, ref, ref1, ref2, space;
+      pretty = (options != null ? options.pretty : void 0) || false;
+      indent = (ref = options != null ? options.indent : void 0) != null ? ref : '  ';
+      offset = (ref1 = options != null ? options.offset : void 0) != null ? ref1 : 0;
+      newline = (ref2 = options != null ? options.newline : void 0) != null ? ref2 : '\n';
+      level || (level = 0);
+      space = new Array(level + offset + 1).join(indent);
+      r = '';
+      if (pretty) {
+        r += space;
+      }
+      r += '<![CDATA[' + this.text + ']]>';
+      if (pretty) {
+        r += newline;
+      }
+      return r;
+    };
+
+    return XMLCData;
+  }(XMLNode);
+}).call(undefined);
+
+},{"./XMLNode":412,"lodash/create":313}],404:[function(require,module,exports){
+'use strict';
+
+// Generated by CoffeeScript 1.9.1
+(function () {
+  var XMLComment,
+      XMLNode,
+      create,
+      extend = function extend(child, parent) {
+    for (var key in parent) {
+      if (hasProp.call(parent, key)) child[key] = parent[key];
+    }function ctor() {
+      this.constructor = child;
+    }ctor.prototype = parent.prototype;child.prototype = new ctor();child.__super__ = parent.prototype;return child;
+  },
+      hasProp = {}.hasOwnProperty;
+
+  create = require('lodash/create');
+
+  XMLNode = require('./XMLNode');
+
+  module.exports = XMLComment = function (superClass) {
+    extend(XMLComment, superClass);
+
+    function XMLComment(parent, text) {
+      XMLComment.__super__.constructor.call(this, parent);
+      if (text == null) {
+        throw new Error("Missing comment text");
+      }
+      this.text = this.stringify.comment(text);
+    }
+
+    XMLComment.prototype.clone = function () {
+      return create(XMLComment.prototype, this);
+    };
+
+    XMLComment.prototype.toString = function (options, level) {
+      var indent, newline, offset, pretty, r, ref, ref1, ref2, space;
+      pretty = (options != null ? options.pretty : void 0) || false;
+      indent = (ref = options != null ? options.indent : void 0) != null ? ref : '  ';
+      offset = (ref1 = options != null ? options.offset : void 0) != null ? ref1 : 0;
+      newline = (ref2 = options != null ? options.newline : void 0) != null ? ref2 : '\n';
+      level || (level = 0);
+      space = new Array(level + offset + 1).join(indent);
+      r = '';
+      if (pretty) {
+        r += space;
+      }
+      r += '<!-- ' + this.text + ' -->';
+      if (pretty) {
+        r += newline;
+      }
+      return r;
+    };
+
+    return XMLComment;
+  }(XMLNode);
+}).call(undefined);
+
+},{"./XMLNode":412,"lodash/create":313}],405:[function(require,module,exports){
+"use strict";
+
+// Generated by CoffeeScript 1.9.1
+(function () {
+  var XMLDTDAttList, create;
+
+  create = require('lodash/create');
+
+  module.exports = XMLDTDAttList = function () {
+    function XMLDTDAttList(parent, elementName, attributeName, attributeType, defaultValueType, defaultValue) {
+      this.stringify = parent.stringify;
+      if (elementName == null) {
+        throw new Error("Missing DTD element name");
+      }
+      if (attributeName == null) {
+        throw new Error("Missing DTD attribute name");
+      }
+      if (!attributeType) {
+        throw new Error("Missing DTD attribute type");
+      }
+      if (!defaultValueType) {
+        throw new Error("Missing DTD attribute default");
+      }
+      if (defaultValueType.indexOf('#') !== 0) {
+        defaultValueType = '#' + defaultValueType;
+      }
+      if (!defaultValueType.match(/^(#REQUIRED|#IMPLIED|#FIXED|#DEFAULT)$/)) {
+        throw new Error("Invalid default value type; expected: #REQUIRED, #IMPLIED, #FIXED or #DEFAULT");
+      }
+      if (defaultValue && !defaultValueType.match(/^(#FIXED|#DEFAULT)$/)) {
+        throw new Error("Default value only applies to #FIXED or #DEFAULT");
+      }
+      this.elementName = this.stringify.eleName(elementName);
+      this.attributeName = this.stringify.attName(attributeName);
+      this.attributeType = this.stringify.dtdAttType(attributeType);
+      this.defaultValue = this.stringify.dtdAttDefault(defaultValue);
+      this.defaultValueType = defaultValueType;
+    }
+
+    XMLDTDAttList.prototype.toString = function (options, level) {
+      var indent, newline, offset, pretty, r, ref, ref1, ref2, space;
+      pretty = (options != null ? options.pretty : void 0) || false;
+      indent = (ref = options != null ? options.indent : void 0) != null ? ref : '  ';
+      offset = (ref1 = options != null ? options.offset : void 0) != null ? ref1 : 0;
+      newline = (ref2 = options != null ? options.newline : void 0) != null ? ref2 : '\n';
+      level || (level = 0);
+      space = new Array(level + offset + 1).join(indent);
+      r = '';
+      if (pretty) {
+        r += space;
+      }
+      r += '<!ATTLIST ' + this.elementName + ' ' + this.attributeName + ' ' + this.attributeType;
+      if (this.defaultValueType !== '#DEFAULT') {
+        r += ' ' + this.defaultValueType;
+      }
+      if (this.defaultValue) {
+        r += ' "' + this.defaultValue + '"';
+      }
+      r += '>';
+      if (pretty) {
+        r += newline;
+      }
+      return r;
+    };
+
+    return XMLDTDAttList;
+  }();
+}).call(undefined);
+
+},{"lodash/create":313}],406:[function(require,module,exports){
+'use strict';
+
+// Generated by CoffeeScript 1.9.1
+(function () {
+  var XMLDTDElement, create;
+
+  create = require('lodash/create');
+
+  module.exports = XMLDTDElement = function () {
+    function XMLDTDElement(parent, name, value) {
+      this.stringify = parent.stringify;
+      if (name == null) {
+        throw new Error("Missing DTD element name");
+      }
+      if (!value) {
+        value = '(#PCDATA)';
+      }
+      if (Array.isArray(value)) {
+        value = '(' + value.join(',') + ')';
+      }
+      this.name = this.stringify.eleName(name);
+      this.value = this.stringify.dtdElementValue(value);
+    }
+
+    XMLDTDElement.prototype.toString = function (options, level) {
+      var indent, newline, offset, pretty, r, ref, ref1, ref2, space;
+      pretty = (options != null ? options.pretty : void 0) || false;
+      indent = (ref = options != null ? options.indent : void 0) != null ? ref : '  ';
+      offset = (ref1 = options != null ? options.offset : void 0) != null ? ref1 : 0;
+      newline = (ref2 = options != null ? options.newline : void 0) != null ? ref2 : '\n';
+      level || (level = 0);
+      space = new Array(level + offset + 1).join(indent);
+      r = '';
+      if (pretty) {
+        r += space;
+      }
+      r += '<!ELEMENT ' + this.name + ' ' + this.value + '>';
+      if (pretty) {
+        r += newline;
+      }
+      return r;
+    };
+
+    return XMLDTDElement;
+  }();
+}).call(undefined);
+
+},{"lodash/create":313}],407:[function(require,module,exports){
+'use strict';
+
+// Generated by CoffeeScript 1.9.1
+(function () {
+  var XMLDTDEntity, create, isObject;
+
+  create = require('lodash/create');
+
+  isObject = require('lodash/isObject');
+
+  module.exports = XMLDTDEntity = function () {
+    function XMLDTDEntity(parent, pe, name, value) {
+      this.stringify = parent.stringify;
+      if (name == null) {
+        throw new Error("Missing entity name");
+      }
+      if (value == null) {
+        throw new Error("Missing entity value");
+      }
+      this.pe = !!pe;
+      this.name = this.stringify.eleName(name);
+      if (!isObject(value)) {
+        this.value = this.stringify.dtdEntityValue(value);
+      } else {
+        if (!value.pubID && !value.sysID) {
+          throw new Error("Public and/or system identifiers are required for an external entity");
+        }
+        if (value.pubID && !value.sysID) {
+          throw new Error("System identifier is required for a public external entity");
+        }
+        if (value.pubID != null) {
+          this.pubID = this.stringify.dtdPubID(value.pubID);
+        }
+        if (value.sysID != null) {
+          this.sysID = this.stringify.dtdSysID(value.sysID);
+        }
+        if (value.nData != null) {
+          this.nData = this.stringify.dtdNData(value.nData);
+        }
+        if (this.pe && this.nData) {
+          throw new Error("Notation declaration is not allowed in a parameter entity");
+        }
+      }
+    }
+
+    XMLDTDEntity.prototype.toString = function (options, level) {
+      var indent, newline, offset, pretty, r, ref, ref1, ref2, space;
+      pretty = (options != null ? options.pretty : void 0) || false;
+      indent = (ref = options != null ? options.indent : void 0) != null ? ref : '  ';
+      offset = (ref1 = options != null ? options.offset : void 0) != null ? ref1 : 0;
+      newline = (ref2 = options != null ? options.newline : void 0) != null ? ref2 : '\n';
+      level || (level = 0);
+      space = new Array(level + offset + 1).join(indent);
+      r = '';
+      if (pretty) {
+        r += space;
+      }
+      r += '<!ENTITY';
+      if (this.pe) {
+        r += ' %';
+      }
+      r += ' ' + this.name;
+      if (this.value) {
+        r += ' "' + this.value + '"';
+      } else {
+        if (this.pubID && this.sysID) {
+          r += ' PUBLIC "' + this.pubID + '" "' + this.sysID + '"';
+        } else if (this.sysID) {
+          r += ' SYSTEM "' + this.sysID + '"';
+        }
+        if (this.nData) {
+          r += ' NDATA ' + this.nData;
+        }
+      }
+      r += '>';
+      if (pretty) {
+        r += newline;
+      }
+      return r;
+    };
+
+    return XMLDTDEntity;
+  }();
+}).call(undefined);
+
+},{"lodash/create":313,"lodash/isObject":326}],408:[function(require,module,exports){
+"use strict";
+
+// Generated by CoffeeScript 1.9.1
+(function () {
+  var XMLDTDNotation, create;
+
+  create = require('lodash/create');
+
+  module.exports = XMLDTDNotation = function () {
+    function XMLDTDNotation(parent, name, value) {
+      this.stringify = parent.stringify;
+      if (name == null) {
+        throw new Error("Missing notation name");
+      }
+      if (!value.pubID && !value.sysID) {
+        throw new Error("Public or system identifiers are required for an external entity");
+      }
+      this.name = this.stringify.eleName(name);
+      if (value.pubID != null) {
+        this.pubID = this.stringify.dtdPubID(value.pubID);
+      }
+      if (value.sysID != null) {
+        this.sysID = this.stringify.dtdSysID(value.sysID);
+      }
+    }
+
+    XMLDTDNotation.prototype.toString = function (options, level) {
+      var indent, newline, offset, pretty, r, ref, ref1, ref2, space;
+      pretty = (options != null ? options.pretty : void 0) || false;
+      indent = (ref = options != null ? options.indent : void 0) != null ? ref : '  ';
+      offset = (ref1 = options != null ? options.offset : void 0) != null ? ref1 : 0;
+      newline = (ref2 = options != null ? options.newline : void 0) != null ? ref2 : '\n';
+      level || (level = 0);
+      space = new Array(level + offset + 1).join(indent);
+      r = '';
+      if (pretty) {
+        r += space;
+      }
+      r += '<!NOTATION ' + this.name;
+      if (this.pubID && this.sysID) {
+        r += ' PUBLIC "' + this.pubID + '" "' + this.sysID + '"';
+      } else if (this.pubID) {
+        r += ' PUBLIC "' + this.pubID + '"';
+      } else if (this.sysID) {
+        r += ' SYSTEM "' + this.sysID + '"';
+      }
+      r += '>';
+      if (pretty) {
+        r += newline;
+      }
+      return r;
+    };
+
+    return XMLDTDNotation;
+  }();
+}).call(undefined);
+
+},{"lodash/create":313}],409:[function(require,module,exports){
+'use strict';
+
+// Generated by CoffeeScript 1.9.1
+(function () {
+  var XMLDeclaration,
+      XMLNode,
+      create,
+      isObject,
+      extend = function extend(child, parent) {
+    for (var key in parent) {
+      if (hasProp.call(parent, key)) child[key] = parent[key];
+    }function ctor() {
+      this.constructor = child;
+    }ctor.prototype = parent.prototype;child.prototype = new ctor();child.__super__ = parent.prototype;return child;
+  },
+      hasProp = {}.hasOwnProperty;
+
+  create = require('lodash/create');
+
+  isObject = require('lodash/isObject');
+
+  XMLNode = require('./XMLNode');
+
+  module.exports = XMLDeclaration = function (superClass) {
+    extend(XMLDeclaration, superClass);
+
+    function XMLDeclaration(parent, version, encoding, standalone) {
+      var ref;
+      XMLDeclaration.__super__.constructor.call(this, parent);
+      if (isObject(version)) {
+        ref = version, version = ref.version, encoding = ref.encoding, standalone = ref.standalone;
+      }
+      if (!version) {
+        version = '1.0';
+      }
+      this.version = this.stringify.xmlVersion(version);
+      if (encoding != null) {
+        this.encoding = this.stringify.xmlEncoding(encoding);
+      }
+      if (standalone != null) {
+        this.standalone = this.stringify.xmlStandalone(standalone);
+      }
+    }
+
+    XMLDeclaration.prototype.toString = function (options, level) {
+      var indent, newline, offset, pretty, r, ref, ref1, ref2, space;
+      pretty = (options != null ? options.pretty : void 0) || false;
+      indent = (ref = options != null ? options.indent : void 0) != null ? ref : '  ';
+      offset = (ref1 = options != null ? options.offset : void 0) != null ? ref1 : 0;
+      newline = (ref2 = options != null ? options.newline : void 0) != null ? ref2 : '\n';
+      level || (level = 0);
+      space = new Array(level + offset + 1).join(indent);
+      r = '';
+      if (pretty) {
+        r += space;
+      }
+      r += '<?xml';
+      r += ' version="' + this.version + '"';
+      if (this.encoding != null) {
+        r += ' encoding="' + this.encoding + '"';
+      }
+      if (this.standalone != null) {
+        r += ' standalone="' + this.standalone + '"';
+      }
+      r += '?>';
+      if (pretty) {
+        r += newline;
+      }
+      return r;
+    };
+
+    return XMLDeclaration;
+  }(XMLNode);
+}).call(undefined);
+
+},{"./XMLNode":412,"lodash/create":313,"lodash/isObject":326}],410:[function(require,module,exports){
+'use strict';
+
+// Generated by CoffeeScript 1.9.1
+(function () {
+  var XMLCData, XMLComment, XMLDTDAttList, XMLDTDElement, XMLDTDEntity, XMLDTDNotation, XMLDocType, XMLProcessingInstruction, create, isObject;
+
+  create = require('lodash/create');
+
+  isObject = require('lodash/isObject');
+
+  XMLCData = require('./XMLCData');
+
+  XMLComment = require('./XMLComment');
+
+  XMLDTDAttList = require('./XMLDTDAttList');
+
+  XMLDTDEntity = require('./XMLDTDEntity');
+
+  XMLDTDElement = require('./XMLDTDElement');
+
+  XMLDTDNotation = require('./XMLDTDNotation');
+
+  XMLProcessingInstruction = require('./XMLProcessingInstruction');
+
+  module.exports = XMLDocType = function () {
+    function XMLDocType(parent, pubID, sysID) {
+      var ref, ref1;
+      this.documentObject = parent;
+      this.stringify = this.documentObject.stringify;
+      this.children = [];
+      if (isObject(pubID)) {
+        ref = pubID, pubID = ref.pubID, sysID = ref.sysID;
+      }
+      if (sysID == null) {
+        ref1 = [pubID, sysID], sysID = ref1[0], pubID = ref1[1];
+      }
+      if (pubID != null) {
+        this.pubID = this.stringify.dtdPubID(pubID);
+      }
+      if (sysID != null) {
+        this.sysID = this.stringify.dtdSysID(sysID);
+      }
+    }
+
+    XMLDocType.prototype.element = function (name, value) {
+      var child;
+      child = new XMLDTDElement(this, name, value);
+      this.children.push(child);
+      return this;
+    };
+
+    XMLDocType.prototype.attList = function (elementName, attributeName, attributeType, defaultValueType, defaultValue) {
+      var child;
+      child = new XMLDTDAttList(this, elementName, attributeName, attributeType, defaultValueType, defaultValue);
+      this.children.push(child);
+      return this;
+    };
+
+    XMLDocType.prototype.entity = function (name, value) {
+      var child;
+      child = new XMLDTDEntity(this, false, name, value);
+      this.children.push(child);
+      return this;
+    };
+
+    XMLDocType.prototype.pEntity = function (name, value) {
+      var child;
+      child = new XMLDTDEntity(this, true, name, value);
+      this.children.push(child);
+      return this;
+    };
+
+    XMLDocType.prototype.notation = function (name, value) {
+      var child;
+      child = new XMLDTDNotation(this, name, value);
+      this.children.push(child);
+      return this;
+    };
+
+    XMLDocType.prototype.cdata = function (value) {
+      var child;
+      child = new XMLCData(this, value);
+      this.children.push(child);
+      return this;
+    };
+
+    XMLDocType.prototype.comment = function (value) {
+      var child;
+      child = new XMLComment(this, value);
+      this.children.push(child);
+      return this;
+    };
+
+    XMLDocType.prototype.instruction = function (target, value) {
+      var child;
+      child = new XMLProcessingInstruction(this, target, value);
+      this.children.push(child);
+      return this;
+    };
+
+    XMLDocType.prototype.root = function () {
+      return this.documentObject.root();
+    };
+
+    XMLDocType.prototype.document = function () {
+      return this.documentObject;
+    };
+
+    XMLDocType.prototype.toString = function (options, level) {
+      var child, i, indent, len, newline, offset, pretty, r, ref, ref1, ref2, ref3, space;
+      pretty = (options != null ? options.pretty : void 0) || false;
+      indent = (ref = options != null ? options.indent : void 0) != null ? ref : '  ';
+      offset = (ref1 = options != null ? options.offset : void 0) != null ? ref1 : 0;
+      newline = (ref2 = options != null ? options.newline : void 0) != null ? ref2 : '\n';
+      level || (level = 0);
+      space = new Array(level + offset + 1).join(indent);
+      r = '';
+      if (pretty) {
+        r += space;
+      }
+      r += '<!DOCTYPE ' + this.root().name;
+      if (this.pubID && this.sysID) {
+        r += ' PUBLIC "' + this.pubID + '" "' + this.sysID + '"';
+      } else if (this.sysID) {
+        r += ' SYSTEM "' + this.sysID + '"';
+      }
+      if (this.children.length > 0) {
+        r += ' [';
+        if (pretty) {
+          r += newline;
+        }
+        ref3 = this.children;
+        for (i = 0, len = ref3.length; i < len; i++) {
+          child = ref3[i];
+          r += child.toString(options, level + 1);
+        }
+        r += ']';
+      }
+      r += '>';
+      if (pretty) {
+        r += newline;
+      }
+      return r;
+    };
+
+    XMLDocType.prototype.ele = function (name, value) {
+      return this.element(name, value);
+    };
+
+    XMLDocType.prototype.att = function (elementName, attributeName, attributeType, defaultValueType, defaultValue) {
+      return this.attList(elementName, attributeName, attributeType, defaultValueType, defaultValue);
+    };
+
+    XMLDocType.prototype.ent = function (name, value) {
+      return this.entity(name, value);
+    };
+
+    XMLDocType.prototype.pent = function (name, value) {
+      return this.pEntity(name, value);
+    };
+
+    XMLDocType.prototype.not = function (name, value) {
+      return this.notation(name, value);
+    };
+
+    XMLDocType.prototype.dat = function (value) {
+      return this.cdata(value);
+    };
+
+    XMLDocType.prototype.com = function (value) {
+      return this.comment(value);
+    };
+
+    XMLDocType.prototype.ins = function (target, value) {
+      return this.instruction(target, value);
+    };
+
+    XMLDocType.prototype.up = function () {
+      return this.root();
+    };
+
+    XMLDocType.prototype.doc = function () {
+      return this.document();
+    };
+
+    return XMLDocType;
+  }();
+}).call(undefined);
+
+},{"./XMLCData":403,"./XMLComment":404,"./XMLDTDAttList":405,"./XMLDTDElement":406,"./XMLDTDEntity":407,"./XMLDTDNotation":408,"./XMLProcessingInstruction":413,"lodash/create":313,"lodash/isObject":326}],411:[function(require,module,exports){
+'use strict';
+
+// Generated by CoffeeScript 1.9.1
+(function () {
+  var XMLAttribute,
+      XMLElement,
+      XMLNode,
+      XMLProcessingInstruction,
+      create,
+      every,
+      isFunction,
+      isObject,
+      extend = function extend(child, parent) {
+    for (var key in parent) {
+      if (hasProp.call(parent, key)) child[key] = parent[key];
+    }function ctor() {
+      this.constructor = child;
+    }ctor.prototype = parent.prototype;child.prototype = new ctor();child.__super__ = parent.prototype;return child;
+  },
+      hasProp = {}.hasOwnProperty;
+
+  create = require('lodash/create');
+
+  isObject = require('lodash/isObject');
+
+  isFunction = require('lodash/isFunction');
+
+  every = require('lodash/every');
+
+  XMLNode = require('./XMLNode');
+
+  XMLAttribute = require('./XMLAttribute');
+
+  XMLProcessingInstruction = require('./XMLProcessingInstruction');
+
+  module.exports = XMLElement = function (superClass) {
+    extend(XMLElement, superClass);
+
+    function XMLElement(parent, name, attributes) {
+      XMLElement.__super__.constructor.call(this, parent);
+      if (name == null) {
+        throw new Error("Missing element name");
+      }
+      this.name = this.stringify.eleName(name);
+      this.children = [];
+      this.instructions = [];
+      this.attributes = {};
+      if (attributes != null) {
+        this.attribute(attributes);
+      }
+    }
+
+    XMLElement.prototype.clone = function () {
+      var att, attName, clonedSelf, i, len, pi, ref, ref1;
+      clonedSelf = create(XMLElement.prototype, this);
+      if (clonedSelf.isRoot) {
+        clonedSelf.documentObject = null;
+      }
+      clonedSelf.attributes = {};
+      ref = this.attributes;
+      for (attName in ref) {
+        if (!hasProp.call(ref, attName)) continue;
+        att = ref[attName];
+        clonedSelf.attributes[attName] = att.clone();
+      }
+      clonedSelf.instructions = [];
+      ref1 = this.instructions;
+      for (i = 0, len = ref1.length; i < len; i++) {
+        pi = ref1[i];
+        clonedSelf.instructions.push(pi.clone());
+      }
+      clonedSelf.children = [];
+      this.children.forEach(function (child) {
+        var clonedChild;
+        clonedChild = child.clone();
+        clonedChild.parent = clonedSelf;
+        return clonedSelf.children.push(clonedChild);
+      });
+      return clonedSelf;
+    };
+
+    XMLElement.prototype.attribute = function (name, value) {
+      var attName, attValue;
+      if (name != null) {
+        name = name.valueOf();
+      }
+      if (isObject(name)) {
+        for (attName in name) {
+          if (!hasProp.call(name, attName)) continue;
+          attValue = name[attName];
+          this.attribute(attName, attValue);
+        }
+      } else {
+        if (isFunction(value)) {
+          value = value.apply();
+        }
+        if (!this.options.skipNullAttributes || value != null) {
+          this.attributes[name] = new XMLAttribute(this, name, value);
+        }
+      }
+      return this;
+    };
+
+    XMLElement.prototype.removeAttribute = function (name) {
+      var attName, i, len;
+      if (name == null) {
+        throw new Error("Missing attribute name");
+      }
+      name = name.valueOf();
+      if (Array.isArray(name)) {
+        for (i = 0, len = name.length; i < len; i++) {
+          attName = name[i];
+          delete this.attributes[attName];
+        }
+      } else {
+        delete this.attributes[name];
+      }
+      return this;
+    };
+
+    XMLElement.prototype.instruction = function (target, value) {
+      var i, insTarget, insValue, instruction, len;
+      if (target != null) {
+        target = target.valueOf();
+      }
+      if (value != null) {
+        value = value.valueOf();
+      }
+      if (Array.isArray(target)) {
+        for (i = 0, len = target.length; i < len; i++) {
+          insTarget = target[i];
+          this.instruction(insTarget);
+        }
+      } else if (isObject(target)) {
+        for (insTarget in target) {
+          if (!hasProp.call(target, insTarget)) continue;
+          insValue = target[insTarget];
+          this.instruction(insTarget, insValue);
+        }
+      } else {
+        if (isFunction(value)) {
+          value = value.apply();
+        }
+        instruction = new XMLProcessingInstruction(this, target, value);
+        this.instructions.push(instruction);
+      }
+      return this;
+    };
+
+    XMLElement.prototype.toString = function (options, level) {
+      var att, child, i, indent, instruction, j, len, len1, name, newline, offset, pretty, r, ref, ref1, ref2, ref3, ref4, ref5, space;
+      pretty = (options != null ? options.pretty : void 0) || false;
+      indent = (ref = options != null ? options.indent : void 0) != null ? ref : '  ';
+      offset = (ref1 = options != null ? options.offset : void 0) != null ? ref1 : 0;
+      newline = (ref2 = options != null ? options.newline : void 0) != null ? ref2 : '\n';
+      level || (level = 0);
+      space = new Array(level + offset + 1).join(indent);
+      r = '';
+      ref3 = this.instructions;
+      for (i = 0, len = ref3.length; i < len; i++) {
+        instruction = ref3[i];
+        r += instruction.toString(options, level);
+      }
+      if (pretty) {
+        r += space;
+      }
+      r += '<' + this.name;
+      ref4 = this.attributes;
+      for (name in ref4) {
+        if (!hasProp.call(ref4, name)) continue;
+        att = ref4[name];
+        r += att.toString(options);
+      }
+      if (this.children.length === 0 || every(this.children, function (e) {
+        return e.value === '';
+      })) {
+        r += '/>';
+        if (pretty) {
+          r += newline;
+        }
+      } else if (pretty && this.children.length === 1 && this.children[0].value != null) {
+        r += '>';
+        r += this.children[0].value;
+        r += '</' + this.name + '>';
+        r += newline;
+      } else {
+        r += '>';
+        if (pretty) {
+          r += newline;
+        }
+        ref5 = this.children;
+        for (j = 0, len1 = ref5.length; j < len1; j++) {
+          child = ref5[j];
+          r += child.toString(options, level + 1);
+        }
+        if (pretty) {
+          r += space;
+        }
+        r += '</' + this.name + '>';
+        if (pretty) {
+          r += newline;
+        }
+      }
+      return r;
+    };
+
+    XMLElement.prototype.att = function (name, value) {
+      return this.attribute(name, value);
+    };
+
+    XMLElement.prototype.ins = function (target, value) {
+      return this.instruction(target, value);
+    };
+
+    XMLElement.prototype.a = function (name, value) {
+      return this.attribute(name, value);
+    };
+
+    XMLElement.prototype.i = function (target, value) {
+      return this.instruction(target, value);
+    };
+
+    return XMLElement;
+  }(XMLNode);
+}).call(undefined);
+
+},{"./XMLAttribute":401,"./XMLNode":412,"./XMLProcessingInstruction":413,"lodash/create":313,"lodash/every":315,"lodash/isFunction":324,"lodash/isObject":326}],412:[function(require,module,exports){
+'use strict';
+
+// Generated by CoffeeScript 1.9.1
+(function () {
+  var XMLCData,
+      XMLComment,
+      XMLDeclaration,
+      XMLDocType,
+      XMLElement,
+      XMLNode,
+      XMLRaw,
+      XMLText,
+      isEmpty,
+      isFunction,
+      isObject,
+      hasProp = {}.hasOwnProperty;
+
+  isObject = require('lodash/isObject');
+
+  isFunction = require('lodash/isFunction');
+
+  isEmpty = require('lodash/isEmpty');
+
+  XMLElement = null;
+
+  XMLCData = null;
+
+  XMLComment = null;
+
+  XMLDeclaration = null;
+
+  XMLDocType = null;
+
+  XMLRaw = null;
+
+  XMLText = null;
+
+  module.exports = XMLNode = function () {
+    function XMLNode(parent) {
+      this.parent = parent;
+      this.options = this.parent.options;
+      this.stringify = this.parent.stringify;
+      if (XMLElement === null) {
+        XMLElement = require('./XMLElement');
+        XMLCData = require('./XMLCData');
+        XMLComment = require('./XMLComment');
+        XMLDeclaration = require('./XMLDeclaration');
+        XMLDocType = require('./XMLDocType');
+        XMLRaw = require('./XMLRaw');
+        XMLText = require('./XMLText');
+      }
+    }
+
+    XMLNode.prototype.element = function (name, attributes, text) {
+      var childNode, item, j, k, key, lastChild, len, len1, ref, val;
+      lastChild = null;
+      if (attributes == null) {
+        attributes = {};
+      }
+      attributes = attributes.valueOf();
+      if (!isObject(attributes)) {
+        ref = [attributes, text], text = ref[0], attributes = ref[1];
+      }
+      if (name != null) {
+        name = name.valueOf();
+      }
+      if (Array.isArray(name)) {
+        for (j = 0, len = name.length; j < len; j++) {
+          item = name[j];
+          lastChild = this.element(item);
+        }
+      } else if (isFunction(name)) {
+        lastChild = this.element(name.apply());
+      } else if (isObject(name)) {
+        for (key in name) {
+          if (!hasProp.call(name, key)) continue;
+          val = name[key];
+          if (isFunction(val)) {
+            val = val.apply();
+          }
+          if (isObject(val) && isEmpty(val)) {
+            val = null;
+          }
+          if (!this.options.ignoreDecorators && this.stringify.convertAttKey && key.indexOf(this.stringify.convertAttKey) === 0) {
+            lastChild = this.attribute(key.substr(this.stringify.convertAttKey.length), val);
+          } else if (!this.options.ignoreDecorators && this.stringify.convertPIKey && key.indexOf(this.stringify.convertPIKey) === 0) {
+            lastChild = this.instruction(key.substr(this.stringify.convertPIKey.length), val);
+          } else if (!this.options.separateArrayItems && Array.isArray(val)) {
+            for (k = 0, len1 = val.length; k < len1; k++) {
+              item = val[k];
+              childNode = {};
+              childNode[key] = item;
+              lastChild = this.element(childNode);
+            }
+          } else if (isObject(val)) {
+            lastChild = this.element(key);
+            lastChild.element(val);
+          } else {
+            lastChild = this.element(key, val);
+          }
+        }
+      } else {
+        if (!this.options.ignoreDecorators && this.stringify.convertTextKey && name.indexOf(this.stringify.convertTextKey) === 0) {
+          lastChild = this.text(text);
+        } else if (!this.options.ignoreDecorators && this.stringify.convertCDataKey && name.indexOf(this.stringify.convertCDataKey) === 0) {
+          lastChild = this.cdata(text);
+        } else if (!this.options.ignoreDecorators && this.stringify.convertCommentKey && name.indexOf(this.stringify.convertCommentKey) === 0) {
+          lastChild = this.comment(text);
+        } else if (!this.options.ignoreDecorators && this.stringify.convertRawKey && name.indexOf(this.stringify.convertRawKey) === 0) {
+          lastChild = this.raw(text);
+        } else {
+          lastChild = this.node(name, attributes, text);
+        }
+      }
+      if (lastChild == null) {
+        throw new Error("Could not create any elements with: " + name);
+      }
+      return lastChild;
+    };
+
+    XMLNode.prototype.insertBefore = function (name, attributes, text) {
+      var child, i, removed;
+      if (this.isRoot) {
+        throw new Error("Cannot insert elements at root level");
+      }
+      i = this.parent.children.indexOf(this);
+      removed = this.parent.children.splice(i);
+      child = this.parent.element(name, attributes, text);
+      Array.prototype.push.apply(this.parent.children, removed);
+      return child;
+    };
+
+    XMLNode.prototype.insertAfter = function (name, attributes, text) {
+      var child, i, removed;
+      if (this.isRoot) {
+        throw new Error("Cannot insert elements at root level");
+      }
+      i = this.parent.children.indexOf(this);
+      removed = this.parent.children.splice(i + 1);
+      child = this.parent.element(name, attributes, text);
+      Array.prototype.push.apply(this.parent.children, removed);
+      return child;
+    };
+
+    XMLNode.prototype.remove = function () {
+      var i, ref;
+      if (this.isRoot) {
+        throw new Error("Cannot remove the root element");
+      }
+      i = this.parent.children.indexOf(this);
+      [].splice.apply(this.parent.children, [i, i - i + 1].concat(ref = [])), ref;
+      return this.parent;
+    };
+
+    XMLNode.prototype.node = function (name, attributes, text) {
+      var child, ref;
+      if (name != null) {
+        name = name.valueOf();
+      }
+      if (attributes == null) {
+        attributes = {};
+      }
+      attributes = attributes.valueOf();
+      if (!isObject(attributes)) {
+        ref = [attributes, text], text = ref[0], attributes = ref[1];
+      }
+      child = new XMLElement(this, name, attributes);
+      if (text != null) {
+        child.text(text);
+      }
+      this.children.push(child);
+      return child;
+    };
+
+    XMLNode.prototype.text = function (value) {
+      var child;
+      child = new XMLText(this, value);
+      this.children.push(child);
+      return this;
+    };
+
+    XMLNode.prototype.cdata = function (value) {
+      var child;
+      child = new XMLCData(this, value);
+      this.children.push(child);
+      return this;
+    };
+
+    XMLNode.prototype.comment = function (value) {
+      var child;
+      child = new XMLComment(this, value);
+      this.children.push(child);
+      return this;
+    };
+
+    XMLNode.prototype.raw = function (value) {
+      var child;
+      child = new XMLRaw(this, value);
+      this.children.push(child);
+      return this;
+    };
+
+    XMLNode.prototype.declaration = function (version, encoding, standalone) {
+      var doc, xmldec;
+      doc = this.document();
+      xmldec = new XMLDeclaration(doc, version, encoding, standalone);
+      doc.xmldec = xmldec;
+      return doc.root();
+    };
+
+    XMLNode.prototype.doctype = function (pubID, sysID) {
+      var doc, doctype;
+      doc = this.document();
+      doctype = new XMLDocType(doc, pubID, sysID);
+      doc.doctype = doctype;
+      return doctype;
+    };
+
+    XMLNode.prototype.up = function () {
+      if (this.isRoot) {
+        throw new Error("The root node has no parent. Use doc() if you need to get the document object.");
+      }
+      return this.parent;
+    };
+
+    XMLNode.prototype.root = function () {
+      var child;
+      if (this.isRoot) {
+        return this;
+      }
+      child = this.parent;
+      while (!child.isRoot) {
+        child = child.parent;
+      }
+      return child;
+    };
+
+    XMLNode.prototype.document = function () {
+      return this.root().documentObject;
+    };
+
+    XMLNode.prototype.end = function (options) {
+      return this.document().toString(options);
+    };
+
+    XMLNode.prototype.prev = function () {
+      var i;
+      if (this.isRoot) {
+        throw new Error("Root node has no siblings");
+      }
+      i = this.parent.children.indexOf(this);
+      if (i < 1) {
+        throw new Error("Already at the first node");
+      }
+      return this.parent.children[i - 1];
+    };
+
+    XMLNode.prototype.next = function () {
+      var i;
+      if (this.isRoot) {
+        throw new Error("Root node has no siblings");
+      }
+      i = this.parent.children.indexOf(this);
+      if (i === -1 || i === this.parent.children.length - 1) {
+        throw new Error("Already at the last node");
+      }
+      return this.parent.children[i + 1];
+    };
+
+    XMLNode.prototype.importXMLBuilder = function (xmlbuilder) {
+      var clonedRoot;
+      clonedRoot = xmlbuilder.root().clone();
+      clonedRoot.parent = this;
+      clonedRoot.isRoot = false;
+      this.children.push(clonedRoot);
+      return this;
+    };
+
+    XMLNode.prototype.ele = function (name, attributes, text) {
+      return this.element(name, attributes, text);
+    };
+
+    XMLNode.prototype.nod = function (name, attributes, text) {
+      return this.node(name, attributes, text);
+    };
+
+    XMLNode.prototype.txt = function (value) {
+      return this.text(value);
+    };
+
+    XMLNode.prototype.dat = function (value) {
+      return this.cdata(value);
+    };
+
+    XMLNode.prototype.com = function (value) {
+      return this.comment(value);
+    };
+
+    XMLNode.prototype.doc = function () {
+      return this.document();
+    };
+
+    XMLNode.prototype.dec = function (version, encoding, standalone) {
+      return this.declaration(version, encoding, standalone);
+    };
+
+    XMLNode.prototype.dtd = function (pubID, sysID) {
+      return this.doctype(pubID, sysID);
+    };
+
+    XMLNode.prototype.e = function (name, attributes, text) {
+      return this.element(name, attributes, text);
+    };
+
+    XMLNode.prototype.n = function (name, attributes, text) {
+      return this.node(name, attributes, text);
+    };
+
+    XMLNode.prototype.t = function (value) {
+      return this.text(value);
+    };
+
+    XMLNode.prototype.d = function (value) {
+      return this.cdata(value);
+    };
+
+    XMLNode.prototype.c = function (value) {
+      return this.comment(value);
+    };
+
+    XMLNode.prototype.r = function (value) {
+      return this.raw(value);
+    };
+
+    XMLNode.prototype.u = function () {
+      return this.up();
+    };
+
+    return XMLNode;
+  }();
+}).call(undefined);
+
+},{"./XMLCData":403,"./XMLComment":404,"./XMLDeclaration":409,"./XMLDocType":410,"./XMLElement":411,"./XMLRaw":414,"./XMLText":416,"lodash/isEmpty":323,"lodash/isFunction":324,"lodash/isObject":326}],413:[function(require,module,exports){
+'use strict';
+
+// Generated by CoffeeScript 1.9.1
+(function () {
+  var XMLProcessingInstruction, create;
+
+  create = require('lodash/create');
+
+  module.exports = XMLProcessingInstruction = function () {
+    function XMLProcessingInstruction(parent, target, value) {
+      this.stringify = parent.stringify;
+      if (target == null) {
+        throw new Error("Missing instruction target");
+      }
+      this.target = this.stringify.insTarget(target);
+      if (value) {
+        this.value = this.stringify.insValue(value);
+      }
+    }
+
+    XMLProcessingInstruction.prototype.clone = function () {
+      return create(XMLProcessingInstruction.prototype, this);
+    };
+
+    XMLProcessingInstruction.prototype.toString = function (options, level) {
+      var indent, newline, offset, pretty, r, ref, ref1, ref2, space;
+      pretty = (options != null ? options.pretty : void 0) || false;
+      indent = (ref = options != null ? options.indent : void 0) != null ? ref : '  ';
+      offset = (ref1 = options != null ? options.offset : void 0) != null ? ref1 : 0;
+      newline = (ref2 = options != null ? options.newline : void 0) != null ? ref2 : '\n';
+      level || (level = 0);
+      space = new Array(level + offset + 1).join(indent);
+      r = '';
+      if (pretty) {
+        r += space;
+      }
+      r += '<?';
+      r += this.target;
+      if (this.value) {
+        r += ' ' + this.value;
+      }
+      r += '?>';
+      if (pretty) {
+        r += newline;
+      }
+      return r;
+    };
+
+    return XMLProcessingInstruction;
+  }();
+}).call(undefined);
+
+},{"lodash/create":313}],414:[function(require,module,exports){
+'use strict';
+
+// Generated by CoffeeScript 1.9.1
+(function () {
+  var XMLNode,
+      XMLRaw,
+      create,
+      extend = function extend(child, parent) {
+    for (var key in parent) {
+      if (hasProp.call(parent, key)) child[key] = parent[key];
+    }function ctor() {
+      this.constructor = child;
+    }ctor.prototype = parent.prototype;child.prototype = new ctor();child.__super__ = parent.prototype;return child;
+  },
+      hasProp = {}.hasOwnProperty;
+
+  create = require('lodash/create');
+
+  XMLNode = require('./XMLNode');
+
+  module.exports = XMLRaw = function (superClass) {
+    extend(XMLRaw, superClass);
+
+    function XMLRaw(parent, text) {
+      XMLRaw.__super__.constructor.call(this, parent);
+      if (text == null) {
+        throw new Error("Missing raw text");
+      }
+      this.value = this.stringify.raw(text);
+    }
+
+    XMLRaw.prototype.clone = function () {
+      return create(XMLRaw.prototype, this);
+    };
+
+    XMLRaw.prototype.toString = function (options, level) {
+      var indent, newline, offset, pretty, r, ref, ref1, ref2, space;
+      pretty = (options != null ? options.pretty : void 0) || false;
+      indent = (ref = options != null ? options.indent : void 0) != null ? ref : '  ';
+      offset = (ref1 = options != null ? options.offset : void 0) != null ? ref1 : 0;
+      newline = (ref2 = options != null ? options.newline : void 0) != null ? ref2 : '\n';
+      level || (level = 0);
+      space = new Array(level + offset + 1).join(indent);
+      r = '';
+      if (pretty) {
+        r += space;
+      }
+      r += this.value;
+      if (pretty) {
+        r += newline;
+      }
+      return r;
+    };
+
+    return XMLRaw;
+  }(XMLNode);
+}).call(undefined);
+
+},{"./XMLNode":412,"lodash/create":313}],415:[function(require,module,exports){
+'use strict';
+
+// Generated by CoffeeScript 1.9.1
+(function () {
+  var XMLStringifier,
+      bind = function bind(fn, me) {
+    return function () {
+      return fn.apply(me, arguments);
+    };
+  },
+      hasProp = {}.hasOwnProperty;
+
+  module.exports = XMLStringifier = function () {
+    function XMLStringifier(options) {
+      this.assertLegalChar = bind(this.assertLegalChar, this);
+      var key, ref, value;
+      this.allowSurrogateChars = options != null ? options.allowSurrogateChars : void 0;
+      this.noDoubleEncoding = options != null ? options.noDoubleEncoding : void 0;
+      ref = (options != null ? options.stringify : void 0) || {};
+      for (key in ref) {
+        if (!hasProp.call(ref, key)) continue;
+        value = ref[key];
+        this[key] = value;
+      }
+    }
+
+    XMLStringifier.prototype.eleName = function (val) {
+      val = '' + val || '';
+      return this.assertLegalChar(val);
+    };
+
+    XMLStringifier.prototype.eleText = function (val) {
+      val = '' + val || '';
+      return this.assertLegalChar(this.elEscape(val));
+    };
+
+    XMLStringifier.prototype.cdata = function (val) {
+      val = '' + val || '';
+      if (val.match(/]]>/)) {
+        throw new Error("Invalid CDATA text: " + val);
+      }
+      return this.assertLegalChar(val);
+    };
+
+    XMLStringifier.prototype.comment = function (val) {
+      val = '' + val || '';
+      if (val.match(/--/)) {
+        throw new Error("Comment text cannot contain double-hypen: " + val);
+      }
+      return this.assertLegalChar(val);
+    };
+
+    XMLStringifier.prototype.raw = function (val) {
+      return '' + val || '';
+    };
+
+    XMLStringifier.prototype.attName = function (val) {
+      return '' + val || '';
+    };
+
+    XMLStringifier.prototype.attValue = function (val) {
+      val = '' + val || '';
+      return this.attEscape(val);
+    };
+
+    XMLStringifier.prototype.insTarget = function (val) {
+      return '' + val || '';
+    };
+
+    XMLStringifier.prototype.insValue = function (val) {
+      val = '' + val || '';
+      if (val.match(/\?>/)) {
+        throw new Error("Invalid processing instruction value: " + val);
+      }
+      return val;
+    };
+
+    XMLStringifier.prototype.xmlVersion = function (val) {
+      val = '' + val || '';
+      if (!val.match(/1\.[0-9]+/)) {
+        throw new Error("Invalid version number: " + val);
+      }
+      return val;
+    };
+
+    XMLStringifier.prototype.xmlEncoding = function (val) {
+      val = '' + val || '';
+      if (!val.match(/^[A-Za-z](?:[A-Za-z0-9._-]|-)*$/)) {
+        throw new Error("Invalid encoding: " + val);
+      }
+      return val;
+    };
+
+    XMLStringifier.prototype.xmlStandalone = function (val) {
+      if (val) {
+        return "yes";
+      } else {
+        return "no";
+      }
+    };
+
+    XMLStringifier.prototype.dtdPubID = function (val) {
+      return '' + val || '';
+    };
+
+    XMLStringifier.prototype.dtdSysID = function (val) {
+      return '' + val || '';
+    };
+
+    XMLStringifier.prototype.dtdElementValue = function (val) {
+      return '' + val || '';
+    };
+
+    XMLStringifier.prototype.dtdAttType = function (val) {
+      return '' + val || '';
+    };
+
+    XMLStringifier.prototype.dtdAttDefault = function (val) {
+      if (val != null) {
+        return '' + val || '';
+      } else {
+        return val;
+      }
+    };
+
+    XMLStringifier.prototype.dtdEntityValue = function (val) {
+      return '' + val || '';
+    };
+
+    XMLStringifier.prototype.dtdNData = function (val) {
+      return '' + val || '';
+    };
+
+    XMLStringifier.prototype.convertAttKey = '@';
+
+    XMLStringifier.prototype.convertPIKey = '?';
+
+    XMLStringifier.prototype.convertTextKey = '#text';
+
+    XMLStringifier.prototype.convertCDataKey = '#cdata';
+
+    XMLStringifier.prototype.convertCommentKey = '#comment';
+
+    XMLStringifier.prototype.convertRawKey = '#raw';
+
+    XMLStringifier.prototype.assertLegalChar = function (str) {
+      var chars, chr;
+      if (this.allowSurrogateChars) {
+        chars = /[\u0000-\u0008\u000B-\u000C\u000E-\u001F\uFFFE-\uFFFF]/;
+      } else {
+        chars = /[\u0000-\u0008\u000B-\u000C\u000E-\u001F\uD800-\uDFFF\uFFFE-\uFFFF]/;
+      }
+      chr = str.match(chars);
+      if (chr) {
+        throw new Error("Invalid character (" + chr + ") in string: " + str + " at index " + chr.index);
+      }
+      return str;
+    };
+
+    XMLStringifier.prototype.elEscape = function (str) {
+      var ampregex;
+      ampregex = this.noDoubleEncoding ? /(?!&\S+;)&/g : /&/g;
+      return str.replace(ampregex, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/\r/g, '&#xD;');
+    };
+
+    XMLStringifier.prototype.attEscape = function (str) {
+      var ampregex;
+      ampregex = this.noDoubleEncoding ? /(?!&\S+;)&/g : /&/g;
+      return str.replace(ampregex, '&amp;').replace(/</g, '&lt;').replace(/"/g, '&quot;');
+    };
+
+    return XMLStringifier;
+  }();
+}).call(undefined);
+
+},{}],416:[function(require,module,exports){
+'use strict';
+
+// Generated by CoffeeScript 1.9.1
+(function () {
+  var XMLNode,
+      XMLText,
+      create,
+      extend = function extend(child, parent) {
+    for (var key in parent) {
+      if (hasProp.call(parent, key)) child[key] = parent[key];
+    }function ctor() {
+      this.constructor = child;
+    }ctor.prototype = parent.prototype;child.prototype = new ctor();child.__super__ = parent.prototype;return child;
+  },
+      hasProp = {}.hasOwnProperty;
+
+  create = require('lodash/create');
+
+  XMLNode = require('./XMLNode');
+
+  module.exports = XMLText = function (superClass) {
+    extend(XMLText, superClass);
+
+    function XMLText(parent, text) {
+      XMLText.__super__.constructor.call(this, parent);
+      if (text == null) {
+        throw new Error("Missing element text");
+      }
+      this.value = this.stringify.eleText(text);
+    }
+
+    XMLText.prototype.clone = function () {
+      return create(XMLText.prototype, this);
+    };
+
+    XMLText.prototype.toString = function (options, level) {
+      var indent, newline, offset, pretty, r, ref, ref1, ref2, space;
+      pretty = (options != null ? options.pretty : void 0) || false;
+      indent = (ref = options != null ? options.indent : void 0) != null ? ref : '  ';
+      offset = (ref1 = options != null ? options.offset : void 0) != null ? ref1 : 0;
+      newline = (ref2 = options != null ? options.newline : void 0) != null ? ref2 : '\n';
+      level || (level = 0);
+      space = new Array(level + offset + 1).join(indent);
+      r = '';
+      if (pretty) {
+        r += space;
+      }
+      r += this.value;
+      if (pretty) {
+        r += newline;
+      }
+      return r;
+    };
+
+    return XMLText;
+  }(XMLNode);
+}).call(undefined);
+
+},{"./XMLNode":412,"lodash/create":313}],417:[function(require,module,exports){
+'use strict';
+
+// Generated by CoffeeScript 1.9.1
+(function () {
+  var XMLBuilder, assign;
+
+  assign = require('lodash/assign');
+
+  XMLBuilder = require('./XMLBuilder');
+
+  module.exports.create = function (name, xmldec, doctype, options) {
+    options = assign({}, xmldec, doctype, options);
+    return new XMLBuilder(name, options).root();
+  };
+}).call(undefined);
+
+},{"./XMLBuilder":402,"lodash/assign":311}],418:[function(require,module,exports){
+"use strict";
+
+module.exports = extend;
+
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+
+function extend() {
+    var target = {};
+
+    for (var i = 0; i < arguments.length; i++) {
+        var source = arguments[i];
+
+        for (var key in source) {
+            if (hasOwnProperty.call(source, key)) {
+                target[key] = source[key];
+            }
+        }
+    }
+
+    return target;
+}
+
+},{}],419:[function(require,module,exports){
+module.exports={
+  "name": "ali-oss",
+  "version": "4.6.0",
+  "description": "aliyun oss(open storage service) node client",
+  "main": "lib/client.js",
+  "files": [
+    "lib"
+  ],
+  "scripts": {
+    "test": "mocha -t 30000 -r thunk-mocha -r should test/*.test.js",
+    "test-cov": "istanbul cover node_modules/.bin/_mocha -- -R dot -t 60000 -r thunk-mocha -r should test/*.test.js",
+    "jshint": "jshint .",
+    "autod": "autod",
+    "build-dist": "node browser-build.js > dist/aliyun-oss-sdk.js && MINIFY=1 node browser-build.js > dist/aliyun-oss-sdk.min.js",
+    "publish-to-cdn": "node publish.js"
+  },
+  "git-pre-hooks": {
+    "pre-release": "npm run build-dist",
+    "post-release": [
+      "npm publish",
+      "npm run publish-to-cdn"
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/aliyun/oss-nodejs-sdk.git"
+  },
+  "keywords": [
+    "oss",
+    "client",
+    "file",
+    "aliyun"
+  ],
+  "author": "dead_horse",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/aliyun/oss-nodejs-sdk/issues"
+  },
+  "engines": {
+    "node": ">=4"
+  },
+  "homepage": "https://github.com/aliyun/oss-nodejs-sdk",
+  "devDependencies": {
+    "aliasify": "^2.0.0",
+    "autod": "^2.6.1",
+    "babel-plugin-transform-runtime": "^6.8.0",
+    "babel-preset-es2015": "^6.3.13",
+    "babel-runtime": "^6.6.1",
+    "babelify": "^7.3.0",
+    "beautify-benchmark": "^0.2.4",
+    "benchmark": "^2.1.1",
+    "bluebird": "^3.1.5",
+    "browserify": "^13.0.1",
+    "co-fs": "^1.2.0",
+    "crypto-browserify": "^1.0.9",
+    "filereader": "^0.10.3",
+    "git-pre-hooks": "^1.2.0",
+    "istanbul": "^0.4.3",
+    "mm": "^2.0.0",
+    "mocha": "^3.0.0",
+    "should": "^11.0.0",
+    "thunk-mocha": "^1.0.3",
+    "uglify-js": "^2.7.1"
+  },
+  "dependencies": {
+    "address": "^1.0.0",
+    "agentkeepalive": "^2.1.1",
+    "co": "^4.6.0",
+    "co-defer": "^1.0.0",
+    "co-gather": "^0.0.1",
+    "copy-to": "^2.0.1",
+    "dateformat": "^1.0.12",
+    "debug": "^2.2.0",
+    "destroy": "^1.0.4",
+    "end-or-error": "^1.0.1",
+    "get-ready": "^1.0.0",
+    "humanize-ms": "^1.2.0",
+    "is-type-of": "^1.0.0",
+    "merge-descriptors": "^1.0.1",
+    "mime": "^1.3.4",
+    "platform": "^1.3.1",
+    "sdk-base": "^2.0.1",
+    "urllib": "^2.16.1",
+    "utility": "^1.8.0",
+    "xml2js": "^0.4.16"
+  }
+}
+
+},{}],420:[function(require,module,exports){
+'use strict';
+
+// use crypto-browserify@1.0.9 to minify dist size
+module.exports = require('crypto-browserify');
+
+},{"crypto-browserify":178}]},{},[1])(1)
+});
diff --git a/dist/aliyun-oss-sdk.min.js b/dist/aliyun-oss-sdk.min.js
index e69de29bb..7fead3078 100644
--- a/dist/aliyun-oss-sdk.min.js
+++ b/dist/aliyun-oss-sdk.min.js
@@ -0,0 +1,16 @@
+// Aliyun OSS SDK for JavaScript v4.6.0
+// Copyright Aliyun.com, Inc. or its affiliates. All Rights Reserved.
+// License at https://github.com/ali-sdk/ali-oss/blob/master/LICENSE
+!function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var t;t="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:this,t.OSS=e()}}(function(){var e;return function e(t,r,n){function i(a,s){if(!r[a]){if(!t[a]){var u="function"==typeof require&&require;if(!s&&u)return u(a,!0);if(o)return o(a,!0);var c=new Error("Cannot find module '"+a+"'");throw c.code="MODULE_NOT_FOUND",c}var l=r[a]={exports:{}};t[a][0].call(l.exports,function(e){var r=t[a][1][e];return i(r?r:e)},l,l.exports,e,t,r,n)}return r[a].exports}for(var o="function"==typeof require&&require,a=0;a<n.length;a++)i(n[a]);return i}({1:[function(e,t,r){"use strict";var n=e(".");n.Buffer=e("buffer").Buffer,n.co=e("co"),n.urllib=e("urllib"),t.exports=n},{".":3,buffer:45,co:51,urllib:379}],2:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}var i=e("babel-runtime/regenerator"),o=n(i),a=r;a.listBuckets=o.default.mark(function e(t,r){var n,i,a;return o.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:return e.next=2,this.request({method:"GET",query:t,timeout:r&&r.timeout,ctx:r&&r.ctx});case 2:if(n=e.sent,200!==n.status){e.next=10;break}return e.next=6,this.parseXML(n.data);case 6:return i=e.sent,a=i.Buckets||null,a&&(a.Bucket&&(a=a.Bucket),Array.isArray(a)||(a=[a]),a=a.map(function(e){return{name:e.Name,region:e.Location,creationDate:e.CreationDate}})),e.abrupt("return",{buckets:a,owner:{id:i.Owner.ID,displayName:i.Owner.DisplayName},isTruncated:"true"===i.IsTruncated,nextMarker:i.NextMarker||null,res:n.res});case 10:return e.next=12,this.requestError(n);case 12:throw e.sent;case 13:case"end":return e.stop()}},e,this)}),a.useBucket=function(e,t){return this.options.bucket=e,this},a.putBucket=o.default.mark(function e(t,r,n){var i,a;return o.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:return i=this._bucketRequestParams("PUT",t,"",n),r&&(i.mime="xml",i.content='<?xml version="1.0" encoding="UTF-8"?>\n<CreateBucketConfiguration><LocationConstraint>'+r+"</LocationConstraint></CreateBucketConfiguration>"),i.successStatuses=[200],e.next=5,this.request(i);case 5:return a=e.sent,e.abrupt("return",{bucket:a.headers.location&&a.headers.location.substring(1)||null,res:a.res});case 7:case"end":return e.stop()}},e,this)}),a.deleteBucket=o.default.mark(function e(t,r,n){var i,a;return o.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:return i=this._bucketRequestParams("DELETE",t,"",n),e.next=3,this.request(i);case 3:if(a=e.sent,200!==a.status&&204!==a.status){e.next=6;break}return e.abrupt("return",{res:a.res});case 6:return e.next=8,this.requestError(a);case 8:throw e.sent;case 9:case"end":return e.stop()}},e,this)}),a.putBucketACL=o.default.mark(function e(t,r,n,i){var a,s;return o.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:return a=this._bucketRequestParams("PUT",t,"acl",i),a.headers={"x-oss-acl":n},a.successStatuses=[200],e.next=5,this.request(a);case 5:return s=e.sent,e.abrupt("return",{bucket:s.headers.location&&s.headers.location.substring(1)||null,res:s.res});case 7:case"end":return e.stop()}},e,this)}),a.getBucketACL=o.default.mark(function e(t,r,n){var i,a;return o.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:return i=this._bucketRequestParams("GET",t,"acl",n),i.successStatuses=[200],i.xmlResponse=!0,e.next=5,this.request(i);case 5:return a=e.sent,e.abrupt("return",{acl:a.data.AccessControlList.Grant,owner:{id:a.data.Owner.ID,displayName:a.data.Owner.DisplayName},res:a.res});case 7:case"end":return e.stop()}},e,this)}),a.putBucketLogging=o.default.mark(function e(t,r,n,i){var a,s,u;return o.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:return a=this._bucketRequestParams("PUT",t,"logging",i),s='<?xml version="1.0" encoding="UTF-8"?>\n<BucketLoggingStatus>\n<LoggingEnabled>\n<TargetBucket>'+t+"</TargetBucket>\n",n&&(s+="<TargetPrefix>"+n+"</TargetPrefix>\n"),s+="</LoggingEnabled>\n</BucketLoggingStatus>",a.content=s,a.mime="xml",a.successStatuses=[200],e.next=9,this.request(a);case 9:return u=e.sent,e.abrupt("return",{res:u.res});case 11:case"end":return e.stop()}},e,this)}),a.getBucketLogging=o.default.mark(function e(t,r,n){var i,a,s;return o.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:return i=this._bucketRequestParams("GET",t,"logging",n),i.successStatuses=[200],i.xmlResponse=!0,e.next=5,this.request(i);case 5:return a=e.sent,s=a.data.LoggingEnabled,e.abrupt("return",{enable:!!s,prefix:s&&s.TargetPrefix||null,res:a.res});case 8:case"end":return e.stop()}},e,this)}),a.deleteBucketLogging=o.default.mark(function e(t,r,n){var i,a;return o.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:return i=this._bucketRequestParams("DELETE",t,"logging",n),i.successStatuses=[204,200],e.next=4,this.request(i);case 4:return a=e.sent,e.abrupt("return",{res:a.res});case 6:case"end":return e.stop()}},e,this)}),a.putBucketWebsite=o.default.mark(function e(t,r,n,i){var a,s,u;return o.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:return a=this._bucketRequestParams("PUT",t,"website",i),n=n||{},n.index=n.index||"index.html",s='<?xml version="1.0" encoding="UTF-8"?>\n<WebsiteConfiguration>\n <IndexDocument><Suffix>'+n.index+"</Suffix></IndexDocument>\n",n.error&&(s+="<ErrorDocument><Key>"+n.error+"</Key></ErrorDocument>\n"),s+="</WebsiteConfiguration>",a.content=s,a.mime="xml",a.successStatuses=[200],e.delegateYield(this.request(a),"t0",10);case 10:return u=e.t0,e.abrupt("return",{res:u.res});case 12:case"end":return e.stop()}},e,this)}),a.getBucketWebsite=o.default.mark(function e(t,r,n){var i,a;return o.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:return i=this._bucketRequestParams("GET",t,"website",n),i.successStatuses=[200],i.xmlResponse=!0,e.next=5,this.request(i);case 5:return a=e.sent,e.abrupt("return",{index:a.data.IndexDocument.Suffix,error:a.data.ErrorDocument&&a.data.ErrorDocument.Key||null,res:a.res});case 7:case"end":return e.stop()}},e,this)}),a.deleteBucketWebsite=o.default.mark(function e(t,r,n){var i,a;return o.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:return i=this._bucketRequestParams("DELETE",t,"website",n),i.successStatuses=[204],e.next=4,this.request(i);case 4:return a=e.sent,e.abrupt("return",{res:a.res});case 6:case"end":return e.stop()}},e,this)}),a.putBucketLifecycle=o.default.mark(function e(t,r,n,i){var a,s,u,c,l,p,f;return o.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:for(a=this._bucketRequestParams("PUT",t,"lifecycle",i),s='<?xml version="1.0" encoding="UTF-8"?>\n<LifecycleConfiguration>\n',u=0;u<n.length;u++)c=n[u],l=c.days?"<Days>"+c.days+"</Days>":"<Date>"+c.date+"</Date>",p=c.id?"<ID>"+c.id+"</ID>\n":"",s+="  <Rule>\n"+p+"    <Prefix>"+c.prefix+"</Prefix>\n    <Status>"+c.status+"</Status>\n    <Expiration>"+l+"</Expiration>\n  </Rule>\n";return s+="</LifecycleConfiguration>",a.content=s,a.mime="xml",a.successStatuses=[200],e.next=9,this.request(a);case 9:return f=e.sent,e.abrupt("return",{res:f.res});case 11:case"end":return e.stop()}},e,this)}),a.getBucketLifecycle=o.default.mark(function e(t,r,n){var i,a,s;return o.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:return i=this._bucketRequestParams("GET",t,"lifecycle",n),i.successStatuses=[200],i.xmlResponse=!0,e.next=5,this.request(i);case 5:return a=e.sent,s=a.data.Rule||null,s&&(Array.isArray(s)||(s=[s]),s=s.map(function(e){var t={id:e.ID,prefix:e.Prefix,status:e.Status};return e.Expiration.Days?t.days=e.Expiration.Days:t.date=e.Expiration.Date,t})),e.abrupt("return",{rules:s,res:a.res});case 9:case"end":return e.stop()}},e,this)}),a.deleteBucketLifecycle=o.default.mark(function e(t,r,n){var i,a;return o.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:return i=this._bucketRequestParams("DELETE",t,"lifecycle",n),i.successStatuses=[204],e.next=4,this.request(i);case 4:return a=e.sent,e.abrupt("return",{res:a.res});case 6:case"end":return e.stop()}},e,this)}),a.putBucketReferer=o.default.mark(function e(t,r,n,i,a){var s,u,c,l;return o.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:if(s=this._bucketRequestParams("PUT",t,"referer",a),u='<?xml version="1.0" encoding="UTF-8"?>\n<RefererConfiguration>\n',u+="  <AllowEmptyReferer>"+(n?"true":"false")+"</AllowEmptyReferer>\n",i&&i.length>0){for(u+="  <RefererList>\n",c=0;c<i.length;c++)u+="    <Referer>"+i[c]+"</Referer>\n";u+="  </RefererList>\n"}else u+="  <RefererList />\n";return u+="</RefererConfiguration>",s.content=u,s.mime="xml",s.successStatuses=[200],e.next=10,this.request(s);case 10:return l=e.sent,e.abrupt("return",{res:l.res});case 12:case"end":return e.stop()}},e,this)}),a.getBucketReferer=o.default.mark(function e(t,r,n){var i,a,s;return o.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:return i=this._bucketRequestParams("GET",t,"referer",n),i.successStatuses=[200],i.xmlResponse=!0,e.next=5,this.request(i);case 5:return a=e.sent,s=a.data.RefererList.Referer||null,s&&(Array.isArray(s)||(s=[s])),e.abrupt("return",{allowEmpty:"true"===a.data.AllowEmptyReferer,referers:s,res:a.res});case 9:case"end":return e.stop()}},e,this)}),a.deleteBucketReferer=o.default.mark(function e(t,r,n){return o.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:return e.next=2,this.putBucketReferer(t,r,!0,null,n);case 2:return e.abrupt("return",e.sent);case 3:case"end":return e.stop()}},e,this)}),a._bucketRequestParams=function(e,t,r,n){return{method:e,bucket:t,subres:r,timeout:n&&n.timeout,ctx:n&&n.ctx}}},{"babel-runtime/regenerator":40}],3:[function(e,t,r){(function(r,n){"use strict";function i(e){return e&&e.__esModule?e:{default:e}}function o(e,t){return this instanceof o?(e&&e.inited?this.options=e:this.options=o.initOptions(e),this.options.urllib?this.urllib=this.options.urllib:(this.urllib=T,this.agent=this.options.agent||O),void(this.ctx=t)):new o(e,t)}function a(e,t){return e[t]||e[t.toLowerCase()]}function s(e){var t=w.parse(e);if(t.protocol||(t=w.parse("http://"+e)),"http:"!=t.protocol&&"https:"!=t.protocol)throw new Error("Endpoint protocol must be http or https.");return t}function u(e,t,r){var n=r?"https://":"http://",i=t?"-internal.aliyuncs.com":".aliyuncs.com";return w.parse(n+e+i)}var c=e("babel-runtime/regenerator"),l=i(c),p=e("babel-runtime/core-js/object/keys"),f=i(p),d=e("debug")("ali-oss"),h=e("./../shims/crypto.js"),m=e("path"),b=(e("querystring"),e("copy-to")),v=e("mime"),g=e("xml2js"),y=e("humanize-ms"),_=e("agentkeepalive"),x=e("merge-descriptors"),w=e("url"),E=e("is-type-of"),j=e("platform"),S=e("utility"),T=e("urllib"),k=e("../package.json"),A=e("dateformat"),O=new _;t.exports=o,o.initOptions=function(e){if(!e||!e.accessKeyId||!e.accessKeySecret)throw new Error("require accessKeyId, accessKeySecret");var t={region:"oss-cn-hangzhou",internal:!1,secure:!1,timeout:6e4,bucket:null,endpoint:null,cname:!1};for(var r in e)void 0!==e[r]&&(t[r]=e[r]);if(t.accessKeyId=t.accessKeyId.trim(),t.accessKeySecret=t.accessKeySecret.trim(),t.timeout=y(t.timeout),t.endpoint)t.endpoint=s(t.endpoint);else{if(!t.region)throw new Error("require options.endpoint or options.region");t.endpoint=u(t.region,t.internal,t.secure)}return t.inited=!0,t};var R=o.prototype;x(R,e("./object")),x(R,e("./bucket")),x(R,e("./multipart")),o.ImageClient=e("./image")(o),o.ClusterClient=e("./cluster")(o),o.STS=e("./sts"),o.Wrapper=e("./wrapper"),R.signature=function e(t){d("authorization stringToSign: %s",t);var e=h.createHmac("sha1",this.options.accessKeySecret);return e=e.update(new n(t,"utf8")).digest("base64")},R.authorization=function(e,t,r,n){var i=[e.toUpperCase(),n["Content-Md5"]||"",a(n,"Content-Type"),n["x-oss-date"]],o={};for(var s in n){var u=s.toLowerCase().trim();0===u.indexOf("x-oss-")&&(o[u]=o[u]||[],o[u].push(String(n[s]).trim()))}var c=[];(0,f.default)(o).sort().forEach(function(e){c.push(e+":"+o[e].join(","))}),i=i.concat(c);var l="";l+=t;var p=[];if(r)if(E.string(r))p.push(r);else if(E.array(r))p=p.concat(r);else for(var d in r){var h=r[d]?d+"="+r[d]:d;p.push(h)}p.length>0&&(l+="?"+p.join("&")),i.push(l);var m=i.join("\n"),b="OSS "+this.options.accessKeyId+":";return b+this.signature(m)},R.createRequest=function(e){var t=this._userAgent(),r={"x-oss-date":A(new Date,"UTC:ddd, dd mmm yyyy HH:MM:ss 'GMT'"),"x-oss-user-agent":t,"User-Agent":t};this.options.stsToken&&(r["x-oss-security-token"]=this.options.stsToken),b(e.headers).to(r),a(r,"Content-Type")||(e.mime===v.default_type&&(e.mime=""),e.mime&&e.mime.indexOf("/")>0?r["Content-Type"]=e.mime:r["Content-Type"]=v.lookup(e.mime||m.extname(e.object||""))),e.content&&(r["Content-Md5"]=h.createHash("md5").update(new n(e.content,"utf8")).digest("base64"),r["Content-Length"]||(r["Content-Length"]=e.content.length));var i=this._getResource(e);r.authorization=this.authorization(e.method,i,e.subres,r);var o=this._getReqUrl(e);d("request %s %s, with headers %j, !!stream: %s",e.method,o,r,!!e.stream);var s=e.timeout||this.options.timeout,u={agent:this.agent,method:e.method,content:e.content,stream:e.stream,headers:r,timeout:s,writeStream:e.writeStream,customResponse:e.customResponse,ctx:e.ctx||this.ctx};return{url:o,params:u}},R.request=l.default.mark(function e(t){var r,n,i;return l.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:return r=this.createRequest(t),e.next=3,this.urllib.request(r.url,r.params);case 3:if(n=e.sent,d("response %s %s, got %s, headers: %j",t.method,r.url,n.status,n.headers),!t.successStatuses||t.successStatuses.indexOf(n.status)!==-1){e.next=10;break}return e.delegateYield(this.requestError(n),"t0",7);case 7:throw i=e.t0,i.params=t,i;case 10:if(!t.xmlResponse){e.next=14;break}return e.next=13,this.parseXML(n.data);case 13:n.data=e.sent;case 14:return e.abrupt("return",n);case 15:case"end":return e.stop()}},e,this)}),R._getResource=function(e){var t="/";return e.bucket&&(t+=e.bucket+"/"),e.object&&(t+=e.object),t},R._isIP=function(e){var t=/^(\d{1,3}\.){3,3}\d{1,3}$/;return t.test(e)},R._escape=function(e){return S.encodeURIComponent(e).replace(/%2F/g,"/")},R._getReqUrl=function(e){var t={};b(this.options.endpoint).to(t);var r=this._isIP(t.hostname),n=this.options.cname;!e.bucket||n||r||(t.host=e.bucket+"."+t.host);var i="/";e.bucket&&r&&(i+=e.bucket+"/"),e.object&&(i+=this._escape(e.object)),t.pathname=i;var o={};if(e.query&&x(o,e.query),e.subres){var a={};E.string(e.subres)?a[e.subres]="":E.array(e.subres)?e.subres.forEach(function(e){a[e]=""}):a=e.subres,x(o,a)}return t.query=o,w.format(t).replace(/%20/g,"+")},R._userAgent=function(){var e=r&&r.browser?"js":"nodejs",t="aliyun-sdk-"+e+"/"+k.version,n=j.description;return t+" "+n},R.parseXML=function(e){return function(t){n.isBuffer(e)&&(e=e.toString()),g.parseString(e,{explicitRoot:!1,explicitArray:!1},t)}},R.requestError=l.default.mark(function e(t){var r,n,i;return l.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:if(t.data&&t.data.length){e.next=6;break}404===t.status?(r=new Error("Object not exists"),r.name="NoSuchKeyError",r.status=404,r.code="NoSuchKey"):412===t.status?(r=new Error("Pre condition failed"),r.name="PreconditionFailedError",r.status=412,r.code="PreconditionFailed"):(r=new Error("Unknow error, status: "+t.status),r.name="UnknowError",r.status=t.status),r.requestId=t.headers["x-oss-request-id"],r.host="",e.next=29;break;case 6:return n=String(t.data),d("request response error data: %s",n),e.prev=8,e.next=11,this.parseXML(n)||{};case 11:i=e.sent,e.next=21;break;case 14:return e.prev=14,e.t0=e.catch(8),d(n),e.t0.message+="\nraw xml: "+n,e.t0.status=t.status,e.t0.requestId=t.headers["x-oss-request-id"],e.abrupt("return",e.t0);case 21:n=i.Message||"unknow request error, status: "+t.status,i.Condition&&(n+=" (condition: "+i.Condition+")"),r=new Error(n),r.name=i.Code?i.Code+"Error":"UnknowError",r.status=t.status,r.code=i.Code,r.requestId=i.RequestId,r.hostId=i.HostId;case 29:return d("generate error %j",r),e.abrupt("return",r);case 31:case"end":return e.stop()}},e,this,[[8,14]])})}).call(this,e("_process"),e("buffer").Buffer)},{"../package.json":419,"./../shims/crypto.js":420,"./bucket":2,"./cluster":4,"./image":5,"./multipart":6,"./object":7,"./sts":8,"./wrapper":9,_process:345,agentkeepalive:11,"babel-runtime/core-js/object/keys":30,"babel-runtime/regenerator":40,buffer:45,"copy-to":54,dateformat:183,debug:184,"humanize-ms":196,"is-type-of":201,"merge-descriptors":335,mime:336,path:342,platform:343,querystring:349,url:377,urllib:379,utility:395,xml2js:400}],4:[function(e,t,r){(function(r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}var i=e("babel-runtime/regenerator"),o=n(i),a=e("co"),s=e("co-defer"),u=e("sdk-base"),c=e("util"),l=e("utility"),p=e("get-ready"),f=e("copy-to"),d=e("address").ip(),h="roundRobin",m="masterSlave";t.exports=function(e){function t(r){if(!(this instanceof t))return new t(r);if(!r||!Array.isArray(r.cluster))throw new Error("require options.cluster to be an array");u.call(this),this.clients=[],this.availables={};for(var n=0;n<r.cluster.length;n++){var i=r.cluster[n];f(r).pick("timeout","agent","urllib").to(i),this.clients.push(new e(i)),this.availables[n]=!0}this.schedule=r.schedule||h,this.index=0;var o=r.heartbeatInterval||1e4;this._checkAvailableLock=!1,this._timerId=s.setInterval(this._checkAvailable.bind(this,!0),o),this._ignoreStatusFile=r.ignoreStatusFile||!1,this._init()}c.inherits(t,u);var n=t.prototype;p.mixin(n);var i=["head","get","getStream","list"],b=["put","putStream","delete","deleteMulti","copy","putMeta"];return i.forEach(function(e){n[e]=o.default.mark(function t(){var r,n,i,a,s,u=arguments;return o.default.wrap(function(t){for(;;)switch(t.prev=t.next){case 0:return r=l.argumentsToArray(u),n=this.chooseAvailable(),t.prev=2,t.next=5,n[e].apply(n,r);case 5:return t.abrupt("return",t.sent);case 8:if(t.prev=8,t.t0=t.catch(2),!(t.t0.status&&t.t0.status>=200&&t.t0.status<500)){t.next=12;break}throw t.t0;case 12:i=t.t0;case 13:a=0;case 14:if(!(a<this.clients.length)){t.next=32;break}if(s=this.clients[a],s!==n){t.next=18;break}return t.abrupt("continue",29);case 18:return t.prev=18,t.next=21,s[e].apply(n,r);case 21:return t.abrupt("return",t.sent);case 24:if(t.prev=24,t.t1=t.catch(18),!(t.t1.status&&t.t1.status>=200&&t.t1.status<500)){t.next=28;break}throw t.t1;case 28:i=t.t1;case 29:a++,t.next=14;break;case 32:throw i.message+=" (all clients are down)",i;case 34:case"end":return t.stop()}},t,this,[[2,8],[18,24]])})}),b.forEach(function(e){n[e]=o.default.mark(function t(){var r,n,i=arguments;return o.default.wrap(function(t){for(;;)switch(t.prev=t.next){case 0:return r=l.argumentsToArray(i),t.next=3,this.clients.map(function(t){return t[e].apply(t,r)});case 3:return n=t.sent,t.abrupt("return",n[0]);case 5:case"end":return t.stop()}},t,this)})}),n.signatureUrl=function(){var e=l.argumentsToArray(arguments),t=this.chooseAvailable();return t.signatureUrl.apply(t,e)},n.getObjectUrl=function(){var e=l.argumentsToArray(arguments),t=this.chooseAvailable();return t.getObjectUrl.apply(t,e)},n._init=function(){var e=this;a(o.default.mark(function t(){return o.default.wrap(function(t){for(;;)switch(t.prev=t.next){case 0:return t.next=2,e._checkAvailable(e._ignoreStatusFile);case 2:e.ready(!0);case 3:case"end":return t.stop()}},t,this)})).catch(function(t){e.emit("error",t)})},n._checkAvailable=o.default.mark(function e(t){var n,i,a,s,u,c;return o.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:if(n="._ali-oss/check.status."+d+".txt",t){e.next=4;break}return e.next=4,this.put(n,new r("check available started at "+Date()));case 4:if(!this._checkAvailableLock){e.next=6;break}return e.abrupt("return");case 6:this._checkAvailableLock=!0,i=[],a=0;case 9:if(!(a<this.clients.length)){e.next=27;break}return s=this.clients[a],e.next=13,this._checkStatus(s,n);case 13:if(u=e.sent){e.next=18;break}return e.next=17,this._checkStatus(s,n);case 17:u=e.sent;case 18:if(u){e.next=23;break}return e.next=21,this._checkStatus(s,n);case 21:u=e.sent,u||i.push(s._objectUrl(n));case 23:this.availables[a]=u;case 24:a++,e.next=9;break;case 27:this._checkAvailableLock=!1,i.length>0&&(c=new Error(i.length+" data node down, please check status file: "+i.join(", ")),c.name="CheckAvailableError",this.emit("error",c));case 29:case"end":return e.stop()}},e,this)}),n._checkStatus=o.default.mark(function e(t,r){var n;return o.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:return n=!0,e.prev=1,e.next=4,t.head(r);case 4:e.next=9;break;case 6:e.prev=6,e.t0=e.catch(1),(!e.t0.status||e.t0.status>=500||e.t0.status<200)&&(n=!1);case 9:return e.abrupt("return",n);case 10:case"end":return e.stop()}},e,this,[[1,6]])}),n.chooseAvailable=function(){if(this.schedule===m){for(var e=0;e<this.clients.length;e++)if(this.availables[e])return this.clients[e];return this.clients[0]}for(var t=this.clients.length;t>0;){var e=this._nextRRIndex();if(this.availables[e])return this.clients[e];t--}return this.clients[0]},n._nextRRIndex=function(){var e=this.index++;return this.index>=this.clients.length&&(this.index=0),e},n.close=function(){clearInterval(this._timerId),this._timerId=null},t}}).call(this,e("buffer").Buffer)},{address:10,"babel-runtime/regenerator":40,buffer:45,co:51,"co-defer":48,"copy-to":54,"get-ready":194,"sdk-base":365,util:384,utility:395}],5:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}function i(e,t,r){r=r||{},t=this._objectName(t);var n="/"+this.options.bucket+"/"+t,i={name:t,method:e,host:this.options.imageHost,resource:"/"+t,timeout:r.timeout,authResource:n,ctx:r.ctx};return r.headers&&(i.headers=r.headers),i}var o=e("babel-runtime/regenerator"),a=n(o);t.exports=function(e){function t(r){if(!(this instanceof t))return new t(r);if(!r.bucket)throw new Error("require bucket for image service instance");if(!r.imageHost)throw new Error("require imageHost for image service instance");this.ossClient=new e(r),this.ossClient.options.imageHost=r.imageHost,this.ossClient._objectRequestParams=i}return t.prototype.get=a.default.mark(function e(t,r,n){return a.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:return e.next=2,this.ossClient.get(t,r,n);case 2:return e.abrupt("return",e.sent);case 3:case"end":return e.stop()}},e,this)}),t.prototype.getStream=a.default.mark(function e(t,r){return a.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:return e.next=2,this.ossClient.getStream(t,r);case 2:return e.abrupt("return",e.sent);case 3:case"end":return e.stop()}},e,this)}),t.prototype.getExif=a.default.mark(function e(t,r){var n,i;return a.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:return n=this.ossClient._objectRequestParams("GET",t+"@exif",r),n.successStatuses=[200],e.next=4,this.ossClient.request(n);case 4:return i=e.sent,e.next=7,this._parseResponse(i);case 7:return i=e.sent,e.abrupt("return",{res:i.res,data:i.data});case 9:case"end":return e.stop()}},e,this)}),t.prototype.getInfo=a.default.mark(function e(t,r){var n,i;return a.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:return n=this.ossClient._objectRequestParams("GET",t+"@infoexif",r),n.successStatuses=[200],e.next=4,this.ossClient.request(n);case 4:return i=e.sent,e.next=7,this._parseResponse(i);case 7:return i=e.sent,e.abrupt("return",{res:i.res,data:i.data});case 9:case"end":return e.stop()}},e,this)}),t.prototype.putStyle=a.default.mark(function e(t,r,n){var i,o;return a.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:return i=this.ossClient._objectRequestParams("PUT","/?style&styleName="+t,n),i.successStatuses=[200],i.content='<?xml version="1.0" encoding="UTF-8"?>\n<Style><Content>'+r+"</Content></Style>",e.next=5,this.ossClient.request(i);case 5:return o=e.sent,e.next=8,this._parseResponse(o);case 8:return o=e.sent,e.abrupt("return",{res:o.res,data:o.data});case 10:case"end":return e.stop()}},e,this)}),t.prototype.getStyle=a.default.mark(function e(t,r){var n,i;return a.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:return n=this.ossClient._objectRequestParams("GET","/?style&styleName="+t,r),n.successStatuses=[200],e.next=4,this.ossClient.request(n);case 4:return i=e.sent,e.next=7,this._parseResponse(i);case 7:return i=e.sent,e.abrupt("return",{res:i.res,data:i.data});case 9:case"end":return e.stop()}},e,this)}),t.prototype.listStyle=a.default.mark(function e(t){var r,n;return a.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:return r=this.ossClient._objectRequestParams("GET","/?style",t),r.successStatuses=[200],e.next=4,this.ossClient.request(r);case 4:return n=e.sent,e.next=7,this._parseResponse(n);case 7:return n=e.sent,e.abrupt("return",{res:n.res,data:n.data.Style});case 9:case"end":return e.stop()}},e,this)}),t.prototype.deleteStyle=a.default.mark(function e(t,r){var n,i;return a.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:return n=this.ossClient._objectRequestParams("DELETE","/?style&styleName="+t,r),n.successStatuses=[204],e.next=4,this.ossClient.request(n);case 4:return i=e.sent,e.abrupt("return",{res:i.res});case 6:case"end":return e.stop()}},e,this)}),t.prototype.signatureUrl=function(e){return this.ossClient.signatureUrl(e,this.ossClient.options.imageHost)},t.prototype._parseResponse=a.default.mark(function e(t){var r,n,i,o;return a.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:if(r=t.data.toString(),n=t.res.headers["content-type"],"application/json"!==n){e.next=8;break}i=JSON.parse(r),t.data={};for(o in i)t.data[o]=parseFloat(i[o].value,10)||i[o].value;e.next=12;break;case 8:if("application/xml"!==n){e.next=12;break}return e.next=11,this.ossClient.parseXML(r);case 11:t.data=e.sent;case 12:return e.abrupt("return",t);case 13:case"end":return e.stop()}},e,this)}),t}},{"babel-runtime/regenerator":40}],6:[function(e,t,r){(function(t){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}function i(e,t){return this instanceof i?(b.call(this,t),this.file=e,void(this.reader=null)):new i(e,t)}var o=e("babel-runtime/core-js/array/from"),a=n(o),s=e("babel-runtime/regenerator"),u=n(s),c=(e("debug")("ali-oss:multipart"),e("fs")),l=e("is-type-of"),p=(e("destroy"),e("end-or-error"),e("util")),f=e("path"),d=e("mime"),h=e("co-gather"),m=r;m.multipartUpload=u.default.mark(function e(t,r,n){var i,o,a,s,c,p,h,m,b;return u.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:if(n=n||{},!n.checkpoint||!n.checkpoint.uploadId){e.next=5;break}return e.next=4,this._resumeMultipart(n.checkpoint,n);case 4:return e.abrupt("return",e.sent);case 5:return i=102400,o=l.file(r)?r.name:r,n.mime=n.mime||d.lookup(f.extname(o)),n.headers=n.headers||{},this._convertMetaToHeaders(n.meta,n.headers),e.next=12,this._getFileSize(r);case 12:if(a=e.sent,!(a<i)){e.next=23;break}return s=this._createStream(r,0,a),n.contentLength=a,e.next=18,this.putStream(t,s,n);case 18:if(c=e.sent,!n||!n.progress){e.next=22;break}return e.next=22,n.progress(1);case 22:return e.abrupt("return",c);case 23:if(!(n.partSize&&n.partSize<i)){e.next=25;break}throw new Error("partSize must not be smaller than "+i);case 25:return e.next=27,this._initMultipartUpload(t,n);case 27:return p=e.sent,h=p.uploadId,m=this._getPartSize(a,n.partSize),b={file:r,name:t,fileSize:a,partSize:m,uploadId:h,doneParts:[]},e.next=33,this._resumeMultipart(b,n);case 33:return e.abrupt("return",e.sent);case 34:case"end":return e.stop()}},e,this)}),m._resumeMultipart=u.default.mark(function e(t,r){var n,i,o,s,c,l,p,f,d,m,b,v,g,y,_,x,w;return u.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:for(n=t.file,i=t.fileSize,o=t.partSize,s=t.uploadId,c=t.doneParts,l=t.name,p=this._divideParts(i,o),f=p.length,d=u.default.mark(function e(i,o){var a,d,h;return u.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:return a=p[o-1],d={stream:i._createStream(n,a.start,a.end),size:a.end-a.start},e.next=4,i._uploadPart(l,s,o,d);case 4:if(h=e.sent,c.push({number:o,etag:h.res.headers.etag}),t.doneParts=c,!r||!r.progress){e.next=10;break}return e.next=10,r.progress(c.length/f,t);case 10:case"end":return e.stop()}},e,this)}),m=(0,a.default)(new Array(f),function(e,t){return t+1}),b=c.map(function(e){return e.number}),v=m.filter(function(e){return b.indexOf(e)<0}),g=[],y=0;y<v.length;y++)g.push(d(this,v[y]));return _=5,x=r.parallel||_,e.next=18,h(g,x);case 18:w=e.sent,y=0;case 20:if(!(y<w.length)){e.next=26;break}if(!w[y].isError){e.next=23;break}throw new Error("Failed to upload some parts with error: "+w[y].error.toString());case 23:y++,e.next=20;break;case 26:return e.next=28,this._completeMultipartUpload(l,s,c,r);case 28:return e.abrupt("return",e.sent);case 29:case"end":return e.stop()}},e,this)}),m.listUploads=u.default.mark(function e(t,r){var n,i,o;return u.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:return r=r||{},r.subres="uploads",n=this._objectRequestParams("GET","",r),n.query=t,n.xmlResponse=!0,n.successStatuses=[200],e.next=8,this.request(n);case 8:return i=e.sent,o=i.data.Upload||[],Array.isArray(o)||(o=[o]),o=o.map(function(e){return{name:e.Key,uploadId:e.UploadId,initiated:e.Initiated}}),e.abrupt("return",{res:i.res,uploads:o,bucket:i.data.Bucket,nextKeyMarker:i.data.NextKeyMarker,nextUploadIdMarker:i.data.NextUploadIdMarker,isTruncated:"true"===i.data.IsTruncated});case 13:case"end":return e.stop()}},e,this)}),m.abortMultipartUpload=u.default.mark(function e(t,r,n){var i,o;return u.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:return n=n||{},n.subres={uploadId:r},i=this._objectRequestParams("DELETE",t,n),i.successStatuses=[204],e.next=6,this.request(i);case 6:return o=e.sent,e.abrupt("return",{res:o.res});case 8:case"end":return e.stop()}},e,this)}),m._initMultipartUpload=u.default.mark(function e(t,r){var n,i;return u.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:return r=r||{},r.headers=r.headers||{},this._convertMetaToHeaders(r.meta,r.headers),r.subres="uploads",n=this._objectRequestParams("POST",t,r),n.mime=r.mime,n.xmlResponse=!0,n.successStatuses=[200],e.next=10,this.request(n);case 10:return i=e.sent,e.abrupt("return",{res:i.res,bucket:i.data.Bucket,name:i.data.Key,uploadId:i.data.UploadId});case 12:case"end":return e.stop()}},e,this)}),m._uploadPart=u.default.mark(function e(t,r,n,i,o){var a,s;return u.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:return o=o||{},o.headers={"Content-Length":i.size},o.subres={partNumber:n,uploadId:r},a=this._objectRequestParams("PUT",t,o),a.mime=o.mime,a.stream=i.stream,a.successStatuses=[200],e.next=9,this.request(a);case 9:return s=e.sent,e.abrupt("return",{name:t,etag:s.res.headers.etag,res:s.res});case 11:case"end":return e.stop()}},e,this)}),m._completeMultipartUpload=u.default.mark(function e(t,r,n,i){var o,a,s,c,l,p;return u.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:for(n.sort(function(e,t){return e.number-t.number}),o='<?xml version="1.0" encoding="UTF-8"?>\n<CompleteMultipartUpload>\n',a=0;a<n.length;a++)s=n[a],o+="<Part>\n",o+="<PartNumber>"+s.number+"</PartNumber>\n",o+="<ETag>"+s.etag+"</ETag>\n",o+="</Part>\n";return o+="</CompleteMultipartUpload>",i=i||{},i.subres={uploadId:r},c=this._objectRequestParams("POST",t,i),c.mime="xml",c.content=o,i.headers&&i.headers["x-oss-callback"]||(c.xmlResponse=!0),c.successStatuses=[200],e.next=13,this.request(c);case 13:return l=e.sent,p={res:l.res,bucket:c.bucket,name:t,etag:l.res.headers.etag},i.headers&&i.headers["x-oss-callback"]&&(p.data=JSON.parse(l.data.toString())),e.abrupt("return",p);case 17:case"end":return e.stop()}},e,this)}),l.file=function(e){return"undefined"!=typeof File&&e instanceof File},m._getFileSize=u.default.mark(function e(t){var r;return u.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:if(!l.buffer(t)){e.next=4;break}return e.abrupt("return",t.length);case 4:if(!l.file(t)){e.next=6;break}return e.abrupt("return",t.size);case 6:if(!l.string(t)){e.next=11;break}return e.next=9,
+this._statFile(t);case 9:return r=e.sent,e.abrupt("return",r.size);case 11:throw new Error("_getFileSize requires Buffer/File/String.");case 12:case"end":return e.stop()}},e,this)});var b=e("stream").Readable;p.inherits(i,b),i.prototype._read=function(){if(!this.reader){var e=this;e.reader=new FileReader,e.reader.onload=function(r){e.push(new t(new Uint8Array(r.target.result))),e.push(null)},e.reader.readAsArrayBuffer(e.file)}},m._createStream=function(e,t,r){if(l.file(e))return new i(e.slice(t,r));if(l.string(e))return c.createReadStream(e,{start:t,end:r-1});throw new Error("_createStream requires File/String.")},m._getPartSize=function(e,t){var r=1e4,n=1048576;return t?Math.max(Math.ceil(e/r),t):n},m._divideParts=function(e,t){for(var r=Math.ceil(e/t),n=[],i=0;i<r;i++){var o=t*i,a=Math.min(o+t,e);n.push({start:o,end:a})}return n}}).call(this,e("buffer").Buffer)},{"babel-runtime/core-js/array/from":15,"babel-runtime/regenerator":40,buffer:45,"co-gather":49,debug:184,destroy:187,"end-or-error":191,fs:43,"is-type-of":201,mime:336,path:342,stream:369,util:384}],7:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}var i=e("babel-runtime/regenerator"),o=n(i),a=e("debug")("ali-oss:object"),s=e("utility"),u=(e("./../shims/crypto.js"),e("fs")),c=e("is-type-of"),l=(e("destroy"),e("end-or-error"),e("url")),p=e("copy-to"),f=(e("querystring"),e("path")),d=e("mime"),h=r;h.put=o.default.mark(function e(t,r,n){var i,a,s,l,p;return o.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:if(n=n||{},!c.buffer(r)){e.next=5;break}i=r,e.next=23;break;case 5:if(!c.string(r)){e.next=16;break}return n.mime=n.mime||d.lookup(f.extname(r)),a=u.createReadStream(r),e.next=10,this._getFileSize(r);case 10:return n.contentLength=e.sent,e.next=13,this.putStream(t,a,n);case 13:return e.abrupt("return",e.sent);case 16:if(!c.readableStream(r)){e.next=22;break}return e.next=19,this.putStream(t,r,n);case 19:return e.abrupt("return",e.sent);case 22:throw new TypeError("Must provide String/Buffer/ReadableStream for put.");case 23:return n.headers=n.headers||{},this._convertMetaToHeaders(n.meta,n.headers),s=this._objectRequestParams("PUT",t,n),s.mime=n.mime,s.content=i,s.successStatuses=[200],e.next=31,this.request(s);case 31:return l=e.sent,p={name:t,url:this._objectUrl(t),res:l.res},n.headers&&n.headers["x-oss-callback"]&&(p.data=JSON.parse(l.data.toString())),e.abrupt("return",p);case 35:case"end":return e.stop()}},e,this)}),h.putStream=o.default.mark(function e(t,r,n){var i,a,s;return o.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:return n=n||{},n.headers=n.headers||{},n.contentLength?n.headers["Content-Length"]=n.contentLength:n.headers["Transfer-Encoding"]="chunked",this._convertMetaToHeaders(n.meta,n.headers),i=this._objectRequestParams("PUT",t,n),i.mime=n.mime,i.stream=r,i.successStatuses=[200],e.next=10,this.request(i);case 10:return a=e.sent,s={name:t,url:this._objectUrl(t),res:a.res},n.headers&&n.headers["x-oss-callback"]&&(s.data=JSON.parse(a.data.toString())),e.abrupt("return",s);case 14:case"end":return e.stop()}},e,this)}),h.head=o.default.mark(function e(t,r){var n,i,a,s;return o.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:return n=this._objectRequestParams("HEAD",t,r),n.successStatuses=[200,304],e.next=4,this.request(n);case 4:if(i=e.sent,a={meta:null,res:i.res,status:i.status},200===i.status)for(s in i.headers)0===s.indexOf("x-oss-meta-")&&(a.meta||(a.meta={}),a.meta[s.substring(11)]=i.headers[s]);return e.abrupt("return",a);case 8:case"end":return e.stop()}},e,this)}),h.get=o.default.mark(function e(t,r,n){var i,s,l,p;return o.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:return i=null,s=!1,c.writableStream(r)?i=r:c.string(r)?(i=u.createWriteStream(r),s=!0):n=r,n=n||{},e.prev=4,p=this._objectRequestParams("GET",t,n),p.writeStream=i,p.successStatuses=[200,206,304],e.next=10,this.request(p);case 10:l=e.sent,s&&i.destroy(),e.next=22;break;case 14:if(e.prev=14,e.t0=e.catch(4),!s){e.next=21;break}return i.destroy(),a("get error: %s, delete the exists file %s",e.t0,r),e.next=21,this._deleteFileSafe(r);case 21:throw e.t0;case 22:return e.abrupt("return",{res:l.res,content:l.data});case 23:case"end":return e.stop()}},e,this,[[4,14]])}),h.getStream=o.default.mark(function e(t,r){var n,i;return o.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:return r=r||{},n=this._objectRequestParams("GET",t,r),n.customResponse=!0,n.successStatuses=[200,206,304],e.next=6,this.request(n);case 6:return i=e.sent,e.abrupt("return",{stream:i.res,res:{status:i.status,headers:i.headers}});case 8:case"end":return e.stop()}},e,this)}),h.delete=o.default.mark(function e(t,r){var n,i;return o.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:return n=this._objectRequestParams("DELETE",t,r),n.successStatuses=[204],e.next=4,this.request(n);case 4:return i=e.sent,e.abrupt("return",{res:i.res});case 6:case"end":return e.stop()}},e,this)}),h.deleteMulti=o.default.mark(function e(t,r){var n,i,u,c,l,p;return o.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:for(r=r||{},n='<?xml version="1.0" encoding="UTF-8"?>\n<Delete>\n',n+=r.quiet?"  <Quiet>true</Quiet>\n":"  <Quiet>false</Quiet>\n",i=0;i<t.length;i++)n+="  <Object><Key>"+s.escape(this._objectName(t[i]))+"</Key></Object>\n";return n+="</Delete>",a("delete multi objects: %s",n),r.subres="delete",u=this._objectRequestParams("POST","",r),u.mime="xml",u.content=n,u.xmlResponse=!0,u.successStatuses=[200],e.next=14,this.request(u);case 14:return c=e.sent,l=c.data,p=l&&l.Deleted||null,p&&(Array.isArray(p)||(p=[p]),p=p.map(function(e){return e.Key})),e.abrupt("return",{res:c.res,deleted:p});case 19:case"end":return e.stop()}},e,this)}),h.copy=o.default.mark(function e(t,r,n){var i,a,s,u;return o.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:n=n||{},n.headers=n.headers||{};for(i in n.headers)n.headers["x-oss-copy-source-"+i.toLowerCase()]=n.headers[i];return n.meta&&(n.headers["x-oss-metadata-directive"]="REPLACE"),this._convertMetaToHeaders(n.meta,n.headers),"/"!==r[0]&&(r="/"+this.options.bucket+"/"+r),n.headers["x-oss-copy-source"]=r,a=this._objectRequestParams("PUT",t,n),a.xmlResponse=!0,a.successStatuses=[200,304],e.next=12,this.request(a);case 12:return s=e.sent,u=s.data,u&&(u={etag:u.ETag,lastModified:u.LastModified}),e.abrupt("return",{data:u,res:s.res});case 16:case"end":return e.stop()}},e,this)}),h.putMeta=o.default.mark(function e(t,r,n){return o.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:return e.next=2,this.copy(t,t,{meta:r||{},timeout:n&&n.timeout,ctx:n&&n.ctx});case 2:return e.abrupt("return",e.sent);case 3:case"end":return e.stop()}},e,this)}),h.list=o.default.mark(function e(t,r){var n,i,a,s,u;return o.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:return n=this._objectRequestParams("GET","",r),n.query=t,n.xmlResponse=!0,n.successStatuses=[200],e.next=6,this.request(n);case 6:return i=e.sent,a=i.data.Contents,s=this,a&&(Array.isArray(a)||(a=[a]),a=a.map(function(e){return{name:e.Key,url:s._objectUrl(e.Key),lastModified:e.LastModified,etag:e.ETag,type:e.Type,size:Number(e.Size),storageClass:e.StorageClass,owner:{id:e.Owner.ID,displayName:e.Owner.DisplayName}}})),u=i.data.CommonPrefixes||null,u&&(Array.isArray(u)||(u=[u]),u=u.map(function(e){return e.Prefix})),e.abrupt("return",{res:i.res,objects:a,prefixes:u,nextMarker:i.data.NextMarker||null,isTruncated:"true"===i.data.IsTruncated});case 13:case"end":return e.stop()}},e,this)}),h.putACL=o.default.mark(function e(t,r,n){var i,a;return o.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:return n=n||{},n.subres="acl",n.headers=n.headers||{},n.headers["x-oss-object-acl"]=r,t=this._objectName(t),i=this._objectRequestParams("PUT",t,n),i.successStatuses=[200],e.next=9,this.request(i);case 9:return a=e.sent,e.abrupt("return",{res:a.res});case 11:case"end":return e.stop()}},e,this)}),h.getACL=o.default.mark(function e(t,r){var n,i;return o.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:return r=r||{},r.subres="acl",t=this._objectName(t),n=this._objectRequestParams("GET",t,r),n.successStatuses=[200],n.xmlResponse=!0,e.next=8,this.request(n);case 8:return i=e.sent,e.abrupt("return",{acl:i.data.AccessControlList.Grant,owner:{id:i.data.Owner.ID,displayName:i.data.Owner.DisplayName},res:i.res});case 10:case"end":return e.stop()}},e,this)}),h.signatureUrl=function(e,t){e=this._objectName(e);var r={bucket:this.options.bucket,object:e};t=t||{};var n=s.timestamp()+(t.expires||1800),i=this._getResource(r),o={},a=[];for(var u in t.response){var c="response-"+u.toLowerCase();o[c]=t.response[u],a.push(c+"="+t.response[u])}this.options.stsToken&&(o["security-token"]=this.options.stsToken,a.push("security-token="+this.options.stsToken)),a.length>0&&(a.sort(),i+="?"+a.join("&"));var f=[t.method||"GET",t["content-md5"]||"",t["content-type"]||"",n,i].join("\n"),d=this.signature(f),h=l.parse(this._getReqUrl(r));return h.query={OSSAccessKeyId:this.options.accessKeyId,Expires:n,Signature:d},p(o).to(h.query),h.format()},h.getObjectUrl=function(e,t){return t?"/"!==t[t.length-1]&&(t+="/"):t=this.options.endpoint.format(),t+this._escape(this._objectName(e))},h._objectUrl=function(e){return this._getReqUrl({bucket:this.options.bucket,object:e})},h._objectRequestParams=function(e,t,r){if(!this.options.bucket)throw new Error("Please create a bucket first");r=r||{},t=this._objectName(t);var n={object:t,bucket:this.options.bucket,method:e,subres:r&&r.subres,timeout:r&&r.timeout,ctx:r&&r.ctx};return r.headers&&(n.headers=r.headers),n},h._objectName=function(e){return e.replace(/^\/+/,"")},h._statFile=function(e){return function(t){u.stat(e,t)}},h._convertMetaToHeaders=function(e,t){if(e)for(var r in e)t["x-oss-meta-"+r]=e[r]},h._deleteFileSafe=function(e){return function(t){u.exists(e,function(r){return r?void u.unlink(e,function(r){r&&a("unlink %j error: %s",e,r),t()}):t()})}}},{"./../shims/crypto.js":420,"babel-runtime/regenerator":40,"copy-to":54,debug:184,destroy:187,"end-or-error":191,fs:43,"is-type-of":201,mime:336,path:342,querystring:349,url:377,utility:395}],8:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}function i(e){if(!(this instanceof i))return new i(e);if(!e||!e.accessKeyId||!e.accessKeySecret)throw new Error("require accessKeyId, accessKeySecret");this.options={endpoint:e.endpoint||"https://sts.aliyuncs.com",format:"JSON",apiVersion:"2015-04-01",sigMethod:"HMAC-SHA1",sigVersion:"1.0",timeout:"60s"},h(e).to(this.options),this.options.urllib?this.urllib=this.options.urllib:(this.urllib=g,this.agent=this.options.agent||y)}var o=e("babel-runtime/core-js/object/keys"),a=n(o),s=e("babel-runtime/regenerator"),u=n(s),c=e("babel-runtime/core-js/json/stringify"),l=n(c),p=e("debug")("ali-oss:sts"),f=e("./../shims/crypto.js"),d=e("querystring"),h=e("copy-to"),m=e("agentkeepalive"),b=e("is-type-of"),v=e("humanize-ms"),g=e("urllib"),y=new m;t.exports=i;var _=i.prototype;_.assumeRole=u.default.mark(function e(t,r,n,i,o){var a,s,c,f,h,m,g,y;return u.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:if(a=this.options,s={Action:"AssumeRole",RoleArn:t,RoleSessionName:i||"app",DurationSeconds:n||3600,Format:a.format,Version:a.apiVersion,AccessKeyId:a.accessKeyId,SignatureMethod:a.sigMethod,SignatureVersion:a.sigVersion,SignatureNonce:Math.random(),Timestamp:(new Date).toISOString()},!r){e.next=15;break}if(!b.string(r)){e.next=13;break}e.prev=4,c=(0,l.default)(JSON.parse(r)),e.next=11;break;case 8:throw e.prev=8,e.t0=e.catch(4),new Error("Policy string is not a valid JSON: "+e.t0.message);case 11:e.next=14;break;case 13:c=(0,l.default)(r);case 14:s.Policy=c;case 15:return f=this._getSignature("POST",s,a.accessKeySecret),s.Signature=f,h=a.endpoint,m={agent:this.agent,timeout:v(o&&o.timeout||a.timeout),method:"POST",content:d.stringify(s),headers:{"Content-Type":"application/x-www-form-urlencoded"},ctx:o&&o.ctx},e.next=21,this.urllib.request(h,m);case 21:if(g=e.sent,p("response %s %s, got %s, headers: %j",m.method,h,g.status,g.headers),2===Math.floor(g.status/100)){e.next=29;break}return e.next=26,this._requestError(g);case 26:throw y=e.sent,y.params=m,y;case 29:return g.data=JSON.parse(g.data),e.abrupt("return",{res:g.res,credentials:g.data.Credentials});case 31:case"end":return e.stop()}},e,this,[[4,8]])}),_._requestError=u.default.mark(function e(t){var r,n;return u.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:return r=new Error,r.status=t.status,e.prev=2,e.next=5,JSON.parse(t.data)||{};case 5:n=e.sent,r.code=n.Code,r.message=n.Code+": "+n.Message,r.requestId=n.RequestId,e.next=14;break;case 11:e.prev=11,e.t0=e.catch(2),r.message="UnknownError: "+String(t.data);case 14:return e.abrupt("return",r);case 15:case"end":return e.stop()}},e,this,[[2,11]])}),_._getSignature=function(e,t,r){var n=this,i=(0,a.default)(t).sort().map(function(e){return n._escape(e)+"="+n._escape(t[e])}).join("&"),o=e.toUpperCase()+"&"+this._escape("/")+"&"+this._escape(i);p("string to sign: %s",o);var s=f.createHmac("sha1",r+"&");return s=s.update(o).digest("base64"),p("signature: %s",s),s},_._escape=function(e){return encodeURIComponent(e).replace(/\*/g,"%2A")}},{"./../shims/crypto.js":420,agentkeepalive:11,"babel-runtime/core-js/json/stringify":18,"babel-runtime/core-js/object/keys":30,"babel-runtime/regenerator":40,"copy-to":54,debug:184,"humanize-ms":196,"is-type-of":201,querystring:349,urllib:379}],9:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}function i(e){return e&&"function"==typeof e.next&&"function"==typeof e.throw}function o(e){if(!e)return!1;var t=e.constructor;return!!t&&("GeneratorFunction"===t.name||"GeneratorFunction"===t.displayName||(i(t.prototype)||i(e.prototype)))}function a(e,t){var r=new e(t),n=(0,p.default)(r),i=(0,p.default)((0,c.default)(r));n.concat(i).forEach(function(e){o(r[e])?this[e]=f.wrap(r[e]).bind(r):this[e]=r[e]},this)}function s(e){return this instanceof s?void a.call(this,d,e):new s(e)}var u=e("babel-runtime/core-js/object/get-prototype-of"),c=n(u),l=e("babel-runtime/core-js/object/keys"),p=n(l),f=e("co"),d=e("..");t.exports=s,s.STS=function e(t){return this instanceof e?void a.call(this,d.STS,t):new e(t)}},{"..":3,"babel-runtime/core-js/object/get-prototype-of":28,"babel-runtime/core-js/object/keys":30,co:51}],10:[function(e,t,r){"use strict";function n(e,t){"function"==typeof e&&(t=e,e=null);var r={ip:n.ip(e),ipv6:n.ipv6(e),mac:null};n.mac(e,function(e,n){n&&(r.mac=n),t(e,r)})}function i(e,t,r){for(var n=e.split("\n"),i=0;i<n.length;i++){var o=n[i].trimRight(),a=f.exec(o)||d.exec(o);if(a){var s=a[1];if(0===s.indexOf(t)){var u=null,c=null,l=h.exec(o);for(l&&(c=l[1]),i++;;){if(o=n[i],!o||f.exec(o)||d.exec(o)){i--;break}c||(l=h.exec(o),l&&(c=l[1])),u||(l=m.exec(o),l&&(u=l[1])),i++}if(u===r)return c}}}}var o=e("os"),a=e("fs"),s=e("child_process"),u="/etc/resolv.conf",c="eth",l="/sbin/ifconfig",p=o.platform();"darwin"===p?c="en":"win32"===p&&(l="ipconfig"),n.interface=function(e,t){var r=o.networkInterfaces(),n=!t;t=t||c,e=e||"IPv4";for(var i=-1;i<8;i++){var a=t+(i>=0?i:""),s=r[a];if(s)for(var u=0;u<s.length;u++){var l=s[u];if(l.family===e)return l}}if(n)for(var p in r)for(var s=r[p],i=0;i<s.length;i++){var l=s[i];if(l.family===e&&"127.0.0.1"!==l.address)return l}},n.ip=function(e){var t=n.interface("IPv4",e);return t&&t.address},n.ipv6=function(e){var t=n.interface("IPv6",e);return t&&t.address};var f=/^(\w+)\:\s+flags=/,d=/^(\w+)\s{2,}link encap:\w+/i,h=n.MAC_RE=/(?:ether|HWaddr)\s+((?:[a-z0-9]{2}\:){5}[a-z0-9]{2})/i,m=n.MAC_IP_RE=/inet\s(?:addr\:)?(\d+\.\d+\.\d+\.\d+)/;n.mac=function(e,t){"function"==typeof e&&(t=e,e=null),e=e||c;var r=n.interface("IPv4",e);return r?r.mac?t(null,r.mac):void s.exec(l,{timeout:5e3},function(n,o,a){if(n||!o)return t(n);var s=i(o||"",e,r.address);t(null,s)}):t()};var b=/^nameserver\s+(\d+\.\d+\.\d+\.\d+)$/i;n.dns=function(e,t){"function"==typeof e&&(t=e,e=null),e=e||u,a.readFile(e,"utf8",function(e,r){if(e)return t(e);var n=[];r=r||"";for(var i=r.split("\n"),o=0;o<i.length;o++){var a=i[o].trim(),s=b.exec(a);s&&n.push(s[1])}t(null,n)})},t.exports=n},{child_process:43,fs:43,os:339}],11:[function(e,t,r){"use strict";function n(){}t.exports=n,t.exports.HttpsAgent=n},{}],12:[function(e,t,r){"use strict";t.exports=e("./register")().Promise},{"./register":14}],13:[function(e,t,r){"use strict";var n="@@any-promise/REGISTRATION",i=null;t.exports=function(e,t){return function(r,o){r=r||null,o=o||{};var a=o.global!==!1;if(null===i&&a&&(i=e[n]||null),null!==i&&null!==r&&i.implementation!==r)throw new Error('any-promise already defined as "'+i.implementation+'".  You can only register an implementation before the first  call to require("any-promise") and an implementation cannot be changed');return null===i&&(i=null!==r&&"undefined"!=typeof o.Promise?{Promise:o.Promise,implementation:r}:t(r),a&&(e[n]=i)),i}}},{}],14:[function(e,t,r){"use strict";function n(){if("undefined"==typeof window.Promise)throw new Error("any-promise browser requires a polyfill or explicit registration e.g: require('any-promise/register/bluebird')");return{Promise:window.Promise,implementation:"window.Promise"}}t.exports=e("./loader")(window,n)},{"./loader":13}],15:[function(e,t,r){"use strict";t.exports={default:e("core-js/library/fn/array/from"),__esModule:!0}},{"core-js/library/fn/array/from":55}],16:[function(e,t,r){"use strict";t.exports={default:e("core-js/library/fn/clear-immediate"),__esModule:!0}},{"core-js/library/fn/clear-immediate":56}],17:[function(e,t,r){"use strict";t.exports={default:e("core-js/library/fn/get-iterator"),__esModule:!0}},{"core-js/library/fn/get-iterator":57}],18:[function(e,t,r){"use strict";t.exports={default:e("core-js/library/fn/json/stringify"),__esModule:!0}},{"core-js/library/fn/json/stringify":58}],19:[function(e,t,r){"use strict";t.exports={default:e("core-js/library/fn/number/is-finite"),__esModule:!0}},{"core-js/library/fn/number/is-finite":59}],20:[function(e,t,r){"use strict";t.exports={default:e("core-js/library/fn/number/is-nan"),__esModule:!0}},{"core-js/library/fn/number/is-nan":60}],21:[function(e,t,r){"use strict";t.exports={default:e("core-js/library/fn/number/max-safe-integer"),__esModule:!0}},{"core-js/library/fn/number/max-safe-integer":61}],22:[function(e,t,r){"use strict";t.exports={default:e("core-js/library/fn/object/create"),__esModule:!0}},{"core-js/library/fn/object/create":62}],23:[function(e,t,r){"use strict";t.exports={default:e("core-js/library/fn/object/define-properties"),__esModule:!0}},{"core-js/library/fn/object/define-properties":63}],24:[function(e,t,r){"use strict";t.exports={default:e("core-js/library/fn/object/define-property"),__esModule:!0}},{"core-js/library/fn/object/define-property":64}],25:[function(e,t,r){"use strict";t.exports={default:e("core-js/library/fn/object/get-own-property-descriptor"),__esModule:!0}},{"core-js/library/fn/object/get-own-property-descriptor":65}],26:[function(e,t,r){"use strict";t.exports={default:e("core-js/library/fn/object/get-own-property-names"),__esModule:!0}},{"core-js/library/fn/object/get-own-property-names":66}],27:[function(e,t,r){"use strict";t.exports={default:e("core-js/library/fn/object/get-own-property-symbols"),__esModule:!0}},{"core-js/library/fn/object/get-own-property-symbols":67}],28:[function(e,t,r){"use strict";t.exports={default:e("core-js/library/fn/object/get-prototype-of"),__esModule:!0}},{"core-js/library/fn/object/get-prototype-of":68}],29:[function(e,t,r){"use strict";t.exports={default:e("core-js/library/fn/object/is-extensible"),__esModule:!0}},{"core-js/library/fn/object/is-extensible":69}],30:[function(e,t,r){"use strict";t.exports={default:e("core-js/library/fn/object/keys"),__esModule:!0}},{"core-js/library/fn/object/keys":70}],31:[function(e,t,r){"use strict";t.exports={default:e("core-js/library/fn/object/prevent-extensions"),__esModule:!0}},{"core-js/library/fn/object/prevent-extensions":71}],32:[function(e,t,r){"use strict";t.exports={default:e("core-js/library/fn/object/set-prototype-of"),__esModule:!0}},{"core-js/library/fn/object/set-prototype-of":72}],33:[function(e,t,r){"use strict";t.exports={default:e("core-js/library/fn/promise"),__esModule:!0}},{"core-js/library/fn/promise":73}],34:[function(e,t,r){"use strict";t.exports={default:e("core-js/library/fn/set-immediate"),__esModule:!0}},{"core-js/library/fn/set-immediate":74}],35:[function(e,t,r){"use strict";t.exports={default:e("core-js/library/fn/string/from-code-point"),__esModule:!0}},{"core-js/library/fn/string/from-code-point":75}],36:[function(e,t,r){"use strict";t.exports={default:e("core-js/library/fn/symbol"),__esModule:!0}},{"core-js/library/fn/symbol":76}],37:[function(e,t,r){"use strict";t.exports={default:e("core-js/library/fn/symbol/iterator"),__esModule:!0}},{"core-js/library/fn/symbol/iterator":77}],38:[function(e,t,r){"use strict";t.exports={default:e("core-js/library/fn/symbol/species"),__esModule:!0}},{"core-js/library/fn/symbol/species":78}],39:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}function i(e){return e&&e.__esModule?e:{default:e}}var o=e("babel-runtime/helpers/typeof"),a=n(o);r.__esModule=!0;var s=e("../core-js/symbol/iterator"),u=i(s),c=e("../core-js/symbol"),l=i(c),p="function"==typeof l.default&&"symbol"===(0,a.default)(u.default)?function(e){return"undefined"==typeof e?"undefined":(0,a.default)(e)}:function(e){return e&&"function"==typeof l.default&&e.constructor===l.default&&e!==l.default.prototype?"symbol":"undefined"==typeof e?"undefined":(0,a.default)(e)};r.default="function"==typeof l.default&&"symbol"===p(u.default)?function(e){return"undefined"==typeof e?"undefined":p(e)}:function(e){return e&&"function"==typeof l.default&&e.constructor===l.default&&e!==l.default.prototype?"symbol":"undefined"==typeof e?"undefined":p(e)}},{"../core-js/symbol":36,"../core-js/symbol/iterator":37,"babel-runtime/helpers/typeof":39}],40:[function(e,t,r){"use strict";t.exports=e("regenerator-runtime")},{"regenerator-runtime":362}],41:[function(e,t,r){"use strict";function n(e){var t=e.length;if(t%4>0)throw new Error("Invalid string. Length must be a multiple of 4");return"="===e[t-2]?2:"="===e[t-1]?1:0}function i(e){return 3*e.length/4-n(e)}function o(e){var t,r,i,o,a,s,u=e.length;a=n(e),s=new p(3*u/4-a),i=a>0?u-4:u;var c=0;for(t=0,r=0;t<i;t+=4,r+=3)o=l[e.charCodeAt(t)]<<18|l[e.charCodeAt(t+1)]<<12|l[e.charCodeAt(t+2)]<<6|l[e.charCodeAt(t+3)],s[c++]=o>>16&255,s[c++]=o>>8&255,s[c++]=255&o;return 2===a?(o=l[e.charCodeAt(t)]<<2|l[e.charCodeAt(t+1)]>>4,s[c++]=255&o):1===a&&(o=l[e.charCodeAt(t)]<<10|l[e.charCodeAt(t+1)]<<4|l[e.charCodeAt(t+2)]>>2,s[c++]=o>>8&255,s[c++]=255&o),s}function a(e){return c[e>>18&63]+c[e>>12&63]+c[e>>6&63]+c[63&e]}function s(e,t,r){for(var n,i=[],o=t;o<r;o+=3)n=(e[o]<<16)+(e[o+1]<<8)+e[o+2],i.push(a(n));return i.join("")}function u(e){for(var t,r=e.length,n=r%3,i="",o=[],a=16383,u=0,l=r-n;u<l;u+=a)o.push(s(e,u,u+a>l?l:u+a));return 1===n?(t=e[r-1],i+=c[t>>2],i+=c[t<<4&63],i+="=="):2===n&&(t=(e[r-2]<<8)+e[r-1],i+=c[t>>10],i+=c[t>>4&63],i+=c[t<<2&63],i+="="),o.push(i),o.join("")}r.byteLength=i,r.toByteArray=o,r.fromByteArray=u;for(var c=[],l=[],p="undefined"!=typeof Uint8Array?Uint8Array:Array,f="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",d=0,h=f.length;d<h;++d)c[d]=f[d],l[f.charCodeAt(d)]=d;l["-".charCodeAt(0)]=62,l["_".charCodeAt(0)]=63},{}],42:[function(e,t,r){"use strict"},{}],43:[function(e,t,r){"use strict"},{}],44:[function(e,t,r){(function(t){"use strict";var n=e("buffer"),i=n.Buffer,o=n.SlowBuffer,a=n.kMaxLength||2147483647;r.alloc=function(e,t,r){if("function"==typeof i.alloc)return i.alloc(e,t,r);if("number"==typeof r)throw new TypeError("encoding must not be number");if("number"!=typeof e)throw new TypeError("size must be a number");if(e>a)throw new RangeError("size is too large");var n=r,o=t;void 0===o&&(n=void 0,o=0);var s=new i(e);if("string"==typeof o)for(var u=new i(o,n),c=u.length,l=-1;++l<e;)s[l]=u[l%c];else s.fill(o);return s},r.allocUnsafe=function(e){if("function"==typeof i.allocUnsafe)return i.allocUnsafe(e);if("number"!=typeof e)throw new TypeError("size must be a number");if(e>a)throw new RangeError("size is too large");return new i(e)},r.from=function(e,r,n){if("function"==typeof i.from&&(!t.Uint8Array||Uint8Array.from!==i.from))return i.from(e,r,n);if("number"==typeof e)throw new TypeError('"value" argument must not be a number');if("string"==typeof e)return new i(e,r);if("undefined"!=typeof ArrayBuffer&&e instanceof ArrayBuffer){var o=r;if(1===arguments.length)return new i(e);"undefined"==typeof o&&(o=0);var a=n;if("undefined"==typeof a&&(a=e.byteLength-o),o>=e.byteLength)throw new RangeError("'offset' is out of bounds");if(a>e.byteLength-o)throw new RangeError("'length' is out of bounds");return new i(e.slice(o,o+a))}if(i.isBuffer(e)){var s=new i(e.length);return e.copy(s,0,0,e.length),s}if(e){if(Array.isArray(e)||"undefined"!=typeof ArrayBuffer&&e.buffer instanceof ArrayBuffer||"length"in e)return new i(e);if("Buffer"===e.type&&Array.isArray(e.data))return new i(e.data)}throw new TypeError("First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.")},r.allocUnsafeSlow=function(e){if("function"==typeof i.allocUnsafeSlow)return i.allocUnsafeSlow(e);if("number"!=typeof e)throw new TypeError("size must be a number");if(e>=a)throw new RangeError("size is too large");return new o(e)}}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{buffer:45}],45:[function(e,t,r){(function(t){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}function i(){try{var e=new Uint8Array(1);return e.__proto__={__proto__:Uint8Array.prototype,foo:function(){return 42}},42===e.foo()&&"function"==typeof e.subarray&&0===e.subarray(1,1).byteLength}catch(e){return!1}}function o(){return s.TYPED_ARRAY_SUPPORT?2147483647:1073741823}function a(e,t){if(o()<t)throw new RangeError("Invalid typed array length");return s.TYPED_ARRAY_SUPPORT?(e=new Uint8Array(t),e.__proto__=s.prototype):(null===e&&(e=new s(t)),e.length=t),e}function s(e,t,r){if(!(s.TYPED_ARRAY_SUPPORT||this instanceof s))return new s(e,t,r);if("number"==typeof e){if("string"==typeof t)throw new Error("If encoding is specified then the first argument must be a string");return p(this,e)}return u(this,e,t,r)}function u(e,t,r,n){if("number"==typeof t)throw new TypeError('"value" argument must not be a number');return"undefined"!=typeof ArrayBuffer&&t instanceof ArrayBuffer?h(e,t,r,n):"string"==typeof t?f(e,t,r):m(e,t)}function c(e){if("number"!=typeof e)throw new TypeError('"size" argument must be a number');if(e<0)throw new RangeError('"size" argument must not be negative')}function l(e,t,r,n){return c(t),t<=0?a(e,t):void 0!==r?"string"==typeof n?a(e,t).fill(r,n):a(e,t).fill(r):a(e,t)}function p(e,t){if(c(t),e=a(e,t<0?0:0|b(t)),!s.TYPED_ARRAY_SUPPORT)for(var r=0;r<t;++r)e[r]=0;return e}function f(e,t,r){if("string"==typeof r&&""!==r||(r="utf8"),!s.isEncoding(r))throw new TypeError('"encoding" must be a valid string encoding');var n=0|g(t,r);e=a(e,n);var i=e.write(t,r);return i!==n&&(e=e.slice(0,i)),e}function d(e,t){var r=t.length<0?0:0|b(t.length);e=a(e,r);for(var n=0;n<r;n+=1)e[n]=255&t[n];return e}function h(e,t,r,n){if(t.byteLength,r<0||t.byteLength<r)throw new RangeError("'offset' is out of bounds");if(t.byteLength<r+(n||0))throw new RangeError("'length' is out of bounds");return t=void 0===r&&void 0===n?new Uint8Array(t):void 0===n?new Uint8Array(t,r):new Uint8Array(t,r,n),s.TYPED_ARRAY_SUPPORT?(e=t,e.__proto__=s.prototype):e=d(e,t),e}function m(e,t){if(s.isBuffer(t)){var r=0|b(t.length);return e=a(e,r),0===e.length?e:(t.copy(e,0,0,r),e)}if(t){if("undefined"!=typeof ArrayBuffer&&t.buffer instanceof ArrayBuffer||"length"in t)return"number"!=typeof t.length||J(t.length)?a(e,0):d(e,t);if("Buffer"===t.type&&ae(t.data))return d(e,t.data)}throw new TypeError("First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.")}function b(e){if(e>=o())throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x"+o().toString(16)+" bytes");return 0|e}function v(e){return+e!=e&&(e=0),s.alloc(+e)}function g(e,t){if(s.isBuffer(e))return e.length;if("undefined"!=typeof ArrayBuffer&&"function"==typeof ArrayBuffer.isView&&(ArrayBuffer.isView(e)||e instanceof ArrayBuffer))return e.byteLength;"string"!=typeof e&&(e=""+e);var r=e.length;if(0===r)return 0;for(var n=!1;;)switch(t){case"ascii":case"latin1":case"binary":return r;case"utf8":case"utf-8":case void 0:return X(e).length;case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return 2*r;case"hex":return r>>>1;case"base64":return W(e).length;default:if(n)return X(e).length;t=(""+t).toLowerCase(),n=!0}}function y(e,t,r){var n=!1;if((void 0===t||t<0)&&(t=0),t>this.length)return"";if((void 0===r||r>this.length)&&(r=this.length),r<=0)return"";if(r>>>=0,t>>>=0,r<=t)return"";for(e||(e="utf8");;)switch(e){case"hex":return P(this,t,r);case"utf8":case"utf-8":return R(this,t,r);case"ascii":return C(this,t,r);case"latin1":case"binary":return M(this,t,r);case"base64":return O(this,t,r);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return N(this,t,r);default:if(n)throw new TypeError("Unknown encoding: "+e);e=(e+"").toLowerCase(),n=!0}}function _(e,t,r){var n=e[t];e[t]=e[r],e[r]=n}function x(e,t,r,n,i){if(0===e.length)return-1;if("string"==typeof r?(n=r,r=0):r>2147483647?r=2147483647:r<-2147483648&&(r=-2147483648),r=+r,isNaN(r)&&(r=i?0:e.length-1),r<0&&(r=e.length+r),r>=e.length){if(i)return-1;r=e.length-1}else if(r<0){if(!i)return-1;r=0}if("string"==typeof t&&(t=s.from(t,n)),s.isBuffer(t))return 0===t.length?-1:w(e,t,r,n,i);if("number"==typeof t)return t&=255,s.TYPED_ARRAY_SUPPORT&&"function"==typeof Uint8Array.prototype.indexOf?i?Uint8Array.prototype.indexOf.call(e,t,r):Uint8Array.prototype.lastIndexOf.call(e,t,r):w(e,[t],r,n,i);throw new TypeError("val must be string, number or Buffer")}function w(e,t,r,n,i){function o(e,t){return 1===a?e[t]:e.readUInt16BE(t*a)}var a=1,s=e.length,u=t.length;if(void 0!==n&&(n=String(n).toLowerCase(),"ucs2"===n||"ucs-2"===n||"utf16le"===n||"utf-16le"===n)){if(e.length<2||t.length<2)return-1;a=2,s/=2,u/=2,r/=2}var c;if(i){var l=-1;for(c=r;c<s;c++)if(o(e,c)===o(t,l===-1?0:c-l)){if(l===-1&&(l=c),c-l+1===u)return l*a}else l!==-1&&(c-=c-l),l=-1}else for(r+u>s&&(r=s-u),c=r;c>=0;c--){for(var p=!0,f=0;f<u;f++)if(o(e,c+f)!==o(t,f)){p=!1;break}if(p)return c}return-1}function E(e,t,r,n){r=Number(r)||0;var i=e.length-r;n?(n=Number(n),n>i&&(n=i)):n=i;var o=t.length;if(o%2!==0)throw new TypeError("Invalid hex string");n>o/2&&(n=o/2);for(var a=0;a<n;++a){var s=parseInt(t.substr(2*a,2),16);if(isNaN(s))return a;e[r+a]=s}return a}function j(e,t,r,n){return $(X(t,e.length-r),e,r,n)}function S(e,t,r,n){return $(K(t),e,r,n)}function T(e,t,r,n){return S(e,t,r,n)}function k(e,t,r,n){return $(W(t),e,r,n)}function A(e,t,r,n){return $(V(t,e.length-r),e,r,n)}function O(e,t,r){return 0===t&&r===e.length?ie.fromByteArray(e):ie.fromByteArray(e.slice(t,r))}function R(e,t,r){r=Math.min(e.length,r);for(var n=[],i=t;i<r;){var o=e[i],a=null,s=o>239?4:o>223?3:o>191?2:1;if(i+s<=r){var u,c,l,p;switch(s){case 1:o<128&&(a=o);break;case 2:u=e[i+1],128===(192&u)&&(p=(31&o)<<6|63&u,p>127&&(a=p));break;case 3:u=e[i+1],c=e[i+2],128===(192&u)&&128===(192&c)&&(p=(15&o)<<12|(63&u)<<6|63&c,p>2047&&(p<55296||p>57343)&&(a=p));break;case 4:u=e[i+1],c=e[i+2],l=e[i+3],128===(192&u)&&128===(192&c)&&128===(192&l)&&(p=(15&o)<<18|(63&u)<<12|(63&c)<<6|63&l,p>65535&&p<1114112&&(a=p))}}null===a?(a=65533,s=1):a>65535&&(a-=65536,n.push(a>>>10&1023|55296),a=56320|1023&a),n.push(a),i+=s}return I(n)}function I(e){var t=e.length;if(t<=se)return String.fromCharCode.apply(String,e);for(var r="",n=0;n<t;)r+=String.fromCharCode.apply(String,e.slice(n,n+=se));return r}function C(e,t,r){var n="";r=Math.min(e.length,r);
+for(var i=t;i<r;++i)n+=String.fromCharCode(127&e[i]);return n}function M(e,t,r){var n="";r=Math.min(e.length,r);for(var i=t;i<r;++i)n+=String.fromCharCode(e[i]);return n}function P(e,t,r){var n=e.length;(!t||t<0)&&(t=0),(!r||r<0||r>n)&&(r=n);for(var i="",o=t;o<r;++o)i+=Y(e[o]);return i}function N(e,t,r){for(var n=e.slice(t,r),i="",o=0;o<n.length;o+=2)i+=String.fromCharCode(n[o]+256*n[o+1]);return i}function D(e,t,r){if(e%1!==0||e<0)throw new RangeError("offset is not uint");if(e+t>r)throw new RangeError("Trying to access beyond buffer length")}function L(e,t,r,n,i,o){if(!s.isBuffer(e))throw new TypeError('"buffer" argument must be a Buffer instance');if(t>i||t<o)throw new RangeError('"value" argument is out of bounds');if(r+n>e.length)throw new RangeError("Index out of range")}function q(e,t,r,n){t<0&&(t=65535+t+1);for(var i=0,o=Math.min(e.length-r,2);i<o;++i)e[r+i]=(t&255<<8*(n?i:1-i))>>>8*(n?i:1-i)}function U(e,t,r,n){t<0&&(t=4294967295+t+1);for(var i=0,o=Math.min(e.length-r,4);i<o;++i)e[r+i]=t>>>8*(n?i:3-i)&255}function B(e,t,r,n,i,o){if(r+n>e.length)throw new RangeError("Index out of range");if(r<0)throw new RangeError("Index out of range")}function F(e,t,r,n,i){return i||B(e,t,r,4,3.4028234663852886e38,-3.4028234663852886e38),oe.write(e,t,r,n,23,4),r+4}function z(e,t,r,n,i){return i||B(e,t,r,8,1.7976931348623157e308,-1.7976931348623157e308),oe.write(e,t,r,n,52,8),r+8}function G(e){if(e=H(e).replace(ue,""),e.length<2)return"";for(;e.length%4!==0;)e+="=";return e}function H(e){return e.trim?e.trim():e.replace(/^\s+|\s+$/g,"")}function Y(e){return e<16?"0"+e.toString(16):e.toString(16)}function X(e,t){t=t||1/0;for(var r,n=e.length,i=null,o=[],a=0;a<n;++a){if(r=e.charCodeAt(a),r>55295&&r<57344){if(!i){if(r>56319){(t-=3)>-1&&o.push(239,191,189);continue}if(a+1===n){(t-=3)>-1&&o.push(239,191,189);continue}i=r;continue}if(r<56320){(t-=3)>-1&&o.push(239,191,189),i=r;continue}r=(i-55296<<10|r-56320)+65536}else i&&(t-=3)>-1&&o.push(239,191,189);if(i=null,r<128){if((t-=1)<0)break;o.push(r)}else if(r<2048){if((t-=2)<0)break;o.push(r>>6|192,63&r|128)}else if(r<65536){if((t-=3)<0)break;o.push(r>>12|224,r>>6&63|128,63&r|128)}else{if(!(r<1114112))throw new Error("Invalid code point");if((t-=4)<0)break;o.push(r>>18|240,r>>12&63|128,r>>6&63|128,63&r|128)}}return o}function K(e){for(var t=[],r=0;r<e.length;++r)t.push(255&e.charCodeAt(r));return t}function V(e,t){for(var r,n,i,o=[],a=0;a<e.length&&!((t-=2)<0);++a)r=e.charCodeAt(a),n=r>>8,i=r%256,o.push(i),o.push(n);return o}function W(e){return ie.toByteArray(G(e))}function $(e,t,r,n){for(var i=0;i<n&&!(i+r>=t.length||i>=e.length);++i)t[i+r]=e[i];return i}function J(e){return e!==e}var Q=e("babel-runtime/core-js/object/define-property"),Z=n(Q),ee=e("babel-runtime/core-js/symbol/species"),te=n(ee),re=e("babel-runtime/core-js/symbol"),ne=n(re),ie=e("base64-js"),oe=e("ieee754"),ae=e("isarray");r.Buffer=s,r.SlowBuffer=v,r.INSPECT_MAX_BYTES=50,s.TYPED_ARRAY_SUPPORT=void 0!==t.TYPED_ARRAY_SUPPORT?t.TYPED_ARRAY_SUPPORT:i(),r.kMaxLength=o(),s.poolSize=8192,s._augment=function(e){return e.__proto__=s.prototype,e},s.from=function(e,t,r){return u(null,e,t,r)},s.TYPED_ARRAY_SUPPORT&&(s.prototype.__proto__=Uint8Array.prototype,s.__proto__=Uint8Array,"undefined"!=typeof ne.default&&te.default&&s[te.default]===s&&(0,Z.default)(s,te.default,{value:null,configurable:!0})),s.alloc=function(e,t,r){return l(null,e,t,r)},s.allocUnsafe=function(e){return p(null,e)},s.allocUnsafeSlow=function(e){return p(null,e)},s.isBuffer=function(e){return!(null==e||!e._isBuffer)},s.compare=function(e,t){if(!s.isBuffer(e)||!s.isBuffer(t))throw new TypeError("Arguments must be Buffers");if(e===t)return 0;for(var r=e.length,n=t.length,i=0,o=Math.min(r,n);i<o;++i)if(e[i]!==t[i]){r=e[i],n=t[i];break}return r<n?-1:n<r?1:0},s.isEncoding=function(e){switch(String(e).toLowerCase()){case"hex":case"utf8":case"utf-8":case"ascii":case"latin1":case"binary":case"base64":case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return!0;default:return!1}},s.concat=function(e,t){if(!ae(e))throw new TypeError('"list" argument must be an Array of Buffers');if(0===e.length)return s.alloc(0);var r;if(void 0===t)for(t=0,r=0;r<e.length;++r)t+=e[r].length;var n=s.allocUnsafe(t),i=0;for(r=0;r<e.length;++r){var o=e[r];if(!s.isBuffer(o))throw new TypeError('"list" argument must be an Array of Buffers');o.copy(n,i),i+=o.length}return n},s.byteLength=g,s.prototype._isBuffer=!0,s.prototype.swap16=function(){var e=this.length;if(e%2!==0)throw new RangeError("Buffer size must be a multiple of 16-bits");for(var t=0;t<e;t+=2)_(this,t,t+1);return this},s.prototype.swap32=function(){var e=this.length;if(e%4!==0)throw new RangeError("Buffer size must be a multiple of 32-bits");for(var t=0;t<e;t+=4)_(this,t,t+3),_(this,t+1,t+2);return this},s.prototype.swap64=function(){var e=this.length;if(e%8!==0)throw new RangeError("Buffer size must be a multiple of 64-bits");for(var t=0;t<e;t+=8)_(this,t,t+7),_(this,t+1,t+6),_(this,t+2,t+5),_(this,t+3,t+4);return this},s.prototype.toString=function(){var e=0|this.length;return 0===e?"":0===arguments.length?R(this,0,e):y.apply(this,arguments)},s.prototype.equals=function(e){if(!s.isBuffer(e))throw new TypeError("Argument must be a Buffer");return this===e||0===s.compare(this,e)},s.prototype.inspect=function(){var e="",t=r.INSPECT_MAX_BYTES;return this.length>0&&(e=this.toString("hex",0,t).match(/.{2}/g).join(" "),this.length>t&&(e+=" ... ")),"<Buffer "+e+">"},s.prototype.compare=function(e,t,r,n,i){if(!s.isBuffer(e))throw new TypeError("Argument must be a Buffer");if(void 0===t&&(t=0),void 0===r&&(r=e?e.length:0),void 0===n&&(n=0),void 0===i&&(i=this.length),t<0||r>e.length||n<0||i>this.length)throw new RangeError("out of range index");if(n>=i&&t>=r)return 0;if(n>=i)return-1;if(t>=r)return 1;if(t>>>=0,r>>>=0,n>>>=0,i>>>=0,this===e)return 0;for(var o=i-n,a=r-t,u=Math.min(o,a),c=this.slice(n,i),l=e.slice(t,r),p=0;p<u;++p)if(c[p]!==l[p]){o=c[p],a=l[p];break}return o<a?-1:a<o?1:0},s.prototype.includes=function(e,t,r){return this.indexOf(e,t,r)!==-1},s.prototype.indexOf=function(e,t,r){return x(this,e,t,r,!0)},s.prototype.lastIndexOf=function(e,t,r){return x(this,e,t,r,!1)},s.prototype.write=function(e,t,r,n){if(void 0===t)n="utf8",r=this.length,t=0;else if(void 0===r&&"string"==typeof t)n=t,r=this.length,t=0;else{if(!isFinite(t))throw new Error("Buffer.write(string, encoding, offset[, length]) is no longer supported");t|=0,isFinite(r)?(r|=0,void 0===n&&(n="utf8")):(n=r,r=void 0)}var i=this.length-t;if((void 0===r||r>i)&&(r=i),e.length>0&&(r<0||t<0)||t>this.length)throw new RangeError("Attempt to write outside buffer bounds");n||(n="utf8");for(var o=!1;;)switch(n){case"hex":return E(this,e,t,r);case"utf8":case"utf-8":return j(this,e,t,r);case"ascii":return S(this,e,t,r);case"latin1":case"binary":return T(this,e,t,r);case"base64":return k(this,e,t,r);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return A(this,e,t,r);default:if(o)throw new TypeError("Unknown encoding: "+n);n=(""+n).toLowerCase(),o=!0}},s.prototype.toJSON=function(){return{type:"Buffer",data:Array.prototype.slice.call(this._arr||this,0)}};var se=4096;s.prototype.slice=function(e,t){var r=this.length;e=~~e,t=void 0===t?r:~~t,e<0?(e+=r,e<0&&(e=0)):e>r&&(e=r),t<0?(t+=r,t<0&&(t=0)):t>r&&(t=r),t<e&&(t=e);var n;if(s.TYPED_ARRAY_SUPPORT)n=this.subarray(e,t),n.__proto__=s.prototype;else{var i=t-e;n=new s(i,void 0);for(var o=0;o<i;++o)n[o]=this[o+e]}return n},s.prototype.readUIntLE=function(e,t,r){e|=0,t|=0,r||D(e,t,this.length);for(var n=this[e],i=1,o=0;++o<t&&(i*=256);)n+=this[e+o]*i;return n},s.prototype.readUIntBE=function(e,t,r){e|=0,t|=0,r||D(e,t,this.length);for(var n=this[e+--t],i=1;t>0&&(i*=256);)n+=this[e+--t]*i;return n},s.prototype.readUInt8=function(e,t){return t||D(e,1,this.length),this[e]},s.prototype.readUInt16LE=function(e,t){return t||D(e,2,this.length),this[e]|this[e+1]<<8},s.prototype.readUInt16BE=function(e,t){return t||D(e,2,this.length),this[e]<<8|this[e+1]},s.prototype.readUInt32LE=function(e,t){return t||D(e,4,this.length),(this[e]|this[e+1]<<8|this[e+2]<<16)+16777216*this[e+3]},s.prototype.readUInt32BE=function(e,t){return t||D(e,4,this.length),16777216*this[e]+(this[e+1]<<16|this[e+2]<<8|this[e+3])},s.prototype.readIntLE=function(e,t,r){e|=0,t|=0,r||D(e,t,this.length);for(var n=this[e],i=1,o=0;++o<t&&(i*=256);)n+=this[e+o]*i;return i*=128,n>=i&&(n-=Math.pow(2,8*t)),n},s.prototype.readIntBE=function(e,t,r){e|=0,t|=0,r||D(e,t,this.length);for(var n=t,i=1,o=this[e+--n];n>0&&(i*=256);)o+=this[e+--n]*i;return i*=128,o>=i&&(o-=Math.pow(2,8*t)),o},s.prototype.readInt8=function(e,t){return t||D(e,1,this.length),128&this[e]?(255-this[e]+1)*-1:this[e]},s.prototype.readInt16LE=function(e,t){t||D(e,2,this.length);var r=this[e]|this[e+1]<<8;return 32768&r?4294901760|r:r},s.prototype.readInt16BE=function(e,t){t||D(e,2,this.length);var r=this[e+1]|this[e]<<8;return 32768&r?4294901760|r:r},s.prototype.readInt32LE=function(e,t){return t||D(e,4,this.length),this[e]|this[e+1]<<8|this[e+2]<<16|this[e+3]<<24},s.prototype.readInt32BE=function(e,t){return t||D(e,4,this.length),this[e]<<24|this[e+1]<<16|this[e+2]<<8|this[e+3]},s.prototype.readFloatLE=function(e,t){return t||D(e,4,this.length),oe.read(this,e,!0,23,4)},s.prototype.readFloatBE=function(e,t){return t||D(e,4,this.length),oe.read(this,e,!1,23,4)},s.prototype.readDoubleLE=function(e,t){return t||D(e,8,this.length),oe.read(this,e,!0,52,8)},s.prototype.readDoubleBE=function(e,t){return t||D(e,8,this.length),oe.read(this,e,!1,52,8)},s.prototype.writeUIntLE=function(e,t,r,n){if(e=+e,t|=0,r|=0,!n){var i=Math.pow(2,8*r)-1;L(this,e,t,r,i,0)}var o=1,a=0;for(this[t]=255&e;++a<r&&(o*=256);)this[t+a]=e/o&255;return t+r},s.prototype.writeUIntBE=function(e,t,r,n){if(e=+e,t|=0,r|=0,!n){var i=Math.pow(2,8*r)-1;L(this,e,t,r,i,0)}var o=r-1,a=1;for(this[t+o]=255&e;--o>=0&&(a*=256);)this[t+o]=e/a&255;return t+r},s.prototype.writeUInt8=function(e,t,r){return e=+e,t|=0,r||L(this,e,t,1,255,0),s.TYPED_ARRAY_SUPPORT||(e=Math.floor(e)),this[t]=255&e,t+1},s.prototype.writeUInt16LE=function(e,t,r){return e=+e,t|=0,r||L(this,e,t,2,65535,0),s.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8):q(this,e,t,!0),t+2},s.prototype.writeUInt16BE=function(e,t,r){return e=+e,t|=0,r||L(this,e,t,2,65535,0),s.TYPED_ARRAY_SUPPORT?(this[t]=e>>>8,this[t+1]=255&e):q(this,e,t,!1),t+2},s.prototype.writeUInt32LE=function(e,t,r){return e=+e,t|=0,r||L(this,e,t,4,4294967295,0),s.TYPED_ARRAY_SUPPORT?(this[t+3]=e>>>24,this[t+2]=e>>>16,this[t+1]=e>>>8,this[t]=255&e):U(this,e,t,!0),t+4},s.prototype.writeUInt32BE=function(e,t,r){return e=+e,t|=0,r||L(this,e,t,4,4294967295,0),s.TYPED_ARRAY_SUPPORT?(this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=255&e):U(this,e,t,!1),t+4},s.prototype.writeIntLE=function(e,t,r,n){if(e=+e,t|=0,!n){var i=Math.pow(2,8*r-1);L(this,e,t,r,i-1,-i)}var o=0,a=1,s=0;for(this[t]=255&e;++o<r&&(a*=256);)e<0&&0===s&&0!==this[t+o-1]&&(s=1),this[t+o]=(e/a>>0)-s&255;return t+r},s.prototype.writeIntBE=function(e,t,r,n){if(e=+e,t|=0,!n){var i=Math.pow(2,8*r-1);L(this,e,t,r,i-1,-i)}var o=r-1,a=1,s=0;for(this[t+o]=255&e;--o>=0&&(a*=256);)e<0&&0===s&&0!==this[t+o+1]&&(s=1),this[t+o]=(e/a>>0)-s&255;return t+r},s.prototype.writeInt8=function(e,t,r){return e=+e,t|=0,r||L(this,e,t,1,127,-128),s.TYPED_ARRAY_SUPPORT||(e=Math.floor(e)),e<0&&(e=255+e+1),this[t]=255&e,t+1},s.prototype.writeInt16LE=function(e,t,r){return e=+e,t|=0,r||L(this,e,t,2,32767,-32768),s.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8):q(this,e,t,!0),t+2},s.prototype.writeInt16BE=function(e,t,r){return e=+e,t|=0,r||L(this,e,t,2,32767,-32768),s.TYPED_ARRAY_SUPPORT?(this[t]=e>>>8,this[t+1]=255&e):q(this,e,t,!1),t+2},s.prototype.writeInt32LE=function(e,t,r){return e=+e,t|=0,r||L(this,e,t,4,2147483647,-2147483648),s.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8,this[t+2]=e>>>16,this[t+3]=e>>>24):U(this,e,t,!0),t+4},s.prototype.writeInt32BE=function(e,t,r){return e=+e,t|=0,r||L(this,e,t,4,2147483647,-2147483648),e<0&&(e=4294967295+e+1),s.TYPED_ARRAY_SUPPORT?(this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=255&e):U(this,e,t,!1),t+4},s.prototype.writeFloatLE=function(e,t,r){return F(this,e,t,!0,r)},s.prototype.writeFloatBE=function(e,t,r){return F(this,e,t,!1,r)},s.prototype.writeDoubleLE=function(e,t,r){return z(this,e,t,!0,r)},s.prototype.writeDoubleBE=function(e,t,r){return z(this,e,t,!1,r)},s.prototype.copy=function(e,t,r,n){if(r||(r=0),n||0===n||(n=this.length),t>=e.length&&(t=e.length),t||(t=0),n>0&&n<r&&(n=r),n===r)return 0;if(0===e.length||0===this.length)return 0;if(t<0)throw new RangeError("targetStart out of bounds");if(r<0||r>=this.length)throw new RangeError("sourceStart out of bounds");if(n<0)throw new RangeError("sourceEnd out of bounds");n>this.length&&(n=this.length),e.length-t<n-r&&(n=e.length-t+r);var i,o=n-r;if(this===e&&r<t&&t<n)for(i=o-1;i>=0;--i)e[i+t]=this[i+r];else if(o<1e3||!s.TYPED_ARRAY_SUPPORT)for(i=0;i<o;++i)e[i+t]=this[i+r];else Uint8Array.prototype.set.call(e,this.subarray(r,r+o),t);return o},s.prototype.fill=function(e,t,r,n){if("string"==typeof e){if("string"==typeof t?(n=t,t=0,r=this.length):"string"==typeof r&&(n=r,r=this.length),1===e.length){var i=e.charCodeAt(0);i<256&&(e=i)}if(void 0!==n&&"string"!=typeof n)throw new TypeError("encoding must be a string");if("string"==typeof n&&!s.isEncoding(n))throw new TypeError("Unknown encoding: "+n)}else"number"==typeof e&&(e&=255);if(t<0||this.length<t||this.length<r)throw new RangeError("Out of range index");if(r<=t)return this;t>>>=0,r=void 0===r?this.length:r>>>0,e||(e=0);var o;if("number"==typeof e)for(o=t;o<r;++o)this[o]=e;else{var a=s.isBuffer(e)?e:X(new s(e,n).toString()),u=a.length;for(o=0;o<r-t;++o)this[o+t]=a[o%u]}return this};var ue=/[^+\/0-9A-Za-z-_]/g}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{"babel-runtime/core-js/object/define-property":24,"babel-runtime/core-js/symbol":36,"babel-runtime/core-js/symbol/species":38,"base64-js":41,ieee754:197,isarray:46}],46:[function(e,t,r){"use strict";var n={}.toString;t.exports=Array.isArray||function(e){return"[object Array]"==n.call(e)}},{}],47:[function(e,t,r){"use strict";t.exports={100:"Continue",101:"Switching Protocols",102:"Processing",200:"OK",201:"Created",202:"Accepted",203:"Non-Authoritative Information",204:"No Content",205:"Reset Content",206:"Partial Content",207:"Multi-Status",208:"Already Reported",226:"IM Used",300:"Multiple Choices",301:"Moved Permanently",302:"Found",303:"See Other",304:"Not Modified",305:"Use Proxy",307:"Temporary Redirect",308:"Permanent Redirect",400:"Bad Request",401:"Unauthorized",402:"Payment Required",403:"Forbidden",404:"Not Found",405:"Method Not Allowed",406:"Not Acceptable",407:"Proxy Authentication Required",408:"Request Timeout",409:"Conflict",410:"Gone",411:"Length Required",412:"Precondition Failed",413:"Payload Too Large",414:"URI Too Long",415:"Unsupported Media Type",416:"Range Not Satisfiable",417:"Expectation Failed",418:"I'm a teapot",421:"Misdirected Request",422:"Unprocessable Entity",423:"Locked",424:"Failed Dependency",425:"Unordered Collection",426:"Upgrade Required",428:"Precondition Required",429:"Too Many Requests",431:"Request Header Fields Too Large",500:"Internal Server Error",501:"Not Implemented",502:"Bad Gateway",503:"Service Unavailable",504:"Gateway Timeout",505:"HTTP Version Not Supported",506:"Variant Also Negotiates",507:"Insufficient Storage",508:"Loop Detected",509:"Bandwidth Limit Exceeded",510:"Not Extended",511:"Network Authentication Required"}},{}],48:[function(e,t,r){(function(n){"use strict";function i(e){return e&&e.__esModule?e:{default:e}}function o(e,t,r){return function(){r=r||s,l.call(e,t).then(function(){r()},r)}}function a(e,t){return(0,c.default)(o(this,e,t))}function s(e){if(e)throw e}var u=e("babel-runtime/core-js/set-immediate"),c=i(u),l=e("co");r=t.exports=a,r.defer=r.immediate=r.setImmediate=a,r.nextTick=function(e,t){return n.nextTick(o(this,e,t))},r.timeout=r.setTimeout=function(e,t,r){return setTimeout(o(this,e,r),t)},r.interval=r.setInterval=function(e,t,r){return setInterval(o(this,e,r),t)}}).call(this,e("_process"))},{_process:345,"babel-runtime/core-js/set-immediate":34,co:51}],49:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}var i=e("babel-runtime/regenerator"),o=n(i),a=e("co-thread");t.exports=o.default.mark(function e(t,r){var n,i,s,u;return o.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:return u=function e(){var r;return o.default.wrap(function(n){for(;;)switch(n.prev=n.next){case 0:return r=s++,i[r]={isError:!1},n.prev=2,n.next=5,t[r];case 5:i[r].value=n.sent,n.next=12;break;case 8:n.prev=8,n.t0=n.catch(2),i[r].error=n.t0,i[r].isError=!0;case 12:if(!(s<t.length)){n.next=15;break}return n.next=15,e;case 15:case"end":return n.stop()}},n[0],this,[[2,8]])},n=[u].map(o.default.mark),r=Math.min(r||5,t.length),i=[],s=0,e.next=7,a(u,r);case 7:return e.abrupt("return",i);case 8:case"end":return e.stop()}},e,this)})},{"babel-runtime/regenerator":40,"co-thread":50}],50:[function(e,t,r){"use strict";function n(e,t){for(var r=[];t--;)r.push(e);return r}t.exports=n},{}],51:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}function i(e){var t=this,r=v.call(arguments,1);return new b.default(function(n,i){function a(t){var r;try{r=e.next(t)}catch(e){return i(e)}u(r)}function s(t){var r;try{r=e.throw(t)}catch(e){return i(e)}u(r)}function u(e){if(e.done)return n(e.value);var r=o.call(t,e.value);return r&&c(r)?r.then(a,s):s(new TypeError('You may only yield a function, promise, generator, array, or object, but the following object was passed: "'+String(e.value)+'"'))}return"function"==typeof e&&(e=e.apply(t,r)),e&&"function"==typeof e.next?void a():n(e)})}function o(e){return e?c(e)?e:p(e)||l(e)?i.call(this,e):"function"==typeof e?a.call(this,e):Array.isArray(e)?s.call(this,e):f(e)?u.call(this,e):e:e}function a(e){var t=this;return new b.default(function(r,n){e.call(t,function(e,t){return e?n(e):(arguments.length>2&&(t=v.call(arguments,1)),void r(t))})})}function s(e){return b.default.all(e.map(o,this))}function u(e){function t(e,t){r[t]=void 0,i.push(e.then(function(e){r[t]=e}))}for(var r=new e.constructor,n=(0,h.default)(e),i=[],a=0;a<n.length;a++){var s=n[a],u=o.call(this,e[s]);u&&c(u)?t(u,s):r[s]=e[s]}return b.default.all(i).then(function(){return r})}function c(e){return"function"==typeof e.then}function l(e){return"function"==typeof e.next&&"function"==typeof e.throw}function p(e){var t=e.constructor;return!!t&&("GeneratorFunction"===t.name||"GeneratorFunction"===t.displayName||l(t.prototype))}function f(e){return Object==e.constructor}var d=e("babel-runtime/core-js/object/keys"),h=n(d),m=e("babel-runtime/core-js/promise"),b=n(m),v=Array.prototype.slice;t.exports=i.default=i.co=i,i.wrap=function(e){function t(){return i.call(this,e.apply(this,arguments))}return t.__generatorFunction__=e,t}},{"babel-runtime/core-js/object/keys":30,"babel-runtime/core-js/promise":33}],52:[function(e,t,r){t.exports={O_RDONLY:0,O_WRONLY:1,O_RDWR:2,S_IFMT:61440,S_IFREG:32768,S_IFDIR:16384,S_IFCHR:8192,S_IFBLK:24576,S_IFIFO:4096,S_IFLNK:40960,S_IFSOCK:49152,O_CREAT:512,O_EXCL:2048,O_NOCTTY:131072,O_TRUNC:1024,O_APPEND:8,O_DIRECTORY:1048576,O_NOFOLLOW:256,O_SYNC:128,O_SYMLINK:2097152,O_NONBLOCK:4,S_IRWXU:448,S_IRUSR:256,S_IWUSR:128,S_IXUSR:64,S_IRWXG:56,S_IRGRP:32,S_IWGRP:16,S_IXGRP:8,S_IRWXO:7,S_IROTH:4,S_IWOTH:2,S_IXOTH:1,E2BIG:7,EACCES:13,EADDRINUSE:48,EADDRNOTAVAIL:49,EAFNOSUPPORT:47,EAGAIN:35,EALREADY:37,EBADF:9,EBADMSG:94,EBUSY:16,ECANCELED:89,ECHILD:10,ECONNABORTED:53,ECONNREFUSED:61,ECONNRESET:54,EDEADLK:11,EDESTADDRREQ:39,EDOM:33,EDQUOT:69,EEXIST:17,EFAULT:14,EFBIG:27,EHOSTUNREACH:65,EIDRM:90,EILSEQ:92,EINPROGRESS:36,EINTR:4,EINVAL:22,EIO:5,EISCONN:56,EISDIR:21,ELOOP:62,EMFILE:24,EMLINK:31,EMSGSIZE:40,EMULTIHOP:95,ENAMETOOLONG:63,ENETDOWN:50,ENETRESET:52,ENETUNREACH:51,ENFILE:23,ENOBUFS:55,ENODATA:96,ENODEV:19,ENOENT:2,ENOEXEC:8,ENOLCK:77,ENOLINK:97,ENOMEM:12,ENOMSG:91,ENOPROTOOPT:42,ENOSPC:28,ENOSR:98,ENOSTR:99,ENOSYS:78,ENOTCONN:57,ENOTDIR:20,ENOTEMPTY:66,ENOTSOCK:38,ENOTSUP:45,ENOTTY:25,ENXIO:6,EOPNOTSUPP:102,EOVERFLOW:84,EPERM:1,EPIPE:32,EPROTO:100,EPROTONOSUPPORT:43,EPROTOTYPE:41,ERANGE:34,EROFS:30,ESPIPE:29,ESRCH:3,ESTALE:70,ETIME:101,ETIMEDOUT:60,ETXTBSY:26,EWOULDBLOCK:35,EXDEV:18,SIGHUP:1,SIGINT:2,SIGQUIT:3,SIGILL:4,SIGTRAP:5,SIGABRT:6,SIGIOT:6,SIGBUS:10,SIGFPE:8,SIGKILL:9,SIGUSR1:30,SIGSEGV:11,SIGUSR2:31,SIGPIPE:13,SIGALRM:14,SIGTERM:15,SIGCHLD:20,SIGCONT:19,SIGSTOP:17,SIGTSTP:18,SIGTTIN:21,SIGTTOU:22,SIGURG:16,SIGXCPU:24,SIGXFSZ:25,SIGVTALRM:26,SIGPROF:27,SIGWINCH:28,SIGIO:23,SIGSYS:12,SSL_OP_ALL:2147486719,SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION:262144,SSL_OP_CIPHER_SERVER_PREFERENCE:4194304,SSL_OP_CISCO_ANYCONNECT:32768,SSL_OP_COOKIE_EXCHANGE:8192,SSL_OP_CRYPTOPRO_TLSEXT_BUG:2147483648,SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS:2048,SSL_OP_EPHEMERAL_RSA:0,SSL_OP_LEGACY_SERVER_CONNECT:4,SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER:32,SSL_OP_MICROSOFT_SESS_ID_BUG:1,SSL_OP_MSIE_SSLV2_RSA_PADDING:0,SSL_OP_NETSCAPE_CA_DN_BUG:536870912,SSL_OP_NETSCAPE_CHALLENGE_BUG:2,SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG:1073741824,SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG:8,SSL_OP_NO_COMPRESSION:131072,SSL_OP_NO_QUERY_MTU:4096,SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION:65536,SSL_OP_NO_SSLv2:16777216,SSL_OP_NO_SSLv3:33554432,SSL_OP_NO_TICKET:16384,SSL_OP_NO_TLSv1:67108864,SSL_OP_NO_TLSv1_1:268435456,SSL_OP_NO_TLSv1_2:134217728,SSL_OP_PKCS1_CHECK_1:0,SSL_OP_PKCS1_CHECK_2:0,SSL_OP_SINGLE_DH_USE:1048576,SSL_OP_SINGLE_ECDH_USE:524288,SSL_OP_SSLEAY_080_CLIENT_DH_BUG:128,SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG:0,SSL_OP_TLS_BLOCK_PADDING_BUG:512,SSL_OP_TLS_D5_BUG:256,SSL_OP_TLS_ROLLBACK_BUG:8388608,ENGINE_METHOD_DSA:2,ENGINE_METHOD_DH:4,ENGINE_METHOD_RAND:8,ENGINE_METHOD_ECDH:16,ENGINE_METHOD_ECDSA:32,ENGINE_METHOD_CIPHERS:64,ENGINE_METHOD_DIGESTS:128,ENGINE_METHOD_STORE:256,ENGINE_METHOD_PKEY_METHS:512,ENGINE_METHOD_PKEY_ASN1_METHS:1024,ENGINE_METHOD_ALL:65535,ENGINE_METHOD_NONE:0,DH_CHECK_P_NOT_SAFE_PRIME:2,DH_CHECK_P_NOT_PRIME:1,DH_UNABLE_TO_CHECK_GENERATOR:4,DH_NOT_SUITABLE_GENERATOR:8,NPN_ENABLED:1,RSA_PKCS1_PADDING:1,RSA_SSLV23_PADDING:2,RSA_NO_PADDING:3,RSA_PKCS1_OAEP_PADDING:4,RSA_X931_PADDING:5,RSA_PKCS1_PSS_PADDING:6,POINT_CONVERSION_COMPRESSED:2,POINT_CONVERSION_UNCOMPRESSED:4,POINT_CONVERSION_HYBRID:6,F_OK:0,R_OK:4,W_OK:2,X_OK:1,UV_UDP_REUSEADDR:4}},{}],53:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}function i(e){if(!e||"object"!==("undefined"==typeof e?"undefined":(0,h.default)(e)))throw new TypeError("argument obj is required");var t=e.parameters,r=e.type;if(!r||!_.test(r))throw new TypeError("invalid type");var n=r;if(t&&"object"===("undefined"==typeof t?"undefined":(0,h.default)(t)))for(var i,o=(0,f.default)(t).sort(),a=0;a<o.length;a++){if(i=o[a],!v.test(i))throw new TypeError("invalid parameter name");n+="; "+i+"="+s(t[i])}return n}function o(e){if(!e)throw new TypeError("argument string is required");if("object"===("undefined"==typeof e?"undefined":(0,h.default)(e))&&(e=a(e),"string"!=typeof e))throw new TypeError("content-type header is missing from object");if("string"!=typeof e)throw new TypeError("argument string is required to be a string");var t=e.indexOf(";"),r=t!==-1?e.substr(0,t).trim():e.trim();if(!_.test(r))throw new TypeError("invalid media type");var n,i,o,s=new u(r.toLowerCase());for(m.lastIndex=t;i=m.exec(e);){if(i.index!==t)throw new TypeError("invalid parameter format");t+=i[0].length,n=i[1].toLowerCase(),o=i[2],'"'===o[0]&&(o=o.substr(1,o.length-2).replace(g,"$1")),s.parameters[n]=o}if(t!==-1&&t!==e.length)throw new TypeError("invalid parameter format");return s}function a(e){return"function"==typeof e.getHeader?e.getHeader("content-type"):"object"===(0,h.default)(e.headers)?e.headers&&e.headers["content-type"]:void 0}function s(e){var t=String(e);if(v.test(t))return t;if(t.length>0&&!b.test(t))throw new TypeError("invalid parameter value");return'"'+t.replace(y,"\\$1")+'"'}function u(e){this.parameters=(0,l.default)(null),this.type=e}var c=e("babel-runtime/core-js/object/create"),l=n(c),p=e("babel-runtime/core-js/object/keys"),f=n(p),d=e("babel-runtime/helpers/typeof"),h=n(d),m=/; *([!#$%&'\*\+\-\.\^_`\|~0-9A-Za-z]+) *= *("(?:[\u000b\u0020\u0021\u0023-\u005b\u005d-\u007e\u0080-\u00ff]|\\[\u000b\u0020-\u00ff])*"|[!#$%&'\*\+\-\.\^_`\|~0-9A-Za-z]+) */g,b=/^[\u000b\u0020-\u007e\u0080-\u00ff]+$/,v=/^[!#$%&'\*\+\-\.\^_`\|~0-9A-Za-z]+$/,g=/\\([\u000b\u0020-\u00ff])/g,y=/([\\"])/g,_=/^[!#$%&'\*\+\-\.\^_`\|~0-9A-Za-z]+\/[!#$%&'\*\+\-\.\^_`\|~0-9A-Za-z]+$/;r.format=i,r.parse=o},{"babel-runtime/core-js/object/create":22,"babel-runtime/core-js/object/keys":30,"babel-runtime/helpers/typeof":39}],54:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}function i(e,t){return this instanceof i?(this.src=e,void(this._withAccess=t)):new i(e,t)}function o(e,t){return void 0===e[t]&&void 0===e.__lookupGetter__(t)&&void 0===e.__lookupSetter__(t)}var a=e("babel-runtime/core-js/object/keys"),s=n(a),u=Array.prototype.slice;t.exports=i,i.prototype.withAccess=function(e){return this._withAccess=e!==!1,this},i.prototype.pick=function(e){return Array.isArray(e)||(e=u.call(arguments)),e.length&&(this.keys=e),this},i.prototype.to=function(e){if(e=e||{},!this.src)return e;var t=this.keys||(0,s.default)(this.src);if(!this._withAccess){for(var r=0;r<t.length;r++)n=t[r],void 0===e[n]&&(e[n]=this.src[n]);return e}for(var r=0;r<t.length;r++){var n=t[r];if(o(e,n)){var i=this.src.__lookupGetter__(n),a=this.src.__lookupSetter__(n);i&&e.__defineGetter__(n,i),a&&e.__defineSetter__(n,a),i||a||(e[n]=this.src[n])}}return e},i.prototype.toCover=function(e){for(var t=this.keys||(0,s.default)(this.src),r=0;r<t.length;r++){var n=t[r];delete e[n];var i=this.src.__lookupGetter__(n),o=this.src.__lookupSetter__(n);i&&e.__defineGetter__(n,i),o&&e.__defineSetter__(n,o),i||o||(e[n]=this.src[n])}},i.prototype.override=i.prototype.toCover,i.prototype.and=function(e){var t={};return this.to(t),this.src=e,this.to(t),this.src=t,this}},{"babel-runtime/core-js/object/keys":30}],55:[function(e,t,r){"use strict";e("../../modules/es6.string.iterator"),e("../../modules/es6.array.from"),t.exports=e("../../modules/_core").Array.from},{"../../modules/_core":86,"../../modules/es6.array.from":152,"../../modules/es6.string.iterator":170}],56:[function(e,t,r){"use strict";e("../modules/web.immediate"),t.exports=e("../modules/_core").clearImmediate},{"../modules/_core":86,"../modules/web.immediate":175}],57:[function(e,t,r){"use strict";e("../modules/web.dom.iterable"),e("../modules/es6.string.iterator"),t.exports=e("../modules/core.get-iterator")},{"../modules/core.get-iterator":151,"../modules/es6.string.iterator":170,"../modules/web.dom.iterable":174}],58:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}var i=e("babel-runtime/core-js/json/stringify"),o=n(i),a=e("../../modules/_core"),s=a.JSON||(a.JSON={stringify:o.default});t.exports=function(e){return s.stringify.apply(s,arguments)}},{"../../modules/_core":86,"babel-runtime/core-js/json/stringify":18}],59:[function(e,t,r){"use strict";e("../../modules/es6.number.is-finite"),t.exports=e("../../modules/_core").Number.isFinite},{"../../modules/_core":86,"../../modules/es6.number.is-finite":154}],60:[function(e,t,r){"use strict";e("../../modules/es6.number.is-nan"),t.exports=e("../../modules/_core").Number.isNaN},{"../../modules/_core":86,"../../modules/es6.number.is-nan":155}],61:[function(e,t,r){"use strict";e("../../modules/es6.number.max-safe-integer"),t.exports=9007199254740991},{"../../modules/es6.number.max-safe-integer":156}],62:[function(e,t,r){"use strict";e("../../modules/es6.object.create");var n=e("../../modules/_core").Object;t.exports=function(e,t){return n.create(e,t)}},{"../../modules/_core":86,"../../modules/es6.object.create":157}],63:[function(e,t,r){"use strict";e("../../modules/es6.object.define-properties");var n=e("../../modules/_core").Object;t.exports=function(e,t){return n.defineProperties(e,t)}},{"../../modules/_core":86,"../../modules/es6.object.define-properties":158}],64:[function(e,t,r){"use strict";e("../../modules/es6.object.define-property");var n=e("../../modules/_core").Object;t.exports=function(e,t,r){return n.defineProperty(e,t,r)}},{"../../modules/_core":86,"../../modules/es6.object.define-property":159}],65:[function(e,t,r){"use strict";e("../../modules/es6.object.get-own-property-descriptor");var n=e("../../modules/_core").Object;t.exports=function(e,t){return n.getOwnPropertyDescriptor(e,t)}},{"../../modules/_core":86,"../../modules/es6.object.get-own-property-descriptor":160}],66:[function(e,t,r){"use strict";e("../../modules/es6.object.get-own-property-names");var n=e("../../modules/_core").Object;t.exports=function(e){return n.getOwnPropertyNames(e)}},{"../../modules/_core":86,"../../modules/es6.object.get-own-property-names":161}],67:[function(e,t,r){"use strict";e("../../modules/es6.symbol"),t.exports=e("../../modules/_core").Object.getOwnPropertySymbols},{"../../modules/_core":86,"../../modules/es6.symbol":171}],68:[function(e,t,r){"use strict";e("../../modules/es6.object.get-prototype-of"),t.exports=e("../../modules/_core").Object.getPrototypeOf},{"../../modules/_core":86,"../../modules/es6.object.get-prototype-of":162}],69:[function(e,t,r){"use strict";e("../../modules/es6.object.is-extensible"),t.exports=e("../../modules/_core").Object.isExtensible},{"../../modules/_core":86,"../../modules/es6.object.is-extensible":163}],70:[function(e,t,r){"use strict";e("../../modules/es6.object.keys"),t.exports=e("../../modules/_core").Object.keys},{"../../modules/_core":86,"../../modules/es6.object.keys":164}],71:[function(e,t,r){"use strict";e("../../modules/es6.object.prevent-extensions"),t.exports=e("../../modules/_core").Object.preventExtensions},{"../../modules/_core":86,"../../modules/es6.object.prevent-extensions":165}],72:[function(e,t,r){"use strict";e("../../modules/es6.object.set-prototype-of"),t.exports=e("../../modules/_core").Object.setPrototypeOf},{"../../modules/_core":86,"../../modules/es6.object.set-prototype-of":166}],73:[function(e,t,r){"use strict";e("../modules/es6.object.to-string"),e("../modules/es6.string.iterator"),e("../modules/web.dom.iterable"),e("../modules/es6.promise"),t.exports=e("../modules/_core").Promise},{"../modules/_core":86,"../modules/es6.object.to-string":167,"../modules/es6.promise":168,"../modules/es6.string.iterator":170,"../modules/web.dom.iterable":174}],74:[function(e,t,r){"use strict";e("../modules/web.immediate"),t.exports=e("../modules/_core").setImmediate},{"../modules/_core":86,"../modules/web.immediate":175}],75:[function(e,t,r){"use strict";e("../../modules/es6.string.from-code-point"),t.exports=e("../../modules/_core").String.fromCodePoint},{"../../modules/_core":86,"../../modules/es6.string.from-code-point":169}],76:[function(e,t,r){"use strict";e("../../modules/es6.symbol"),e("../../modules/es6.object.to-string"),e("../../modules/es7.symbol.async-iterator"),e("../../modules/es7.symbol.observable"),t.exports=e("../../modules/_core").Symbol},{"../../modules/_core":86,"../../modules/es6.object.to-string":167,"../../modules/es6.symbol":171,"../../modules/es7.symbol.async-iterator":172,"../../modules/es7.symbol.observable":173}],77:[function(e,t,r){"use strict";e("../../modules/es6.string.iterator"),e("../../modules/web.dom.iterable"),t.exports=e("../../modules/_wks-ext").f("iterator")},{"../../modules/_wks-ext":148,"../../modules/es6.string.iterator":170,"../../modules/web.dom.iterable":174}],78:[function(e,t,r){"use strict";t.exports=e("../../modules/_wks-ext").f("species")},{"../../modules/_wks-ext":148}],79:[function(e,t,r){"use strict";t.exports=function(e){if("function"!=typeof e)throw TypeError(e+" is not a function!");return e}},{}],80:[function(e,t,r){"use strict";t.exports=function(){}},{}],
+81:[function(e,t,r){"use strict";t.exports=function(e,t,r,n){if(!(e instanceof t)||void 0!==n&&n in e)throw TypeError(r+": incorrect invocation!");return e}},{}],82:[function(e,t,r){"use strict";var n=e("./_is-object");t.exports=function(e){if(!n(e))throw TypeError(e+" is not an object!");return e}},{"./_is-object":106}],83:[function(e,t,r){"use strict";var n=e("./_to-iobject"),i=e("./_to-length"),o=e("./_to-index");t.exports=function(e){return function(t,r,a){var s,u=n(t),c=i(u.length),l=o(a,c);if(e&&r!=r){for(;c>l;)if(s=u[l++],s!=s)return!0}else for(;c>l;l++)if((e||l in u)&&u[l]===r)return e||l||0;return!e&&-1}}},{"./_to-index":140,"./_to-iobject":142,"./_to-length":143}],84:[function(e,t,r){"use strict";var n=e("./_cof"),i=e("./_wks")("toStringTag"),o="Arguments"==n(function(){return arguments}()),a=function(e,t){try{return e[t]}catch(e){}};t.exports=function(e){var t,r,s;return void 0===e?"Undefined":null===e?"Null":"string"==typeof(r=a(t=Object(e),i))?r:o?n(t):"Object"==(s=n(t))&&"function"==typeof t.callee?"Arguments":s}},{"./_cof":85,"./_wks":149}],85:[function(e,t,r){"use strict";var n={}.toString;t.exports=function(e){return n.call(e).slice(8,-1)}},{}],86:[function(e,t,r){"use strict";var n=t.exports={version:"2.4.0"};"number"==typeof __e&&(__e=n)},{}],87:[function(e,t,r){"use strict";var n=e("./_object-dp"),i=e("./_property-desc");t.exports=function(e,t,r){t in e?n.f(e,t,i(0,r)):e[t]=r}},{"./_object-dp":118,"./_property-desc":129}],88:[function(e,t,r){"use strict";var n=e("./_a-function");t.exports=function(e,t,r){if(n(e),void 0===t)return e;switch(r){case 1:return function(r){return e.call(t,r)};case 2:return function(r,n){return e.call(t,r,n)};case 3:return function(r,n,i){return e.call(t,r,n,i)}}return function(){return e.apply(t,arguments)}}},{"./_a-function":79}],89:[function(e,t,r){"use strict";t.exports=function(e){if(void 0==e)throw TypeError("Can't call method on  "+e);return e}},{}],90:[function(e,t,r){"use strict";t.exports=!e("./_fails")(function(){return 7!=Object.defineProperty({},"a",{get:function(){return 7}}).a})},{"./_fails":95}],91:[function(e,t,r){"use strict";var n=e("./_is-object"),i=e("./_global").document,o=n(i)&&n(i.createElement);t.exports=function(e){return o?i.createElement(e):{}}},{"./_global":97,"./_is-object":106}],92:[function(e,t,r){"use strict";t.exports="constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf".split(",")},{}],93:[function(e,t,r){"use strict";var n=e("./_object-keys"),i=e("./_object-gops"),o=e("./_object-pie");t.exports=function(e){var t=n(e),r=i.f;if(r)for(var a,s=r(e),u=o.f,c=0;s.length>c;)u.call(e,a=s[c++])&&t.push(a);return t}},{"./_object-gops":123,"./_object-keys":126,"./_object-pie":127}],94:[function(e,t,r){"use strict";var n=e("./_global"),i=e("./_core"),o=e("./_ctx"),a=e("./_hide"),s="prototype",u=function e(t,r,u){var c,l,p,f=t&e.F,d=t&e.G,h=t&e.S,m=t&e.P,b=t&e.B,v=t&e.W,g=d?i:i[r]||(i[r]={}),y=g[s],_=d?n:h?n[r]:(n[r]||{})[s];d&&(u=r);for(c in u)l=!f&&_&&void 0!==_[c],l&&c in g||(p=l?_[c]:u[c],g[c]=d&&"function"!=typeof _[c]?u[c]:b&&l?o(p,n):v&&_[c]==p?function(e){var t=function(t,r,n){if(this instanceof e){switch(arguments.length){case 0:return new e;case 1:return new e(t);case 2:return new e(t,r)}return new e(t,r,n)}return e.apply(this,arguments)};return t[s]=e[s],t}(p):m&&"function"==typeof p?o(Function.call,p):p,m&&((g.virtual||(g.virtual={}))[c]=p,t&e.R&&y&&!y[c]&&a(y,c,p)))};u.F=1,u.G=2,u.S=4,u.P=8,u.B=16,u.W=32,u.U=64,u.R=128,t.exports=u},{"./_core":86,"./_ctx":88,"./_global":97,"./_hide":99}],95:[function(e,t,r){"use strict";t.exports=function(e){try{return!!e()}catch(e){return!0}}},{}],96:[function(e,t,r){"use strict";var n=e("./_ctx"),i=e("./_iter-call"),o=e("./_is-array-iter"),a=e("./_an-object"),s=e("./_to-length"),u=e("./core.get-iterator-method"),c={},l={},p=t.exports=function(e,t,r,p,f){var d,h,m,b,v=f?function(){return e}:u(e),g=n(r,p,t?2:1),y=0;if("function"!=typeof v)throw TypeError(e+" is not iterable!");if(o(v)){for(d=s(e.length);d>y;y++)if(b=t?g(a(h=e[y])[0],h[1]):g(e[y]),b===c||b===l)return b}else for(m=v.call(e);!(h=m.next()).done;)if(b=i(m,g,h.value,t),b===c||b===l)return b};p.BREAK=c,p.RETURN=l},{"./_an-object":82,"./_ctx":88,"./_is-array-iter":104,"./_iter-call":107,"./_to-length":143,"./core.get-iterator-method":150}],97:[function(e,t,r){"use strict";var n=t.exports="undefined"!=typeof window&&window.Math==Math?window:"undefined"!=typeof self&&self.Math==Math?self:Function("return this")();"number"==typeof __g&&(__g=n)},{}],98:[function(e,t,r){"use strict";var n={}.hasOwnProperty;t.exports=function(e,t){return n.call(e,t)}},{}],99:[function(e,t,r){"use strict";var n=e("./_object-dp"),i=e("./_property-desc");t.exports=e("./_descriptors")?function(e,t,r){return n.f(e,t,i(1,r))}:function(e,t,r){return e[t]=r,e}},{"./_descriptors":90,"./_object-dp":118,"./_property-desc":129}],100:[function(e,t,r){"use strict";t.exports=e("./_global").document&&document.documentElement},{"./_global":97}],101:[function(e,t,r){"use strict";t.exports=!e("./_descriptors")&&!e("./_fails")(function(){return 7!=Object.defineProperty(e("./_dom-create")("div"),"a",{get:function(){return 7}}).a})},{"./_descriptors":90,"./_dom-create":91,"./_fails":95}],102:[function(e,t,r){"use strict";t.exports=function(e,t,r){var n=void 0===r;switch(t.length){case 0:return n?e():e.call(r);case 1:return n?e(t[0]):e.call(r,t[0]);case 2:return n?e(t[0],t[1]):e.call(r,t[0],t[1]);case 3:return n?e(t[0],t[1],t[2]):e.call(r,t[0],t[1],t[2]);case 4:return n?e(t[0],t[1],t[2],t[3]):e.call(r,t[0],t[1],t[2],t[3])}return e.apply(r,t)}},{}],103:[function(e,t,r){"use strict";var n=e("./_cof");t.exports=Object("z").propertyIsEnumerable(0)?Object:function(e){return"String"==n(e)?e.split(""):Object(e)}},{"./_cof":85}],104:[function(e,t,r){"use strict";var n=e("./_iterators"),i=e("./_wks")("iterator"),o=Array.prototype;t.exports=function(e){return void 0!==e&&(n.Array===e||o[i]===e)}},{"./_iterators":112,"./_wks":149}],105:[function(e,t,r){"use strict";var n=e("./_cof");t.exports=Array.isArray||function(e){return"Array"==n(e)}},{"./_cof":85}],106:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}var i=e("babel-runtime/helpers/typeof"),o=n(i);t.exports=function(e){return"object"===("undefined"==typeof e?"undefined":(0,o.default)(e))?null!==e:"function"==typeof e}},{"babel-runtime/helpers/typeof":39}],107:[function(e,t,r){"use strict";var n=e("./_an-object");t.exports=function(e,t,r,i){try{return i?t(n(r)[0],r[1]):t(r)}catch(t){var o=e.return;throw void 0!==o&&n(o.call(e)),t}}},{"./_an-object":82}],108:[function(e,t,r){"use strict";var n=e("./_object-create"),i=e("./_property-desc"),o=e("./_set-to-string-tag"),a={};e("./_hide")(a,e("./_wks")("iterator"),function(){return this}),t.exports=function(e,t,r){e.prototype=n(a,{next:i(1,r)}),o(e,t+" Iterator")}},{"./_hide":99,"./_object-create":117,"./_property-desc":129,"./_set-to-string-tag":134,"./_wks":149}],109:[function(e,t,r){"use strict";var n=e("./_library"),i=e("./_export"),o=e("./_redefine"),a=e("./_hide"),s=e("./_has"),u=e("./_iterators"),c=e("./_iter-create"),l=e("./_set-to-string-tag"),p=e("./_object-gpo"),f=e("./_wks")("iterator"),d=!([].keys&&"next"in[].keys()),h="@@iterator",m="keys",b="values",v=function(){return this};t.exports=function(e,t,r,g,y,_,x){c(r,t,g);var w,E,j,S=function(e){if(!d&&e in O)return O[e];switch(e){case m:return function(){return new r(this,e)};case b:return function(){return new r(this,e)}}return function(){return new r(this,e)}},T=t+" Iterator",k=y==b,A=!1,O=e.prototype,R=O[f]||O[h]||y&&O[y],I=R||S(y),C=y?k?S("entries"):I:void 0,M="Array"==t?O.entries||R:R;if(M&&(j=p(M.call(new e)),j!==Object.prototype&&(l(j,T,!0),n||s(j,f)||a(j,f,v))),k&&R&&R.name!==b&&(A=!0,I=function(){return R.call(this)}),n&&!x||!d&&!A&&O[f]||a(O,f,I),u[t]=I,u[T]=v,y)if(w={values:k?I:S(b),keys:_?I:S(m),entries:C},x)for(E in w)E in O||o(O,E,w[E]);else i(i.P+i.F*(d||A),t,w);return w}},{"./_export":94,"./_has":98,"./_hide":99,"./_iter-create":108,"./_iterators":112,"./_library":114,"./_object-gpo":124,"./_redefine":131,"./_set-to-string-tag":134,"./_wks":149}],110:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}var i=e("babel-runtime/core-js/array/from"),o=n(i),a=e("./_wks")("iterator"),s=!1;try{var u=[7][a]();u.return=function(){s=!0},(0,o.default)(u,function(){throw 2})}catch(e){}t.exports=function(e,t){if(!t&&!s)return!1;var r=!1;try{var n=[7],i=n[a]();i.next=function(){return{done:r=!0}},n[a]=function(){return i},e(n)}catch(e){}return r}},{"./_wks":149,"babel-runtime/core-js/array/from":15}],111:[function(e,t,r){"use strict";t.exports=function(e,t){return{value:t,done:!!e}}},{}],112:[function(e,t,r){"use strict";t.exports={}},{}],113:[function(e,t,r){"use strict";var n=e("./_object-keys"),i=e("./_to-iobject");t.exports=function(e,t){for(var r,o=i(e),a=n(o),s=a.length,u=0;s>u;)if(o[r=a[u++]]===t)return r}},{"./_object-keys":126,"./_to-iobject":142}],114:[function(e,t,r){"use strict";t.exports=!0},{}],115:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}var i=e("babel-runtime/helpers/typeof"),o=n(i),a=e("babel-runtime/core-js/object/prevent-extensions"),s=n(a),u=e("babel-runtime/core-js/object/is-extensible"),c=n(u),l=e("./_uid")("meta"),p=e("./_is-object"),f=e("./_has"),d=e("./_object-dp").f,h=0,m=c.default||function(){return!0},b=!e("./_fails")(function(){return m((0,s.default)({}))}),v=function(e){d(e,l,{value:{i:"O"+ ++h,w:{}}})},g=function(e,t){if(!p(e))return"symbol"==("undefined"==typeof e?"undefined":(0,o.default)(e))?e:("string"==typeof e?"S":"P")+e;if(!f(e,l)){if(!m(e))return"F";if(!t)return"E";v(e)}return e[l].i},y=function(e,t){if(!f(e,l)){if(!m(e))return!0;if(!t)return!1;v(e)}return e[l].w},_=function(e){return b&&x.NEED&&m(e)&&!f(e,l)&&v(e),e},x=t.exports={KEY:l,NEED:!1,fastKey:g,getWeak:y,onFreeze:_}},{"./_fails":95,"./_has":98,"./_is-object":106,"./_object-dp":118,"./_uid":146,"babel-runtime/core-js/object/is-extensible":29,"babel-runtime/core-js/object/prevent-extensions":31,"babel-runtime/helpers/typeof":39}],116:[function(e,t,r){"use strict";var n=e("./_global"),i=e("./_task").set,o=n.MutationObserver||n.WebKitMutationObserver,a=n.process,s=n.Promise,u="process"==e("./_cof")(a);t.exports=function(){var e,t,r,c=function(){var n,i;for(u&&(n=a.domain)&&n.exit();e;){i=e.fn,e=e.next;try{i()}catch(n){throw e?r():t=void 0,n}}t=void 0,n&&n.enter()};if(u)r=function(){a.nextTick(c)};else if(o){var l=!0,p=document.createTextNode("");new o(c).observe(p,{characterData:!0}),r=function(){p.data=l=!l}}else if(s&&s.resolve){var f=s.resolve();r=function(){f.then(c)}}else r=function(){i.call(n,c)};return function(n){var i={fn:n,next:void 0};t&&(t.next=i),e||(e=i,r()),t=i}}},{"./_cof":85,"./_global":97,"./_task":139}],117:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}var i=e("babel-runtime/core-js/object/create"),o=n(i),a=e("./_an-object"),s=e("./_object-dps"),u=e("./_enum-bug-keys"),c=e("./_shared-key")("IE_PROTO"),l=function(){},p="prototype",f=function(){var t,r=e("./_dom-create")("iframe"),n=u.length,i="<",o=">";for(r.style.display="none",e("./_html").appendChild(r),r.src="javascript:",t=r.contentWindow.document,t.open(),t.write(i+"script"+o+"document.F=Object"+i+"/script"+o),t.close(),f=t.F;n--;)delete f[p][u[n]];return f()};t.exports=o.default||function(e,t){var r;return null!==e?(l[p]=a(e),r=new l,l[p]=null,r[c]=e):r=f(),void 0===t?r:s(r,t)}},{"./_an-object":82,"./_dom-create":91,"./_enum-bug-keys":92,"./_html":100,"./_object-dps":119,"./_shared-key":135,"babel-runtime/core-js/object/create":22}],118:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}var i=e("babel-runtime/core-js/object/define-property"),o=n(i),a=e("./_an-object"),s=e("./_ie8-dom-define"),u=e("./_to-primitive"),c=o.default;r.f=e("./_descriptors")?o.default:function(e,t,r){if(a(e),t=u(t,!0),a(r),s)try{return c(e,t,r)}catch(e){}if("get"in r||"set"in r)throw TypeError("Accessors not supported!");return"value"in r&&(e[t]=r.value),e}},{"./_an-object":82,"./_descriptors":90,"./_ie8-dom-define":101,"./_to-primitive":145,"babel-runtime/core-js/object/define-property":24}],119:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}var i=e("babel-runtime/core-js/object/define-properties"),o=n(i),a=e("./_object-dp"),s=e("./_an-object"),u=e("./_object-keys");t.exports=e("./_descriptors")?o.default:function(e,t){s(e);for(var r,n=u(t),i=n.length,o=0;i>o;)a.f(e,r=n[o++],t[r]);return e}},{"./_an-object":82,"./_descriptors":90,"./_object-dp":118,"./_object-keys":126,"babel-runtime/core-js/object/define-properties":23}],120:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}var i=e("babel-runtime/core-js/object/get-own-property-descriptor"),o=n(i),a=e("./_object-pie"),s=e("./_property-desc"),u=e("./_to-iobject"),c=e("./_to-primitive"),l=e("./_has"),p=e("./_ie8-dom-define"),f=o.default;r.f=e("./_descriptors")?f:function(e,t){if(e=u(e),t=c(t,!0),p)try{return f(e,t)}catch(e){}if(l(e,t))return s(!a.f.call(e,t),e[t])}},{"./_descriptors":90,"./_has":98,"./_ie8-dom-define":101,"./_object-pie":127,"./_property-desc":129,"./_to-iobject":142,"./_to-primitive":145,"babel-runtime/core-js/object/get-own-property-descriptor":25}],121:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}var i=e("babel-runtime/core-js/object/get-own-property-names"),o=n(i),a=e("babel-runtime/helpers/typeof"),s=n(a),u=e("./_to-iobject"),c=e("./_object-gopn").f,l={}.toString,p="object"==("undefined"==typeof window?"undefined":(0,s.default)(window))&&window&&o.default?(0,o.default)(window):[],f=function(e){try{return c(e)}catch(e){return p.slice()}};t.exports.f=function(e){return p&&"[object Window]"==l.call(e)?f(e):c(u(e))}},{"./_object-gopn":122,"./_to-iobject":142,"babel-runtime/core-js/object/get-own-property-names":26,"babel-runtime/helpers/typeof":39}],122:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}var i=e("babel-runtime/core-js/object/get-own-property-names"),o=n(i),a=e("./_object-keys-internal"),s=e("./_enum-bug-keys").concat("length","prototype");r.f=o.default||function(e){return a(e,s)}},{"./_enum-bug-keys":92,"./_object-keys-internal":125,"babel-runtime/core-js/object/get-own-property-names":26}],123:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}var i=e("babel-runtime/core-js/object/get-own-property-symbols"),o=n(i);r.f=o.default},{"babel-runtime/core-js/object/get-own-property-symbols":27}],124:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}var i=e("babel-runtime/core-js/object/get-prototype-of"),o=n(i),a=e("./_has"),s=e("./_to-object"),u=e("./_shared-key")("IE_PROTO"),c=Object.prototype;t.exports=o.default||function(e){return e=s(e),a(e,u)?e[u]:"function"==typeof e.constructor&&e instanceof e.constructor?e.constructor.prototype:e instanceof Object?c:null}},{"./_has":98,"./_shared-key":135,"./_to-object":144,"babel-runtime/core-js/object/get-prototype-of":28}],125:[function(e,t,r){"use strict";var n=e("./_has"),i=e("./_to-iobject"),o=e("./_array-includes")(!1),a=e("./_shared-key")("IE_PROTO");t.exports=function(e,t){var r,s=i(e),u=0,c=[];for(r in s)r!=a&&n(s,r)&&c.push(r);for(;t.length>u;)n(s,r=t[u++])&&(~o(c,r)||c.push(r));return c}},{"./_array-includes":83,"./_has":98,"./_shared-key":135,"./_to-iobject":142}],126:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}var i=e("babel-runtime/core-js/object/keys"),o=n(i),a=e("./_object-keys-internal"),s=e("./_enum-bug-keys");t.exports=o.default||function(e){return a(e,s)}},{"./_enum-bug-keys":92,"./_object-keys-internal":125,"babel-runtime/core-js/object/keys":30}],127:[function(e,t,r){"use strict";r.f={}.propertyIsEnumerable},{}],128:[function(e,t,r){"use strict";var n=e("./_export"),i=e("./_core"),o=e("./_fails");t.exports=function(e,t){var r=(i.Object||{})[e]||Object[e],a={};a[e]=t(r),n(n.S+n.F*o(function(){r(1)}),"Object",a)}},{"./_core":86,"./_export":94,"./_fails":95}],129:[function(e,t,r){"use strict";t.exports=function(e,t){return{enumerable:!(1&e),configurable:!(2&e),writable:!(4&e),value:t}}},{}],130:[function(e,t,r){"use strict";var n=e("./_hide");t.exports=function(e,t,r){for(var i in t)r&&e[i]?e[i]=t[i]:n(e,i,t[i]);return e}},{"./_hide":99}],131:[function(e,t,r){"use strict";t.exports=e("./_hide")},{"./_hide":99}],132:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}var i=e("babel-runtime/core-js/object/set-prototype-of"),o=n(i),a=e("./_is-object"),s=e("./_an-object"),u=function(e,t){if(s(e),!a(t)&&null!==t)throw TypeError(t+": can't set as prototype!")};t.exports={set:o.default||("__proto__"in{}?function(t,r,n){try{n=e("./_ctx")(Function.call,e("./_object-gopd").f(Object.prototype,"__proto__").set,2),n(t,[]),r=!(t instanceof Array)}catch(e){r=!0}return function(e,t){return u(e,t),r?e.__proto__=t:n(e,t),e}}({},!1):void 0),check:u}},{"./_an-object":82,"./_ctx":88,"./_is-object":106,"./_object-gopd":120,"babel-runtime/core-js/object/set-prototype-of":32}],133:[function(e,t,r){"use strict";var n=e("./_global"),i=e("./_core"),o=e("./_object-dp"),a=e("./_descriptors"),s=e("./_wks")("species");t.exports=function(e){var t="function"==typeof i[e]?i[e]:n[e];a&&t&&!t[s]&&o.f(t,s,{configurable:!0,get:function(){return this}})}},{"./_core":86,"./_descriptors":90,"./_global":97,"./_object-dp":118,"./_wks":149}],134:[function(e,t,r){"use strict";var n=e("./_object-dp").f,i=e("./_has"),o=e("./_wks")("toStringTag");t.exports=function(e,t,r){e&&!i(e=r?e:e.prototype,o)&&n(e,o,{configurable:!0,value:t})}},{"./_has":98,"./_object-dp":118,"./_wks":149}],135:[function(e,t,r){"use strict";var n=e("./_shared")("keys"),i=e("./_uid");t.exports=function(e){return n[e]||(n[e]=i(e))}},{"./_shared":136,"./_uid":146}],136:[function(e,t,r){"use strict";var n=e("./_global"),i="__core-js_shared__",o=n[i]||(n[i]={});t.exports=function(e){return o[e]||(o[e]={})}},{"./_global":97}],137:[function(e,t,r){"use strict";var n=e("./_an-object"),i=e("./_a-function"),o=e("./_wks")("species");t.exports=function(e,t){var r,a=n(e).constructor;return void 0===a||void 0==(r=n(a)[o])?t:i(r)}},{"./_a-function":79,"./_an-object":82,"./_wks":149}],138:[function(e,t,r){"use strict";var n=e("./_to-integer"),i=e("./_defined");t.exports=function(e){return function(t,r){var o,a,s=String(i(t)),u=n(r),c=s.length;return u<0||u>=c?e?"":void 0:(o=s.charCodeAt(u),o<55296||o>56319||u+1===c||(a=s.charCodeAt(u+1))<56320||a>57343?e?s.charAt(u):o:e?s.slice(u,u+2):(o-55296<<10)+(a-56320)+65536)}}},{"./_defined":89,"./_to-integer":141}],139:[function(e,t,r){"use strict";var n,i,o,a=e("./_ctx"),s=e("./_invoke"),u=e("./_html"),c=e("./_dom-create"),l=e("./_global"),p=l.process,f=l.setImmediate,d=l.clearImmediate,h=l.MessageChannel,m=0,b={},v="onreadystatechange",g=function(){var e=+this;if(b.hasOwnProperty(e)){var t=b[e];delete b[e],t()}},y=function(e){g.call(e.data)};f&&d||(f=function(e){for(var t=[],r=1;arguments.length>r;)t.push(arguments[r++]);return b[++m]=function(){s("function"==typeof e?e:Function(e),t)},n(m),m},d=function(e){delete b[e]},"process"==e("./_cof")(p)?n=function(e){p.nextTick(a(g,e,1))}:h?(i=new h,o=i.port2,i.port1.onmessage=y,n=a(o.postMessage,o,1)):l.addEventListener&&"function"==typeof postMessage&&!l.importScripts?(n=function(e){l.postMessage(e+"","*")},l.addEventListener("message",y,!1)):n=v in c("script")?function(e){u.appendChild(c("script"))[v]=function(){u.removeChild(this),g.call(e)}}:function(e){setTimeout(a(g,e,1),0)}),t.exports={set:f,clear:d}},{"./_cof":85,"./_ctx":88,"./_dom-create":91,"./_global":97,"./_html":100,"./_invoke":102}],140:[function(e,t,r){"use strict";var n=e("./_to-integer"),i=Math.max,o=Math.min;t.exports=function(e,t){return e=n(e),e<0?i(e+t,0):o(e,t)}},{"./_to-integer":141}],141:[function(e,t,r){"use strict";var n=Math.ceil,i=Math.floor;t.exports=function(e){return isNaN(e=+e)?0:(e>0?i:n)(e)}},{}],142:[function(e,t,r){"use strict";var n=e("./_iobject"),i=e("./_defined");t.exports=function(e){return n(i(e))}},{"./_defined":89,"./_iobject":103}],143:[function(e,t,r){"use strict";var n=e("./_to-integer"),i=Math.min;t.exports=function(e){return e>0?i(n(e),9007199254740991):0}},{"./_to-integer":141}],144:[function(e,t,r){"use strict";var n=e("./_defined");t.exports=function(e){return Object(n(e))}},{"./_defined":89}],145:[function(e,t,r){"use strict";var n=e("./_is-object");t.exports=function(e,t){if(!n(e))return e;var r,i;if(t&&"function"==typeof(r=e.toString)&&!n(i=r.call(e)))return i;if("function"==typeof(r=e.valueOf)&&!n(i=r.call(e)))return i;if(!t&&"function"==typeof(r=e.toString)&&!n(i=r.call(e)))return i;throw TypeError("Can't convert object to primitive value")}},{"./_is-object":106}],146:[function(e,t,r){"use strict";var n=0,i=Math.random();t.exports=function(e){return"Symbol(".concat(void 0===e?"":e,")_",(++n+i).toString(36))}},{}],147:[function(e,t,r){"use strict";var n=e("./_global"),i=e("./_core"),o=e("./_library"),a=e("./_wks-ext"),s=e("./_object-dp").f;t.exports=function(e){var t=i.Symbol||(i.Symbol=o?{}:n.Symbol||{});"_"==e.charAt(0)||e in t||s(t,e,{value:a.f(e)})}},{"./_core":86,"./_global":97,"./_library":114,"./_object-dp":118,"./_wks-ext":148}],148:[function(e,t,r){"use strict";r.f=e("./_wks")},{"./_wks":149}],149:[function(e,t,r){"use strict";var n=e("./_shared")("wks"),i=e("./_uid"),o=e("./_global").Symbol,a="function"==typeof o,s=t.exports=function(e){return n[e]||(n[e]=a&&o[e]||(a?o:i)("Symbol."+e))};s.store=n},{"./_global":97,"./_shared":136,"./_uid":146}],150:[function(e,t,r){"use strict";var n=e("./_classof"),i=e("./_wks")("iterator"),o=e("./_iterators");t.exports=e("./_core").getIteratorMethod=function(e){if(void 0!=e)return e[i]||e["@@iterator"]||o[n(e)]}},{"./_classof":84,"./_core":86,"./_iterators":112,"./_wks":149}],151:[function(e,t,r){"use strict";var n=e("./_an-object"),i=e("./core.get-iterator-method");t.exports=e("./_core").getIterator=function(e){var t=i(e);if("function"!=typeof t)throw TypeError(e+" is not iterable!");return n(t.call(e))}},{"./_an-object":82,"./_core":86,"./core.get-iterator-method":150}],152:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}var i=e("babel-runtime/core-js/array/from"),o=n(i),a=e("./_ctx"),s=e("./_export"),u=e("./_to-object"),c=e("./_iter-call"),l=e("./_is-array-iter"),p=e("./_to-length"),f=e("./_create-property"),d=e("./core.get-iterator-method");s(s.S+s.F*!e("./_iter-detect")(function(e){(0,o.default)(e)}),"Array",{from:function(e){var t,r,n,i,o=u(e),s="function"==typeof this?this:Array,h=arguments.length,m=h>1?arguments[1]:void 0,b=void 0!==m,v=0,g=d(o);if(b&&(m=a(m,h>2?arguments[2]:void 0,2)),void 0==g||s==Array&&l(g))for(t=p(o.length),r=new s(t);t>v;v++)f(r,v,b?m(o[v],v):o[v]);else for(i=g.call(o),r=new s;!(n=i.next()).done;v++)f(r,v,b?c(i,m,[n.value,v],!0):n.value);return r.length=v,r}})},{"./_create-property":87,"./_ctx":88,"./_export":94,"./_is-array-iter":104,"./_iter-call":107,"./_iter-detect":110,"./_to-length":143,"./_to-object":144,"./core.get-iterator-method":150,"babel-runtime/core-js/array/from":15}],153:[function(e,t,r){"use strict";var n=e("./_add-to-unscopables"),i=e("./_iter-step"),o=e("./_iterators"),a=e("./_to-iobject");t.exports=e("./_iter-define")(Array,"Array",function(e,t){this._t=a(e),this._i=0,this._k=t},function(){var e=this._t,t=this._k,r=this._i++;return!e||r>=e.length?(this._t=void 0,i(1)):"keys"==t?i(0,r):"values"==t?i(0,e[r]):i(0,[r,e[r]])},"values"),o.Arguments=o.Array,n("keys"),n("values"),n("entries")},{"./_add-to-unscopables":80,"./_iter-define":109,"./_iter-step":111,"./_iterators":112,"./_to-iobject":142}],154:[function(e,t,r){"use strict";var n=e("./_export"),i=e("./_global").isFinite;n(n.S,"Number",{isFinite:function(e){return"number"==typeof e&&i(e)}})},{"./_export":94,"./_global":97}],155:[function(e,t,r){"use strict";var n=e("./_export");n(n.S,"Number",{isNaN:function(e){return e!=e}})},{"./_export":94}],156:[function(e,t,r){"use strict";var n=e("./_export");n(n.S,"Number",{MAX_SAFE_INTEGER:9007199254740991})},{"./_export":94}],157:[function(e,t,r){"use strict";var n=e("./_export");n(n.S,"Object",{create:e("./_object-create")})},{"./_export":94,"./_object-create":117}],158:[function(e,t,r){"use strict";var n=e("./_export");n(n.S+n.F*!e("./_descriptors"),"Object",{defineProperties:e("./_object-dps")})},{"./_descriptors":90,"./_export":94,"./_object-dps":119}],159:[function(e,t,r){"use strict";var n=e("./_export");n(n.S+n.F*!e("./_descriptors"),"Object",{defineProperty:e("./_object-dp").f})},{"./_descriptors":90,"./_export":94,"./_object-dp":118}],160:[function(e,t,r){"use strict";var n=e("./_to-iobject"),i=e("./_object-gopd").f;e("./_object-sap")("getOwnPropertyDescriptor",function(){return function(e,t){return i(n(e),t)}})},{"./_object-gopd":120,"./_object-sap":128,"./_to-iobject":142}],161:[function(e,t,r){"use strict";e("./_object-sap")("getOwnPropertyNames",function(){return e("./_object-gopn-ext").f})},{"./_object-gopn-ext":121,"./_object-sap":128}],162:[function(e,t,r){"use strict";var n=e("./_to-object"),i=e("./_object-gpo");e("./_object-sap")("getPrototypeOf",function(){return function(e){return i(n(e))}})},{"./_object-gpo":124,"./_object-sap":128,"./_to-object":144}],163:[function(e,t,r){"use strict";var n=e("./_is-object");e("./_object-sap")("isExtensible",function(e){return function(t){return!!n(t)&&(!e||e(t))}})},{"./_is-object":106,"./_object-sap":128}],164:[function(e,t,r){"use strict";var n=e("./_to-object"),i=e("./_object-keys");e("./_object-sap")("keys",function(){return function(e){return i(n(e))}})},{"./_object-keys":126,"./_object-sap":128,"./_to-object":144}],165:[function(e,t,r){"use strict";var n=e("./_is-object"),i=e("./_meta").onFreeze;e("./_object-sap")("preventExtensions",function(e){return function(t){return e&&n(t)?e(i(t)):t}})},{"./_is-object":106,"./_meta":115,"./_object-sap":128}],166:[function(e,t,r){"use strict";var n=e("./_export");n(n.S,"Object",{setPrototypeOf:e("./_set-proto").set})},{"./_export":94,"./_set-proto":132}],167:[function(e,t,r){"use strict"},{}],168:[function(e,t,r){"use strict";var n,i,o,a=e("./_library"),s=e("./_global"),u=e("./_ctx"),c=e("./_classof"),l=e("./_export"),p=e("./_is-object"),f=e("./_a-function"),d=e("./_an-instance"),h=e("./_for-of"),m=e("./_species-constructor"),b=e("./_task").set,v=e("./_microtask")(),g="Promise",y=s.TypeError,_=s.process,x=s[g],_=s.process,w="process"==c(_),E=function(){},j=!!function(){try{var t=x.resolve(1),r=(t.constructor={})[e("./_wks")("species")]=function(e){e(E,E)};return(w||"function"==typeof PromiseRejectionEvent)&&t.then(E)instanceof r}catch(e){}}(),S=function(e,t){return e===t||e===x&&t===o},T=function(e){var t;return!(!p(e)||"function"!=typeof(t=e.then))&&t},k=function(e){return S(x,e)?new A(e):new i(e)},A=i=function(e){var t,r;this.promise=new e(function(e,n){if(void 0!==t||void 0!==r)throw y("Bad Promise constructor");t=e,r=n}),this.resolve=f(t),this.reject=f(r)},O=function(e){try{e()}catch(e){return{error:e}}},R=function(e,t){if(!e._n){e._n=!0;var r=e._c;v(function(){for(var n=e._v,i=1==e._s,o=0,a=function(t){var r,o,a=i?t.ok:t.fail,s=t.resolve,u=t.reject,c=t.domain;try{a?(i||(2==e._h&&M(e),e._h=1),a===!0?r=n:(c&&c.enter(),r=a(n),c&&c.exit()),r===t.promise?u(y("Promise-chain cycle")):(o=T(r))?o.call(r,s,u):s(r)):u(n)}catch(e){u(e)}};r.length>o;)a(r[o++]);e._c=[],e._n=!1,t&&!e._h&&I(e)})}},I=function(e){b.call(s,function(){var t,r,n,i=e._v;if(C(e)&&(t=O(function(){w?_.emit("unhandledRejection",i,e):(r=s.onunhandledrejection)?r({promise:e,reason:i}):(n=s.console)&&n.error&&n.error("Unhandled promise rejection",i)}),e._h=w||C(e)?2:1),e._a=void 0,t)throw t.error})},C=function e(t){if(1==t._h)return!1;for(var r,n=t._a||t._c,i=0;n.length>i;)if(r=n[i++],r.fail||!e(r.promise))return!1;return!0},M=function(e){b.call(s,function(){var t;w?_.emit("rejectionHandled",e):(t=s.onrejectionhandled)&&t({promise:e,reason:e._v})})},P=function(e){var t=this;t._d||(t._d=!0,t=t._w||t,t._v=e,t._s=2,t._a||(t._a=t._c.slice()),R(t,!0))},N=function e(t){var r,n=this;if(!n._d){n._d=!0,n=n._w||n;try{if(n===t)throw y("Promise can't be resolved itself");(r=T(t))?v(function(){var i={_w:n,_d:!1};try{r.call(t,u(e,i,1),u(P,i,1))}catch(e){P.call(i,e)}}):(n._v=t,n._s=1,R(n,!1))}catch(e){P.call({_w:n,_d:!1},e)}}};j||(x=function(e){d(this,x,g,"_h"),f(e),n.call(this);try{e(u(N,this,1),u(P,this,1))}catch(e){P.call(this,e)}},n=function(e){this._c=[],this._a=void 0,this._s=0,this._d=!1,this._v=void 0,this._h=0,this._n=!1},n.prototype=e("./_redefine-all")(x.prototype,{then:function(e,t){var r=k(m(this,x));return r.ok="function"!=typeof e||e,r.fail="function"==typeof t&&t,r.domain=w?_.domain:void 0,this._c.push(r),this._a&&this._a.push(r),this._s&&R(this,!1),r.promise},catch:function(e){return this.then(void 0,e)}}),A=function(){var e=new n;this.promise=e,this.resolve=u(N,e,1),this.reject=u(P,e,1)}),l(l.G+l.W+l.F*!j,{Promise:x}),e("./_set-to-string-tag")(x,g),e("./_set-species")(g),o=e("./_core")[g],l(l.S+l.F*!j,g,{reject:function(e){var t=k(this),r=t.reject;return r(e),t.promise}}),l(l.S+l.F*(a||!j),g,{resolve:function(e){if(e instanceof x&&S(e.constructor,this))return e;var t=k(this),r=t.resolve;return r(e),t.promise}}),l(l.S+l.F*!(j&&e("./_iter-detect")(function(e){x.all(e).catch(E)})),g,{all:function(e){var t=this,r=k(t),n=r.resolve,i=r.reject,o=O(function(){var r=[],o=0,a=1;h(e,!1,function(e){var s=o++,u=!1;r.push(void 0),a++,t.resolve(e).then(function(e){u||(u=!0,r[s]=e,--a||n(r))},i)}),--a||n(r)});return o&&i(o.error),r.promise},race:function(e){var t=this,r=k(t),n=r.reject,i=O(function(){h(e,!1,function(e){t.resolve(e).then(r.resolve,n)})});return i&&n(i.error),r.promise}})},{"./_a-function":79,"./_an-instance":81,"./_classof":84,"./_core":86,"./_ctx":88,"./_export":94,"./_for-of":96,"./_global":97,"./_is-object":106,"./_iter-detect":110,"./_library":114,"./_microtask":116,"./_redefine-all":130,"./_set-species":133,"./_set-to-string-tag":134,"./_species-constructor":137,"./_task":139,"./_wks":149}],169:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}var i=e("babel-runtime/core-js/string/from-code-point"),o=n(i),a=e("./_export"),s=e("./_to-index"),u=String.fromCharCode,c=o.default;a(a.S+a.F*(!!c&&1!=c.length),"String",{fromCodePoint:function(e){for(var t,r=[],n=arguments.length,i=0;n>i;){if(t=+arguments[i++],s(t,1114111)!==t)throw RangeError(t+" is not a valid code point");r.push(t<65536?u(t):u(((t-=65536)>>10)+55296,t%1024+56320))}return r.join("")}})},{"./_export":94,"./_to-index":140,"babel-runtime/core-js/string/from-code-point":35}],170:[function(e,t,r){"use strict";var n=e("./_string-at")(!0);e("./_iter-define")(String,"String",function(e){this._t=String(e),this._i=0},function(){var e,t=this._t,r=this._i;return r>=t.length?{value:void 0,done:!0}:(e=n(t,r),this._i+=e.length,{value:e,done:!1})})},{"./_iter-define":109,"./_string-at":138}],171:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}var i=e("babel-runtime/helpers/typeof"),o=n(i),a=e("./_global"),s=e("./_has"),u=e("./_descriptors"),c=e("./_export"),l=e("./_redefine"),p=e("./_meta").KEY,f=e("./_fails"),d=e("./_shared"),h=e("./_set-to-string-tag"),m=e("./_uid"),b=e("./_wks"),v=e("./_wks-ext"),g=e("./_wks-define"),y=e("./_keyof"),_=e("./_enum-keys"),x=e("./_is-array"),w=e("./_an-object"),E=e("./_to-iobject"),j=e("./_to-primitive"),S=e("./_property-desc"),T=e("./_object-create"),k=e("./_object-gopn-ext"),A=e("./_object-gopd"),O=e("./_object-dp"),R=e("./_object-keys"),I=A.f,C=O.f,M=k.f,P=a.Symbol,N=a.JSON,D=N&&N.stringify,L="prototype",q=b("_hidden"),U=b("toPrimitive"),B={}.propertyIsEnumerable,F=d("symbol-registry"),z=d("symbols"),G=d("op-symbols"),H=Object[L],Y="function"==typeof P,X=a.QObject,K=!X||!X[L]||!X[L].findChild,V=u&&f(function(){return 7!=T(C({},"a",{
+get:function(){return C(this,"a",{value:7}).a}})).a})?function(e,t,r){var n=I(H,t);n&&delete H[t],C(e,t,r),n&&e!==H&&C(H,t,n)}:C,W=function(e){var t=z[e]=T(P[L]);return t._k=e,t},$=Y&&"symbol"==(0,o.default)(P.iterator)?function(e){return"symbol"==("undefined"==typeof e?"undefined":(0,o.default)(e))}:function(e){return e instanceof P},J=function(e,t,r){return e===H&&J(G,t,r),w(e),t=j(t,!0),w(r),s(z,t)?(r.enumerable?(s(e,q)&&e[q][t]&&(e[q][t]=!1),r=T(r,{enumerable:S(0,!1)})):(s(e,q)||C(e,q,S(1,{})),e[q][t]=!0),V(e,t,r)):C(e,t,r)},Q=function(e,t){w(e);for(var r,n=_(t=E(t)),i=0,o=n.length;o>i;)J(e,r=n[i++],t[r]);return e},Z=function(e,t){return void 0===t?T(e):Q(T(e),t)},ee=function(e){var t=B.call(this,e=j(e,!0));return!(this===H&&s(z,e)&&!s(G,e))&&(!(t||!s(this,e)||!s(z,e)||s(this,q)&&this[q][e])||t)},te=function(e,t){if(e=E(e),t=j(t,!0),e!==H||!s(z,t)||s(G,t)){var r=I(e,t);return!r||!s(z,t)||s(e,q)&&e[q][t]||(r.enumerable=!0),r}},re=function(e){for(var t,r=M(E(e)),n=[],i=0;r.length>i;)s(z,t=r[i++])||t==q||t==p||n.push(t);return n},ne=function(e){for(var t,r=e===H,n=M(r?G:E(e)),i=[],o=0;n.length>o;)!s(z,t=n[o++])||r&&!s(H,t)||i.push(z[t]);return i};Y||(P=function(){if(this instanceof P)throw TypeError("Symbol is not a constructor!");var e=m(arguments.length>0?arguments[0]:void 0),t=function t(r){this===H&&t.call(G,r),s(this,q)&&s(this[q],e)&&(this[q][e]=!1),V(this,e,S(1,r))};return u&&K&&V(H,e,{configurable:!0,set:t}),W(e)},l(P[L],"toString",function(){return this._k}),A.f=te,O.f=J,e("./_object-gopn").f=k.f=re,e("./_object-pie").f=ee,e("./_object-gops").f=ne,u&&!e("./_library")&&l(H,"propertyIsEnumerable",ee,!0),v.f=function(e){return W(b(e))}),c(c.G+c.W+c.F*!Y,{Symbol:P});for(var ie="hasInstance,isConcatSpreadable,iterator,match,replace,search,species,split,toPrimitive,toStringTag,unscopables".split(","),oe=0;ie.length>oe;)b(ie[oe++]);for(var ie=R(b.store),oe=0;ie.length>oe;)g(ie[oe++]);c(c.S+c.F*!Y,"Symbol",{for:function(e){return s(F,e+="")?F[e]:F[e]=P(e)},keyFor:function(e){if($(e))return y(F,e);throw TypeError(e+" is not a symbol!")},useSetter:function(){K=!0},useSimple:function(){K=!1}}),c(c.S+c.F*!Y,"Object",{create:Z,defineProperty:J,defineProperties:Q,getOwnPropertyDescriptor:te,getOwnPropertyNames:re,getOwnPropertySymbols:ne}),N&&c(c.S+c.F*(!Y||f(function(){var e=P();return"[null]"!=D([e])||"{}"!=D({a:e})||"{}"!=D(Object(e))})),"JSON",{stringify:function(e){if(void 0!==e&&!$(e)){for(var t,r,n=[e],i=1;arguments.length>i;)n.push(arguments[i++]);return t=n[1],"function"==typeof t&&(r=t),!r&&x(t)||(t=function(e,t){if(r&&(t=r.call(this,e,t)),!$(t))return t}),n[1]=t,D.apply(N,n)}}}),P[L][U]||e("./_hide")(P[L],U,P[L].valueOf),h(P,"Symbol"),h(Math,"Math",!0),h(a.JSON,"JSON",!0)},{"./_an-object":82,"./_descriptors":90,"./_enum-keys":93,"./_export":94,"./_fails":95,"./_global":97,"./_has":98,"./_hide":99,"./_is-array":105,"./_keyof":113,"./_library":114,"./_meta":115,"./_object-create":117,"./_object-dp":118,"./_object-gopd":120,"./_object-gopn":122,"./_object-gopn-ext":121,"./_object-gops":123,"./_object-keys":126,"./_object-pie":127,"./_property-desc":129,"./_redefine":131,"./_set-to-string-tag":134,"./_shared":136,"./_to-iobject":142,"./_to-primitive":145,"./_uid":146,"./_wks":149,"./_wks-define":147,"./_wks-ext":148,"babel-runtime/helpers/typeof":39}],172:[function(e,t,r){"use strict";e("./_wks-define")("asyncIterator")},{"./_wks-define":147}],173:[function(e,t,r){"use strict";e("./_wks-define")("observable")},{"./_wks-define":147}],174:[function(e,t,r){"use strict";e("./es6.array.iterator");for(var n=e("./_global"),i=e("./_hide"),o=e("./_iterators"),a=e("./_wks")("toStringTag"),s=["NodeList","DOMTokenList","MediaList","StyleSheetList","CSSRuleList"],u=0;u<5;u++){var c=s[u],l=n[c],p=l&&l.prototype;p&&!p[a]&&i(p,a,c),o[c]=o.Array}},{"./_global":97,"./_hide":99,"./_iterators":112,"./_wks":149,"./es6.array.iterator":153}],175:[function(e,t,r){"use strict";var n=e("./_export"),i=e("./_task");n(n.G+n.B,{setImmediate:i.set,clearImmediate:i.clear})},{"./_export":94,"./_task":139}],176:[function(e,t,r){(function(t){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}function i(e){return Array.isArray?Array.isArray(e):"[object Array]"===g(e)}function o(e){return"boolean"==typeof e}function a(e){return null===e}function s(e){return null==e}function u(e){return"number"==typeof e}function c(e){return"string"==typeof e}function l(e){return"symbol"===("undefined"==typeof e?"undefined":(0,_.default)(e))}function p(e){return void 0===e}function f(e){return"[object RegExp]"===g(e)}function d(e){return"object"===("undefined"==typeof e?"undefined":(0,_.default)(e))&&null!==e}function h(e){return"[object Date]"===g(e)}function m(e){return"[object Error]"===g(e)||e instanceof Error}function b(e){return"function"==typeof e}function v(e){return null===e||"boolean"==typeof e||"number"==typeof e||"string"==typeof e||"symbol"===("undefined"==typeof e?"undefined":(0,_.default)(e))||"undefined"==typeof e}function g(e){return Object.prototype.toString.call(e)}var y=e("babel-runtime/helpers/typeof"),_=n(y);r.isArray=i,r.isBoolean=o,r.isNull=a,r.isNullOrUndefined=s,r.isNumber=u,r.isString=c,r.isSymbol=l,r.isUndefined=p,r.isRegExp=f,r.isObject=d,r.isDate=h,r.isError=m,r.isFunction=b,r.isPrimitive=v,r.isBuffer=t.isBuffer}).call(this,{isBuffer:e("../../is-buffer/index.js")})},{"../../is-buffer/index.js":199,"babel-runtime/helpers/typeof":39}],177:[function(e,t,r){"use strict";function n(e,t){if(e.length%s!==0){var r=e.length+(s-e.length%s);e=a.concat([e,u],r)}for(var n=[],i=t?e.readInt32BE:e.readInt32LE,o=0;o<e.length;o+=s)n.push(i.call(e,o));return n}function i(e,t,r){for(var n=new a(t),i=r?n.writeInt32BE:n.writeInt32LE,o=0;o<e.length;o++)i.call(n,e[o],4*o,!0);return n}function o(e,t,r,o){a.isBuffer(e)||(e=new a(e));var s=t(n(e,o),e.length*c);return i(s,r,o)}var a=e("buffer").Buffer,s=4,u=new a(s);u.fill(0);var c=8;t.exports={hash:o}},{buffer:45}],178:[function(e,t,r){"use strict";function n(e,t,r){s.isBuffer(t)||(t=new s(t)),s.isBuffer(r)||(r=new s(r)),t.length>d?t=e(t):t.length<d&&(t=s.concat([t,h],d));for(var n=new s(d),i=new s(d),o=0;o<d;o++)n[o]=54^t[o],i[o]=92^t[o];var a=e(s.concat([n,r]));return e(s.concat([i,a]))}function i(e,t){e=e||"sha1";var r=f[e],i=[],a=0;return r||o("algorithm:",e,"is not yet supported"),{update:function(e){return s.isBuffer(e)||(e=new s(e)),i.push(e),a+=e.length,this},digest:function(e){var o=s.concat(i),a=t?n(r,t,o):r(o);return i=null,e?a.toString(e):a}}}function o(){var e=[].slice.call(arguments).join(" ");throw new Error([e,"we accept pull requests","http://github.com/dominictarr/crypto-browserify"].join("\n"))}function a(e,t){for(var r in e)t(e[r],r)}var s=e("buffer").Buffer,u=e("./sha"),c=e("./sha256"),l=e("./rng"),p=e("./md5"),f={sha1:u,sha256:c,md5:p},d=64,h=new s(d);h.fill(0),r.createHash=function(e){return i(e)},r.createHmac=function(e,t){return i(e,t)},r.randomBytes=function(e,t){if(!t||!t.call)return new s(l(e));try{t.call(this,void 0,new s(l(e)))}catch(e){t(e)}},a(["createCredentials","createCipher","createCipheriv","createDecipher","createDecipheriv","createSign","createVerify","createDiffieHellman","pbkdf2"],function(e){r[e]=function(){o("sorry,",e,"is not implemented yet")}})},{"./md5":179,"./rng":180,"./sha":181,"./sha256":182,buffer:45}],179:[function(e,t,r){"use strict";function n(e,t){e[t>>5]|=128<<t%32,e[(t+64>>>9<<4)+14]=t;for(var r=1732584193,n=-271733879,i=-1732584194,l=271733878,p=0;p<e.length;p+=16){var f=r,d=n,h=i,m=l;r=o(r,n,i,l,e[p+0],7,-680876936),l=o(l,r,n,i,e[p+1],12,-389564586),i=o(i,l,r,n,e[p+2],17,606105819),n=o(n,i,l,r,e[p+3],22,-1044525330),r=o(r,n,i,l,e[p+4],7,-176418897),l=o(l,r,n,i,e[p+5],12,1200080426),i=o(i,l,r,n,e[p+6],17,-1473231341),n=o(n,i,l,r,e[p+7],22,-45705983),r=o(r,n,i,l,e[p+8],7,1770035416),l=o(l,r,n,i,e[p+9],12,-1958414417),i=o(i,l,r,n,e[p+10],17,-42063),n=o(n,i,l,r,e[p+11],22,-1990404162),r=o(r,n,i,l,e[p+12],7,1804603682),l=o(l,r,n,i,e[p+13],12,-40341101),i=o(i,l,r,n,e[p+14],17,-1502002290),n=o(n,i,l,r,e[p+15],22,1236535329),r=a(r,n,i,l,e[p+1],5,-165796510),l=a(l,r,n,i,e[p+6],9,-1069501632),i=a(i,l,r,n,e[p+11],14,643717713),n=a(n,i,l,r,e[p+0],20,-373897302),r=a(r,n,i,l,e[p+5],5,-701558691),l=a(l,r,n,i,e[p+10],9,38016083),i=a(i,l,r,n,e[p+15],14,-660478335),n=a(n,i,l,r,e[p+4],20,-405537848),r=a(r,n,i,l,e[p+9],5,568446438),l=a(l,r,n,i,e[p+14],9,-1019803690),i=a(i,l,r,n,e[p+3],14,-187363961),n=a(n,i,l,r,e[p+8],20,1163531501),r=a(r,n,i,l,e[p+13],5,-1444681467),l=a(l,r,n,i,e[p+2],9,-51403784),i=a(i,l,r,n,e[p+7],14,1735328473),n=a(n,i,l,r,e[p+12],20,-1926607734),r=s(r,n,i,l,e[p+5],4,-378558),l=s(l,r,n,i,e[p+8],11,-2022574463),i=s(i,l,r,n,e[p+11],16,1839030562),n=s(n,i,l,r,e[p+14],23,-35309556),r=s(r,n,i,l,e[p+1],4,-1530992060),l=s(l,r,n,i,e[p+4],11,1272893353),i=s(i,l,r,n,e[p+7],16,-155497632),n=s(n,i,l,r,e[p+10],23,-1094730640),r=s(r,n,i,l,e[p+13],4,681279174),l=s(l,r,n,i,e[p+0],11,-358537222),i=s(i,l,r,n,e[p+3],16,-722521979),n=s(n,i,l,r,e[p+6],23,76029189),r=s(r,n,i,l,e[p+9],4,-640364487),l=s(l,r,n,i,e[p+12],11,-421815835),i=s(i,l,r,n,e[p+15],16,530742520),n=s(n,i,l,r,e[p+2],23,-995338651),r=u(r,n,i,l,e[p+0],6,-198630844),l=u(l,r,n,i,e[p+7],10,1126891415),i=u(i,l,r,n,e[p+14],15,-1416354905),n=u(n,i,l,r,e[p+5],21,-57434055),r=u(r,n,i,l,e[p+12],6,1700485571),l=u(l,r,n,i,e[p+3],10,-1894986606),i=u(i,l,r,n,e[p+10],15,-1051523),n=u(n,i,l,r,e[p+1],21,-2054922799),r=u(r,n,i,l,e[p+8],6,1873313359),l=u(l,r,n,i,e[p+15],10,-30611744),i=u(i,l,r,n,e[p+6],15,-1560198380),n=u(n,i,l,r,e[p+13],21,1309151649),r=u(r,n,i,l,e[p+4],6,-145523070),l=u(l,r,n,i,e[p+11],10,-1120210379),i=u(i,l,r,n,e[p+2],15,718787259),n=u(n,i,l,r,e[p+9],21,-343485551),r=c(r,f),n=c(n,d),i=c(i,h),l=c(l,m)}return Array(r,n,i,l)}function i(e,t,r,n,i,o){return c(l(c(c(t,e),c(n,o)),i),r)}function o(e,t,r,n,o,a,s){return i(t&r|~t&n,e,t,o,a,s)}function a(e,t,r,n,o,a,s){return i(t&n|r&~n,e,t,o,a,s)}function s(e,t,r,n,o,a,s){return i(t^r^n,e,t,o,a,s)}function u(e,t,r,n,o,a,s){return i(r^(t|~n),e,t,o,a,s)}function c(e,t){var r=(65535&e)+(65535&t),n=(e>>16)+(t>>16)+(r>>16);return n<<16|65535&r}function l(e,t){return e<<t|e>>>32-t}var p=e("./helpers");t.exports=function(e){return p.hash(e,n,16)}},{"./helpers":177}],180:[function(e,t,r){"use strict";!function(){var e,r,n=this;e=function(e){for(var t,t,r=new Array(e),n=0;n<e;n++)0==(3&n)&&(t=4294967296*Math.random()),r[n]=t>>>((3&n)<<3)&255;return r},n.crypto&&crypto.getRandomValues&&(r=function(e){var t=new Uint8Array(e);return crypto.getRandomValues(t),t}),t.exports=r||e}()},{}],181:[function(e,t,r){"use strict";function n(e,t){e[t>>5]|=128<<24-t%32,e[(t+64>>9<<4)+15]=t;for(var r=Array(80),n=1732584193,u=-271733879,c=-1732584194,l=271733878,p=-1009589776,f=0;f<e.length;f+=16){for(var d=n,h=u,m=c,b=l,v=p,g=0;g<80;g++){g<16?r[g]=e[f+g]:r[g]=s(r[g-3]^r[g-8]^r[g-14]^r[g-16],1);var y=a(a(s(n,5),i(g,u,c,l)),a(a(p,r[g]),o(g)));p=l,l=c,c=s(u,30),u=n,n=y}n=a(n,d),u=a(u,h),c=a(c,m),l=a(l,b),p=a(p,v)}return Array(n,u,c,l,p)}function i(e,t,r,n){return e<20?t&r|~t&n:e<40?t^r^n:e<60?t&r|t&n|r&n:t^r^n}function o(e){return e<20?1518500249:e<40?1859775393:e<60?-1894007588:-899497514}function a(e,t){var r=(65535&e)+(65535&t),n=(e>>16)+(t>>16)+(r>>16);return n<<16|65535&r}function s(e,t){return e<<t|e>>>32-t}var u=e("./helpers");t.exports=function(e){return u.hash(e,n,20,!0)}},{"./helpers":177}],182:[function(e,t,r){"use strict";var n=e("./helpers"),i=function(e,t){var r=(65535&e)+(65535&t),n=(e>>16)+(t>>16)+(r>>16);return n<<16|65535&r},o=function(e,t){return e>>>t|e<<32-t},a=function(e,t){return e>>>t},s=function(e,t,r){return e&t^~e&r},u=function(e,t,r){return e&t^e&r^t&r},c=function(e){return o(e,2)^o(e,13)^o(e,22)},l=function(e){return o(e,6)^o(e,11)^o(e,25)},p=function(e){return o(e,7)^o(e,18)^a(e,3)},f=function(e){return o(e,17)^o(e,19)^a(e,10)},d=function(e,t){var r,n,o,a,d,h,m,b,v,g,y,_,x=new Array(1116352408,1899447441,3049323471,3921009573,961987163,1508970993,2453635748,2870763221,3624381080,310598401,607225278,1426881987,1925078388,2162078206,2614888103,3248222580,3835390401,4022224774,264347078,604807628,770255983,1249150122,1555081692,1996064986,2554220882,2821834349,2952996808,3210313671,3336571891,3584528711,113926993,338241895,666307205,773529912,1294757372,1396182291,1695183700,1986661051,2177026350,2456956037,2730485921,2820302411,3259730800,3345764771,3516065817,3600352804,4094571909,275423344,430227734,506948616,659060556,883997877,958139571,1322822218,1537002063,1747873779,1955562222,2024104815,2227730452,2361852424,2428436474,2756734187,3204031479,3329325298),w=new Array(1779033703,3144134277,1013904242,2773480762,1359893119,2600822924,528734635,1541459225),E=new Array(64);e[t>>5]|=128<<24-t%32,e[(t+64>>9<<4)+15]=t;for(var v=0;v<e.length;v+=16){r=w[0],n=w[1],o=w[2],a=w[3],d=w[4],h=w[5],m=w[6],b=w[7];for(var g=0;g<64;g++)g<16?E[g]=e[g+v]:E[g]=i(i(i(f(E[g-2]),E[g-7]),p(E[g-15])),E[g-16]),y=i(i(i(i(b,l(d)),s(d,h,m)),x[g]),E[g]),_=i(c(r),u(r,n,o)),b=m,m=h,h=d,d=i(a,y),a=o,o=n,n=r,r=i(y,_);w[0]=i(r,w[0]),w[1]=i(n,w[1]),w[2]=i(o,w[2]),w[3]=i(a,w[3]),w[4]=i(d,w[4]),w[5]=i(h,w[5]),w[6]=i(m,w[6]),w[7]=i(b,w[7])}return w};t.exports=function(e){return n.hash(e,d,32,!0)}},{"./helpers":177}],183:[function(t,r,n){"use strict";function i(e){return e&&e.__esModule?e:{default:e}}var o=t("babel-runtime/helpers/typeof"),a=i(o);!function(t){function i(e,t){for(e=String(e),t=t||2;e.length<t;)e="0"+e;return e}function o(e){var t=new Date(e.getFullYear(),e.getMonth(),e.getDate());t.setDate(t.getDate()-(t.getDay()+6)%7+3);var r=new Date(t.getFullYear(),0,4);r.setDate(r.getDate()-(r.getDay()+6)%7+3);var n=t.getTimezoneOffset()-r.getTimezoneOffset();t.setHours(t.getHours()-n);var i=(t-r)/6048e5;return 1+Math.floor(i)}function s(e){var t=e.getDay();return 0===t&&(t=7),t}function u(e){return null===e?"null":void 0===e?"undefined":"object"!==("undefined"==typeof e?"undefined":(0,a.default)(e))?"undefined"==typeof e?"undefined":(0,a.default)(e):Array.isArray(e)?"array":{}.toString.call(e).slice(8,-1).toLowerCase()}var c=function(){var e=/d{1,4}|m{1,4}|yy(?:yy)?|([HhMsTt])\1?|[LloSZWN]|'[^']*'|'[^']*'/g,t=/\b(?:[PMCEA][SDP]T|(?:Pacific|Mountain|Central|Eastern|Atlantic) (?:Standard|Daylight|Prevailing) Time|(?:GMT|UTC)(?:[-+]\d{4})?)\b/g,r=/[^-+\dA-Z]/g;return function(n,a,l,p){if(1!==arguments.length||"string"!==u(n)||/\d/.test(n)||(a=n,n=void 0),n=n||new Date,n instanceof Date||(n=new Date(n)),isNaN(n))throw TypeError("Invalid date");a=String(c.masks[a]||a||c.masks.default);var f=a.slice(0,4);"UTC:"!==f&&"GMT:"!==f||(a=a.slice(4),l=!0,"GMT:"===f&&(p=!0));var d=l?"getUTC":"get",h=n[d+"Date"](),m=n[d+"Day"](),b=n[d+"Month"](),v=n[d+"FullYear"](),g=n[d+"Hours"](),y=n[d+"Minutes"](),_=n[d+"Seconds"](),x=n[d+"Milliseconds"](),w=l?0:n.getTimezoneOffset(),E=o(n),j=s(n),S={d:h,dd:i(h),ddd:c.i18n.dayNames[m],dddd:c.i18n.dayNames[m+7],m:b+1,mm:i(b+1),mmm:c.i18n.monthNames[b],mmmm:c.i18n.monthNames[b+12],yy:String(v).slice(2),yyyy:v,h:g%12||12,hh:i(g%12||12),H:g,HH:i(g),M:y,MM:i(y),s:_,ss:i(_),l:i(x,3),L:i(Math.round(x/10)),t:g<12?"a":"p",tt:g<12?"am":"pm",T:g<12?"A":"P",TT:g<12?"AM":"PM",Z:p?"GMT":l?"UTC":(String(n).match(t)||[""]).pop().replace(r,""),o:(w>0?"-":"+")+i(100*Math.floor(Math.abs(w)/60)+Math.abs(w)%60,4),S:["th","st","nd","rd"][h%10>3?0:(h%100-h%10!=10)*h%10],W:E,N:j};return a.replace(e,function(e){return e in S?S[e]:e.slice(1,e.length-1)})}}();c.masks={default:"ddd mmm dd yyyy HH:MM:ss",shortDate:"m/d/yy",mediumDate:"mmm d, yyyy",longDate:"mmmm d, yyyy",fullDate:"dddd, mmmm d, yyyy",shortTime:"h:MM TT",mediumTime:"h:MM:ss TT",longTime:"h:MM:ss TT Z",isoDate:"yyyy-mm-dd",isoTime:"HH:MM:ss",isoDateTime:"yyyy-mm-dd'T'HH:MM:sso",isoUtcDateTime:"UTC:yyyy-mm-dd'T'HH:MM:ss'Z'",expiresHeaderFormat:"ddd, dd mmm yyyy HH:MM:ss Z"},c.i18n={dayNames:["Sun","Mon","Tue","Wed","Thu","Fri","Sat","Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],monthNames:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec","January","February","March","April","May","June","July","August","September","October","November","December"]},"function"==typeof e&&e.amd?e(function(){return c}):"object"===("undefined"==typeof n?"undefined":(0,a.default)(n))?r.exports=c:t.dateFormat=c}(void 0)},{"babel-runtime/helpers/typeof":39}],184:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}function i(){return"WebkitAppearance"in document.documentElement.style||window.console&&(console.firebug||console.exception&&console.table)||navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)&&parseInt(RegExp.$1,10)>=31}function o(){var e=arguments,t=this.useColors;if(e[0]=(t?"%c":"")+this.namespace+(t?" %c":" ")+e[0]+(t?"%c ":" ")+"+"+r.humanize(this.diff),!t)return e;var n="color: "+this.color;e=[e[0],n,"color: inherit"].concat(Array.prototype.slice.call(e,1));var i=0,o=0;return e[0].replace(/%[a-z%]/g,function(e){"%%"!==e&&(i++,"%c"===e&&(o=i))}),e.splice(o,0,n),e}function a(){return"object"===("undefined"==typeof console?"undefined":(0,p.default)(console))&&console.log&&Function.prototype.apply.call(console.log,console,arguments)}function s(e){try{null==e?r.storage.removeItem("debug"):r.storage.debug=e}catch(e){}}function u(){var e;try{e=r.storage.debug}catch(e){}return e}function c(){try{return window.localStorage}catch(e){}}var l=e("babel-runtime/helpers/typeof"),p=n(l),f=e("babel-runtime/core-js/json/stringify"),d=n(f);r=t.exports=e("./debug"),r.log=a,r.formatArgs=o,r.save=s,r.load=u,r.useColors=i,r.storage="undefined"!=typeof chrome&&"undefined"!=typeof chrome.storage?chrome.storage.local:c(),r.colors=["lightseagreen","forestgreen","goldenrod","dodgerblue","darkorchid","crimson"],r.formatters.j=function(e){return(0,d.default)(e)},r.enable(u())},{"./debug":185,"babel-runtime/core-js/json/stringify":18,"babel-runtime/helpers/typeof":39}],185:[function(e,t,r){"use strict";function n(){return r.colors[l++%r.colors.length]}function i(e){function t(){}function i(){var e=i,t=+new Date,o=t-(c||t);e.diff=o,e.prev=c,e.curr=t,c=t,null==e.useColors&&(e.useColors=r.useColors()),null==e.color&&e.useColors&&(e.color=n());var a=Array.prototype.slice.call(arguments);a[0]=r.coerce(a[0]),"string"!=typeof a[0]&&(a=["%o"].concat(a));var s=0;a[0]=a[0].replace(/%([a-z%])/g,function(t,n){if("%%"===t)return t;s++;var i=r.formatters[n];if("function"==typeof i){var o=a[s];t=i.call(e,o),a.splice(s,1),s--}return t}),"function"==typeof r.formatArgs&&(a=r.formatArgs.apply(e,a));var u=i.log||r.log||console.log.bind(console);u.apply(e,a)}t.enabled=!1,i.enabled=!0;var o=r.enabled(e)?i:t;return o.namespace=e,o}function o(e){r.save(e);for(var t=(e||"").split(/[\s,]+/),n=t.length,i=0;i<n;i++)t[i]&&(e=t[i].replace(/\*/g,".*?"),"-"===e[0]?r.skips.push(new RegExp("^"+e.substr(1)+"$")):r.names.push(new RegExp("^"+e+"$")))}function a(){r.enable("")}function s(e){var t,n;for(t=0,n=r.skips.length;t<n;t++)if(r.skips[t].test(e))return!1;for(t=0,n=r.names.length;t<n;t++)if(r.names[t].test(e))return!0;return!1}function u(e){return e instanceof Error?e.stack||e.message:e}r=t.exports=i,r.coerce=u,r.disable=a,r.enable=o,r.enabled=s,r.humanize=e("ms"),r.names=[],r.skips=[],r.formatters={};var c,l=0},{ms:338}],186:[function(e,t,r){(function(r){"use strict";var n=e("os-name"),i="Node.js/"+r.version.slice(1)+" ("+n()+"; "+r.arch+")";t.exports=function(e,t){return 2!==arguments.length?i:e+"/"+t+" "+i}}).call(this,e("_process"))},{_process:345,"os-name":340}],187:[function(e,t,r){"use strict";function n(e){return e instanceof a?i(e):e instanceof s?("function"==typeof e.destroy&&e.destroy(),e):e}function i(e){return e.destroy(),"function"==typeof e.close&&e.on("open",o),e}function o(){"number"==typeof this.fd&&this.close()}var a=e("fs").ReadStream,s=e("stream");t.exports=n},{fs:43,stream:369}],188:[function(e,t,r){"use strict";function n(e,t,r,n){for(var c=r.split(","),l={},p=0;p<c.length;p++){var f=c[p].match(a);f&&(l[f[1]]=f[2].replace(/["']/g,""))}if(!l.realm||!l.nonce)return"";var d=l.qop||"";n=n.split(":");var h=String(++s);h=u.substring(h.length)+h;var m=i.randomBytes(8).toString("hex"),b=o.md5(n[0]+":"+l.realm+":"+n[1]),v=o.md5(e.toUpperCase()+":"+t),g=b+":"+l.nonce;d&&(d=d.split(",")[0],g+=":"+h+":"+m+":"+d),g+=":"+v;var y=o.md5(g),_='Digest username="'+n[0]+'", realm="'+l.realm+'", nonce="'+l.nonce+'", uri="'+t+'", response="'+y+'"';return l.opaque&&(_+=', opaque="'+l.opaque+'"'),d&&(_+=", qop="+d+", nc="+h+', cnonce="'+m+'"'),_}var i=e("./../../shims/crypto.js"),o=e("utility"),a=/(\w+)=["']?([^'"]+)["']?/,s=0,u="00000000";t.exports=n},{"./../../shims/crypto.js":420,utility:189}],189:[function(e,t,r){"use strict";t.exports=e("./lib/utility")},{"./lib/utility":190}],190:[function(e,t,r){(function(t,n){"use strict";function i(e){return e&&e.__esModule?e:{default:e}}function o(e){if(!e||Array.isArray(e)||"object"!==("undefined"==typeof e?"undefined":(0,d.default)(e)))return e;var t=(0,p.default)(e);t.sort();for(var r=[],n=0;n<t.length;n++){var i=t[n];r.push([i,o(e[i])])}return r}var a=e("babel-runtime/core-js/set-immediate"),s=i(a),u=e("babel-runtime/core-js/json/stringify"),c=i(u),l=e("babel-runtime/core-js/object/keys"),p=i(l),f=e("babel-runtime/helpers/typeof"),d=i(f),h=e("./../../../../../shims/crypto.js"),m=e("address");r.noop=function(){},r.hash=function(e,t,r){var i=h.createHash(e),a=n.isBuffer(t);return a||"object"!==("undefined"==typeof t?"undefined":(0,d.default)(t))||(t=(0,c.default)(o(t))),i.update(t,a?"binary":"utf8"),i.digest(r||"hex")},r.md5=function(e,t){return r.hash("md5",e,t)},r.sha1=function(e,t){return r.hash("sha1",e,t)},r.hmac=function(e,t,r,i){i=i||"base64";var o=h.createHmac(e,t);return o.update(r,n.isBuffer(r)?"binary":"utf8"),o.digest(i)},r.base64encode=function(e,t){n.isBuffer(e)||(e=new n(e));var r=e.toString("base64");return t&&(r=r.replace(/\+/g,"-").replace(/\//g,"_")),r},r.base64decode=function(e,t){return t&&(e=e.replace(/\-/g,"+").replace(/_/g,"/")),e=new n(e,"base64"),e.toString()},r.escape=function(e){return String(e).replace(/&(?!\w+;)/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/"/g,"&quot;")},r.randomSlice=function(e,t){if(!t||t>=e.length)return e.slice();for(var r=Math.floor(Math.random()*e.length),n=[],i=0,o=r;i<t;i++)n.push(e[o++]),o===e.length&&(o=0);return n},r.encodeURIComponent=function(e){try{return encodeURIComponent(e)}catch(t){return e}},r.decodeURIComponent=function(e){try{return decodeURIComponent(e)}catch(t){return e}};var b=["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"],v=" ",g=parseInt(-(new Date).getTimezoneOffset()/60,10);v+=g>=0?"+":"-",g=Math.abs(g),g<10&&(g="0"+g),v+=g+"00",r.accessLogDate=function(e){e=e||new Date;var t=e.getDate();t<10&&(t="0"+t);var r=e.getHours();r<10&&(r="0"+r);var n=e.getMinutes();n<10&&(n="0"+n);var i=e.getSeconds();return i<10&&(i="0"+i),t+"/"+b[e.getMonth()]+"/"+e.getFullYear()+":"+r+":"+n+":"+i+v},r.logDate=r.YYYYMMDDHHmmssSSS=function(e){e=e||new Date;var t=e.getDate();t<10&&(t="0"+t);var r=e.getMonth()+1;r<10&&(r="0"+r);var n=e.getHours();n<10&&(n="0"+n);var i=e.getMinutes();i<10&&(i="0"+i);var o=e.getSeconds();o<10&&(o="0"+o);var a=e.getMilliseconds();return a<10?a="00"+a:a<100&&(a="0"+a),e.getFullYear()+"-"+r+"-"+t+" "+n+":"+i+":"+o+"."+a},r.YYYYMMDDHHmmss=function(e){e=e||new Date;var t=e.getDate();t<10&&(t="0"+t);var r=e.getMonth()+1;r<10&&(r="0"+r);var n=e.getHours();n<10&&(n="0"+n);var i=e.getMinutes();i<10&&(i="0"+i);var o=e.getSeconds();return o<10&&(o="0"+o),e.getFullYear()+"-"+r+"-"+t+" "+n+":"+i+":"+o},r.YYYYMMDD=function(e){e=e||new Date;var t=e.getDate();t<10&&(t="0"+t);var r=e.getMonth()+1;return r<10&&(r="0"+r),e.getFullYear()+"-"+r+"-"+t},r.datestruct=function(e){return e=e||new Date,{YYYYMMDD:1e4*e.getFullYear()+100*(e.getMonth()+1)+e.getDate(),H:e.getHours()}};var y=!1;r.getIP=r.getIPv4=function(e){return y||(y=!0,console.warn("[WARNNING] getIP() remove, PLEASE use `https://github.com/fengmk2/address` module instead")),m.ip(e)},r.getIPv6=function(e){return m.ipv6(e)},r.getParamNames=function(e,t){if(t=t!==!1,t&&e.__cache_names)return e.__cache_names;var r=e.toString(),n=r.slice(r.indexOf("(")+1,r.indexOf(")")).match(/([^\s,]+)/g)||[];return e.__cache_names=n,n},r.MAX_SAFE_INTEGER=Math.pow(2,53)-1,r.MIN_SAFE_INTEGER=-r.MAX_SAFE_INTEGER;var _=r.MAX_SAFE_INTEGER_STR=String(r.MAX_SAFE_INTEGER),x=_.length;r.isSafeNumberString=function(e){return"-"===e[0]&&(e=e.substring(1)),e.length<x||e.length===x&&e<=_},r.toSafeNumber=function(e){return"number"==typeof e?e:r.isSafeNumberString(e)?Number(e):e},r.timestamp=function(e){if(e){var t=e;return"string"==typeof t&&(t=Number(t)),10===String(e).length&&(t*=1e3),new Date(t)}return Math.round(Date.now()/1e3)};var w="function"==typeof s.default?s.default:t.nextTick;r.setImmediate=function(e){w(e)},r.randomString=function(e,t){var r=[];for(e=e||16,t=t||"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";e--;)r.push(t[Math.floor(Math.random()*t.length)]);return r.join("")},r.has=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)}}).call(this,e("_process"),e("buffer").Buffer)},{"./../../../../../shims/crypto.js":420,_process:345,address:10,"babel-runtime/core-js/json/stringify":18,"babel-runtime/core-js/object/keys":30,"babel-runtime/core-js/set-immediate":34,"babel-runtime/helpers/typeof":39,buffer:45}],191:[function(e,t,r){"use strict";t.exports=function(e,t){function r(e){i(),t(e)}function n(e){i(),t(null,e)}function i(){e.removeListener("error",r),e.removeListener("end",n)}return e.readable?(e.on("error",r),void e.on("end",n)):t()}},{}],192:[function(e,t,r){"use strict";function n(e){var t=""+e,r=i.exec(t);if(!r)return t;var n,o="",a=0,s=0;for(a=r.index;a<t.length;a++){switch(t.charCodeAt(a)){case 34:n="&quot;";break;case 38:n="&amp;";break;case 39:n="&#39;";break;case 60:n="&lt;";break;case 62:n="&gt;";break;default:continue}s!==a&&(o+=t.substring(s,a)),s=a+1,o+=n}return s!==a?o+t.substring(s,a):o}var i=/["'&<>]/;t.exports=n},{}],193:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}function i(){this._events=this._events||{},this._maxListeners=this._maxListeners||void 0}function o(e){return"function"==typeof e}function a(e){return"number"==typeof e}function s(e){return"object"===("undefined"==typeof e?"undefined":(0,l.default)(e))&&null!==e}function u(e){return void 0===e}var c=e("babel-runtime/helpers/typeof"),l=n(c);t.exports=i,i.EventEmitter=i,i.prototype._events=void 0,i.prototype._maxListeners=void 0,i.defaultMaxListeners=10,i.prototype.setMaxListeners=function(e){if(!a(e)||e<0||isNaN(e))throw TypeError("n must be a positive number");return this._maxListeners=e,this},i.prototype.emit=function(e){var t,r,n,i,a,c;if(this._events||(this._events={}),"error"===e&&(!this._events.error||s(this._events.error)&&!this._events.error.length)){if(t=arguments[1],t instanceof Error)throw t;var l=new Error('Uncaught, unspecified "error" event. ('+t+")");throw l.context=t,l}if(r=this._events[e],u(r))return!1;if(o(r))switch(arguments.length){case 1:r.call(this);break;case 2:r.call(this,arguments[1]);break;case 3:r.call(this,arguments[1],arguments[2]);break;default:i=Array.prototype.slice.call(arguments,1),r.apply(this,i)}else if(s(r))for(i=Array.prototype.slice.call(arguments,1),c=r.slice(),n=c.length,a=0;a<n;a++)c[a].apply(this,i);return!0},i.prototype.addListener=function(e,t){var r;if(!o(t))throw TypeError("listener must be a function");return this._events||(this._events={}),this._events.newListener&&this.emit("newListener",e,o(t.listener)?t.listener:t),this._events[e]?s(this._events[e])?this._events[e].push(t):this._events[e]=[this._events[e],t]:this._events[e]=t,s(this._events[e])&&!this._events[e].warned&&(r=u(this._maxListeners)?i.defaultMaxListeners:this._maxListeners,r&&r>0&&this._events[e].length>r&&(this._events[e].warned=!0,console.error("(node) warning: possible EventEmitter memory leak detected. %d listeners added. Use emitter.setMaxListeners() to increase limit.",this._events[e].length),"function"==typeof console.trace&&console.trace())),this},i.prototype.on=i.prototype.addListener,i.prototype.once=function(e,t){function r(){this.removeListener(e,r),n||(n=!0,t.apply(this,arguments))}if(!o(t))throw TypeError("listener must be a function");var n=!1;return r.listener=t,this.on(e,r),this},i.prototype.removeListener=function(e,t){var r,n,i,a;if(!o(t))throw TypeError("listener must be a function");if(!this._events||!this._events[e])return this;if(r=this._events[e],i=r.length,n=-1,r===t||o(r.listener)&&r.listener===t)delete this._events[e],this._events.removeListener&&this.emit("removeListener",e,t);else if(s(r)){for(a=i;a-- >0;)if(r[a]===t||r[a].listener&&r[a].listener===t){n=a;break}if(n<0)return this;1===r.length?(r.length=0,delete this._events[e]):r.splice(n,1),this._events.removeListener&&this.emit("removeListener",e,t)}return this},i.prototype.removeAllListeners=function(e){var t,r;if(!this._events)return this;if(!this._events.removeListener)return 0===arguments.length?this._events={}:this._events[e]&&delete this._events[e],this;if(0===arguments.length){for(t in this._events)"removeListener"!==t&&this.removeAllListeners(t);return this.removeAllListeners("removeListener"),this._events={},this}if(r=this._events[e],o(r))this.removeListener(e,r);else if(r)for(;r.length;)this.removeListener(e,r[r.length-1]);return delete this._events[e],this},i.prototype.listeners=function(e){var t;return t=this._events&&this._events[e]?o(this._events[e])?[this._events[e]]:this._events[e].slice():[]},i.prototype.listenerCount=function(e){if(this._events){var t=this._events[e];if(o(t))return 1;if(t)return t.length}return 0},i.listenerCount=function(e,t){return e.listenerCount(t)}},{"babel-runtime/helpers/typeof":39}],194:[function(e,t,r){(function(r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}function i(e){return this._ready=!!this._ready,this._readyCallbacks=this._readyCallbacks||[],0===arguments.length?new s.default(function(e){return this._ready?e():void this._readyCallbacks.push(e)}.bind(this)):("function"==typeof e?this._readyCallbacks.push(e):this._ready=!!e,void(this._ready&&this._readyCallbacks.splice(0,1/0).forEach(function(e){r.nextTick(e)})))}function o(e){e.ready=i}var a=e("babel-runtime/core-js/promise"),s=n(a);t.exports=o,t.exports.mixin=o}).call(this,e("_process"))},{_process:345,"babel-runtime/core-js/promise":33}],195:[function(e,t,r){"use strict";var n=e("http"),i=t.exports;for(var o in n)n.hasOwnProperty(o)&&(i[o]=n[o]);i.request=function(e,t){return e||(e={}),e.scheme="https",e.protocol="https:",n.request.call(this,e,t)}},{http:370}],196:[function(e,t,r){"use strict";var n=e("util"),i=e("ms");t.exports=function(e){if("number"==typeof e)return e;var t=i(e);if(void 0===t){var r=new Error(n.format("humanize-ms(%j) result undefined",e));console.warn(r.stack)}return t}},{ms:338,util:384}],197:[function(e,t,r){"use strict";r.read=function(e,t,r,n,i){var o,a,s=8*i-n-1,u=(1<<s)-1,c=u>>1,l=-7,p=r?i-1:0,f=r?-1:1,d=e[t+p];for(p+=f,o=d&(1<<-l)-1,d>>=-l,l+=s;l>0;o=256*o+e[t+p],p+=f,l-=8);for(a=o&(1<<-l)-1,o>>=-l,l+=n;l>0;a=256*a+e[t+p],p+=f,l-=8);if(0===o)o=1-c;else{if(o===u)return a?NaN:(d?-1:1)*(1/0);a+=Math.pow(2,n),o-=c}return(d?-1:1)*a*Math.pow(2,o-n)},r.write=function(e,t,r,n,i,o){var a,s,u,c=8*o-i-1,l=(1<<c)-1,p=l>>1,f=23===i?Math.pow(2,-24)-Math.pow(2,-77):0,d=n?0:o-1,h=n?1:-1,m=t<0||0===t&&1/t<0?1:0;for(t=Math.abs(t),isNaN(t)||t===1/0?(s=isNaN(t)?1:0,a=l):(a=Math.floor(Math.log(t)/Math.LN2),t*(u=Math.pow(2,-a))<1&&(a--,u*=2),t+=a+p>=1?f/u:f*Math.pow(2,1-p),t*u>=2&&(a++,u/=2),a+p>=l?(s=0,a=l):a+p>=1?(s=(t*u-1)*Math.pow(2,i),a+=p):(s=t*Math.pow(2,p-1)*Math.pow(2,i),a=0));i>=8;e[r+d]=255&s,d+=h,s/=256,i-=8);for(a=a<<i|s,c+=i;c>0;e[r+d]=255&a,d+=h,a/=256,c-=8);e[r+d-h]|=128*m}},{}],198:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}var i=e("babel-runtime/core-js/object/create"),o=n(i);"function"==typeof o.default?t.exports=function(e,t){e.super_=t,e.prototype=(0,o.default)(t.prototype,{constructor:{
+value:e,enumerable:!1,writable:!0,configurable:!0}})}:t.exports=function(e,t){e.super_=t;var r=function(){};r.prototype=t.prototype,e.prototype=new r,e.prototype.constructor=e}},{"babel-runtime/core-js/object/create":22}],199:[function(e,t,r){"use strict";function n(e){return!!e.constructor&&"function"==typeof e.constructor.isBuffer&&e.constructor.isBuffer(e)}function i(e){return"function"==typeof e.readFloatLE&&"function"==typeof e.slice&&n(e.slice(0,0))}t.exports=function(e){return null!=e&&(n(e)||i(e)||!!e._isBuffer)}},{}],200:[function(t,r,n){"use strict";!function(t){function i(e){return a.call(e).replace(/^[^{]*{\s*/,"").replace(/\s*}[^}]*$/,"")}function o(e){return"function"==typeof e&&(/^class\s/.test(a.call(e))||/^.*classCallCheck\(/.test(i(e)))}var a=Function.prototype.toString;"undefined"!=typeof n?("undefined"!=typeof r&&r.exports&&(n=r.exports=o),n.isClass=o):"function"==typeof e&&e.amd?e([],function(){return o}):t.isClass=o}(void 0)},{}],201:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}function i(e){var t=e.slice(2);return t=t[0].toLowerCase()+t.slice(1)}var o=e("babel-runtime/core-js/number/is-nan"),a=n(o),s=e("babel-runtime/core-js/number/is-finite"),u=n(s),c=e("babel-runtime/core-js/object/keys"),l=n(c),p=e("core-util-is"),f=e("isstream"),d=e("is-class");(0,l.default)(p).map(function(e){r[i(e)]=p[e]}),r.stream=f,r.readableStream=f.isReadable,r.writableStream=f.isWritable,r.duplexStream=f.isDuplex,r.class=d,r.finite=function(e){return(0,u.default)(e)},r.NaN=function(e){return(0,a.default)(e)},r.generator=function(e){return e&&"function"==typeof e.next&&"function"==typeof e.throw},r.generatorFunction=function(e){return e&&e.constructor&&"GeneratorFunction"===e.constructor.name},r.promise=function(e){return e&&"function"==typeof e.then};var h=Math.pow(2,31);r.int=function(e){return p.isNumber(e)&&e%1===0},r.int32=function(e){return r.int(e)&&e<h&&e>=-h},r.long=function(e){return r.int(e)&&(e>=h||e<-h)},r.Long=function(e){return r.object(e)&&r.number(e.high)&&r.number(e.low)},r.double=function(e){return p.isNumber(e)&&!isNaN(e)&&e%1!==0}},{"babel-runtime/core-js/number/is-finite":19,"babel-runtime/core-js/number/is-nan":20,"babel-runtime/core-js/object/keys":30,"core-util-is":176,"is-class":200,isstream:202}],202:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}function i(e){return e instanceof l.Stream}function o(e){return i(e)&&"function"==typeof e._read&&"object"==(0,c.default)(e._readableState)}function a(e){return i(e)&&"function"==typeof e._write&&"object"==(0,c.default)(e._writableState)}function s(e){return o(e)&&a(e)}var u=e("babel-runtime/helpers/typeof"),c=n(u),l=e("stream");t.exports=i,t.exports.isReadable=o,t.exports.isWritable=a,t.exports.isDuplex=s},{"babel-runtime/helpers/typeof":39,stream:369}],203:[function(e,t,r){"use strict";var n=e("./_getNative"),i=e("./_root"),o=n(i,"DataView");t.exports=o},{"./_getNative":263,"./_root":297}],204:[function(e,t,r){"use strict";function n(e){var t=-1,r=e?e.length:0;for(this.clear();++t<r;){var n=e[t];this.set(n[0],n[1])}}var i=e("./_hashClear"),o=e("./_hashDelete"),a=e("./_hashGet"),s=e("./_hashHas"),u=e("./_hashSet");n.prototype.clear=i,n.prototype.delete=o,n.prototype.get=a,n.prototype.has=s,n.prototype.set=u,t.exports=n},{"./_hashClear":267,"./_hashDelete":268,"./_hashGet":269,"./_hashHas":270,"./_hashSet":271}],205:[function(e,t,r){"use strict";function n(e){var t=-1,r=e?e.length:0;for(this.clear();++t<r;){var n=e[t];this.set(n[0],n[1])}}var i=e("./_listCacheClear"),o=e("./_listCacheDelete"),a=e("./_listCacheGet"),s=e("./_listCacheHas"),u=e("./_listCacheSet");n.prototype.clear=i,n.prototype.delete=o,n.prototype.get=a,n.prototype.has=s,n.prototype.set=u,t.exports=n},{"./_listCacheClear":279,"./_listCacheDelete":280,"./_listCacheGet":281,"./_listCacheHas":282,"./_listCacheSet":283}],206:[function(e,t,r){"use strict";var n=e("./_getNative"),i=e("./_root"),o=n(i,"Map");t.exports=o},{"./_getNative":263,"./_root":297}],207:[function(e,t,r){"use strict";function n(e){var t=-1,r=e?e.length:0;for(this.clear();++t<r;){var n=e[t];this.set(n[0],n[1])}}var i=e("./_mapCacheClear"),o=e("./_mapCacheDelete"),a=e("./_mapCacheGet"),s=e("./_mapCacheHas"),u=e("./_mapCacheSet");n.prototype.clear=i,n.prototype.delete=o,n.prototype.get=a,n.prototype.has=s,n.prototype.set=u,t.exports=n},{"./_mapCacheClear":284,"./_mapCacheDelete":285,"./_mapCacheGet":286,"./_mapCacheHas":287,"./_mapCacheSet":288}],208:[function(e,t,r){"use strict";var n=e("./_getNative"),i=e("./_root"),o=n(i,"Promise");t.exports=o},{"./_getNative":263,"./_root":297}],209:[function(e,t,r){"use strict";var n=e("./_getNative"),i=e("./_root"),o=n(i,"Set");t.exports=o},{"./_getNative":263,"./_root":297}],210:[function(e,t,r){"use strict";function n(e){var t=-1,r=e?e.length:0;for(this.__data__=new i;++t<r;)this.add(e[t])}var i=e("./_MapCache"),o=e("./_setCacheAdd"),a=e("./_setCacheHas");n.prototype.add=n.prototype.push=o,n.prototype.has=a,t.exports=n},{"./_MapCache":207,"./_setCacheAdd":298,"./_setCacheHas":299}],211:[function(e,t,r){"use strict";function n(e){var t=this.__data__=new i(e);this.size=t.size}var i=e("./_ListCache"),o=e("./_stackClear"),a=e("./_stackDelete"),s=e("./_stackGet"),u=e("./_stackHas"),c=e("./_stackSet");n.prototype.clear=o,n.prototype.delete=a,n.prototype.get=s,n.prototype.has=u,n.prototype.set=c,t.exports=n},{"./_ListCache":205,"./_stackClear":303,"./_stackDelete":304,"./_stackGet":305,"./_stackHas":306,"./_stackSet":307}],212:[function(e,t,r){"use strict";var n=e("./_root"),i=n.Symbol;t.exports=i},{"./_root":297}],213:[function(e,t,r){"use strict";var n=e("./_root"),i=n.Uint8Array;t.exports=i},{"./_root":297}],214:[function(e,t,r){"use strict";var n=e("./_getNative"),i=e("./_root"),o=n(i,"WeakMap");t.exports=o},{"./_getNative":263,"./_root":297}],215:[function(e,t,r){"use strict";function n(e,t,r){switch(r.length){case 0:return e.call(t);case 1:return e.call(t,r[0]);case 2:return e.call(t,r[0],r[1]);case 3:return e.call(t,r[0],r[1],r[2])}return e.apply(t,r)}t.exports=n},{}],216:[function(e,t,r){"use strict";function n(e,t){for(var r=-1,n=e?e.length:0;++r<n;)if(!t(e[r],r,e))return!1;return!0}t.exports=n},{}],217:[function(e,t,r){"use strict";function n(e,t){var r=a(e),n=!r&&o(e),l=!r&&!n&&s(e),f=!r&&!n&&!l&&c(e),d=r||n||l||f,h=d?i(e.length,String):[],m=h.length;for(var b in e)!t&&!p.call(e,b)||d&&("length"==b||l&&("offset"==b||"parent"==b)||f&&("buffer"==b||"byteLength"==b||"byteOffset"==b)||u(b,m))||h.push(b);return h}var i=e("./_baseTimes"),o=e("./isArguments"),a=e("./isArray"),s=e("./isBuffer"),u=e("./_isIndex"),c=e("./isTypedArray"),l=Object.prototype,p=l.hasOwnProperty;t.exports=n},{"./_baseTimes":246,"./_isIndex":272,"./isArguments":319,"./isArray":320,"./isBuffer":322,"./isTypedArray":329}],218:[function(e,t,r){"use strict";function n(e,t){for(var r=-1,n=e?e.length:0,i=Array(n);++r<n;)i[r]=t(e[r],r,e);return i}t.exports=n},{}],219:[function(e,t,r){"use strict";function n(e,t){for(var r=-1,n=e?e.length:0;++r<n;)if(t(e[r],r,e))return!0;return!1}t.exports=n},{}],220:[function(e,t,r){"use strict";function n(e,t,r){var n=e[t];s.call(e,t)&&o(n,r)&&(void 0!==r||t in e)||i(e,t,r)}var i=e("./_baseAssignValue"),o=e("./eq"),a=Object.prototype,s=a.hasOwnProperty;t.exports=n},{"./_baseAssignValue":223,"./eq":314}],221:[function(e,t,r){"use strict";function n(e,t){for(var r=e.length;r--;)if(i(e[r][0],t))return r;return-1}var i=e("./eq");t.exports=n},{"./eq":314}],222:[function(e,t,r){"use strict";function n(e,t){return e&&i(t,o(t),e)}var i=e("./_copyObject"),o=e("./keys");t.exports=n},{"./_copyObject":251,"./keys":330}],223:[function(e,t,r){"use strict";function n(e,t,r){"__proto__"==t&&i?i(e,t,{configurable:!0,enumerable:!0,value:r,writable:!0}):e[t]=r}var i=e("./_defineProperty");t.exports=n},{"./_defineProperty":256}],224:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}var i=e("babel-runtime/core-js/object/create"),o=n(i),a=e("./isObject"),s=o.default,u=function(){function e(){}return function(t){if(!a(t))return{};if(s)return s(t);e.prototype=t;var r=new e;return e.prototype=void 0,r}}();t.exports=u},{"./isObject":326,"babel-runtime/core-js/object/create":22}],225:[function(e,t,r){"use strict";var n=e("./_baseForOwn"),i=e("./_createBaseEach"),o=i(n);t.exports=o},{"./_baseForOwn":228,"./_createBaseEach":254}],226:[function(e,t,r){"use strict";function n(e,t){var r=!0;return i(e,function(e,n,i){return r=!!t(e,n,i)}),r}var i=e("./_baseEach");t.exports=n},{"./_baseEach":225}],227:[function(e,t,r){"use strict";var n=e("./_createBaseFor"),i=n();t.exports=i},{"./_createBaseFor":255}],228:[function(e,t,r){"use strict";function n(e,t){return e&&i(e,t,o)}var i=e("./_baseFor"),o=e("./keys");t.exports=n},{"./_baseFor":227,"./keys":330}],229:[function(e,t,r){"use strict";function n(e,t){t=o(t,e)?[t]:i(t);for(var r=0,n=t.length;null!=e&&r<n;)e=e[a(t[r++])];return r&&r==n?e:void 0}var i=e("./_castPath"),o=e("./_isKey"),a=e("./_toKey");t.exports=n},{"./_castPath":250,"./_isKey":274,"./_toKey":309}],230:[function(e,t,r){"use strict";function n(e){return o.call(e)}var i=Object.prototype,o=i.toString;t.exports=n},{}],231:[function(e,t,r){"use strict";function n(e,t){return null!=e&&t in Object(e)}t.exports=n},{}],232:[function(e,t,r){"use strict";function n(e){return i(e)&&s.call(e)==o}var i=e("./isObjectLike"),o="[object Arguments]",a=Object.prototype,s=a.toString;t.exports=n},{"./isObjectLike":327}],233:[function(e,t,r){"use strict";function n(e,t,r,s,u){return e===t||(null==e||null==t||!o(e)&&!a(t)?e!==e&&t!==t:i(e,t,n,r,s,u))}var i=e("./_baseIsEqualDeep"),o=e("./isObject"),a=e("./isObjectLike");t.exports=n},{"./_baseIsEqualDeep":234,"./isObject":326,"./isObjectLike":327}],234:[function(e,t,r){"use strict";function n(e,t,r,n,b,g){var y=c(e),_=c(t),x=h,w=h;y||(x=u(e),x=x==d?m:x),_||(w=u(t),w=w==d?m:w);var E=x==m,j=w==m,S=x==w;if(S&&l(e)){if(!l(t))return!1;y=!0,E=!1}if(S&&!E)return g||(g=new i),y||p(e)?o(e,t,r,n,b,g):a(e,t,x,r,n,b,g);if(!(b&f)){var T=E&&v.call(e,"__wrapped__"),k=j&&v.call(t,"__wrapped__");if(T||k){var A=T?e.value():e,O=k?t.value():t;return g||(g=new i),r(A,O,n,b,g)}}return!!S&&(g||(g=new i),s(e,t,r,n,b,g))}var i=e("./_Stack"),o=e("./_equalArrays"),a=e("./_equalByTag"),s=e("./_equalObjects"),u=e("./_getTag"),c=e("./isArray"),l=e("./isBuffer"),p=e("./isTypedArray"),f=2,d="[object Arguments]",h="[object Array]",m="[object Object]",b=Object.prototype,v=b.hasOwnProperty;t.exports=n},{"./_Stack":211,"./_equalArrays":257,"./_equalByTag":258,"./_equalObjects":259,"./_getTag":264,"./isArray":320,"./isBuffer":322,"./isTypedArray":329}],235:[function(e,t,r){"use strict";function n(e,t,r,n){var u=r.length,c=u,l=!n;if(null==e)return!c;for(e=Object(e);u--;){var p=r[u];if(l&&p[2]?p[1]!==e[p[0]]:!(p[0]in e))return!1}for(;++u<c;){p=r[u];var f=p[0],d=e[f],h=p[1];if(l&&p[2]){if(void 0===d&&!(f in e))return!1}else{var m=new i;if(n)var b=n(d,h,f,e,t,m);if(!(void 0===b?o(h,d,n,a|s,m):b))return!1}}return!0}var i=e("./_Stack"),o=e("./_baseIsEqual"),a=1,s=2;t.exports=n},{"./_Stack":211,"./_baseIsEqual":233}],236:[function(e,t,r){"use strict";function n(e){if(!a(e)||o(e))return!1;var t=i(e)?h:c;return t.test(s(e))}var i=e("./isFunction"),o=e("./_isMasked"),a=e("./isObject"),s=e("./_toSource"),u=/[\\^$.*+?()[\]{}|]/g,c=/^\[object .+?Constructor\]$/,l=Function.prototype,p=Object.prototype,f=l.toString,d=p.hasOwnProperty,h=RegExp("^"+f.call(d).replace(u,"\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g,"$1.*?")+"$");t.exports=n},{"./_isMasked":276,"./_toSource":310,"./isFunction":324,"./isObject":326}],237:[function(e,t,r){"use strict";function n(e){return o(e)&&i(e.length)&&!!R[C.call(e)]}var i=e("./isLength"),o=e("./isObjectLike"),a="[object Arguments]",s="[object Array]",u="[object Boolean]",c="[object Date]",l="[object Error]",p="[object Function]",f="[object Map]",d="[object Number]",h="[object Object]",m="[object RegExp]",b="[object Set]",v="[object String]",g="[object WeakMap]",y="[object ArrayBuffer]",_="[object DataView]",x="[object Float32Array]",w="[object Float64Array]",E="[object Int8Array]",j="[object Int16Array]",S="[object Int32Array]",T="[object Uint8Array]",k="[object Uint8ClampedArray]",A="[object Uint16Array]",O="[object Uint32Array]",R={};R[x]=R[w]=R[E]=R[j]=R[S]=R[T]=R[k]=R[A]=R[O]=!0,R[a]=R[s]=R[y]=R[u]=R[_]=R[c]=R[l]=R[p]=R[f]=R[d]=R[h]=R[m]=R[b]=R[v]=R[g]=!1;var I=Object.prototype,C=I.toString;t.exports=n},{"./isLength":325,"./isObjectLike":327}],238:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}function i(e){return"function"==typeof e?e:null==e?c:"object"==("undefined"==typeof e?"undefined":(0,a.default)(e))?l(e)?u(e[0],e[1]):s(e):p(e)}var o=e("babel-runtime/helpers/typeof"),a=n(o),s=e("./_baseMatches"),u=e("./_baseMatchesProperty"),c=e("./identity"),l=e("./isArray"),p=e("./property");t.exports=i},{"./_baseMatches":240,"./_baseMatchesProperty":241,"./identity":318,"./isArray":320,"./property":332,"babel-runtime/helpers/typeof":39}],239:[function(e,t,r){"use strict";function n(e){if(!i(e))return o(e);var t=[];for(var r in Object(e))s.call(e,r)&&"constructor"!=r&&t.push(r);return t}var i=e("./_isPrototype"),o=e("./_nativeKeys"),a=Object.prototype,s=a.hasOwnProperty;t.exports=n},{"./_isPrototype":277,"./_nativeKeys":293}],240:[function(e,t,r){"use strict";function n(e){var t=o(e);return 1==t.length&&t[0][2]?a(t[0][0],t[0][1]):function(r){return r===e||i(r,e,t)}}var i=e("./_baseIsMatch"),o=e("./_getMatchData"),a=e("./_matchesStrictComparable");t.exports=n},{"./_baseIsMatch":235,"./_getMatchData":262,"./_matchesStrictComparable":290}],241:[function(e,t,r){"use strict";function n(e,t){return s(e)&&u(t)?c(l(e),t):function(r){var n=o(r,e);return void 0===n&&n===t?a(r,e):i(t,n,void 0,p|f)}}var i=e("./_baseIsEqual"),o=e("./get"),a=e("./hasIn"),s=e("./_isKey"),u=e("./_isStrictComparable"),c=e("./_matchesStrictComparable"),l=e("./_toKey"),p=1,f=2;t.exports=n},{"./_baseIsEqual":233,"./_isKey":274,"./_isStrictComparable":278,"./_matchesStrictComparable":290,"./_toKey":309,"./get":316,"./hasIn":317}],242:[function(e,t,r){"use strict";function n(e){return function(t){return null==t?void 0:t[e]}}t.exports=n},{}],243:[function(e,t,r){"use strict";function n(e){return function(t){return i(t,e)}}var i=e("./_baseGet");t.exports=n},{"./_baseGet":229}],244:[function(e,t,r){"use strict";function n(e,t){return a(o(e,t,i),e+"")}var i=e("./identity"),o=e("./_overRest"),a=e("./_setToString");t.exports=n},{"./_overRest":296,"./_setToString":301,"./identity":318}],245:[function(e,t,r){"use strict";var n=e("./constant"),i=e("./_defineProperty"),o=e("./identity"),a=i?function(e,t){return i(e,"toString",{configurable:!0,enumerable:!1,value:n(t),writable:!0})}:o;t.exports=a},{"./_defineProperty":256,"./constant":312,"./identity":318}],246:[function(e,t,r){"use strict";function n(e,t){for(var r=-1,n=Array(e);++r<e;)n[r]=t(r);return n}t.exports=n},{}],247:[function(e,t,r){"use strict";function n(e){if("string"==typeof e)return e;if(a(e))return o(e,n)+"";if(s(e))return l?l.call(e):"";var t=e+"";return"0"==t&&1/e==-u?"-0":t}var i=e("./_Symbol"),o=e("./_arrayMap"),a=e("./isArray"),s=e("./isSymbol"),u=1/0,c=i?i.prototype:void 0,l=c?c.toString:void 0;t.exports=n},{"./_Symbol":212,"./_arrayMap":218,"./isArray":320,"./isSymbol":328}],248:[function(e,t,r){"use strict";function n(e){return function(t){return e(t)}}t.exports=n},{}],249:[function(e,t,r){"use strict";function n(e,t){return e.has(t)}t.exports=n},{}],250:[function(e,t,r){"use strict";function n(e){return i(e)?e:o(e)}var i=e("./isArray"),o=e("./_stringToPath");t.exports=n},{"./_stringToPath":308,"./isArray":320}],251:[function(e,t,r){"use strict";function n(e,t,r,n){var a=!r;r||(r={});for(var s=-1,u=t.length;++s<u;){var c=t[s],l=n?n(r[c],e[c],c,r,e):void 0;void 0===l&&(l=e[c]),a?o(r,c,l):i(r,c,l)}return r}var i=e("./_assignValue"),o=e("./_baseAssignValue");t.exports=n},{"./_assignValue":220,"./_baseAssignValue":223}],252:[function(e,t,r){"use strict";var n=e("./_root"),i=n["__core-js_shared__"];t.exports=i},{"./_root":297}],253:[function(e,t,r){"use strict";function n(e){return i(function(t,r){var n=-1,i=r.length,a=i>1?r[i-1]:void 0,s=i>2?r[2]:void 0;for(a=e.length>3&&"function"==typeof a?(i--,a):void 0,s&&o(r[0],r[1],s)&&(a=i<3?void 0:a,i=1),t=Object(t);++n<i;){var u=r[n];u&&e(t,u,n,a)}return t})}var i=e("./_baseRest"),o=e("./_isIterateeCall");t.exports=n},{"./_baseRest":244,"./_isIterateeCall":273}],254:[function(e,t,r){"use strict";function n(e,t){return function(r,n){if(null==r)return r;if(!i(r))return e(r,n);for(var o=r.length,a=t?o:-1,s=Object(r);(t?a--:++a<o)&&n(s[a],a,s)!==!1;);return r}}var i=e("./isArrayLike");t.exports=n},{"./isArrayLike":321}],255:[function(e,t,r){"use strict";function n(e){return function(t,r,n){for(var i=-1,o=Object(t),a=n(t),s=a.length;s--;){var u=a[e?s:++i];if(r(o[u],u,o)===!1)break}return t}}t.exports=n},{}],256:[function(e,t,r){"use strict";var n=e("./_getNative"),i=function(){try{var e=n(Object,"defineProperty");return e({},"",{}),e}catch(e){}}();t.exports=i},{"./_getNative":263}],257:[function(e,t,r){"use strict";function n(e,t,r,n,c,l){var p=c&u,f=e.length,d=t.length;if(f!=d&&!(p&&d>f))return!1;var h=l.get(e);if(h&&l.get(t))return h==t;var m=-1,b=!0,v=c&s?new i:void 0;for(l.set(e,t),l.set(t,e);++m<f;){var g=e[m],y=t[m];if(n)var _=p?n(y,g,m,t,e,l):n(g,y,m,e,t,l);if(void 0!==_){if(_)continue;b=!1;break}if(v){if(!o(t,function(e,t){if(!a(v,t)&&(g===e||r(g,e,n,c,l)))return v.push(t)})){b=!1;break}}else if(g!==y&&!r(g,y,n,c,l)){b=!1;break}}return l.delete(e),l.delete(t),b}var i=e("./_SetCache"),o=e("./_arraySome"),a=e("./_cacheHas"),s=1,u=2;t.exports=n},{"./_SetCache":210,"./_arraySome":219,"./_cacheHas":249}],258:[function(e,t,r){"use strict";function n(e,t,r,n,i,E,S){switch(r){case w:if(e.byteLength!=t.byteLength||e.byteOffset!=t.byteOffset)return!1;e=e.buffer,t=t.buffer;case x:return!(e.byteLength!=t.byteLength||!n(new o(e),new o(t)));case f:case d:case b:return a(+e,+t);case h:return e.name==t.name&&e.message==t.message;case v:case y:return e==t+"";case m:var T=u;case g:var k=E&p;if(T||(T=c),e.size!=t.size&&!k)return!1;var A=S.get(e);if(A)return A==t;E|=l,S.set(e,t);var O=s(T(e),T(t),n,i,E,S);return S.delete(e),O;case _:if(j)return j.call(e)==j.call(t)}return!1}var i=e("./_Symbol"),o=e("./_Uint8Array"),a=e("./eq"),s=e("./_equalArrays"),u=e("./_mapToArray"),c=e("./_setToArray"),l=1,p=2,f="[object Boolean]",d="[object Date]",h="[object Error]",m="[object Map]",b="[object Number]",v="[object RegExp]",g="[object Set]",y="[object String]",_="[object Symbol]",x="[object ArrayBuffer]",w="[object DataView]",E=i?i.prototype:void 0,j=E?E.valueOf:void 0;t.exports=n},{"./_Symbol":212,"./_Uint8Array":213,"./_equalArrays":257,"./_mapToArray":289,"./_setToArray":300,"./eq":314}],259:[function(e,t,r){"use strict";function n(e,t,r,n,a,u){var c=a&o,l=i(e),p=l.length,f=i(t),d=f.length;if(p!=d&&!c)return!1;for(var h=p;h--;){var m=l[h];if(!(c?m in t:s.call(t,m)))return!1}var b=u.get(e);if(b&&u.get(t))return b==t;var v=!0;u.set(e,t),u.set(t,e);for(var g=c;++h<p;){m=l[h];var y=e[m],_=t[m];if(n)var x=c?n(_,y,m,t,e,u):n(y,_,m,e,t,u);if(!(void 0===x?y===_||r(y,_,n,a,u):x)){v=!1;break}g||(g="constructor"==m)}if(v&&!g){var w=e.constructor,E=t.constructor;w!=E&&"constructor"in e&&"constructor"in t&&!("function"==typeof w&&w instanceof w&&"function"==typeof E&&E instanceof E)&&(v=!1)}return u.delete(e),u.delete(t),v}var i=e("./keys"),o=2,a=Object.prototype,s=a.hasOwnProperty;t.exports=n},{"./keys":330}],260:[function(e,t,r){(function(r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}var i=e("babel-runtime/helpers/typeof"),o=n(i),a="object"==("undefined"==typeof r?"undefined":(0,o.default)(r))&&r&&r.Object===Object&&r;t.exports=a}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{"babel-runtime/helpers/typeof":39}],261:[function(e,t,r){"use strict";function n(e,t){var r=e.__data__;return i(t)?r["string"==typeof t?"string":"hash"]:r.map}var i=e("./_isKeyable");t.exports=n},{"./_isKeyable":275}],262:[function(e,t,r){"use strict";function n(e){for(var t=o(e),r=t.length;r--;){var n=t[r],a=e[n];t[r]=[n,a,i(a)]}return t}var i=e("./_isStrictComparable"),o=e("./keys");t.exports=n},{"./_isStrictComparable":278,"./keys":330}],263:[function(e,t,r){"use strict";function n(e,t){var r=o(e,t);return i(r)?r:void 0}var i=e("./_baseIsNative"),o=e("./_getValue");t.exports=n},{"./_baseIsNative":236,"./_getValue":265}],264:[function(e,t,r){"use strict";var n=e("./_DataView"),i=e("./_Map"),o=e("./_Promise"),a=e("./_Set"),s=e("./_WeakMap"),u=e("./_baseGetTag"),c=e("./_toSource"),l="[object Map]",p="[object Object]",f="[object Promise]",d="[object Set]",h="[object WeakMap]",m="[object DataView]",b=Object.prototype,v=b.toString,g=c(n),y=c(i),_=c(o),x=c(a),w=c(s),E=u;(n&&E(new n(new ArrayBuffer(1)))!=m||i&&E(new i)!=l||o&&E(o.resolve())!=f||a&&E(new a)!=d||s&&E(new s)!=h)&&(E=function(e){var t=v.call(e),r=t==p?e.constructor:void 0,n=r?c(r):void 0;if(n)switch(n){case g:return m;case y:return l;case _:return f;case x:return d;case w:return h}return t}),t.exports=E},{"./_DataView":203,"./_Map":206,"./_Promise":208,"./_Set":209,"./_WeakMap":214,"./_baseGetTag":230,"./_toSource":310}],265:[function(e,t,r){"use strict";function n(e,t){return null==e?void 0:e[t]}t.exports=n},{}],266:[function(e,t,r){"use strict";function n(e,t,r){t=u(t,e)?[t]:i(t);for(var n=-1,p=t.length,f=!1;++n<p;){var d=l(t[n]);if(!(f=null!=e&&r(e,d)))break;e=e[d]}return f||++n!=p?f:(p=e?e.length:0,!!p&&c(p)&&s(d,p)&&(a(e)||o(e)))}var i=e("./_castPath"),o=e("./isArguments"),a=e("./isArray"),s=e("./_isIndex"),u=e("./_isKey"),c=e("./isLength"),l=e("./_toKey");t.exports=n},{"./_castPath":250,"./_isIndex":272,"./_isKey":274,"./_toKey":309,"./isArguments":319,"./isArray":320,"./isLength":325}],267:[function(e,t,r){"use strict";function n(){this.__data__=i?i(null):{},this.size=0}var i=e("./_nativeCreate");t.exports=n},{"./_nativeCreate":292}],268:[function(e,t,r){"use strict";function n(e){var t=this.has(e)&&delete this.__data__[e];return this.size-=t?1:0,t}t.exports=n},{}],269:[function(e,t,r){"use strict";function n(e){var t=this.__data__;if(i){var r=t[e];return r===o?void 0:r}return s.call(t,e)?t[e]:void 0}var i=e("./_nativeCreate"),o="__lodash_hash_undefined__",a=Object.prototype,s=a.hasOwnProperty;t.exports=n},{"./_nativeCreate":292}],270:[function(e,t,r){"use strict";function n(e){var t=this.__data__;return i?void 0!==t[e]:a.call(t,e)}var i=e("./_nativeCreate"),o=Object.prototype,a=o.hasOwnProperty;t.exports=n},{"./_nativeCreate":292}],271:[function(e,t,r){"use strict";function n(e,t){var r=this.__data__;return this.size+=this.has(e)?0:1,r[e]=i&&void 0===t?o:t,this}var i=e("./_nativeCreate"),o="__lodash_hash_undefined__";t.exports=n},{"./_nativeCreate":292}],272:[function(e,t,r){"use strict";function n(e,t){return t=null==t?i:t,!!t&&("number"==typeof e||o.test(e))&&e>-1&&e%1==0&&e<t}var i=9007199254740991,o=/^(?:0|[1-9]\d*)$/;t.exports=n},{}],273:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}function i(e,t,r){if(!l(r))return!1;var n="undefined"==typeof t?"undefined":(0,a.default)(t);return!!("number"==n?u(r)&&c(t,r.length):"string"==n&&t in r)&&s(r[t],e)}var o=e("babel-runtime/helpers/typeof"),a=n(o),s=e("./eq"),u=e("./isArrayLike"),c=e("./_isIndex"),l=e("./isObject");t.exports=i},{"./_isIndex":272,"./eq":314,"./isArrayLike":321,"./isObject":326,"babel-runtime/helpers/typeof":39}],274:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}function i(e,t){if(s(e))return!1;var r="undefined"==typeof e?"undefined":(0,a.default)(e);return!("number"!=r&&"symbol"!=r&&"boolean"!=r&&null!=e&&!u(e))||(l.test(e)||!c.test(e)||null!=t&&e in Object(t))}var o=e("babel-runtime/helpers/typeof"),a=n(o),s=e("./isArray"),u=e("./isSymbol"),c=/\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,l=/^\w*$/;t.exports=i},{"./isArray":320,"./isSymbol":328,"babel-runtime/helpers/typeof":39}],275:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}function i(e){var t="undefined"==typeof e?"undefined":(0,a.default)(e);return"string"==t||"number"==t||"symbol"==t||"boolean"==t?"__proto__"!==e:null===e}var o=e("babel-runtime/helpers/typeof"),a=n(o);t.exports=i},{"babel-runtime/helpers/typeof":39}],276:[function(e,t,r){"use strict";function n(e){return!!o&&o in e}var i=e("./_coreJsData"),o=function(){var e=/[^.]+$/.exec(i&&i.keys&&i.keys.IE_PROTO||"");return e?"Symbol(src)_1."+e:""}();t.exports=n},{"./_coreJsData":252}],277:[function(e,t,r){"use strict";function n(e){var t=e&&e.constructor,r="function"==typeof t&&t.prototype||i;return e===r}var i=Object.prototype;t.exports=n},{}],278:[function(e,t,r){"use strict";function n(e){return e===e&&!i(e)}var i=e("./isObject");t.exports=n},{"./isObject":326}],279:[function(e,t,r){"use strict";function n(){this.__data__=[],this.size=0}t.exports=n},{}],280:[function(e,t,r){"use strict";function n(e){var t=this.__data__,r=i(t,e);if(r<0)return!1;var n=t.length-1;return r==n?t.pop():a.call(t,r,1),--this.size,!0}var i=e("./_assocIndexOf"),o=Array.prototype,a=o.splice;t.exports=n},{"./_assocIndexOf":221}],281:[function(e,t,r){"use strict";function n(e){var t=this.__data__,r=i(t,e);return r<0?void 0:t[r][1]}var i=e("./_assocIndexOf");t.exports=n},{"./_assocIndexOf":221}],282:[function(e,t,r){"use strict";function n(e){return i(this.__data__,e)>-1}var i=e("./_assocIndexOf");t.exports=n},{"./_assocIndexOf":221}],283:[function(e,t,r){"use strict";function n(e,t){var r=this.__data__,n=i(r,e);return n<0?(++this.size,r.push([e,t])):r[n][1]=t,this}var i=e("./_assocIndexOf");t.exports=n},{"./_assocIndexOf":221}],284:[function(e,t,r){"use strict";function n(){this.size=0,this.__data__={hash:new i,map:new(a||o),string:new i}}var i=e("./_Hash"),o=e("./_ListCache"),a=e("./_Map");t.exports=n},{"./_Hash":204,"./_ListCache":205,"./_Map":206}],285:[function(e,t,r){"use strict";function n(e){var t=i(this,e).delete(e);return this.size-=t?1:0,t}var i=e("./_getMapData");t.exports=n},{"./_getMapData":261}],286:[function(e,t,r){"use strict";function n(e){return i(this,e).get(e)}var i=e("./_getMapData");t.exports=n},{"./_getMapData":261}],287:[function(e,t,r){"use strict";function n(e){return i(this,e).has(e)}var i=e("./_getMapData");t.exports=n},{"./_getMapData":261}],288:[function(e,t,r){"use strict";function n(e,t){var r=i(this,e),n=r.size;return r.set(e,t),this.size+=r.size==n?0:1,this}var i=e("./_getMapData");t.exports=n},{"./_getMapData":261}],289:[function(e,t,r){"use strict";function n(e){var t=-1,r=Array(e.size);return e.forEach(function(e,n){r[++t]=[n,e]}),r}t.exports=n},{}],290:[function(e,t,r){"use strict";function n(e,t){return function(r){return null!=r&&(r[e]===t&&(void 0!==t||e in Object(r)))}}t.exports=n},{}],291:[function(e,t,r){"use strict";function n(e){var t=i(e,function(e){return r.size===o&&r.clear(),e}),r=t.cache;return t}var i=e("./memoize"),o=500;t.exports=n},{"./memoize":331}],292:[function(e,t,r){"use strict";var n=e("./_getNative"),i=n(Object,"create");t.exports=i},{"./_getNative":263}],293:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}var i=e("babel-runtime/core-js/object/keys"),o=n(i),a=e("./_overArg"),s=a(o.default,Object);t.exports=s},{"./_overArg":295,"babel-runtime/core-js/object/keys":30}],294:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}var i=e("babel-runtime/helpers/typeof"),o=n(i),a=e("./_freeGlobal"),s="object"==("undefined"==typeof r?"undefined":(0,o.default)(r))&&r&&!r.nodeType&&r,u=s&&"object"==("undefined"==typeof t?"undefined":(0,o.default)(t))&&t&&!t.nodeType&&t,c=u&&u.exports===s,l=c&&a.process,p=function(){try{return l&&l.binding("util")}catch(e){}}();t.exports=p},{"./_freeGlobal":260,"babel-runtime/helpers/typeof":39}],295:[function(e,t,r){"use strict";function n(e,t){return function(r){return e(t(r))}}t.exports=n},{}],296:[function(e,t,r){"use strict";function n(e,t,r){return t=o(void 0===t?e.length-1:t,0),function(){for(var n=arguments,a=-1,s=o(n.length-t,0),u=Array(s);++a<s;)u[a]=n[t+a];a=-1;for(var c=Array(t+1);++a<t;)c[a]=n[a];return c[t]=r(u),i(e,this,c)}}var i=e("./_apply"),o=Math.max;t.exports=n},{"./_apply":215}],297:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}var i=e("babel-runtime/helpers/typeof"),o=n(i),a=e("./_freeGlobal"),s="object"==("undefined"==typeof self?"undefined":(0,o.default)(self))&&self&&self.Object===Object&&self,u=a||s||Function("return this")();t.exports=u},{"./_freeGlobal":260,"babel-runtime/helpers/typeof":39}],298:[function(e,t,r){"use strict";function n(e){return this.__data__.set(e,i),this}var i="__lodash_hash_undefined__";t.exports=n},{}],299:[function(e,t,r){"use strict";function n(e){return this.__data__.has(e)}t.exports=n},{}],300:[function(e,t,r){"use strict";function n(e){var t=-1,r=Array(e.size);return e.forEach(function(e){r[++t]=e}),r}t.exports=n},{}],301:[function(e,t,r){"use strict";var n=e("./_baseSetToString"),i=e("./_shortOut"),o=i(n);t.exports=o},{"./_baseSetToString":245,"./_shortOut":302}],302:[function(e,t,r){"use strict";function n(e){var t=0,r=0;return function(){var n=a(),s=o-(n-r);if(r=n,s>0){if(++t>=i)return arguments[0]}else t=0;return e.apply(void 0,arguments)}}var i=500,o=16,a=Date.now;t.exports=n},{}],303:[function(e,t,r){"use strict";function n(){this.__data__=new i,this.size=0}var i=e("./_ListCache");t.exports=n},{"./_ListCache":205}],304:[function(e,t,r){"use strict";function n(e){var t=this.__data__,r=t.delete(e);return this.size=t.size,r}t.exports=n},{}],305:[function(e,t,r){"use strict";function n(e){return this.__data__.get(e)}t.exports=n},{}],306:[function(e,t,r){"use strict";function n(e){return this.__data__.has(e)}t.exports=n},{}],307:[function(e,t,r){"use strict";function n(e,t){var r=this.__data__;if(r instanceof i){var n=r.__data__;if(!o||n.length<s-1)return n.push([e,t]),this.size=++r.size,this;r=this.__data__=new a(n)}return r.set(e,t),this.size=r.size,this}var i=e("./_ListCache"),o=e("./_Map"),a=e("./_MapCache"),s=200;t.exports=n},{"./_ListCache":205,"./_Map":206,"./_MapCache":207}],308:[function(e,t,r){"use strict";var n=e("./_memoizeCapped"),i=e("./toString"),o=/^\./,a=/[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g,s=/\\(\\)?/g,u=n(function(e){e=i(e);var t=[];return o.test(e)&&t.push(""),e.replace(a,function(e,r,n,i){t.push(n?i.replace(s,"$1"):r||e)}),t});t.exports=u},{"./_memoizeCapped":291,"./toString":334}],309:[function(e,t,r){"use strict";function n(e){if("string"==typeof e||i(e))return e;var t=e+"";return"0"==t&&1/e==-o?"-0":t}var i=e("./isSymbol"),o=1/0;t.exports=n},{"./isSymbol":328}],310:[function(e,t,r){"use strict";function n(e){if(null!=e){try{return o.call(e)}catch(e){}try{return e+""}catch(e){}}return""}var i=Function.prototype,o=i.toString;t.exports=n},{}],311:[function(e,t,r){"use strict";var n=e("./_assignValue"),i=e("./_copyObject"),o=e("./_createAssigner"),a=e("./isArrayLike"),s=e("./_isPrototype"),u=e("./keys"),c=Object.prototype,l=c.hasOwnProperty,p=o(function(e,t){if(s(t)||a(t))return void i(t,u(t),e);for(var r in t)l.call(t,r)&&n(e,r,t[r])});t.exports=p},{"./_assignValue":220,"./_copyObject":251,"./_createAssigner":253,"./_isPrototype":277,"./isArrayLike":321,"./keys":330}],312:[function(e,t,r){"use strict";function n(e){return function(){return e}}t.exports=n},{}],313:[function(e,t,r){"use strict";function n(e,t){var r=o(e);return t?i(r,t):r}var i=e("./_baseAssign"),o=e("./_baseCreate");t.exports=n},{"./_baseAssign":222,"./_baseCreate":224}],314:[function(e,t,r){"use strict";function n(e,t){return e===t||e!==e&&t!==t}t.exports=n},{}],315:[function(e,t,r){"use strict";function n(e,t,r){var n=s(e)?i:o;return r&&u(e,t,r)&&(t=void 0),n(e,a(t,3))}var i=e("./_arrayEvery"),o=e("./_baseEvery"),a=e("./_baseIteratee"),s=e("./isArray"),u=e("./_isIterateeCall");
+t.exports=n},{"./_arrayEvery":216,"./_baseEvery":226,"./_baseIteratee":238,"./_isIterateeCall":273,"./isArray":320}],316:[function(e,t,r){"use strict";function n(e,t,r){var n=null==e?void 0:i(e,t);return void 0===n?r:n}var i=e("./_baseGet");t.exports=n},{"./_baseGet":229}],317:[function(e,t,r){"use strict";function n(e,t){return null!=e&&o(e,t,i)}var i=e("./_baseHasIn"),o=e("./_hasPath");t.exports=n},{"./_baseHasIn":231,"./_hasPath":266}],318:[function(e,t,r){"use strict";function n(e){return e}t.exports=n},{}],319:[function(e,t,r){"use strict";var n=e("./_baseIsArguments"),i=e("./isObjectLike"),o=Object.prototype,a=o.hasOwnProperty,s=o.propertyIsEnumerable,u=n(function(){return arguments}())?n:function(e){return i(e)&&a.call(e,"callee")&&!s.call(e,"callee")};t.exports=u},{"./_baseIsArguments":232,"./isObjectLike":327}],320:[function(e,t,r){"use strict";var n=Array.isArray;t.exports=n},{}],321:[function(e,t,r){"use strict";function n(e){return null!=e&&o(e.length)&&!i(e)}var i=e("./isFunction"),o=e("./isLength");t.exports=n},{"./isFunction":324,"./isLength":325}],322:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}var i=e("babel-runtime/helpers/typeof"),o=n(i),a=e("./_root"),s=e("./stubFalse"),u="object"==("undefined"==typeof r?"undefined":(0,o.default)(r))&&r&&!r.nodeType&&r,c=u&&"object"==("undefined"==typeof t?"undefined":(0,o.default)(t))&&t&&!t.nodeType&&t,l=c&&c.exports===u,p=l?a.Buffer:void 0,f=p?p.isBuffer:void 0,d=f||s;t.exports=d},{"./_root":297,"./stubFalse":333,"babel-runtime/helpers/typeof":39}],323:[function(e,t,r){"use strict";function n(e){if(u(e)&&(s(e)||"string"==typeof e||"function"==typeof e.splice||c(e)||p(e)||a(e)))return!e.length;var t=o(e);if(t==f||t==d)return!e.size;if(l(e))return!i(e).length;for(var r in e)if(m.call(e,r))return!1;return!0}var i=e("./_baseKeys"),o=e("./_getTag"),a=e("./isArguments"),s=e("./isArray"),u=e("./isArrayLike"),c=e("./isBuffer"),l=e("./_isPrototype"),p=e("./isTypedArray"),f="[object Map]",d="[object Set]",h=Object.prototype,m=h.hasOwnProperty;t.exports=n},{"./_baseKeys":239,"./_getTag":264,"./_isPrototype":277,"./isArguments":319,"./isArray":320,"./isArrayLike":321,"./isBuffer":322,"./isTypedArray":329}],324:[function(e,t,r){"use strict";function n(e){var t=i(e)?c.call(e):"";return t==o||t==a||t==s}var i=e("./isObject"),o="[object Function]",a="[object GeneratorFunction]",s="[object Proxy]",u=Object.prototype,c=u.toString;t.exports=n},{"./isObject":326}],325:[function(e,t,r){"use strict";function n(e){return"number"==typeof e&&e>-1&&e%1==0&&e<=i}var i=9007199254740991;t.exports=n},{}],326:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}function i(e){var t="undefined"==typeof e?"undefined":(0,a.default)(e);return null!=e&&("object"==t||"function"==t)}var o=e("babel-runtime/helpers/typeof"),a=n(o);t.exports=i},{"babel-runtime/helpers/typeof":39}],327:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}function i(e){return null!=e&&"object"==("undefined"==typeof e?"undefined":(0,a.default)(e))}var o=e("babel-runtime/helpers/typeof"),a=n(o);t.exports=i},{"babel-runtime/helpers/typeof":39}],328:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}function i(e){return"symbol"==("undefined"==typeof e?"undefined":(0,a.default)(e))||s(e)&&l.call(e)==u}var o=e("babel-runtime/helpers/typeof"),a=n(o),s=e("./isObjectLike"),u="[object Symbol]",c=Object.prototype,l=c.toString;t.exports=i},{"./isObjectLike":327,"babel-runtime/helpers/typeof":39}],329:[function(e,t,r){"use strict";var n=e("./_baseIsTypedArray"),i=e("./_baseUnary"),o=e("./_nodeUtil"),a=o&&o.isTypedArray,s=a?i(a):n;t.exports=s},{"./_baseIsTypedArray":237,"./_baseUnary":248,"./_nodeUtil":294}],330:[function(e,t,r){"use strict";function n(e){return a(e)?i(e):o(e)}var i=e("./_arrayLikeKeys"),o=e("./_baseKeys"),a=e("./isArrayLike");t.exports=n},{"./_arrayLikeKeys":217,"./_baseKeys":239,"./isArrayLike":321}],331:[function(e,t,r){"use strict";function n(e,t){if("function"!=typeof e||t&&"function"!=typeof t)throw new TypeError(o);var r=function r(){var n=arguments,i=t?t.apply(this,n):n[0],o=r.cache;if(o.has(i))return o.get(i);var a=e.apply(this,n);return r.cache=o.set(i,a)||o,a};return r.cache=new(n.Cache||i),r}var i=e("./_MapCache"),o="Expected a function";n.Cache=i,t.exports=n},{"./_MapCache":207}],332:[function(e,t,r){"use strict";function n(e){return a(e)?i(s(e)):o(e)}var i=e("./_baseProperty"),o=e("./_basePropertyDeep"),a=e("./_isKey"),s=e("./_toKey");t.exports=n},{"./_baseProperty":242,"./_basePropertyDeep":243,"./_isKey":274,"./_toKey":309}],333:[function(e,t,r){"use strict";function n(){return!1}t.exports=n},{}],334:[function(e,t,r){"use strict";function n(e){return null==e?"":i(e)}var i=e("./_baseToString");t.exports=n},{"./_baseToString":247}],335:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}function i(e,t,r){if(!e)throw new TypeError("argument dest is required");if(!t)throw new TypeError("argument src is required");return void 0===r&&(r=!0),(0,l.default)(t).forEach(function(n){if(r||!p.call(e,n)){var i=(0,u.default)(t,n);(0,a.default)(e,n,i)}}),e}var o=e("babel-runtime/core-js/object/define-property"),a=n(o),s=e("babel-runtime/core-js/object/get-own-property-descriptor"),u=n(s),c=e("babel-runtime/core-js/object/get-own-property-names"),l=n(c);t.exports=i;var p=Object.prototype.hasOwnProperty},{"babel-runtime/core-js/object/define-property":24,"babel-runtime/core-js/object/get-own-property-descriptor":25,"babel-runtime/core-js/object/get-own-property-names":26}],336:[function(e,t,r){(function(r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}function i(){this.types=(0,a.default)(null),this.extensions=(0,a.default)(null)}var o=e("babel-runtime/core-js/object/create"),a=n(o),s=(e("path"),e("fs"));i.prototype.define=function(e){for(var t in e){for(var n=e[t],i=0;i<n.length;i++)r.env.DEBUG_MIME&&this.types[n]&&console.warn(this._loading.replace(/.*\//,""),'changes "'+n[i]+'" extension type from '+this.types[n]+" to "+t),this.types[n[i]]=t;this.extensions[t]||(this.extensions[t]=n[0])}},i.prototype.load=function(e){this._loading=e;var t={},r=s.readFileSync(e,"ascii"),n=r.split(/[\r\n]+/);n.forEach(function(e){var r=e.replace(/\s*#.*|^\s*|\s*$/g,"").split(/\s+/);t[r.shift()]=r}),this.define(t),this._loading=null},i.prototype.lookup=function(e,t){var r=e.replace(/.*[\.\/\\]/,"").toLowerCase();return this.types[r]||t||this.default_type},i.prototype.extension=function(e){var t=e.match(/^\s*([^;\s]*)(?:;|\s|$)/)[1].toLowerCase();return this.extensions[t]};var u=new i;u.define(e("./types.json")),u.default_type=u.lookup("bin"),u.Mime=i,u.charsets={lookup:function(e,t){return/^text\//.test(e)?"UTF-8":t}},t.exports=u}).call(this,e("_process"))},{"./types.json":337,_process:345,"babel-runtime/core-js/object/create":22,fs:43,path:342}],337:[function(e,t,r){t.exports={"application/andrew-inset":["ez"],"application/applixware":["aw"],"application/atom+xml":["atom"],"application/atomcat+xml":["atomcat"],"application/atomsvc+xml":["atomsvc"],"application/ccxml+xml":["ccxml"],"application/cdmi-capability":["cdmia"],"application/cdmi-container":["cdmic"],"application/cdmi-domain":["cdmid"],"application/cdmi-object":["cdmio"],"application/cdmi-queue":["cdmiq"],"application/cu-seeme":["cu"],"application/dash+xml":["mdp"],"application/davmount+xml":["davmount"],"application/docbook+xml":["dbk"],"application/dssc+der":["dssc"],"application/dssc+xml":["xdssc"],"application/ecmascript":["ecma"],"application/emma+xml":["emma"],"application/epub+zip":["epub"],"application/exi":["exi"],"application/font-tdpfr":["pfr"],"application/font-woff":["woff"],"application/font-woff2":["woff2"],"application/gml+xml":["gml"],"application/gpx+xml":["gpx"],"application/gxf":["gxf"],"application/hyperstudio":["stk"],"application/inkml+xml":["ink","inkml"],"application/ipfix":["ipfix"],"application/java-archive":["jar"],"application/java-serialized-object":["ser"],"application/java-vm":["class"],"application/javascript":["js"],"application/json":["json","map"],"application/json5":["json5"],"application/jsonml+json":["jsonml"],"application/lost+xml":["lostxml"],"application/mac-binhex40":["hqx"],"application/mac-compactpro":["cpt"],"application/mads+xml":["mads"],"application/marc":["mrc"],"application/marcxml+xml":["mrcx"],"application/mathematica":["ma","nb","mb"],"application/mathml+xml":["mathml"],"application/mbox":["mbox"],"application/mediaservercontrol+xml":["mscml"],"application/metalink+xml":["metalink"],"application/metalink4+xml":["meta4"],"application/mets+xml":["mets"],"application/mods+xml":["mods"],"application/mp21":["m21","mp21"],"application/mp4":["mp4s","m4p"],"application/msword":["doc","dot"],"application/mxf":["mxf"],"application/octet-stream":["bin","dms","lrf","mar","so","dist","distz","pkg","bpk","dump","elc","deploy","buffer"],"application/oda":["oda"],"application/oebps-package+xml":["opf"],"application/ogg":["ogx"],"application/omdoc+xml":["omdoc"],"application/onenote":["onetoc","onetoc2","onetmp","onepkg"],"application/oxps":["oxps"],"application/patch-ops-error+xml":["xer"],"application/pdf":["pdf"],"application/pgp-encrypted":["pgp"],"application/pgp-signature":["asc","sig"],"application/pics-rules":["prf"],"application/pkcs10":["p10"],"application/pkcs7-mime":["p7m","p7c"],"application/pkcs7-signature":["p7s"],"application/pkcs8":["p8"],"application/pkix-attr-cert":["ac"],"application/pkix-cert":["cer"],"application/pkix-crl":["crl"],"application/pkix-pkipath":["pkipath"],"application/pkixcmp":["pki"],"application/pls+xml":["pls"],"application/postscript":["ai","eps","ps"],"application/prs.cww":["cww"],"application/pskc+xml":["pskcxml"],"application/rdf+xml":["rdf"],"application/reginfo+xml":["rif"],"application/relax-ng-compact-syntax":["rnc"],"application/resource-lists+xml":["rl"],"application/resource-lists-diff+xml":["rld"],"application/rls-services+xml":["rs"],"application/rpki-ghostbusters":["gbr"],"application/rpki-manifest":["mft"],"application/rpki-roa":["roa"],"application/rsd+xml":["rsd"],"application/rss+xml":["rss"],"application/rtf":["rtf"],"application/sbml+xml":["sbml"],"application/scvp-cv-request":["scq"],"application/scvp-cv-response":["scs"],"application/scvp-vp-request":["spq"],"application/scvp-vp-response":["spp"],"application/sdp":["sdp"],"application/set-payment-initiation":["setpay"],"application/set-registration-initiation":["setreg"],"application/shf+xml":["shf"],"application/smil+xml":["smi","smil"],"application/sparql-query":["rq"],"application/sparql-results+xml":["srx"],"application/srgs":["gram"],"application/srgs+xml":["grxml"],"application/sru+xml":["sru"],"application/ssdl+xml":["ssdl"],"application/ssml+xml":["ssml"],"application/tei+xml":["tei","teicorpus"],"application/thraud+xml":["tfi"],"application/timestamped-data":["tsd"],"application/vnd.3gpp.pic-bw-large":["plb"],"application/vnd.3gpp.pic-bw-small":["psb"],"application/vnd.3gpp.pic-bw-var":["pvb"],"application/vnd.3gpp2.tcap":["tcap"],"application/vnd.3m.post-it-notes":["pwn"],"application/vnd.accpac.simply.aso":["aso"],"application/vnd.accpac.simply.imp":["imp"],"application/vnd.acucobol":["acu"],"application/vnd.acucorp":["atc","acutc"],"application/vnd.adobe.air-application-installer-package+zip":["air"],"application/vnd.adobe.formscentral.fcdt":["fcdt"],"application/vnd.adobe.fxp":["fxp","fxpl"],"application/vnd.adobe.xdp+xml":["xdp"],"application/vnd.adobe.xfdf":["xfdf"],"application/vnd.ahead.space":["ahead"],"application/vnd.airzip.filesecure.azf":["azf"],"application/vnd.airzip.filesecure.azs":["azs"],"application/vnd.amazon.ebook":["azw"],"application/vnd.americandynamics.acc":["acc"],"application/vnd.amiga.ami":["ami"],"application/vnd.android.package-archive":["apk"],"application/vnd.anser-web-certificate-issue-initiation":["cii"],"application/vnd.anser-web-funds-transfer-initiation":["fti"],"application/vnd.antix.game-component":["atx"],"application/vnd.apple.installer+xml":["mpkg"],"application/vnd.apple.mpegurl":["m3u8"],"application/vnd.aristanetworks.swi":["swi"],"application/vnd.astraea-software.iota":["iota"],"application/vnd.audiograph":["aep"],"application/vnd.blueice.multipass":["mpm"],"application/vnd.bmi":["bmi"],"application/vnd.businessobjects":["rep"],"application/vnd.chemdraw+xml":["cdxml"],"application/vnd.chipnuts.karaoke-mmd":["mmd"],"application/vnd.cinderella":["cdy"],"application/vnd.claymore":["cla"],"application/vnd.cloanto.rp9":["rp9"],"application/vnd.clonk.c4group":["c4g","c4d","c4f","c4p","c4u"],"application/vnd.cluetrust.cartomobile-config":["c11amc"],"application/vnd.cluetrust.cartomobile-config-pkg":["c11amz"],"application/vnd.commonspace":["csp"],"application/vnd.contact.cmsg":["cdbcmsg"],"application/vnd.cosmocaller":["cmc"],"application/vnd.crick.clicker":["clkx"],"application/vnd.crick.clicker.keyboard":["clkk"],"application/vnd.crick.clicker.palette":["clkp"],"application/vnd.crick.clicker.template":["clkt"],"application/vnd.crick.clicker.wordbank":["clkw"],"application/vnd.criticaltools.wbs+xml":["wbs"],"application/vnd.ctc-posml":["pml"],"application/vnd.cups-ppd":["ppd"],"application/vnd.curl.car":["car"],"application/vnd.curl.pcurl":["pcurl"],"application/vnd.dart":["dart"],"application/vnd.data-vision.rdz":["rdz"],"application/vnd.dece.data":["uvf","uvvf","uvd","uvvd"],"application/vnd.dece.ttml+xml":["uvt","uvvt"],"application/vnd.dece.unspecified":["uvx","uvvx"],"application/vnd.dece.zip":["uvz","uvvz"],"application/vnd.denovo.fcselayout-link":["fe_launch"],"application/vnd.dna":["dna"],"application/vnd.dolby.mlp":["mlp"],"application/vnd.dpgraph":["dpg"],"application/vnd.dreamfactory":["dfac"],"application/vnd.ds-keypoint":["kpxx"],"application/vnd.dvb.ait":["ait"],"application/vnd.dvb.service":["svc"],"application/vnd.dynageo":["geo"],"application/vnd.ecowin.chart":["mag"],"application/vnd.enliven":["nml"],"application/vnd.epson.esf":["esf"],"application/vnd.epson.msf":["msf"],"application/vnd.epson.quickanime":["qam"],"application/vnd.epson.salt":["slt"],"application/vnd.epson.ssf":["ssf"],"application/vnd.eszigno3+xml":["es3","et3"],"application/vnd.ezpix-album":["ez2"],"application/vnd.ezpix-package":["ez3"],"application/vnd.fdf":["fdf"],"application/vnd.fdsn.mseed":["mseed"],"application/vnd.fdsn.seed":["seed","dataless"],"application/vnd.flographit":["gph"],"application/vnd.fluxtime.clip":["ftc"],"application/vnd.framemaker":["fm","frame","maker","book"],"application/vnd.frogans.fnc":["fnc"],"application/vnd.frogans.ltf":["ltf"],"application/vnd.fsc.weblaunch":["fsc"],"application/vnd.fujitsu.oasys":["oas"],"application/vnd.fujitsu.oasys2":["oa2"],"application/vnd.fujitsu.oasys3":["oa3"],"application/vnd.fujitsu.oasysgp":["fg5"],"application/vnd.fujitsu.oasysprs":["bh2"],"application/vnd.fujixerox.ddd":["ddd"],"application/vnd.fujixerox.docuworks":["xdw"],"application/vnd.fujixerox.docuworks.binder":["xbd"],"application/vnd.fuzzysheet":["fzs"],"application/vnd.genomatix.tuxedo":["txd"],"application/vnd.geogebra.file":["ggb"],"application/vnd.geogebra.tool":["ggt"],"application/vnd.geometry-explorer":["gex","gre"],"application/vnd.geonext":["gxt"],"application/vnd.geoplan":["g2w"],"application/vnd.geospace":["g3w"],"application/vnd.gmx":["gmx"],"application/vnd.google-earth.kml+xml":["kml"],"application/vnd.google-earth.kmz":["kmz"],"application/vnd.grafeq":["gqf","gqs"],"application/vnd.groove-account":["gac"],"application/vnd.groove-help":["ghf"],"application/vnd.groove-identity-message":["gim"],"application/vnd.groove-injector":["grv"],"application/vnd.groove-tool-message":["gtm"],"application/vnd.groove-tool-template":["tpl"],"application/vnd.groove-vcard":["vcg"],"application/vnd.hal+xml":["hal"],"application/vnd.handheld-entertainment+xml":["zmm"],"application/vnd.hbci":["hbci"],"application/vnd.hhe.lesson-player":["les"],"application/vnd.hp-hpgl":["hpgl"],"application/vnd.hp-hpid":["hpid"],"application/vnd.hp-hps":["hps"],"application/vnd.hp-jlyt":["jlt"],"application/vnd.hp-pcl":["pcl"],"application/vnd.hp-pclxl":["pclxl"],"application/vnd.ibm.minipay":["mpy"],"application/vnd.ibm.modcap":["afp","listafp","list3820"],"application/vnd.ibm.rights-management":["irm"],"application/vnd.ibm.secure-container":["sc"],"application/vnd.iccprofile":["icc","icm"],"application/vnd.igloader":["igl"],"application/vnd.immervision-ivp":["ivp"],"application/vnd.immervision-ivu":["ivu"],"application/vnd.insors.igm":["igm"],"application/vnd.intercon.formnet":["xpw","xpx"],"application/vnd.intergeo":["i2g"],"application/vnd.intu.qbo":["qbo"],"application/vnd.intu.qfx":["qfx"],"application/vnd.ipunplugged.rcprofile":["rcprofile"],"application/vnd.irepository.package+xml":["irp"],"application/vnd.is-xpr":["xpr"],"application/vnd.isac.fcs":["fcs"],"application/vnd.jam":["jam"],"application/vnd.jcp.javame.midlet-rms":["rms"],"application/vnd.jisp":["jisp"],"application/vnd.joost.joda-archive":["joda"],"application/vnd.kahootz":["ktz","ktr"],"application/vnd.kde.karbon":["karbon"],"application/vnd.kde.kchart":["chrt"],"application/vnd.kde.kformula":["kfo"],"application/vnd.kde.kivio":["flw"],"application/vnd.kde.kontour":["kon"],"application/vnd.kde.kpresenter":["kpr","kpt"],"application/vnd.kde.kspread":["ksp"],"application/vnd.kde.kword":["kwd","kwt"],"application/vnd.kenameaapp":["htke"],"application/vnd.kidspiration":["kia"],"application/vnd.kinar":["kne","knp"],"application/vnd.koan":["skp","skd","skt","skm"],"application/vnd.kodak-descriptor":["sse"],"application/vnd.las.las+xml":["lasxml"],"application/vnd.llamagraphics.life-balance.desktop":["lbd"],"application/vnd.llamagraphics.life-balance.exchange+xml":["lbe"],"application/vnd.lotus-1-2-3":["123"],"application/vnd.lotus-approach":["apr"],"application/vnd.lotus-freelance":["pre"],"application/vnd.lotus-notes":["nsf"],"application/vnd.lotus-organizer":["org"],"application/vnd.lotus-screencam":["scm"],"application/vnd.lotus-wordpro":["lwp"],"application/vnd.macports.portpkg":["portpkg"],"application/vnd.mcd":["mcd"],"application/vnd.medcalcdata":["mc1"],"application/vnd.mediastation.cdkey":["cdkey"],"application/vnd.mfer":["mwf"],"application/vnd.mfmp":["mfm"],"application/vnd.micrografx.flo":["flo"],"application/vnd.micrografx.igx":["igx"],"application/vnd.mif":["mif"],"application/vnd.mobius.daf":["daf"],"application/vnd.mobius.dis":["dis"],"application/vnd.mobius.mbk":["mbk"],"application/vnd.mobius.mqy":["mqy"],"application/vnd.mobius.msl":["msl"],"application/vnd.mobius.plc":["plc"],"application/vnd.mobius.txf":["txf"],"application/vnd.mophun.application":["mpn"],"application/vnd.mophun.certificate":["mpc"],"application/vnd.mozilla.xul+xml":["xul"],"application/vnd.ms-artgalry":["cil"],"application/vnd.ms-cab-compressed":["cab"],"application/vnd.ms-excel":["xls","xlm","xla","xlc","xlt","xlw"],"application/vnd.ms-excel.addin.macroenabled.12":["xlam"],"application/vnd.ms-excel.sheet.binary.macroenabled.12":["xlsb"],"application/vnd.ms-excel.sheet.macroenabled.12":["xlsm"],"application/vnd.ms-excel.template.macroenabled.12":["xltm"],"application/vnd.ms-fontobject":["eot"],"application/vnd.ms-htmlhelp":["chm"],"application/vnd.ms-ims":["ims"],"application/vnd.ms-lrm":["lrm"],"application/vnd.ms-officetheme":["thmx"],"application/vnd.ms-pki.seccat":["cat"],"application/vnd.ms-pki.stl":["stl"],"application/vnd.ms-powerpoint":["ppt","pps","pot"],"application/vnd.ms-powerpoint.addin.macroenabled.12":["ppam"],"application/vnd.ms-powerpoint.presentation.macroenabled.12":["pptm"],"application/vnd.ms-powerpoint.slide.macroenabled.12":["sldm"],"application/vnd.ms-powerpoint.slideshow.macroenabled.12":["ppsm"],"application/vnd.ms-powerpoint.template.macroenabled.12":["potm"],"application/vnd.ms-project":["mpp","mpt"],"application/vnd.ms-word.document.macroenabled.12":["docm"],"application/vnd.ms-word.template.macroenabled.12":["dotm"],"application/vnd.ms-works":["wps","wks","wcm","wdb"],"application/vnd.ms-wpl":["wpl"],"application/vnd.ms-xpsdocument":["xps"],"application/vnd.mseq":["mseq"],"application/vnd.musician":["mus"],"application/vnd.muvee.style":["msty"],"application/vnd.mynfc":["taglet"],"application/vnd.neurolanguage.nlu":["nlu"],"application/vnd.nitf":["ntf","nitf"],"application/vnd.noblenet-directory":["nnd"],"application/vnd.noblenet-sealer":["nns"],"application/vnd.noblenet-web":["nnw"],"application/vnd.nokia.n-gage.data":["ngdat"],"application/vnd.nokia.radio-preset":["rpst"],"application/vnd.nokia.radio-presets":["rpss"],"application/vnd.novadigm.edm":["edm"],"application/vnd.novadigm.edx":["edx"],"application/vnd.novadigm.ext":["ext"],"application/vnd.oasis.opendocument.chart":["odc"],"application/vnd.oasis.opendocument.chart-template":["otc"],"application/vnd.oasis.opendocument.database":["odb"],"application/vnd.oasis.opendocument.formula":["odf"],"application/vnd.oasis.opendocument.formula-template":["odft"],"application/vnd.oasis.opendocument.graphics":["odg"],"application/vnd.oasis.opendocument.graphics-template":["otg"],"application/vnd.oasis.opendocument.image":["odi"],"application/vnd.oasis.opendocument.image-template":["oti"],"application/vnd.oasis.opendocument.presentation":["odp"],"application/vnd.oasis.opendocument.presentation-template":["otp"],"application/vnd.oasis.opendocument.spreadsheet":["ods"],"application/vnd.oasis.opendocument.spreadsheet-template":["ots"],"application/vnd.oasis.opendocument.text":["odt"],"application/vnd.oasis.opendocument.text-master":["odm"],"application/vnd.oasis.opendocument.text-template":["ott"],"application/vnd.oasis.opendocument.text-web":["oth"],"application/vnd.olpc-sugar":["xo"],"application/vnd.oma.dd2+xml":["dd2"],"application/vnd.openofficeorg.extension":["oxt"],"application/vnd.openxmlformats-officedocument.presentationml.presentation":["pptx"],"application/vnd.openxmlformats-officedocument.presentationml.slide":["sldx"],"application/vnd.openxmlformats-officedocument.presentationml.slideshow":["ppsx"],"application/vnd.openxmlformats-officedocument.presentationml.template":["potx"],"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet":["xlsx"],"application/vnd.openxmlformats-officedocument.spreadsheetml.template":["xltx"],"application/vnd.openxmlformats-officedocument.wordprocessingml.document":["docx"],"application/vnd.openxmlformats-officedocument.wordprocessingml.template":["dotx"],"application/vnd.osgeo.mapguide.package":["mgp"],"application/vnd.osgi.dp":["dp"],"application/vnd.osgi.subsystem":["esa"],"application/vnd.palm":["pdb","pqa","oprc"],"application/vnd.pawaafile":["paw"],"application/vnd.pg.format":["str"],"application/vnd.pg.osasli":["ei6"],"application/vnd.picsel":["efif"],"application/vnd.pmi.widget":["wg"],"application/vnd.pocketlearn":["plf"],"application/vnd.powerbuilder6":["pbd"],"application/vnd.previewsystems.box":["box"],"application/vnd.proteus.magazine":["mgz"],"application/vnd.publishare-delta-tree":["qps"],"application/vnd.pvi.ptid1":["ptid"],"application/vnd.quark.quarkxpress":["qxd","qxt","qwd","qwt","qxl","qxb"],"application/vnd.realvnc.bed":["bed"],"application/vnd.recordare.musicxml":["mxl"],"application/vnd.recordare.musicxml+xml":["musicxml"],"application/vnd.rig.cryptonote":["cryptonote"],"application/vnd.rim.cod":["cod"],"application/vnd.rn-realmedia":["rm"],"application/vnd.rn-realmedia-vbr":["rmvb"],"application/vnd.route66.link66+xml":["link66"],"application/vnd.sailingtracker.track":["st"],"application/vnd.seemail":["see"],"application/vnd.sema":["sema"],"application/vnd.semd":["semd"],"application/vnd.semf":["semf"],"application/vnd.shana.informed.formdata":["ifm"],"application/vnd.shana.informed.formtemplate":["itp"],"application/vnd.shana.informed.interchange":["iif"],"application/vnd.shana.informed.package":["ipk"],"application/vnd.simtech-mindmapper":["twd","twds"],"application/vnd.smaf":["mmf"],"application/vnd.smart.teacher":["teacher"],"application/vnd.solent.sdkm+xml":["sdkm","sdkd"],"application/vnd.spotfire.dxp":["dxp"],"application/vnd.spotfire.sfs":["sfs"],"application/vnd.stardivision.calc":["sdc"],"application/vnd.stardivision.draw":["sda"],"application/vnd.stardivision.impress":["sdd"],"application/vnd.stardivision.math":["smf"],"application/vnd.stardivision.writer":["sdw","vor"],"application/vnd.stardivision.writer-global":["sgl"],"application/vnd.stepmania.package":["smzip"],"application/vnd.stepmania.stepchart":["sm"],"application/vnd.sun.xml.calc":["sxc"],"application/vnd.sun.xml.calc.template":["stc"],"application/vnd.sun.xml.draw":["sxd"],"application/vnd.sun.xml.draw.template":["std"],"application/vnd.sun.xml.impress":["sxi"],"application/vnd.sun.xml.impress.template":["sti"],"application/vnd.sun.xml.math":["sxm"],"application/vnd.sun.xml.writer":["sxw"],"application/vnd.sun.xml.writer.global":["sxg"],"application/vnd.sun.xml.writer.template":["stw"],"application/vnd.sus-calendar":["sus","susp"],"application/vnd.svd":["svd"],"application/vnd.symbian.install":["sis","sisx"],"application/vnd.syncml+xml":["xsm"],"application/vnd.syncml.dm+wbxml":["bdm"],"application/vnd.syncml.dm+xml":["xdm"],"application/vnd.tao.intent-module-archive":["tao"],"application/vnd.tcpdump.pcap":["pcap","cap","dmp"],"application/vnd.tmobile-livetv":["tmo"],"application/vnd.trid.tpt":["tpt"],"application/vnd.triscape.mxs":["mxs"],"application/vnd.trueapp":["tra"],"application/vnd.ufdl":["ufd","ufdl"],"application/vnd.uiq.theme":["utz"],"application/vnd.umajin":["umj"],"application/vnd.unity":["unityweb"],"application/vnd.uoml+xml":["uoml"],"application/vnd.vcx":["vcx"],"application/vnd.visio":["vsd","vst","vss","vsw"],"application/vnd.visionary":["vis"],"application/vnd.vsf":["vsf"],"application/vnd.wap.wbxml":["wbxml"],"application/vnd.wap.wmlc":["wmlc"],"application/vnd.wap.wmlscriptc":["wmlsc"],"application/vnd.webturbo":["wtb"],"application/vnd.wolfram.player":["nbp"],"application/vnd.wordperfect":["wpd"],"application/vnd.wqd":["wqd"],"application/vnd.wt.stf":["stf"],"application/vnd.xara":["xar"],"application/vnd.xfdl":["xfdl"],"application/vnd.yamaha.hv-dic":["hvd"],"application/vnd.yamaha.hv-script":["hvs"],"application/vnd.yamaha.hv-voice":["hvp"],"application/vnd.yamaha.openscoreformat":["osf"],"application/vnd.yamaha.openscoreformat.osfpvg+xml":["osfpvg"],"application/vnd.yamaha.smaf-audio":["saf"],"application/vnd.yamaha.smaf-phrase":["spf"],"application/vnd.yellowriver-custom-menu":["cmp"],"application/vnd.zul":["zir","zirz"],"application/vnd.zzazz.deck+xml":["zaz"],"application/voicexml+xml":["vxml"],"application/widget":["wgt"],"application/winhlp":["hlp"],"application/wsdl+xml":["wsdl"],"application/wspolicy+xml":["wspolicy"],"application/x-7z-compressed":["7z"],"application/x-abiword":["abw"],"application/x-ace-compressed":["ace"],"application/x-apple-diskimage":["dmg"],"application/x-authorware-bin":["aab","x32","u32","vox"],"application/x-authorware-map":["aam"],"application/x-authorware-seg":["aas"],"application/x-bcpio":["bcpio"],"application/x-bittorrent":["torrent"],"application/x-blorb":["blb","blorb"],"application/x-bzip":["bz"],"application/x-bzip2":["bz2","boz"],"application/x-cbr":["cbr","cba","cbt","cbz","cb7"],"application/x-cdlink":["vcd"],"application/x-cfs-compressed":["cfs"],"application/x-chat":["chat"],"application/x-chess-pgn":["pgn"],"application/x-chrome-extension":["crx"],"application/x-conference":["nsc"],"application/x-cpio":["cpio"],"application/x-csh":["csh"],"application/x-debian-package":["deb","udeb"],"application/x-dgc-compressed":["dgc"],"application/x-director":["dir","dcr","dxr","cst","cct","cxt","w3d","fgd","swa"],"application/x-doom":["wad"],"application/x-dtbncx+xml":["ncx"],"application/x-dtbook+xml":["dtb"],"application/x-dtbresource+xml":["res"],"application/x-dvi":["dvi"],"application/x-envoy":["evy"],"application/x-eva":["eva"],"application/x-font-bdf":["bdf"],"application/x-font-ghostscript":["gsf"],"application/x-font-linux-psf":["psf"],"application/x-font-otf":["otf"],"application/x-font-pcf":["pcf"],"application/x-font-snf":["snf"],"application/x-font-ttf":["ttf","ttc"],"application/x-font-type1":["pfa","pfb","pfm","afm"],"application/x-freearc":["arc"],"application/x-futuresplash":["spl"],"application/x-gca-compressed":["gca"],"application/x-glulx":["ulx"],"application/x-gnumeric":["gnumeric"],"application/x-gramps-xml":["gramps"],"application/x-gtar":["gtar"],"application/x-hdf":["hdf"],"application/x-install-instructions":["install"],"application/x-iso9660-image":["iso"],"application/x-java-jnlp-file":["jnlp"],"application/x-latex":["latex"],"application/x-lua-bytecode":["luac"],"application/x-lzh-compressed":["lzh","lha"],"application/x-mie":["mie"],"application/x-mobipocket-ebook":["prc","mobi"],"application/x-ms-application":["application"],"application/x-ms-shortcut":["lnk"],"application/x-ms-wmd":["wmd"],"application/x-ms-wmz":["wmz"],"application/x-ms-xbap":["xbap"],"application/x-msaccess":["mdb"],"application/x-msbinder":["obd"],"application/x-mscardfile":["crd"],"application/x-msclip":["clp"],"application/x-msdownload":["exe","dll","com","bat","msi"],"application/x-msmediaview":["mvb","m13","m14"],"application/x-msmetafile":["wmf","wmz","emf","emz"],"application/x-msmoney":["mny"],"application/x-mspublisher":["pub"],"application/x-msschedule":["scd"],"application/x-msterminal":["trm"],"application/x-mswrite":["wri"],"application/x-netcdf":["nc","cdf"],"application/x-nzb":["nzb"],"application/x-pkcs12":["p12","pfx"],"application/x-pkcs7-certificates":["p7b","spc"],"application/x-pkcs7-certreqresp":["p7r"],"application/x-rar-compressed":["rar"],"application/x-research-info-systems":["ris"],"application/x-sh":["sh"],"application/x-shar":["shar"],"application/x-shockwave-flash":["swf"],"application/x-silverlight-app":["xap"],"application/x-sql":["sql"],"application/x-stuffit":["sit"],"application/x-stuffitx":["sitx"],"application/x-subrip":["srt"],"application/x-sv4cpio":["sv4cpio"],"application/x-sv4crc":["sv4crc"],"application/x-t3vm-image":["t3"],"application/x-tads":["gam"],"application/x-tar":["tar"],"application/x-tcl":["tcl"],"application/x-tex":["tex"],"application/x-tex-tfm":["tfm"],"application/x-texinfo":["texinfo","texi"],"application/x-tgif":["obj"],"application/x-ustar":["ustar"],"application/x-wais-source":["src"],"application/x-web-app-manifest+json":["webapp"],"application/x-x509-ca-cert":["der","crt"],"application/x-xfig":["fig"],"application/x-xliff+xml":["xlf"],"application/x-xpinstall":["xpi"],"application/x-xz":["xz"],"application/x-zmachine":["z1","z2","z3","z4","z5","z6","z7","z8"],"application/xaml+xml":["xaml"],"application/xcap-diff+xml":["xdf"],"application/xenc+xml":["xenc"],"application/xhtml+xml":["xhtml","xht"],"application/xml":["xml","xsl","xsd"],"application/xml-dtd":["dtd"],"application/xop+xml":["xop"],"application/xproc+xml":["xpl"],"application/xslt+xml":["xslt"],"application/xspf+xml":["xspf"],"application/xv+xml":["mxml","xhvml","xvml","xvm"],"application/yang":["yang"],"application/yin+xml":["yin"],"application/zip":["zip"],"audio/adpcm":["adp"],"audio/basic":["au","snd"],"audio/midi":["mid","midi","kar","rmi"],"audio/mp4":["mp4a","m4a"],"audio/mpeg":["mpga","mp2","mp2a","mp3","m2a","m3a"],"audio/ogg":["oga","ogg","spx"],"audio/s3m":["s3m"],"audio/silk":["sil"],"audio/vnd.dece.audio":["uva","uvva"],"audio/vnd.digital-winds":["eol"],"audio/vnd.dra":["dra"],"audio/vnd.dts":["dts"],"audio/vnd.dts.hd":["dtshd"],"audio/vnd.lucent.voice":["lvp"],"audio/vnd.ms-playready.media.pya":["pya"],"audio/vnd.nuera.ecelp4800":["ecelp4800"],"audio/vnd.nuera.ecelp7470":["ecelp7470"],"audio/vnd.nuera.ecelp9600":["ecelp9600"],"audio/vnd.rip":["rip"],"audio/webm":["weba"],"audio/x-aac":["aac"],"audio/x-aiff":["aif","aiff","aifc"],"audio/x-caf":["caf"],"audio/x-flac":["flac"],"audio/x-matroska":["mka"],"audio/x-mpegurl":["m3u"],"audio/x-ms-wax":["wax"],"audio/x-ms-wma":["wma"],"audio/x-pn-realaudio":["ram","ra"],"audio/x-pn-realaudio-plugin":["rmp"],
+"audio/x-wav":["wav"],"audio/xm":["xm"],"chemical/x-cdx":["cdx"],"chemical/x-cif":["cif"],"chemical/x-cmdf":["cmdf"],"chemical/x-cml":["cml"],"chemical/x-csml":["csml"],"chemical/x-xyz":["xyz"],"font/opentype":["otf"],"image/bmp":["bmp"],"image/cgm":["cgm"],"image/g3fax":["g3"],"image/gif":["gif"],"image/ief":["ief"],"image/jpeg":["jpeg","jpg","jpe"],"image/ktx":["ktx"],"image/png":["png"],"image/prs.btif":["btif"],"image/sgi":["sgi"],"image/svg+xml":["svg","svgz"],"image/tiff":["tiff","tif"],"image/vnd.adobe.photoshop":["psd"],"image/vnd.dece.graphic":["uvi","uvvi","uvg","uvvg"],"image/vnd.djvu":["djvu","djv"],"image/vnd.dvb.subtitle":["sub"],"image/vnd.dwg":["dwg"],"image/vnd.dxf":["dxf"],"image/vnd.fastbidsheet":["fbs"],"image/vnd.fpx":["fpx"],"image/vnd.fst":["fst"],"image/vnd.fujixerox.edmics-mmr":["mmr"],"image/vnd.fujixerox.edmics-rlc":["rlc"],"image/vnd.ms-modi":["mdi"],"image/vnd.ms-photo":["wdp"],"image/vnd.net-fpx":["npx"],"image/vnd.wap.wbmp":["wbmp"],"image/vnd.xiff":["xif"],"image/webp":["webp"],"image/x-3ds":["3ds"],"image/x-cmu-raster":["ras"],"image/x-cmx":["cmx"],"image/x-freehand":["fh","fhc","fh4","fh5","fh7"],"image/x-icon":["ico"],"image/x-mrsid-image":["sid"],"image/x-pcx":["pcx"],"image/x-pict":["pic","pct"],"image/x-portable-anymap":["pnm"],"image/x-portable-bitmap":["pbm"],"image/x-portable-graymap":["pgm"],"image/x-portable-pixmap":["ppm"],"image/x-rgb":["rgb"],"image/x-tga":["tga"],"image/x-xbitmap":["xbm"],"image/x-xpixmap":["xpm"],"image/x-xwindowdump":["xwd"],"message/rfc822":["eml","mime"],"model/iges":["igs","iges"],"model/mesh":["msh","mesh","silo"],"model/vnd.collada+xml":["dae"],"model/vnd.dwf":["dwf"],"model/vnd.gdl":["gdl"],"model/vnd.gtw":["gtw"],"model/vnd.mts":["mts"],"model/vnd.vtu":["vtu"],"model/vrml":["wrl","vrml"],"model/x3d+binary":["x3db","x3dbz"],"model/x3d+vrml":["x3dv","x3dvz"],"model/x3d+xml":["x3d","x3dz"],"text/cache-manifest":["appcache","manifest"],"text/calendar":["ics","ifb"],"text/coffeescript":["coffee"],"text/css":["css"],"text/csv":["csv"],"text/hjson":["hjson"],"text/html":["html","htm"],"text/jade":["jade"],"text/jsx":["jsx"],"text/less":["less"],"text/n3":["n3"],"text/plain":["txt","text","conf","def","list","log","in","ini"],"text/prs.lines.tag":["dsc"],"text/richtext":["rtx"],"text/sgml":["sgml","sgm"],"text/stylus":["stylus","styl"],"text/tab-separated-values":["tsv"],"text/troff":["t","tr","roff","man","me","ms"],"text/turtle":["ttl"],"text/uri-list":["uri","uris","urls"],"text/vcard":["vcard"],"text/vnd.curl":["curl"],"text/vnd.curl.dcurl":["dcurl"],"text/vnd.curl.mcurl":["mcurl"],"text/vnd.curl.scurl":["scurl"],"text/vnd.dvb.subtitle":["sub"],"text/vnd.fly":["fly"],"text/vnd.fmi.flexstor":["flx"],"text/vnd.graphviz":["gv"],"text/vnd.in3d.3dml":["3dml"],"text/vnd.in3d.spot":["spot"],"text/vnd.sun.j2me.app-descriptor":["jad"],"text/vnd.wap.wml":["wml"],"text/vnd.wap.wmlscript":["wmls"],"text/vtt":["vtt"],"text/x-asm":["s","asm"],"text/x-c":["c","cc","cxx","cpp","h","hh","dic"],"text/x-component":["htc"],"text/x-fortran":["f","for","f77","f90"],"text/x-handlebars-template":["hbs"],"text/x-java-source":["java"],"text/x-lua":["lua"],"text/x-markdown":["markdown","md","mkd"],"text/x-nfo":["nfo"],"text/x-opml":["opml"],"text/x-pascal":["p","pas"],"text/x-sass":["sass"],"text/x-scss":["scss"],"text/x-setext":["etx"],"text/x-sfv":["sfv"],"text/x-uuencode":["uu"],"text/x-vcalendar":["vcs"],"text/x-vcard":["vcf"],"text/yaml":["yaml","yml"],"video/3gpp":["3gp"],"video/3gpp2":["3g2"],"video/h261":["h261"],"video/h263":["h263"],"video/h264":["h264"],"video/jpeg":["jpgv"],"video/jpm":["jpm","jpgm"],"video/mj2":["mj2","mjp2"],"video/mp2t":["ts"],"video/mp4":["mp4","mp4v","mpg4"],"video/mpeg":["mpeg","mpg","mpe","m1v","m2v"],"video/ogg":["ogv"],"video/quicktime":["qt","mov"],"video/vnd.dece.hd":["uvh","uvvh"],"video/vnd.dece.mobile":["uvm","uvvm"],"video/vnd.dece.pd":["uvp","uvvp"],"video/vnd.dece.sd":["uvs","uvvs"],"video/vnd.dece.video":["uvv","uvvv"],"video/vnd.dvb.file":["dvb"],"video/vnd.fvt":["fvt"],"video/vnd.mpegurl":["mxu","m4u"],"video/vnd.ms-playready.media.pyv":["pyv"],"video/vnd.uvvu.mp4":["uvu","uvvu"],"video/vnd.vivo":["viv"],"video/webm":["webm"],"video/x-f4v":["f4v"],"video/x-fli":["fli"],"video/x-flv":["flv"],"video/x-m4v":["m4v"],"video/x-matroska":["mkv","mk3d","mks"],"video/x-mng":["mng"],"video/x-ms-asf":["asf","asx"],"video/x-ms-vob":["vob"],"video/x-ms-wm":["wm"],"video/x-ms-wmv":["wmv"],"video/x-ms-wmx":["wmx"],"video/x-ms-wvx":["wvx"],"video/x-msvideo":["avi"],"video/x-sgi-movie":["movie"],"video/x-smv":["smv"],"x-conference/x-cooltalk":["ice"]}},{}],338:[function(e,t,r){"use strict";function n(e){if(e=""+e,!(e.length>1e4)){var t=/^((?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec(e);if(t){var r=parseFloat(t[1]),n=(t[2]||"ms").toLowerCase();switch(n){case"years":case"year":case"yrs":case"yr":case"y":return r*p;case"days":case"day":case"d":return r*l;case"hours":case"hour":case"hrs":case"hr":case"h":return r*c;case"minutes":case"minute":case"mins":case"min":case"m":return r*u;case"seconds":case"second":case"secs":case"sec":case"s":return r*s;case"milliseconds":case"millisecond":case"msecs":case"msec":case"ms":return r}}}}function i(e){return e>=l?Math.round(e/l)+"d":e>=c?Math.round(e/c)+"h":e>=u?Math.round(e/u)+"m":e>=s?Math.round(e/s)+"s":e+"ms"}function o(e){return a(e,l,"day")||a(e,c,"hour")||a(e,u,"minute")||a(e,s,"second")||e+" ms"}function a(e,t,r){if(!(e<t))return e<1.5*t?Math.floor(e/t)+" "+r:Math.ceil(e/t)+" "+r+"s"}var s=1e3,u=60*s,c=60*u,l=24*c,p=365.25*l;t.exports=function(e,t){return t=t||{},"string"==typeof e?n(e):t.long?o(e):i(e)}},{}],339:[function(e,t,r){"use strict";r.endianness=function(){return"LE"},r.hostname=function(){return"undefined"!=typeof location?location.hostname:""},r.loadavg=function(){return[]},r.uptime=function(){return 0},r.freemem=function(){return Number.MAX_VALUE},r.totalmem=function(){return Number.MAX_VALUE},r.cpus=function(){return[]},r.type=function(){return"Browser"},r.release=function(){return"undefined"!=typeof navigator?navigator.appVersion:""},r.networkInterfaces=r.getNetworkInterfaces=function(){return{}},r.arch=function(){return"javascript"},r.platform=function(){return"browser"},r.tmpdir=r.tmpDir=function(){return"/tmp"},r.EOL="\n"},{}],340:[function(e,t,r){"use strict";var n=e("os"),i=e("osx-release"),o=e("win-release");t.exports=function(e,t){if(!e&&t)throw new Error("You can't specify a `release` without specfying `platform`");e=e||n.platform(),t=t||n.release();var r;return"darwin"===e?(r=i(t).name,"OS X"+(r?" "+r:"")):"linux"===e?(r=t.replace(/^(\d+\.\d+).*/,"$1"),"Linux"+(r?" "+r:"")):"win32"===e?(r=o(t),"Windows"+(r?" "+r:"")):e}},{os:339,"osx-release":341,"win-release":397}],341:[function(e,t,r){"use strict";var n=e("os"),i={15:"El Capitan",14:"Yosemite",13:"Mavericks",12:"Mountain Lion",11:"Lion",10:"Snow Leopard",9:"Leopard",8:"Tiger",7:"Panther",6:"Jaguar",5:"Puma"};t.exports=function(e){return e=(e||n.release()).split(".")[0],{name:i[e],version:"10."+(Number(e)-4)}}},{os:339}],342:[function(e,t,r){(function(e){"use strict";function t(e,t){for(var r=0,n=e.length-1;n>=0;n--){var i=e[n];"."===i?e.splice(n,1):".."===i?(e.splice(n,1),r++):r&&(e.splice(n,1),r--)}if(t)for(;r--;r)e.unshift("..");return e}function n(e,t){if(e.filter)return e.filter(t);for(var r=[],n=0;n<e.length;n++)t(e[n],n,e)&&r.push(e[n]);return r}var i=/^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/,o=function(e){return i.exec(e).slice(1)};r.resolve=function(){for(var r="",i=!1,o=arguments.length-1;o>=-1&&!i;o--){var a=o>=0?arguments[o]:e.cwd();if("string"!=typeof a)throw new TypeError("Arguments to path.resolve must be strings");a&&(r=a+"/"+r,i="/"===a.charAt(0))}return r=t(n(r.split("/"),function(e){return!!e}),!i).join("/"),(i?"/":"")+r||"."},r.normalize=function(e){var i=r.isAbsolute(e),o="/"===a(e,-1);return e=t(n(e.split("/"),function(e){return!!e}),!i).join("/"),e||i||(e="."),e&&o&&(e+="/"),(i?"/":"")+e},r.isAbsolute=function(e){return"/"===e.charAt(0)},r.join=function(){var e=Array.prototype.slice.call(arguments,0);return r.normalize(n(e,function(e,t){if("string"!=typeof e)throw new TypeError("Arguments to path.join must be strings");return e}).join("/"))},r.relative=function(e,t){function n(e){for(var t=0;t<e.length&&""===e[t];t++);for(var r=e.length-1;r>=0&&""===e[r];r--);return t>r?[]:e.slice(t,r-t+1)}e=r.resolve(e).substr(1),t=r.resolve(t).substr(1);for(var i=n(e.split("/")),o=n(t.split("/")),a=Math.min(i.length,o.length),s=a,u=0;u<a;u++)if(i[u]!==o[u]){s=u;break}for(var c=[],u=s;u<i.length;u++)c.push("..");return c=c.concat(o.slice(s)),c.join("/")},r.sep="/",r.delimiter=":",r.dirname=function(e){var t=o(e),r=t[0],n=t[1];return r||n?(n&&(n=n.substr(0,n.length-1)),r+n):"."},r.basename=function(e,t){var r=o(e)[2];return t&&r.substr(-1*t.length)===t&&(r=r.substr(0,r.length-t.length)),r},r.extname=function(e){return o(e)[3]};var a="b"==="ab".substr(-1)?function(e,t,r){return e.substr(t,r)}:function(e,t,r){return t<0&&(t=e.length+t),e.substr(t,r)}}).call(this,e("_process"))},{_process:345}],343:[function(t,r,n){(function(i){"use strict";function o(e){return e&&e.__esModule?e:{default:e}}var a=t("babel-runtime/helpers/typeof"),s=o(a);(function(){function t(e){return e=String(e),e.charAt(0).toUpperCase()+e.slice(1)}function o(e,t,r){var n={6.4:"10",6.3:"8.1",6.2:"8",6.1:"Server 2008 R2 / 7","6.0":"Server 2008 / Vista",5.2:"Server 2003 / XP 64-bit",5.1:"XP",5.01:"2000 SP1","5.0":"2000","4.0":"NT","4.90":"ME"};return t&&r&&/^Win/i.test(e)&&(n=n[/[\d.]+$/.exec(e)])&&(e="Windows "+n),e=String(e),t&&r&&(e=e.replace(RegExp(t,"i"),r)),e=u(e.replace(/ ce$/i," CE").replace(/\bhpw/i,"web").replace(/\bMacintosh\b/,"Mac OS").replace(/_PowerPC\b/i," OS").replace(/\b(OS X) [^ \d]+/i,"$1").replace(/\bMac (OS X)\b/,"$1").replace(/\/(\d)/," $1").replace(/_/g,".").replace(/(?: BePC|[ .]*fc[ \d.]+)$/i,"").replace(/\bx86\.64\b/gi,"x86_64").replace(/\b(Windows Phone) OS\b/,"$1").split(" on ")[0])}function a(e,t){var r=-1,n=e?e.length:0;if("number"==typeof n&&n>-1&&n<=w)for(;++r<n;)t(e[r],r,e);else c(e,t)}function u(e){return e=h(e),/^(?:webOS|i(?:OS|P))/.test(e)?e:t(e)}function c(e,t){for(var r in e)T.call(e,r)&&t(e[r],r,e)}function l(e){return null==e?t(e):k.call(e).slice(8,-1)}function p(e,t){var r=null!=e?(0,s.default)(e[t]):"number";return!(/^(?:boolean|number|string|undefined)$/.test(r)||"object"==r&&!e[t])}function f(e){return String(e).replace(/([ -])(?!$)/g,"$1?")}function d(e,t){var r=null;return a(e,function(n,i){r=t(r,n,i,e)}),r}function h(e){return String(e).replace(/^ +| +$/g,"")}function m(e){function t(t){return d(t,function(t,r){return t||RegExp("\\b"+(r.pattern||f(r))+"\\b","i").exec(e)&&(r.label||r)})}function r(t){return d(t,function(t,r,n){return t||(r[$]||r[/^[a-z]+(?: +[a-z]+\b)*/i.exec($)]||RegExp("\\b"+f(n)+"(?:\\b|\\w*\\d)","i").exec(e))&&n})}function n(t){return d(t,function(t,r){return t||RegExp("\\b"+(r.pattern||f(r))+"\\b","i").exec(e)&&(r.label||r)})}function i(t){return d(t,function(t,r){var n=r.pattern||f(r);return!t&&(t=RegExp("\\b"+n+"(?:/[\\d.]+|[ \\w.]*)","i").exec(e))&&(t=o(t,n,r.label||r)),t})}function a(t){return d(t,function(t,r){var n=r.pattern||f(r);return!t&&(t=RegExp("\\b"+n+" *\\d+[.\\w_]*","i").exec(e)||RegExp("\\b"+n+"(?:; *(?:[a-z]+[_-])?[a-z]+\\d+|[^ ();-]*)","i").exec(e))&&((t=String(r.label&&!RegExp(n,"i").test(r.label)?r.label:t).split("/"))[1]&&!/[\d.]+/.test(t[0])&&(t[0]+=" "+t[1]),r=r.label||r,t=u(t[0].replace(RegExp(n,"i"),r).replace(RegExp("; *(?:"+r+"[_-])?","i")," ").replace(RegExp("("+r+")[-_.]?(\\w)","i"),"$1 $2"))),t})}function b(t){return d(t,function(t,r){return t||(RegExp(r+"(?:-[\\d.]+/|(?: for [\\w-]+)?[ /-])([\\d.]+[^ ();/_-]*)","i").exec(e)||0)[1]||null})}function y(){return this.description||""}var _=v,x=e&&"object"==("undefined"==typeof e?"undefined":(0,s.default)(e))&&"String"!=l(e);x&&(_=e,e=null);var w=_.navigator||{},S=w.userAgent||"";e||(e=S);var T,A,O=x||j==g,R=x?!!w.likeChrome:/\bChrome\b/.test(e)&&!/internal|\n/i.test(k.toString()),I="Object",C=x?I:"ScriptBridgingProxyObject",M=x?I:"Environment",P=x&&_.java?"JavaPackage":l(_.java),N=x?I:"RuntimeObject",D=/\bJava/.test(P)&&_.java,L=D&&l(_.environment)==M,q=D?"a":"α",U=D?"b":"β",B=_.document||{},F=_.operamini||_.opera,z=E.test(z=x&&F?F["[[Class]]"]:l(F))?z:F=null,G=e,H=[],Y=null,X=e==S,K=X&&F&&"function"==typeof F.version&&F.version(),V=t(["Trident",{label:"WebKit",pattern:"AppleWebKit"},"iCab","Presto","NetFront","Tasman","KHTML","Gecko"]),W=n(["Adobe AIR","Arora","Avant Browser","Breach","Camino","Epiphany","Fennec","Flock","Galeon","GreenBrowser","iCab","Iceweasel",{label:"SRWare Iron",pattern:"Iron"},"K-Meleon","Konqueror","Lunascape","Maxthon","Midori","Nook Browser","PhantomJS","Raven","Rekonq","RockMelt","SeaMonkey",{label:"Silk",pattern:"(?:Cloud9|Silk-Accelerated)"},"Sleipnir","SlimBrowser","Sunrise","Swiftfox","WebPositive","Opera Mini",{label:"Opera Mini",pattern:"OPiOS"},"Opera",{label:"Opera",pattern:"OPR"},"Chrome",{label:"Chrome Mobile",pattern:"(?:CriOS|CrMo)"},{label:"Firefox",pattern:"(?:Firefox|Minefield)"},{label:"IE",pattern:"IEMobile"},{label:"IE",pattern:"MSIE"},"Safari"]),$=a([{label:"BlackBerry",pattern:"BB10"},"BlackBerry",{label:"Galaxy S",pattern:"GT-I9000"},{label:"Galaxy S2",pattern:"GT-I9100"},{label:"Galaxy S3",pattern:"GT-I9300"},{label:"Galaxy S4",pattern:"GT-I9500"},"Google TV","Lumia","iPad","iPod","iPhone","Kindle",{label:"Kindle Fire",pattern:"(?:Cloud9|Silk-Accelerated)"},"Nook","PlayBook","PlayStation 4","PlayStation 3","PlayStation Vita","TouchPad","Transformer",{label:"Wii U",pattern:"WiiU"},"Wii","Xbox One",{label:"Xbox 360",pattern:"Xbox"},"Xoom"]),J=r({Apple:{iPad:1,iPhone:1,iPod:1},Amazon:{Kindle:1,"Kindle Fire":1},Asus:{Transformer:1},"Barnes & Noble":{Nook:1},BlackBerry:{PlayBook:1},Google:{"Google TV":1},HP:{TouchPad:1},HTC:{},LG:{},Microsoft:{Xbox:1,"Xbox One":1},Motorola:{Xoom:1},Nintendo:{"Wii U":1,Wii:1},Nokia:{Lumia:1},Samsung:{"Galaxy S":1,"Galaxy S2":1,"Galaxy S3":1,"Galaxy S4":1},Sony:{"PlayStation 4":1,"PlayStation 3":1,"PlayStation Vita":1}}),Q=i(["Windows Phone ","Android","CentOS","Debian","Fedora","FreeBSD","Gentoo","Haiku","Kubuntu","Linux Mint","Red Hat","SuSE","Ubuntu","Xubuntu","Cygwin","Symbian OS","hpwOS","webOS ","webOS","Tablet OS","Linux","Mac OS X","Macintosh","Mac","Windows 98;","Windows "]);if(V&&(V=[V]),J&&!$&&($=a([J])),(T=/\bGoogle TV\b/.exec($))&&($=T[0]),/\bSimulator\b/i.test(e)&&($=($?$+" ":"")+"Simulator"),"Opera Mini"==W&&/\bOPiOS\b/.test(e)&&H.push("running in Turbo/Uncompressed mode"),/^iP/.test($)?(W||(W="Safari"),Q="iOS"+((T=/ OS ([\d_]+)/i.exec(e))?" "+T[1].replace(/_/g,"."):"")):"Konqueror"!=W||/buntu/i.test(Q)?J&&"Google"!=J&&(/Chrome/.test(W)&&!/\bMobile Safari\b/i.test(e)||/\bVita\b/.test($))?(W="Android Browser",Q=/\bAndroid\b/.test(Q)?Q:"Android"):W&&!(T=!/\bMinefield\b|\(Android;/i.test(e)&&/\b(?:Firefox|Safari)\b/.exec(W))||(W&&!$&&/[\/,]|^[^(]+?\)/.test(e.slice(e.indexOf(T+"/")+8))&&(W=null),(T=$||J||Q)&&($||J||/\b(?:Android|Symbian OS|Tablet OS|webOS)\b/.test(Q))&&(W=/[a-z]+(?: Hat)?/i.exec(/\bAndroid\b/.test(Q)?Q:T)+" Browser")):Q="Kubuntu",(T=/\((Mobile|Tablet).*?Firefox\b/i.exec(e))&&T[1]&&(Q="Firefox OS",$||($=T[1])),K||(K=b(["(?:Cloud9|CriOS|CrMo|IEMobile|Iron|Opera ?Mini|OPiOS|OPR|Raven|Silk(?!/[\\d.]+$))","Version",f(W),"(?:Firefox|Minefield|NetFront)"])),"iCab"==V&&parseFloat(K)>3?V=["WebKit"]:"Trident"!=V&&(T=/\bOpera\b/.test(W)&&(/\bOPR\b/.test(e)?"Blink":"Presto")||/\b(?:Midori|Nook|Safari)\b/i.test(e)&&"WebKit"||!V&&/\bMSIE\b/i.test(e)&&("Mac OS"==Q?"Tasman":"Trident"))?V=[T]:/\bPlayStation\b(?! Vita\b)/i.test(W)&&"WebKit"==V&&(V=["NetFront"]),"IE"==W&&(T=(/; *(?:XBLWP|ZuneWP)(\d+)/i.exec(e)||0)[1])?(W+=" Mobile",Q="Windows Phone "+(/\+$/.test(T)?T:T+".x"),H.unshift("desktop mode")):/\bWPDesktop\b/i.test(e)?(W="IE Mobile",Q="Windows Phone 8+",H.unshift("desktop mode"),K||(K=(/\brv:([\d.]+)/.exec(e)||0)[1])):"IE"!=W&&"Trident"==V&&(T=/\brv:([\d.]+)/.exec(e))?(/\bWPDesktop\b/i.test(e)||(W&&H.push("identifying as "+W+(K?" "+K:"")),W="IE"),K=T[1]):"Chrome"!=W&&"IE"==W||!(T=/\bEdge\/([\d.]+)/.exec(e))||(W="Microsoft Edge",K=T[1],V=["Trident"]),X){if(p(_,"global"))if(D&&(T=D.lang.System,G=T.getProperty("os.arch"),Q=Q||T.getProperty("os.name")+" "+T.getProperty("os.version")),O&&p(_,"system")&&(T=[_.system])[0]){Q||(Q=T[0].os||null);try{T[1]=_.require("ringo/engine").version,K=T[1].join("."),W="RingoJS"}catch(e){T[0].global.system==_.system&&(W="Narwhal")}}else"object"==(0,s.default)(_.process)&&(T=_.process)?(W="Node.js",G=T.arch,Q=T.platform,K=/[\d.]+/.exec(T.version)[0]):L&&(W="Rhino");else l(T=_.runtime)==C?(W="Adobe AIR",Q=T.flash.system.Capabilities.os):l(T=_.phantom)==N?(W="PhantomJS",K=(T=T.version||null)&&T.major+"."+T.minor+"."+T.patch):"number"==typeof B.documentMode&&(T=/\bTrident\/(\d+)/i.exec(e))&&(K=[K,B.documentMode],(T=+T[1]+4)!=K[1]&&(H.push("IE "+K[1]+" mode"),V&&(V[1]=""),K[1]=T),K="IE"==W?String(K[1].toFixed(1)):K[0]);Q=Q&&u(Q)}K&&(T=/(?:[ab]|dp|pre|[ab]\d+pre)(?:\d+\+?)?$/i.exec(K)||/(?:alpha|beta)(?: ?\d)?/i.exec(e+";"+(X&&w.appMinorVersion))||/\bMinefield\b/i.test(e)&&"a")&&(Y=/b/i.test(T)?"beta":"alpha",K=K.replace(RegExp(T+"\\+?$"),"")+("beta"==Y?U:q)+(/\d+\+?/.exec(T)||"")),"Fennec"==W||"Firefox"==W&&/\b(?:Android|Firefox OS)\b/.test(Q)?W="Firefox Mobile":"Maxthon"==W&&K?K=K.replace(/\.[\d.]+/,".x"):"Silk"==W?(/\bMobi/i.test(e)||(Q="Android",H.unshift("desktop mode")),/Accelerated *= *true/i.test(e)&&H.unshift("accelerated")):/\bXbox\b/i.test($)?(Q=null,"Xbox 360"==$&&/\bIEMobile\b/.test(e)&&H.unshift("mobile mode")):!/^(?:Chrome|IE|Opera)$/.test(W)&&(!W||$||/Browser|Mobi/.test(W))||"Windows CE"!=Q&&!/Mobi/i.test(e)?"IE"==W&&X&&null===_.external?H.unshift("platform preview"):(/\bBlackBerry\b/.test($)||/\bBB10\b/.test(e))&&(T=(RegExp($.replace(/ +/g," *")+"/([.\\d]+)","i").exec(e)||0)[1]||K)?(T=[T,/BB10/.test(e)],Q=(T[1]?($=null,J="BlackBerry"):"Device Software")+" "+T[0],K=null):this!=c&&"Wii"!=$&&(X&&F||/Opera/.test(W)&&/\b(?:MSIE|Firefox)\b/i.test(e)||"Firefox"==W&&/\bOS X (?:\d+\.){2,}/.test(Q)||"IE"==W&&(Q&&!/^Win/.test(Q)&&K>5.5||/\bWindows XP\b/.test(Q)&&K>8||8==K&&!/\bTrident\b/.test(e)))&&!E.test(T=m.call(c,e.replace(E,"")+";"))&&T.name&&(T="ing as "+T.name+((T=T.version)?" "+T:""),E.test(W)?(/\bIE\b/.test(T)&&"Mac OS"==Q&&(Q=null),T="identify"+T):(T="mask"+T,W=z?u(z.replace(/([a-z])([A-Z])/g,"$1 $2")):"Opera",/\bIE\b/.test(T)&&(Q=null),X||(K=null)),V=["Presto"],H.push(T)):W+=" Mobile",(T=(/\bAppleWebKit\/([\d.]+\+?)/i.exec(e)||0)[1])&&(T=[parseFloat(T.replace(/\.(\d)$/,".0$1")),T],"Safari"==W&&"+"==T[1].slice(-1)?(W="WebKit Nightly",Y="alpha",K=T[1].slice(0,-1)):K!=T[1]&&K!=(T[2]=(/\bSafari\/([\d.]+\+?)/i.exec(e)||0)[1])||(K=null),T[1]=(/\bChrome\/([\d.]+)/i.exec(e)||0)[1],537.36==T[0]&&537.36==T[2]&&parseFloat(T[1])>=28&&"IE"!=W&&"Microsoft Edge"!=W&&(V=["Blink"]),X&&(R||T[1])?(V&&(V[1]="like Chrome"),T=T[1]||(T=T[0],T<530?1:T<532?2:T<532.05?3:T<533?4:T<534.03?5:T<534.07?6:T<534.1?7:T<534.13?8:T<534.16?9:T<534.24?10:T<534.3?11:T<535.01?12:T<535.02?"13+":T<535.07?15:T<535.11?16:T<535.19?17:T<536.05?18:T<536.1?19:T<537.01?20:T<537.11?"21+":T<537.13?23:T<537.18?24:T<537.24?25:T<537.36?26:"Blink"!=V?"27":"28")):(V&&(V[1]="like Safari"),T=T[0],T=T<400?1:T<500?2:T<526?3:T<533?4:T<534?"4+":T<535?5:T<537?6:T<538?7:T<601?8:"8"),V&&(V[1]+=" "+(T+="number"==typeof T?".x":/[.+]/.test(T)?"":"+")),"Safari"==W&&(!K||parseInt(K)>45)&&(K=T)),"Opera"==W&&(T=/\bzbov|zvav$/.exec(Q))?(W+=" ",H.unshift("desktop mode"),"zvav"==T?(W+="Mini",K=null):W+="Mobile",Q=Q.replace(RegExp(" *"+T+"$"),"")):"Safari"==W&&/\bChrome\b/.exec(V&&V[1])&&(H.unshift("desktop mode"),W="Chrome Mobile",K=null,/\bOS X\b/.test(Q)?(J="Apple",Q="iOS 4.3+"):Q=null),K&&0==K.indexOf(T=/[\d.]+$/.exec(Q))&&e.indexOf("/"+T+"-")>-1&&(Q=h(Q.replace(T,""))),V&&!/\b(?:Avant|Nook)\b/.test(W)&&(/Browser|Lunascape|Maxthon/.test(W)||/^(?:Adobe|Arora|Breach|Midori|Opera|Phantom|Rekonq|Rock|Sleipnir|Web)/.test(W)&&V[1])&&(T=V[V.length-1])&&H.push(T),H.length&&(H=["("+H.join("; ")+")"]),J&&$&&$.indexOf(J)<0&&H.push("on "+J),$&&H.push((/^on /.test(H[H.length-1])?"":"on ")+$),Q&&(T=/ ([\d.+]+)$/.exec(Q),A=T&&"/"==Q.charAt(Q.length-T[0].length-1),Q={architecture:32,family:T&&!A?Q.replace(T[0],""):Q,version:T?T[1]:null,toString:function(){var e=this.version;return this.family+(e&&!A?" "+e:"")+(64==this.architecture?" 64-bit":"")}}),(T=/\b(?:AMD|IA|Win|WOW|x86_|x)64\b/i.exec(G))&&!/\bi686\b/i.test(G)&&(Q&&(Q.architecture=64,Q.family=Q.family.replace(RegExp(" *"+T),"")),W&&(/\bWOW64\b/i.test(e)||X&&/\w(?:86|32)$/.test(w.cpuClass||w.platform)&&!/\bWin64; x64\b/i.test(e))&&H.unshift("32-bit")),e||(e=null);var Z={};return Z.description=e,Z.layout=V&&V[0],Z.manufacturer=J,Z.name=W,Z.prerelease=Y,Z.product=$,Z.ua=e,Z.version=W&&K,Z.os=Q||{architecture:null,family:null,version:null,toString:function(){return"null"}},Z.parse=m,Z.toString=y,Z.version&&H.unshift(K),Z.name&&H.unshift(W),Q&&W&&(Q!=String(Q).split(" ")[0]||Q!=W.split(" ")[0]&&!$)&&H.push($?"("+Q+")":"on "+Q),H.length&&(Z.description=H.join(" ")),Z}var b={function:!0,object:!0},v=b["undefined"==typeof window?"undefined":(0,s.default)(window)]&&window||this,g=v,y=b["undefined"==typeof n?"undefined":(0,s.default)(n)]&&n,_=b["undefined"==typeof r?"undefined":(0,s.default)(r)]&&r&&!r.nodeType&&r,x=y&&_&&"object"==("undefined"==typeof i?"undefined":(0,s.default)(i))&&i;!x||x.global!==x&&x.window!==x&&x.self!==x||(v=x);var w=Math.pow(2,53)-1,E=/\bOpera/,j=this,S=Object.prototype,T=S.hasOwnProperty,k=S.toString;"function"==typeof e&&"object"==(0,s.default)(e.amd)&&e.amd?e(function(){return m()}):y&&_?c(m(),function(e,t){y[t]=e}):v.platform=m()}).call(void 0)}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{"babel-runtime/helpers/typeof":39}],344:[function(e,t,r){(function(e){"use strict";function r(t,r,n,i){if("function"!=typeof t)throw new TypeError('"callback" argument must be a function');var o,a,s=arguments.length;switch(s){case 0:case 1:return e.nextTick(t);case 2:return e.nextTick(function(){t.call(null,r)});case 3:return e.nextTick(function(){t.call(null,r,n)});case 4:return e.nextTick(function(){t.call(null,r,n,i)});default:for(o=new Array(s-1),a=0;a<o.length;)o[a++]=arguments[a];return e.nextTick(function(){t.apply(null,o)})}}!e.version||0===e.version.indexOf("v0.")||0===e.version.indexOf("v1.")&&0!==e.version.indexOf("v1.8.")?t.exports=r:t.exports=e.nextTick}).call(this,e("_process"))},{_process:345}],345:[function(e,t,r){"use strict";function n(){throw new Error("setTimeout has not been defined")}function i(){throw new Error("clearTimeout has not been defined")}function o(e){if(p===setTimeout)return setTimeout(e,0);if((p===n||!p)&&setTimeout)return p=setTimeout,setTimeout(e,0);try{return p(e,0)}catch(t){try{return p.call(null,e,0)}catch(t){return p.call(this,e,0)}}}function a(e){if(f===clearTimeout)return clearTimeout(e);if((f===i||!f)&&clearTimeout)return f=clearTimeout,clearTimeout(e);try{return f(e)}catch(t){try{return f.call(null,e)}catch(t){return f.call(this,e)}}}function s(){b&&h&&(b=!1,h.length?m=h.concat(m):v=-1,m.length&&u())}function u(){if(!b){var e=o(s);b=!0;for(var t=m.length;t;){for(h=m,m=[];++v<t;)h&&h[v].run();v=-1,t=m.length}h=null,b=!1,a(e)}}function c(e,t){this.fun=e,this.array=t}function l(){}var p,f,d=t.exports={};!function(){try{p="function"==typeof setTimeout?setTimeout:n}catch(e){p=n}try{f="function"==typeof clearTimeout?clearTimeout:i}catch(e){f=i}}();var h,m=[],b=!1,v=-1;d.nextTick=function(e){var t=new Array(arguments.length-1);if(arguments.length>1)for(var r=1;r<arguments.length;r++)t[r-1]=arguments[r];m.push(new c(e,t)),1!==m.length||b||o(u)},c.prototype.run=function(){this.fun.apply(null,this.array)},d.title="browser",d.browser=!0,d.env={},d.argv=[],d.version="",d.versions={},d.on=l,d.addListener=l,d.once=l,d.off=l,d.removeListener=l,d.removeAllListeners=l,d.emit=l,d.binding=function(e){throw new Error("process.binding is not supported")},d.cwd=function(){return"/"},d.chdir=function(e){throw new Error("process.chdir is not supported")},d.umask=function(){return 0}},{}],346:[function(t,r,n){(function(i){"use strict";function o(e){return e&&e.__esModule?e:{default:e}}var a=t("babel-runtime/helpers/typeof"),s=o(a);!function(t){function o(e){throw new RangeError(N[e])}function a(e,t){for(var r=e.length,n=[];r--;)n[r]=t(e[r]);return n}function u(e,t){var r=e.split("@"),n="";r.length>1&&(n=r[0]+"@",e=r[1]),e=e.replace(P,".");var i=e.split("."),o=a(i,t).join(".");return n+o}function c(e){for(var t,r,n=[],i=0,o=e.length;i<o;)t=e.charCodeAt(i++),t>=55296&&t<=56319&&i<o?(r=e.charCodeAt(i++),56320==(64512&r)?n.push(((1023&t)<<10)+(1023&r)+65536):(n.push(t),i--)):n.push(t);return n}function l(e){return a(e,function(e){var t="";return e>65535&&(e-=65536,t+=q(e>>>10&1023|55296),e=56320|1023&e),t+=q(e)}).join("")}function p(e){return e-48<10?e-22:e-65<26?e-65:e-97<26?e-97:j}function f(e,t){return e+22+75*(e<26)-((0!=t)<<5)}function d(e,t,r){var n=0;for(e=r?L(e/A):e>>1,e+=L(e/t);e>D*T>>1;n+=j)e=L(e/D);return L(n+(D+1)*e/(e+k))}function h(e){var t,r,n,i,a,s,u,c,f,h,m=[],b=e.length,v=0,g=R,y=O;for(r=e.lastIndexOf(I),r<0&&(r=0),n=0;n<r;++n)e.charCodeAt(n)>=128&&o("not-basic"),m.push(e.charCodeAt(n));for(i=r>0?r+1:0;i<b;){for(a=v,s=1,u=j;i>=b&&o("invalid-input"),c=p(e.charCodeAt(i++)),(c>=j||c>L((E-v)/s))&&o("overflow"),v+=c*s,f=u<=y?S:u>=y+T?T:u-y,!(c<f);u+=j)h=j-f,s>L(E/h)&&o("overflow"),s*=h;t=m.length+1,y=d(v-a,t,0==a),L(v/t)>E-g&&o("overflow"),g+=L(v/t),v%=t,m.splice(v++,0,g)}return l(m)}function m(e){var t,r,n,i,a,s,u,l,p,h,m,b,v,g,y,_=[];for(e=c(e),b=e.length,t=R,r=0,a=O,s=0;s<b;++s)m=e[s],m<128&&_.push(q(m));for(n=i=_.length,i&&_.push(I);n<b;){for(u=E,s=0;s<b;++s)m=e[s],m>=t&&m<u&&(u=m);for(v=n+1,u-t>L((E-r)/v)&&o("overflow"),r+=(u-t)*v,t=u,s=0;s<b;++s)if(m=e[s],m<t&&++r>E&&o("overflow"),m==t){for(l=r,p=j;h=p<=a?S:p>=a+T?T:p-a,!(l<h);p+=j)y=l-h,g=j-h,_.push(q(f(h+y%g,0))),l=L(y/g);_.push(q(f(l,0))),a=d(r,v,n==i),r=0,++n}++r,++t}return _.join("")}function b(e){return u(e,function(e){return C.test(e)?h(e.slice(4).toLowerCase()):e})}function v(e){return u(e,function(e){return M.test(e)?"xn--"+m(e):e})}var g="object"==("undefined"==typeof n?"undefined":(0,s.default)(n))&&n&&!n.nodeType&&n,y="object"==("undefined"==typeof r?"undefined":(0,s.default)(r))&&r&&!r.nodeType&&r,_="object"==("undefined"==typeof i?"undefined":(0,s.default)(i))&&i;_.global!==_&&_.window!==_&&_.self!==_||(t=_);var x,w,E=2147483647,j=36,S=1,T=26,k=38,A=700,O=72,R=128,I="-",C=/^xn--/,M=/[^\x20-\x7E]/,P=/[\x2E\u3002\uFF0E\uFF61]/g,N={overflow:"Overflow: input needs wider integers to process","not-basic":"Illegal input >= 0x80 (not a basic code point)","invalid-input":"Invalid input"},D=j-S,L=Math.floor,q=String.fromCharCode;if(x={version:"1.4.1",ucs2:{decode:c,encode:l},decode:h,encode:m,toASCII:v,toUnicode:b},"function"==typeof e&&"object"==(0,s.default)(e.amd)&&e.amd)e("punycode",function(){return x});else if(g&&y)if(r.exports==g)y.exports=x;else for(w in x)x.hasOwnProperty(w)&&(g[w]=x[w]);else t.punycode=x}(void 0)}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{"babel-runtime/helpers/typeof":39}],347:[function(e,t,r){"use strict";function n(e,t){return Object.prototype.hasOwnProperty.call(e,t)}t.exports=function(e,t,r,o){t=t||"&",r=r||"=";var a={};if("string"!=typeof e||0===e.length)return a;var s=/\+/g;e=e.split(t);var u=1e3;o&&"number"==typeof o.maxKeys&&(u=o.maxKeys);var c=e.length;u>0&&c>u&&(c=u);for(var l=0;l<c;++l){var p,f,d,h,m=e[l].replace(s,"%20"),b=m.indexOf(r);b>=0?(p=m.substr(0,b),f=m.substr(b+1)):(p=m,f=""),d=decodeURIComponent(p),h=decodeURIComponent(f),n(a,d)?i(a[d])?a[d].push(h):a[d]=[a[d],h]:a[d]=h}return a};var i=Array.isArray||function(e){return"[object Array]"===Object.prototype.toString.call(e)}},{}],348:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}function i(e,t){if(e.map)return e.map(t);for(var r=[],n=0;n<e.length;n++)r.push(t(e[n],n));return r}var o=e("babel-runtime/core-js/object/keys"),a=n(o),s=e("babel-runtime/helpers/typeof"),u=n(s),c=function(e){switch("undefined"==typeof e?"undefined":(0,u.default)(e)){case"string":return e;case"boolean":return e?"true":"false";case"number":return isFinite(e)?e:"";default:return""}};t.exports=function(e,t,r,n){return t=t||"&",r=r||"=",null===e&&(e=void 0),"object"===("undefined"==typeof e?"undefined":(0,u.default)(e))?i(p(e),function(n){var o=encodeURIComponent(c(n))+r;return l(e[n])?i(e[n],function(e){return o+encodeURIComponent(c(e))}).join(t):o+encodeURIComponent(c(e[n]))}).join(t):n?encodeURIComponent(c(n))+r+encodeURIComponent(c(e)):""};var l=Array.isArray||function(e){return"[object Array]"===Object.prototype.toString.call(e)},p=a.default||function(e){var t=[];for(var r in e)Object.prototype.hasOwnProperty.call(e,r)&&t.push(r);return t}},{"babel-runtime/core-js/object/keys":30,"babel-runtime/helpers/typeof":39}],349:[function(e,t,r){"use strict";r.decode=r.parse=e("./decode"),r.encode=r.stringify=e("./encode")},{"./decode":347,"./encode":348}],350:[function(e,t,r){"use strict";t.exports=e("./lib/_stream_duplex.js")},{"./lib/_stream_duplex.js":351}],351:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}function i(e){return this instanceof i?(f.call(this,e),d.call(this,e),e&&e.readable===!1&&(this.readable=!1),e&&e.writable===!1&&(this.writable=!1),this.allowHalfOpen=!0,e&&e.allowHalfOpen===!1&&(this.allowHalfOpen=!1),void this.once("end",o)):new i(e)}function o(){this.allowHalfOpen||this._writableState.ended||l(a,this)}function a(e){e.end()}var s=e("babel-runtime/core-js/object/keys"),u=n(s),c=u.default||function(e){var t=[];for(var r in e)t.push(r);return t};t.exports=i;var l=e("process-nextick-args"),p=e("core-util-is");p.inherits=e("inherits");var f=e("./_stream_readable"),d=e("./_stream_writable");p.inherits(i,f);for(var h=c(d.prototype),m=0;m<h.length;m++){var b=h[m];i.prototype[b]||(i.prototype[b]=d.prototype[b])}},{"./_stream_readable":353,"./_stream_writable":355,"babel-runtime/core-js/object/keys":30,"core-util-is":176,inherits:198,"process-nextick-args":344}],352:[function(e,t,r){"use strict";function n(e){return this instanceof n?void i.call(this,e):new n(e)}t.exports=n;var i=e("./_stream_transform"),o=e("core-util-is");o.inherits=e("inherits"),o.inherits(n,i),n.prototype._transform=function(e,t,r){r(null,e)}},{"./_stream_transform":354,"core-util-is":176,inherits:198}],353:[function(e,t,r){(function(r){"use strict";function n(e,t,r){return"function"==typeof e.prependListener?e.prependListener(t,r):void(e._events&&e._events[t]?R(e._events[t])?e._events[t].unshift(r):e._events[t]=[r,e._events[t]]:e.on(t,r))}function i(t,r){B=B||e("./_stream_duplex"),t=t||{},this.objectMode=!!t.objectMode,r instanceof B&&(this.objectMode=this.objectMode||!!t.readableObjectMode);var n=t.highWaterMark,i=this.objectMode?16:16384;this.highWaterMark=n||0===n?n:i,this.highWaterMark=~~this.highWaterMark,this.buffer=new U,this.length=0,this.pipes=null,this.pipesCount=0,this.flowing=null,this.ended=!1,this.endEmitted=!1,this.reading=!1,this.sync=!0,this.needReadable=!1,this.emittedReadable=!1,this.readableListening=!1,this.resumeScheduled=!1,this.defaultEncoding=t.defaultEncoding||"utf8",this.ranOut=!1,this.awaitDrain=0,this.readingMore=!1,this.decoder=null,this.encoding=null,t.encoding&&(q||(q=e("string_decoder/").StringDecoder),this.decoder=new q(t.encoding),this.encoding=t.encoding)}function o(t){return B=B||e("./_stream_duplex"),this instanceof o?(this._readableState=new i(t,this),this.readable=!0,t&&"function"==typeof t.read&&(this._read=t.read),void I.call(this)):new o(t)}function a(e,t,r,n,i){var o=l(t,r);if(o)e.emit("error",o);else if(null===r)t.reading=!1,p(e,t);else if(t.objectMode||r&&r.length>0)if(t.ended&&!i){var a=new Error("stream.push() after EOF");
+e.emit("error",a)}else if(t.endEmitted&&i){var u=new Error("stream.unshift() after end event");e.emit("error",u)}else{var c;!t.decoder||i||n||(r=t.decoder.write(r),c=!t.objectMode&&0===r.length),i||(t.reading=!1),c||(t.flowing&&0===t.length&&!t.sync?(e.emit("data",r),e.read(0)):(t.length+=t.objectMode?1:r.length,i?t.buffer.unshift(r):t.buffer.push(r),t.needReadable&&f(e))),h(e,t)}else i||(t.reading=!1);return s(t)}function s(e){return!e.ended&&(e.needReadable||e.length<e.highWaterMark||0===e.length)}function u(e){return e>=F?e=F:(e--,e|=e>>>1,e|=e>>>2,e|=e>>>4,e|=e>>>8,e|=e>>>16,e++),e}function c(e,t){return e<=0||0===t.length&&t.ended?0:t.objectMode?1:e!==e?t.flowing&&t.length?t.buffer.head.data.length:t.length:(e>t.highWaterMark&&(t.highWaterMark=u(e)),e<=t.length?e:t.ended?t.length:(t.needReadable=!0,0))}function l(e,t){var r=null;return M.isBuffer(t)||"string"==typeof t||null===t||void 0===t||e.objectMode||(r=new TypeError("Invalid non-string/buffer chunk")),r}function p(e,t){if(!t.ended){if(t.decoder){var r=t.decoder.end();r&&r.length&&(t.buffer.push(r),t.length+=t.objectMode?1:r.length)}t.ended=!0,f(e)}}function f(e){var t=e._readableState;t.needReadable=!1,t.emittedReadable||(L("emitReadable",t.flowing),t.emittedReadable=!0,t.sync?O(d,e):d(e))}function d(e){L("emit readable"),e.emit("readable"),_(e)}function h(e,t){t.readingMore||(t.readingMore=!0,O(m,e,t))}function m(e,t){for(var r=t.length;!t.reading&&!t.flowing&&!t.ended&&t.length<t.highWaterMark&&(L("maybeReadMore read 0"),e.read(0),r!==t.length);)r=t.length;t.readingMore=!1}function b(e){return function(){var t=e._readableState;L("pipeOnDrain",t.awaitDrain),t.awaitDrain&&t.awaitDrain--,0===t.awaitDrain&&C(e,"data")&&(t.flowing=!0,_(e))}}function v(e){L("readable nexttick read 0"),e.read(0)}function g(e,t){t.resumeScheduled||(t.resumeScheduled=!0,O(y,e,t))}function y(e,t){t.reading||(L("resume read 0"),e.read(0)),t.resumeScheduled=!1,t.awaitDrain=0,e.emit("resume"),_(e),t.flowing&&!t.reading&&e.read(0)}function _(e){var t=e._readableState;for(L("flow",t.flowing);t.flowing&&null!==e.read(););}function x(e,t){if(0===t.length)return null;var r;return t.objectMode?r=t.buffer.shift():!e||e>=t.length?(r=t.decoder?t.buffer.join(""):1===t.buffer.length?t.buffer.head.data:t.buffer.concat(t.length),t.buffer.clear()):r=w(e,t.buffer,t.decoder),r}function w(e,t,r){var n;return e<t.head.data.length?(n=t.head.data.slice(0,e),t.head.data=t.head.data.slice(e)):n=e===t.head.data.length?t.shift():r?E(e,t):j(e,t),n}function E(e,t){var r=t.head,n=1,i=r.data;for(e-=i.length;r=r.next;){var o=r.data,a=e>o.length?o.length:e;if(i+=a===o.length?o:o.slice(0,e),e-=a,0===e){a===o.length?(++n,r.next?t.head=r.next:t.head=t.tail=null):(t.head=r,r.data=o.slice(a));break}++n}return t.length-=n,i}function j(e,t){var r=P.allocUnsafe(e),n=t.head,i=1;for(n.data.copy(r),e-=n.data.length;n=n.next;){var o=n.data,a=e>o.length?o.length:e;if(o.copy(r,r.length-e,0,a),e-=a,0===e){a===o.length?(++i,n.next?t.head=n.next:t.head=t.tail=null):(t.head=n,n.data=o.slice(a));break}++i}return t.length-=i,r}function S(e){var t=e._readableState;if(t.length>0)throw new Error('"endReadable()" called on non-empty stream');t.endEmitted||(t.ended=!0,O(T,t,e))}function T(e,t){e.endEmitted||0!==e.length||(e.endEmitted=!0,t.readable=!1,t.emit("end"))}function k(e,t){for(var r=0,n=e.length;r<n;r++)t(e[r],r)}function A(e,t){for(var r=0,n=e.length;r<n;r++)if(e[r]===t)return r;return-1}t.exports=o;var O=e("process-nextick-args"),R=e("isarray");o.ReadableState=i;var I,C=(e("events").EventEmitter,function(e,t){return e.listeners(t).length});!function(){try{I=e("stream")}catch(e){}finally{I||(I=e("events").EventEmitter)}}();var M=e("buffer").Buffer,P=e("buffer-shims"),N=e("core-util-is");N.inherits=e("inherits");var D=e("util"),L=void 0;L=D&&D.debuglog?D.debuglog("stream"):function(){};var q,U=e("./internal/streams/BufferList");N.inherits(o,I);var B,B;o.prototype.push=function(e,t){var r=this._readableState;return r.objectMode||"string"!=typeof e||(t=t||r.defaultEncoding,t!==r.encoding&&(e=P.from(e,t),t="")),a(this,r,e,t,!1)},o.prototype.unshift=function(e){var t=this._readableState;return a(this,t,e,"",!0)},o.prototype.isPaused=function(){return this._readableState.flowing===!1},o.prototype.setEncoding=function(t){return q||(q=e("string_decoder/").StringDecoder),this._readableState.decoder=new q(t),this._readableState.encoding=t,this};var F=8388608;o.prototype.read=function(e){L("read",e),e=parseInt(e,10);var t=this._readableState,r=e;if(0!==e&&(t.emittedReadable=!1),0===e&&t.needReadable&&(t.length>=t.highWaterMark||t.ended))return L("read: emitReadable",t.length,t.ended),0===t.length&&t.ended?S(this):f(this),null;if(e=c(e,t),0===e&&t.ended)return 0===t.length&&S(this),null;var n=t.needReadable;L("need readable",n),(0===t.length||t.length-e<t.highWaterMark)&&(n=!0,L("length less than watermark",n)),t.ended||t.reading?(n=!1,L("reading or ended",n)):n&&(L("do read"),t.reading=!0,t.sync=!0,0===t.length&&(t.needReadable=!0),this._read(t.highWaterMark),t.sync=!1,t.reading||(e=c(r,t)));var i;return i=e>0?x(e,t):null,null===i?(t.needReadable=!0,e=0):t.length-=e,0===t.length&&(t.ended||(t.needReadable=!0),r!==e&&t.ended&&S(this)),null!==i&&this.emit("data",i),i},o.prototype._read=function(e){this.emit("error",new Error("not implemented"))},o.prototype.pipe=function(e,t){function i(e){L("onunpipe"),e===f&&a()}function o(){L("onend"),e.end()}function a(){L("cleanup"),e.removeListener("close",c),e.removeListener("finish",l),e.removeListener("drain",v),e.removeListener("error",u),e.removeListener("unpipe",i),f.removeListener("end",o),f.removeListener("end",a),f.removeListener("data",s),g=!0,!d.awaitDrain||e._writableState&&!e._writableState.needDrain||v()}function s(t){L("ondata"),y=!1;var r=e.write(t);!1!==r||y||((1===d.pipesCount&&d.pipes===e||d.pipesCount>1&&A(d.pipes,e)!==-1)&&!g&&(L("false write response, pause",f._readableState.awaitDrain),f._readableState.awaitDrain++,y=!0),f.pause())}function u(t){L("onerror",t),p(),e.removeListener("error",u),0===C(e,"error")&&e.emit("error",t)}function c(){e.removeListener("finish",l),p()}function l(){L("onfinish"),e.removeListener("close",c),p()}function p(){L("unpipe"),f.unpipe(e)}var f=this,d=this._readableState;switch(d.pipesCount){case 0:d.pipes=e;break;case 1:d.pipes=[d.pipes,e];break;default:d.pipes.push(e)}d.pipesCount+=1,L("pipe count=%d opts=%j",d.pipesCount,t);var h=(!t||t.end!==!1)&&e!==r.stdout&&e!==r.stderr,m=h?o:a;d.endEmitted?O(m):f.once("end",m),e.on("unpipe",i);var v=b(f);e.on("drain",v);var g=!1,y=!1;return f.on("data",s),n(e,"error",u),e.once("close",c),e.once("finish",l),e.emit("pipe",f),d.flowing||(L("pipe resume"),f.resume()),e},o.prototype.unpipe=function(e){var t=this._readableState;if(0===t.pipesCount)return this;if(1===t.pipesCount)return e&&e!==t.pipes?this:(e||(e=t.pipes),t.pipes=null,t.pipesCount=0,t.flowing=!1,e&&e.emit("unpipe",this),this);if(!e){var r=t.pipes,n=t.pipesCount;t.pipes=null,t.pipesCount=0,t.flowing=!1;for(var i=0;i<n;i++)r[i].emit("unpipe",this);return this}var o=A(t.pipes,e);return o===-1?this:(t.pipes.splice(o,1),t.pipesCount-=1,1===t.pipesCount&&(t.pipes=t.pipes[0]),e.emit("unpipe",this),this)},o.prototype.on=function(e,t){var r=I.prototype.on.call(this,e,t);if("data"===e)this._readableState.flowing!==!1&&this.resume();else if("readable"===e){var n=this._readableState;n.endEmitted||n.readableListening||(n.readableListening=n.needReadable=!0,n.emittedReadable=!1,n.reading?n.length&&f(this,n):O(v,this))}return r},o.prototype.addListener=o.prototype.on,o.prototype.resume=function(){var e=this._readableState;return e.flowing||(L("resume"),e.flowing=!0,g(this,e)),this},o.prototype.pause=function(){return L("call pause flowing=%j",this._readableState.flowing),!1!==this._readableState.flowing&&(L("pause"),this._readableState.flowing=!1,this.emit("pause")),this},o.prototype.wrap=function(e){var t=this._readableState,r=!1,n=this;e.on("end",function(){if(L("wrapped end"),t.decoder&&!t.ended){var e=t.decoder.end();e&&e.length&&n.push(e)}n.push(null)}),e.on("data",function(i){if(L("wrapped data"),t.decoder&&(i=t.decoder.write(i)),(!t.objectMode||null!==i&&void 0!==i)&&(t.objectMode||i&&i.length)){var o=n.push(i);o||(r=!0,e.pause())}});for(var i in e)void 0===this[i]&&"function"==typeof e[i]&&(this[i]=function(t){return function(){return e[t].apply(e,arguments)}}(i));var o=["error","close","destroy","pause","resume"];return k(o,function(t){e.on(t,n.emit.bind(n,t))}),n._read=function(t){L("wrapped _read",t),r&&(r=!1,e.resume())},n},o._fromList=x}).call(this,e("_process"))},{"./_stream_duplex":351,"./internal/streams/BufferList":356,_process:345,buffer:45,"buffer-shims":44,"core-util-is":176,events:193,inherits:198,isarray:357,"process-nextick-args":344,"string_decoder/":374,util:42}],354:[function(e,t,r){"use strict";function n(e){this.afterTransform=function(t,r){return i(e,t,r)},this.needTransform=!1,this.transforming=!1,this.writecb=null,this.writechunk=null,this.writeencoding=null}function i(e,t,r){var n=e._transformState;n.transforming=!1;var i=n.writecb;if(!i)return e.emit("error",new Error("no writecb in Transform class"));n.writechunk=null,n.writecb=null,null!==r&&void 0!==r&&e.push(r),i(t);var o=e._readableState;o.reading=!1,(o.needReadable||o.length<o.highWaterMark)&&e._read(o.highWaterMark)}function o(e){if(!(this instanceof o))return new o(e);s.call(this,e),this._transformState=new n(this);var t=this;this._readableState.needReadable=!0,this._readableState.sync=!1,e&&("function"==typeof e.transform&&(this._transform=e.transform),"function"==typeof e.flush&&(this._flush=e.flush)),this.once("prefinish",function(){"function"==typeof this._flush?this._flush(function(e){a(t,e)}):a(t)})}function a(e,t){if(t)return e.emit("error",t);var r=e._writableState,n=e._transformState;if(r.length)throw new Error("Calling transform done when ws.length != 0");if(n.transforming)throw new Error("Calling transform done when still transforming");return e.push(null)}t.exports=o;var s=e("./_stream_duplex"),u=e("core-util-is");u.inherits=e("inherits"),u.inherits(o,s),o.prototype.push=function(e,t){return this._transformState.needTransform=!1,s.prototype.push.call(this,e,t)},o.prototype._transform=function(e,t,r){throw new Error("Not implemented")},o.prototype._write=function(e,t,r){var n=this._transformState;if(n.writecb=r,n.writechunk=e,n.writeencoding=t,!n.transforming){var i=this._readableState;(n.needTransform||i.needReadable||i.length<i.highWaterMark)&&this._read(i.highWaterMark)}},o.prototype._read=function(e){var t=this._transformState;null!==t.writechunk&&t.writecb&&!t.transforming?(t.transforming=!0,this._transform(t.writechunk,t.writeencoding,t.afterTransform)):t.needTransform=!0}},{"./_stream_duplex":351,"core-util-is":176,inherits:198}],355:[function(e,t,r){(function(r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}function i(){}function o(e,t,r){this.chunk=e,this.encoding=t,this.callback=r,this.next=null}function a(t,r){M=M||e("./_stream_duplex"),t=t||{},this.objectMode=!!t.objectMode,r instanceof M&&(this.objectMode=this.objectMode||!!t.writableObjectMode);var n=t.highWaterMark,i=this.objectMode?16:16384;this.highWaterMark=n||0===n?n:i,this.highWaterMark=~~this.highWaterMark,this.needDrain=!1,this.ending=!1,this.ended=!1,this.finished=!1;var o=t.decodeStrings===!1;this.decodeStrings=!o,this.defaultEncoding=t.defaultEncoding||"utf8",this.length=0,this.writing=!1,this.corked=0,this.sync=!0,this.bufferProcessing=!1,this.onwrite=function(e){m(r,e)},this.writecb=null,this.writelen=0,this.bufferedRequest=null,this.lastBufferedRequest=null,this.pendingcb=0,this.prefinished=!1,this.errorEmitted=!1,this.bufferedRequestCount=0,this.corkedRequestsFree=new E(this)}function s(t){return M=M||e("./_stream_duplex"),this instanceof s||this instanceof M?(this._writableState=new a(t,this),this.writable=!0,t&&("function"==typeof t.write&&(this._write=t.write),"function"==typeof t.writev&&(this._writev=t.writev)),void O.call(this)):new s(t)}function u(e,t){var r=new Error("write after end");e.emit("error",r),T(t,r)}function c(e,t,r,n){var i=!0,o=!1;return null===r?o=new TypeError("May not write null values to stream"):I.isBuffer(r)||"string"==typeof r||void 0===r||t.objectMode||(o=new TypeError("Invalid non-string/buffer chunk")),o&&(e.emit("error",o),T(n,o),i=!1),i}function l(e,t,r){return e.objectMode||e.decodeStrings===!1||"string"!=typeof t||(t=C.from(t,r)),t}function p(e,t,r,n,i){r=l(t,r,n),I.isBuffer(r)&&(n="buffer");var a=t.objectMode?1:r.length;t.length+=a;var s=t.length<t.highWaterMark;if(s||(t.needDrain=!0),t.writing||t.corked){var u=t.lastBufferedRequest;t.lastBufferedRequest=new o(r,n,i),u?u.next=t.lastBufferedRequest:t.bufferedRequest=t.lastBufferedRequest,t.bufferedRequestCount+=1}else f(e,t,!1,a,r,n,i);return s}function f(e,t,r,n,i,o,a){t.writelen=n,t.writecb=a,t.writing=!0,t.sync=!0,r?e._writev(i,t.onwrite):e._write(i,o,t.onwrite),t.sync=!1}function d(e,t,r,n,i){--t.pendingcb,r?T(i,n):i(n),e._writableState.errorEmitted=!0,e.emit("error",n)}function h(e){e.writing=!1,e.writecb=null,e.length-=e.writelen,e.writelen=0}function m(e,t){var r=e._writableState,n=r.sync,i=r.writecb;if(h(r),t)d(e,r,n,t,i);else{var o=y(r);o||r.corked||r.bufferProcessing||!r.bufferedRequest||g(e,r),n?k(b,e,r,o,i):b(e,r,o,i)}}function b(e,t,r,n){r||v(e,t),t.pendingcb--,n(),x(e,t)}function v(e,t){0===t.length&&t.needDrain&&(t.needDrain=!1,e.emit("drain"))}function g(e,t){t.bufferProcessing=!0;var r=t.bufferedRequest;if(e._writev&&r&&r.next){var n=t.bufferedRequestCount,i=new Array(n),o=t.corkedRequestsFree;o.entry=r;for(var a=0;r;)i[a]=r,r=r.next,a+=1;f(e,t,!0,t.length,i,"",o.finish),t.pendingcb++,t.lastBufferedRequest=null,o.next?(t.corkedRequestsFree=o.next,o.next=null):t.corkedRequestsFree=new E(t)}else{for(;r;){var s=r.chunk,u=r.encoding,c=r.callback,l=t.objectMode?1:s.length;if(f(e,t,!1,l,s,u,c),r=r.next,t.writing)break}null===r&&(t.lastBufferedRequest=null)}t.bufferedRequestCount=0,t.bufferedRequest=r,t.bufferProcessing=!1}function y(e){return e.ending&&0===e.length&&null===e.bufferedRequest&&!e.finished&&!e.writing}function _(e,t){t.prefinished||(t.prefinished=!0,e.emit("prefinish"))}function x(e,t){var r=y(t);return r&&(0===t.pendingcb?(_(e,t),t.finished=!0,e.emit("finish")):_(e,t)),r}function w(e,t,r){t.ending=!0,x(e,t),r&&(t.finished?T(r):e.once("finish",r)),t.ended=!0,e.writable=!1}function E(e){var t=this;this.next=null,this.entry=null,this.finish=function(r){var n=t.entry;for(t.entry=null;n;){var i=n.callback;e.pendingcb--,i(r),n=n.next}e.corkedRequestsFree?e.corkedRequestsFree.next=t:e.corkedRequestsFree=t}}var j=e("babel-runtime/core-js/set-immediate"),S=n(j);t.exports=s;var T=e("process-nextick-args"),k=!r.browser&&["v0.10","v0.9."].indexOf(r.version.slice(0,5))>-1?S.default:T;s.WritableState=a;var A=e("core-util-is");A.inherits=e("inherits");var O,R={deprecate:e("util-deprecate")};!function(){try{O=e("stream")}catch(e){}finally{O||(O=e("events").EventEmitter)}}();var I=e("buffer").Buffer,C=e("buffer-shims");A.inherits(s,O);var M;a.prototype.getBuffer=function(){for(var e=this.bufferedRequest,t=[];e;)t.push(e),e=e.next;return t},function(){try{Object.defineProperty(a.prototype,"buffer",{get:R.deprecate(function(){return this.getBuffer()},"_writableState.buffer is deprecated. Use _writableState.getBuffer instead.")})}catch(e){}}();var M;s.prototype.pipe=function(){this.emit("error",new Error("Cannot pipe, not readable"))},s.prototype.write=function(e,t,r){var n=this._writableState,o=!1;return"function"==typeof t&&(r=t,t=null),I.isBuffer(e)?t="buffer":t||(t=n.defaultEncoding),"function"!=typeof r&&(r=i),n.ended?u(this,r):c(this,n,e,r)&&(n.pendingcb++,o=p(this,n,e,t,r)),o},s.prototype.cork=function(){var e=this._writableState;e.corked++},s.prototype.uncork=function(){var e=this._writableState;e.corked&&(e.corked--,e.writing||e.corked||e.finished||e.bufferProcessing||!e.bufferedRequest||g(this,e))},s.prototype.setDefaultEncoding=function(e){if("string"==typeof e&&(e=e.toLowerCase()),!(["hex","utf8","utf-8","ascii","binary","base64","ucs2","ucs-2","utf16le","utf-16le","raw"].indexOf((e+"").toLowerCase())>-1))throw new TypeError("Unknown encoding: "+e);return this._writableState.defaultEncoding=e,this},s.prototype._write=function(e,t,r){r(new Error("not implemented"))},s.prototype._writev=null,s.prototype.end=function(e,t,r){var n=this._writableState;"function"==typeof e?(r=e,e=null,t=null):"function"==typeof t&&(r=t,t=null),null!==e&&void 0!==e&&this.write(e,t),n.corked&&(n.corked=1,this.uncork()),n.ending||n.finished||w(this,n,r)}}).call(this,e("_process"))},{"./_stream_duplex":351,_process:345,"babel-runtime/core-js/set-immediate":34,buffer:45,"buffer-shims":44,"core-util-is":176,events:193,inherits:198,"process-nextick-args":344,"util-deprecate":381}],356:[function(e,t,r){"use strict";function n(){this.head=null,this.tail=null,this.length=0}var i=(e("buffer").Buffer,e("buffer-shims"));t.exports=n,n.prototype.push=function(e){var t={data:e,next:null};this.length>0?this.tail.next=t:this.head=t,this.tail=t,++this.length},n.prototype.unshift=function(e){var t={data:e,next:this.head};0===this.length&&(this.tail=t),this.head=t,++this.length},n.prototype.shift=function(){if(0!==this.length){var e=this.head.data;return 1===this.length?this.head=this.tail=null:this.head=this.head.next,--this.length,e}},n.prototype.clear=function(){this.head=this.tail=null,this.length=0},n.prototype.join=function(e){if(0===this.length)return"";for(var t=this.head,r=""+t.data;t=t.next;)r+=e+t.data;return r},n.prototype.concat=function(e){if(0===this.length)return i.alloc(0);if(1===this.length)return this.head.data;for(var t=i.allocUnsafe(e>>>0),r=this.head,n=0;r;)r.data.copy(t,n),n+=r.data.length,r=r.next;return t}},{buffer:45,"buffer-shims":44}],357:[function(e,t,r){arguments[4][46][0].apply(r,arguments)},{dup:46}],358:[function(e,t,r){"use strict";t.exports=e("./lib/_stream_passthrough.js")},{"./lib/_stream_passthrough.js":352}],359:[function(e,t,r){(function(n){"use strict";var i=function(){try{return e("stream")}catch(e){}}();r=t.exports=e("./lib/_stream_readable.js"),r.Stream=i||r,r.Readable=r,r.Writable=e("./lib/_stream_writable.js"),r.Duplex=e("./lib/_stream_duplex.js"),r.Transform=e("./lib/_stream_transform.js"),r.PassThrough=e("./lib/_stream_passthrough.js"),!n.browser&&"disable"===n.env.READABLE_STREAM&&i&&(t.exports=i)}).call(this,e("_process"))},{"./lib/_stream_duplex.js":351,"./lib/_stream_passthrough.js":352,"./lib/_stream_readable.js":353,"./lib/_stream_transform.js":354,"./lib/_stream_writable.js":355,_process:345}],360:[function(e,t,r){"use strict";t.exports=e("./lib/_stream_transform.js")},{"./lib/_stream_transform.js":354}],361:[function(e,t,r){"use strict";t.exports=e("./lib/_stream_writable.js")},{"./lib/_stream_writable.js":355}],362:[function(e,t,r){(function(r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}var i=e("babel-runtime/core-js/object/get-own-property-names"),o=n(i),a=e("babel-runtime/helpers/typeof"),s=n(a),u="object"===("undefined"==typeof r?"undefined":(0,s.default)(r))?r:"object"===("undefined"==typeof window?"undefined":(0,s.default)(window))?window:"object"===("undefined"==typeof self?"undefined":(0,s.default)(self))?self:void 0,c=u.regeneratorRuntime&&(0,o.default)(u).indexOf("regeneratorRuntime")>=0,l=c&&u.regeneratorRuntime;if(u.regeneratorRuntime=void 0,t.exports=e("./runtime"),c)u.regeneratorRuntime=l;else try{delete u.regeneratorRuntime}catch(e){u.regeneratorRuntime=void 0}}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{"./runtime":363,"babel-runtime/core-js/object/get-own-property-names":26,"babel-runtime/helpers/typeof":39}],363:[function(e,t,r){(function(r,n){"use strict";function i(e){return e&&e.__esModule?e:{default:e}}var o=e("babel-runtime/core-js/promise"),a=i(o),s=e("babel-runtime/core-js/object/set-prototype-of"),u=i(s),c=e("babel-runtime/core-js/object/create"),l=i(c),p=e("babel-runtime/helpers/typeof"),f=i(p),d=e("babel-runtime/core-js/symbol"),h=i(d);!function(e){function n(e,t,r,n){var i=(0,l.default)((t||o).prototype),a=new y(n||[]);return i._invoke=b(e,r,a),i}function i(e,t,r){try{return{type:"normal",arg:e.call(t,r)}}catch(e){return{type:"throw",arg:e}}}function o(){}function s(){}function c(){}function p(e){["next","throw","return"].forEach(function(t){e[t]=function(e){return this._invoke(t,e)}})}function d(e){this.arg=e}function m(e){function t(r,n,o,s){var u=i(e[r],e,n);if("throw"!==u.type){var c=u.arg,l=c.value;return l instanceof d?a.default.resolve(l.arg).then(function(e){t("next",e,o,s)},function(e){t("throw",e,o,s)}):a.default.resolve(l).then(function(e){c.value=e,o(c)},s)}s(u.arg)}function n(e,r){function n(){return new a.default(function(n,i){t(e,r,n,i)})}return o=o?o.then(n,n):n()}"object"===("undefined"==typeof r?"undefined":(0,f.default)(r))&&r.domain&&(t=r.domain.bind(t));var o;this._invoke=n}function b(e,t,r){var n=O;return function(o,a){if(n===I)throw new Error("Generator is already running");if(n===C){if("throw"===o)throw a;return x()}for(;;){var s=r.delegate;if(s){if("return"===o||"throw"===o&&s.iterator[o]===w){r.delegate=null;var u=s.iterator.return;if(u){var c=i(u,s.iterator,a);if("throw"===c.type){o="throw",a=c.arg;continue}}if("return"===o)continue}var c=i(s.iterator[o],s.iterator,a);if("throw"===c.type){r.delegate=null,o="throw",a=c.arg;continue}o="next",a=w;var l=c.arg;if(!l.done)return n=R,l;r[s.resultName]=l.value,r.next=s.nextLoc,r.delegate=null}if("next"===o)r.sent=r._sent=a;else if("throw"===o){if(n===O)throw n=C,a;r.dispatchException(a)&&(o="next",a=w)}else"return"===o&&r.abrupt("return",a);n=I;var c=i(e,t,r);if("normal"===c.type){n=r.done?C:R;var l={value:c.arg,done:r.done};if(c.arg!==M)return l;r.delegate&&"next"===o&&(a=w)}else"throw"===c.type&&(n=C,o="throw",a=c.arg)}}}function v(e){var t={tryLoc:e[0]};1 in e&&(t.catchLoc=e[1]),2 in e&&(t.finallyLoc=e[2],t.afterLoc=e[3]),this.tryEntries.push(t)}function g(e){var t=e.completion||{};t.type="normal",delete t.arg,e.completion=t}function y(e){this.tryEntries=[{tryLoc:"root"}],e.forEach(v,this),this.reset(!0)}function _(e){if(e){var t=e[S];if(t)return t.call(e);if("function"==typeof e.next)return e;if(!isNaN(e.length)){var r=-1,n=function t(){for(;++r<e.length;)if(E.call(e,r))return t.value=e[r],t.done=!1,t;return t.value=w,t.done=!0,t};return n.next=n}}return{next:x}}function x(){return{value:w,done:!0}}var w,E=Object.prototype.hasOwnProperty,j="function"==typeof h.default?h.default:{},S=j.iterator||"@@iterator",T=j.toStringTag||"@@toStringTag",k="object"===("undefined"==typeof t?"undefined":(0,f.default)(t)),A=e.regeneratorRuntime;if(A)return void(k&&(t.exports=A));A=e.regeneratorRuntime=k?t.exports:{},A.wrap=n;var O="suspendedStart",R="suspendedYield",I="executing",C="completed",M={},P=c.prototype=o.prototype;s.prototype=P.constructor=c,c.constructor=s,c[T]=s.displayName="GeneratorFunction",A.isGeneratorFunction=function(e){var t="function"==typeof e&&e.constructor;return!!t&&(t===s||"GeneratorFunction"===(t.displayName||t.name))},A.mark=function(e){return u.default?(0,u.default)(e,c):(e.__proto__=c,T in e||(e[T]="GeneratorFunction")),e.prototype=(0,l.default)(P),e},A.awrap=function(e){return new d(e)},p(m.prototype),A.async=function(e,t,r,i){var o=new m(n(e,t,r,i));return A.isGeneratorFunction(t)?o:o.next().then(function(e){return e.done?e.value:o.next()})},p(P),P[S]=function(){return this},P[T]="Generator",P.toString=function(){return"[object Generator]"},A.keys=function(e){var t=[];for(var r in e)t.push(r);return t.reverse(),function r(){for(;t.length;){var n=t.pop();if(n in e)return r.value=n,r.done=!1,r}return r.done=!0,r}},A.values=_,y.prototype={constructor:y,reset:function(e){if(this.prev=0,this.next=0,this.sent=this._sent=w,this.done=!1,this.delegate=null,this.tryEntries.forEach(g),!e)for(var t in this)"t"===t.charAt(0)&&E.call(this,t)&&!isNaN(+t.slice(1))&&(this[t]=w)},stop:function(){this.done=!0;var e=this.tryEntries[0],t=e.completion;if("throw"===t.type)throw t.arg;return this.rval},dispatchException:function(e){function t(t,n){return o.type="throw",o.arg=e,r.next=t,!!n}if(this.done)throw e;for(var r=this,n=this.tryEntries.length-1;n>=0;--n){var i=this.tryEntries[n],o=i.completion;if("root"===i.tryLoc)return t("end");if(i.tryLoc<=this.prev){var a=E.call(i,"catchLoc"),s=E.call(i,"finallyLoc");if(a&&s){if(this.prev<i.catchLoc)return t(i.catchLoc,!0);if(this.prev<i.finallyLoc)return t(i.finallyLoc)}else if(a){if(this.prev<i.catchLoc)return t(i.catchLoc,!0)}else{if(!s)throw new Error("try statement without catch or finally");if(this.prev<i.finallyLoc)return t(i.finallyLoc)}}}},abrupt:function(e,t){for(var r=this.tryEntries.length-1;r>=0;--r){var n=this.tryEntries[r];if(n.tryLoc<=this.prev&&E.call(n,"finallyLoc")&&this.prev<n.finallyLoc){var i=n;break}}i&&("break"===e||"continue"===e)&&i.tryLoc<=t&&t<=i.finallyLoc&&(i=null);var o=i?i.completion:{};return o.type=e,o.arg=t,i?this.next=i.finallyLoc:this.complete(o),M},complete:function(e,t){if("throw"===e.type)throw e.arg;"break"===e.type||"continue"===e.type?this.next=e.arg:"return"===e.type?(this.rval=e.arg,this.next="end"):"normal"===e.type&&t&&(this.next=t)},finish:function(e){for(var t=this.tryEntries.length-1;t>=0;--t){var r=this.tryEntries[t];if(r.finallyLoc===e)return this.complete(r.completion,r.afterLoc),g(r),M}},catch:function(e){for(var t=this.tryEntries.length-1;t>=0;--t){var r=this.tryEntries[t];if(r.tryLoc===e){var n=r.completion;if("throw"===n.type){var i=n.arg;g(r)}return i}}throw new Error("illegal catch attempt")},delegateYield:function(e,t,r){return this.delegate={iterator:_(e),resultName:t,nextLoc:r},M}}}("object"===("undefined"==typeof n?"undefined":(0,f.default)(n))?n:"object"===("undefined"==typeof window?"undefined":(0,f.default)(window))?window:"object"===("undefined"==typeof self?"undefined":(0,f.default)(self))?self:void 0)}).call(this,e("_process"),"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{_process:345,"babel-runtime/core-js/object/create":22,"babel-runtime/core-js/object/set-prototype-of":32,"babel-runtime/core-js/promise":33,"babel-runtime/core-js/symbol":36,"babel-runtime/helpers/typeof":39}],364:[function(e,t,r){(function(t){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}var i=e("babel-runtime/core-js/string/from-code-point"),o=n(i),a=e("babel-runtime/core-js/json/stringify"),s=n(a),u=e("babel-runtime/helpers/typeof"),c=n(u),l=e("babel-runtime/core-js/object/define-property"),p=n(l),f=e("babel-runtime/core-js/object/keys"),d=n(f),h=e("babel-runtime/core-js/object/create"),m=n(h);!function(r){function n(e,t){if(!(this instanceof n))return new n(e,t);var i=this;a(i),i.q=i.c="",i.bufferCheckPosition=r.MAX_BUFFER_LENGTH,i.opt=t||{},i.opt.lowercase=i.opt.lowercase||i.opt.lowercasetags,i.looseCase=i.opt.lowercase?"toLowerCase":"toUpperCase",i.tags=[],i.closed=i.closedRoot=i.sawRoot=!1,i.tag=i.error=null,i.strict=!!e,i.noscript=!(!e&&!i.opt.noscript),i.state=Q.BEGIN,i.strictEntities=i.opt.strictEntities,i.ENTITIES=i.strictEntities?(0,m.default)(r.XML_ENTITIES):(0,m.default)(r.ENTITIES),i.attribList=[],i.opt.xmlns&&(i.ns=(0,m.default)(K)),i.trackPosition=i.opt.position!==!1,i.trackPosition&&(i.position=i.line=i.column=0),y(i,"onready")}function i(e){for(var t=Math.max(r.MAX_BUFFER_LENGTH,10),n=0,i=0,o=N.length;i<o;i++){var a=e[N[i]].length;if(a>t)switch(N[i]){case"textNode":x(e);break;case"cdata":_(e,"oncdata",e.cdata),e.cdata="";break;case"script":_(e,"onscript",e.script),e.script="";break;default:E(e,"Max buffer length exceeded: "+N[i])}n=Math.max(n,a)}var s=r.MAX_BUFFER_LENGTH-n;e.bufferCheckPosition=s+e.position}function a(e){for(var t=0,r=N.length;t<r;t++)e[N[t]]=""}function u(e){x(e),""!==e.cdata&&(_(e,"oncdata",e.cdata),e.cdata=""),""!==e.script&&(_(e,"onscript",e.script),e.script="")}function l(e,t){return new f(e,t)}function f(e,t){if(!(this instanceof f))return new f(e,t);D.apply(this),this._parser=new n(e,t),this.writable=!0,this.readable=!0;var r=this;this._parser.onend=function(){r.emit("end")},this._parser.onerror=function(e){r.emit("error",e),r._parser.error=null},this._decoder=null,L.forEach(function(e){(0,p.default)(r,"on"+e,{get:function(){return r._parser["on"+e]},set:function(t){return t?void r.on(e,t):(r.removeAllListeners(e),r._parser["on"+e]=t,t)},enumerable:!0,configurable:!1})})}function h(e){return e.split("").reduce(function(e,t){return e[t]=!0,e},{})}function b(e){return"[object RegExp]"===Object.prototype.toString.call(e)}function v(e,t){return b(e)?!!t.match(e):e[t]}function g(e,t){return!v(e,t)}function y(e,t,r){e[t]&&e[t](r)}function _(e,t,r){e.textNode&&x(e),y(e,t,r)}function x(e){e.textNode=w(e.opt,e.textNode),e.textNode&&y(e,"ontext",e.textNode),e.textNode=""}function w(e,t){return e.trim&&(t=t.trim()),e.normalize&&(t=t.replace(/\s+/g," ")),t}function E(e,t){return x(e),e.trackPosition&&(t+="\nLine: "+e.line+"\nColumn: "+e.column+"\nChar: "+e.c),t=new Error(t),e.error=t,y(e,"onerror",t),e}function j(e){return e.sawRoot&&!e.closedRoot&&S(e,"Unclosed root tag"),e.state!==Q.BEGIN&&e.state!==Q.BEGIN_WHITESPACE&&e.state!==Q.TEXT&&E(e,"Unexpected end"),x(e),e.c="",e.closed=!0,y(e,"onend"),n.call(e,e.strict,e.opt),e}function S(e,t){if("object"!==("undefined"==typeof e?"undefined":(0,c.default)(e))||!(e instanceof n))throw new Error("bad call to strictFail");e.strict&&E(e,t)}function T(e){e.strict||(e.tagName=e.tagName[e.looseCase]());var t=e.tags[e.tags.length-1]||e,r=e.tag={name:e.tagName,attributes:{}};e.opt.xmlns&&(r.ns=t.ns),e.attribList.length=0,_(e,"onopentagstart",r)}function k(e,t){var r=e.indexOf(":"),n=r<0?["",e]:e.split(":"),i=n[0],o=n[1];return t&&"xmlns"===e&&(i="xmlns",o=""),{prefix:i,local:o}}function A(e){if(e.strict||(e.attribName=e.attribName[e.looseCase]()),e.attribList.indexOf(e.attribName)!==-1||e.tag.attributes.hasOwnProperty(e.attribName))return void(e.attribName=e.attribValue="");if(e.opt.xmlns){var t=k(e.attribName,!0),r=t.prefix,n=t.local;if("xmlns"===r)if("xml"===n&&e.attribValue!==Y)S(e,"xml: prefix must be bound to "+Y+"\nActual: "+e.attribValue);else if("xmlns"===n&&e.attribValue!==X)S(e,"xmlns: prefix must be bound to "+X+"\nActual: "+e.attribValue);else{var i=e.tag,o=e.tags[e.tags.length-1]||e;i.ns===o.ns&&(i.ns=(0,m.default)(o.ns)),i.ns[n]=e.attribValue}e.attribList.push([e.attribName,e.attribValue])}else e.tag.attributes[e.attribName]=e.attribValue,_(e,"onattribute",{name:e.attribName,value:e.attribValue});e.attribName=e.attribValue=""}function O(e,t){if(e.opt.xmlns){var r=e.tag,n=k(e.tagName);r.prefix=n.prefix,r.local=n.local,r.uri=r.ns[n.prefix]||"",r.prefix&&!r.uri&&(S(e,"Unbound namespace prefix: "+(0,s.default)(e.tagName)),r.uri=n.prefix);var i=e.tags[e.tags.length-1]||e;r.ns&&i.ns!==r.ns&&(0,d.default)(r.ns).forEach(function(t){_(e,"onopennamespace",{prefix:t,uri:r.ns[t]})});for(var o=0,a=e.attribList.length;o<a;o++){var u=e.attribList[o],c=u[0],l=u[1],p=k(c,!0),f=p.prefix,h=p.local,m=""===f?"":r.ns[f]||"",b={name:c,value:l,prefix:f,local:h,uri:m};f&&"xmlns"!==f&&!m&&(S(e,"Unbound namespace prefix: "+(0,s.default)(f)),b.uri=f),e.tag.attributes[c]=b,_(e,"onattribute",b)}e.attribList.length=0}e.tag.isSelfClosing=!!t,e.sawRoot=!0,e.tags.push(e.tag),_(e,"onopentag",e.tag),t||(e.noscript||"script"!==e.tagName.toLowerCase()?e.state=Q.TEXT:e.state=Q.SCRIPT,e.tag=null,e.tagName=""),e.attribName=e.attribValue="",e.attribList.length=0}function R(e){if(!e.tagName)return S(e,"Weird empty close tag."),e.textNode+="</>",void(e.state=Q.TEXT);if(e.script){if("script"!==e.tagName)return e.script+="</"+e.tagName+">",e.tagName="",void(e.state=Q.SCRIPT);_(e,"onscript",e.script),e.script=""}var t=e.tags.length,r=e.tagName;e.strict||(r=r[e.looseCase]());for(var n=r;t--;){var i=e.tags[t];if(i.name===n)break;S(e,"Unexpected close tag")}if(t<0)return S(e,"Unmatched closing tag: "+e.tagName),e.textNode+="</"+e.tagName+">",void(e.state=Q.TEXT);
+e.tagName=r;for(var o=e.tags.length;o-- >t;){var a=e.tag=e.tags.pop();e.tagName=e.tag.name,_(e,"onclosetag",e.tagName);var s={};for(var u in a.ns)s[u]=a.ns[u];var c=e.tags[e.tags.length-1]||e;e.opt.xmlns&&a.ns!==c.ns&&(0,d.default)(a.ns).forEach(function(t){var r=a.ns[t];_(e,"onclosenamespace",{prefix:t,uri:r})})}0===t&&(e.closedRoot=!0),e.tagName=e.attribValue=e.attribName="",e.attribList.length=0,e.state=Q.TEXT}function I(e){var t,r=e.entity,n=r.toLowerCase(),i="";return e.ENTITIES[r]?e.ENTITIES[r]:e.ENTITIES[n]?e.ENTITIES[n]:(r=n,"#"===r.charAt(0)&&("x"===r.charAt(1)?(r=r.slice(2),t=parseInt(r,16),i=t.toString(16)):(r=r.slice(1),t=parseInt(r,10),i=t.toString(10))),r=r.replace(/^0+/,""),i.toLowerCase()!==r?(S(e,"Invalid character entity"),"&"+e.entity+";"):(0,o.default)(t))}function C(e,t){"<"===t?(e.state=Q.OPEN_WAKA,e.startTagPosition=e.position):g(q,t)&&(S(e,"Non-whitespace before first tag."),e.textNode=t,e.state=Q.TEXT)}function M(e,t){var r="";return t<e.length&&(r=e.charAt(t)),r}function P(e){var t=this;if(this.error)throw this.error;if(t.closed)return E(t,"Cannot write after close. Assign an onready handler.");if(null===e)return j(t);"object"===("undefined"==typeof e?"undefined":(0,c.default)(e))&&(e=e.toString());for(var r=0,n="";;){if(n=M(e,r++),t.c=n,!n)break;switch(t.trackPosition&&(t.position++,"\n"===n?(t.line++,t.column=0):t.column++),t.state){case Q.BEGIN:if(t.state=Q.BEGIN_WHITESPACE,"\ufeff"===n)continue;C(t,n);continue;case Q.BEGIN_WHITESPACE:C(t,n);continue;case Q.TEXT:if(t.sawRoot&&!t.closedRoot){for(var o=r-1;n&&"<"!==n&&"&"!==n;)n=M(e,r++),n&&t.trackPosition&&(t.position++,"\n"===n?(t.line++,t.column=0):t.column++);t.textNode+=e.substring(o,r-1)}"<"!==n||t.sawRoot&&t.closedRoot&&!t.strict?(!g(q,n)||t.sawRoot&&!t.closedRoot||S(t,"Text data outside of root node."),"&"===n?t.state=Q.TEXT_ENTITY:t.textNode+=n):(t.state=Q.OPEN_WAKA,t.startTagPosition=t.position);continue;case Q.SCRIPT:"<"===n?t.state=Q.SCRIPT_ENDING:t.script+=n;continue;case Q.SCRIPT_ENDING:"/"===n?t.state=Q.CLOSE_TAG:(t.script+="<"+n,t.state=Q.SCRIPT);continue;case Q.OPEN_WAKA:if("!"===n)t.state=Q.SGML_DECL,t.sgmlDecl="";else if(v(q,n));else if(v(V,n))t.state=Q.OPEN_TAG,t.tagName=n;else if("/"===n)t.state=Q.CLOSE_TAG,t.tagName="";else if("?"===n)t.state=Q.PROC_INST,t.procInstName=t.procInstBody="";else{if(S(t,"Unencoded <"),t.startTagPosition+1<t.position){var a=t.position-t.startTagPosition;n=new Array(a).join(" ")+n}t.textNode+="<"+n,t.state=Q.TEXT}continue;case Q.SGML_DECL:(t.sgmlDecl+n).toUpperCase()===G?(_(t,"onopencdata"),t.state=Q.CDATA,t.sgmlDecl="",t.cdata=""):t.sgmlDecl+n==="--"?(t.state=Q.COMMENT,t.comment="",t.sgmlDecl=""):(t.sgmlDecl+n).toUpperCase()===H?(t.state=Q.DOCTYPE,(t.doctype||t.sawRoot)&&S(t,"Inappropriately located doctype declaration"),t.doctype="",t.sgmlDecl=""):">"===n?(_(t,"onsgmldeclaration",t.sgmlDecl),t.sgmlDecl="",t.state=Q.TEXT):v(F,n)?(t.state=Q.SGML_DECL_QUOTED,t.sgmlDecl+=n):t.sgmlDecl+=n;continue;case Q.SGML_DECL_QUOTED:n===t.q&&(t.state=Q.SGML_DECL,t.q=""),t.sgmlDecl+=n;continue;case Q.DOCTYPE:">"===n?(t.state=Q.TEXT,_(t,"ondoctype",t.doctype),t.doctype=!0):(t.doctype+=n,"["===n?t.state=Q.DOCTYPE_DTD:v(F,n)&&(t.state=Q.DOCTYPE_QUOTED,t.q=n));continue;case Q.DOCTYPE_QUOTED:t.doctype+=n,n===t.q&&(t.q="",t.state=Q.DOCTYPE);continue;case Q.DOCTYPE_DTD:t.doctype+=n,"]"===n?t.state=Q.DOCTYPE:v(F,n)&&(t.state=Q.DOCTYPE_DTD_QUOTED,t.q=n);continue;case Q.DOCTYPE_DTD_QUOTED:t.doctype+=n,n===t.q&&(t.state=Q.DOCTYPE_DTD,t.q="");continue;case Q.COMMENT:"-"===n?t.state=Q.COMMENT_ENDING:t.comment+=n;continue;case Q.COMMENT_ENDING:"-"===n?(t.state=Q.COMMENT_ENDED,t.comment=w(t.opt,t.comment),t.comment&&_(t,"oncomment",t.comment),t.comment=""):(t.comment+="-"+n,t.state=Q.COMMENT);continue;case Q.COMMENT_ENDED:">"!==n?(S(t,"Malformed comment"),t.comment+="--"+n,t.state=Q.COMMENT):t.state=Q.TEXT;continue;case Q.CDATA:"]"===n?t.state=Q.CDATA_ENDING:t.cdata+=n;continue;case Q.CDATA_ENDING:"]"===n?t.state=Q.CDATA_ENDING_2:(t.cdata+="]"+n,t.state=Q.CDATA);continue;case Q.CDATA_ENDING_2:">"===n?(t.cdata&&_(t,"oncdata",t.cdata),_(t,"onclosecdata"),t.cdata="",t.state=Q.TEXT):"]"===n?t.cdata+="]":(t.cdata+="]]"+n,t.state=Q.CDATA);continue;case Q.PROC_INST:"?"===n?t.state=Q.PROC_INST_ENDING:v(q,n)?t.state=Q.PROC_INST_BODY:t.procInstName+=n;continue;case Q.PROC_INST_BODY:if(!t.procInstBody&&v(q,n))continue;"?"===n?t.state=Q.PROC_INST_ENDING:t.procInstBody+=n;continue;case Q.PROC_INST_ENDING:">"===n?(_(t,"onprocessinginstruction",{name:t.procInstName,body:t.procInstBody}),t.procInstName=t.procInstBody="",t.state=Q.TEXT):(t.procInstBody+="?"+n,t.state=Q.PROC_INST_BODY);continue;case Q.OPEN_TAG:v(W,n)?t.tagName+=n:(T(t),">"===n?O(t):"/"===n?t.state=Q.OPEN_TAG_SLASH:(g(q,n)&&S(t,"Invalid character in tag name"),t.state=Q.ATTRIB));continue;case Q.OPEN_TAG_SLASH:">"===n?(O(t,!0),R(t)):(S(t,"Forward-slash in opening tag not followed by >"),t.state=Q.ATTRIB);continue;case Q.ATTRIB:if(v(q,n))continue;">"===n?O(t):"/"===n?t.state=Q.OPEN_TAG_SLASH:v(V,n)?(t.attribName=n,t.attribValue="",t.state=Q.ATTRIB_NAME):S(t,"Invalid attribute name");continue;case Q.ATTRIB_NAME:"="===n?t.state=Q.ATTRIB_VALUE:">"===n?(S(t,"Attribute without value"),t.attribValue=t.attribName,A(t),O(t)):v(q,n)?t.state=Q.ATTRIB_NAME_SAW_WHITE:v(W,n)?t.attribName+=n:S(t,"Invalid attribute name");continue;case Q.ATTRIB_NAME_SAW_WHITE:if("="===n)t.state=Q.ATTRIB_VALUE;else{if(v(q,n))continue;S(t,"Attribute without value"),t.tag.attributes[t.attribName]="",t.attribValue="",_(t,"onattribute",{name:t.attribName,value:""}),t.attribName="",">"===n?O(t):v(V,n)?(t.attribName=n,t.state=Q.ATTRIB_NAME):(S(t,"Invalid attribute name"),t.state=Q.ATTRIB)}continue;case Q.ATTRIB_VALUE:if(v(q,n))continue;v(F,n)?(t.q=n,t.state=Q.ATTRIB_VALUE_QUOTED):(S(t,"Unquoted attribute value"),t.state=Q.ATTRIB_VALUE_UNQUOTED,t.attribValue=n);continue;case Q.ATTRIB_VALUE_QUOTED:if(n!==t.q){"&"===n?t.state=Q.ATTRIB_VALUE_ENTITY_Q:t.attribValue+=n;continue}A(t),t.q="",t.state=Q.ATTRIB_VALUE_CLOSED;continue;case Q.ATTRIB_VALUE_CLOSED:v(q,n)?t.state=Q.ATTRIB:">"===n?O(t):"/"===n?t.state=Q.OPEN_TAG_SLASH:v(V,n)?(S(t,"No whitespace between attributes"),t.attribName=n,t.attribValue="",t.state=Q.ATTRIB_NAME):S(t,"Invalid attribute name");continue;case Q.ATTRIB_VALUE_UNQUOTED:if(g(z,n)){"&"===n?t.state=Q.ATTRIB_VALUE_ENTITY_U:t.attribValue+=n;continue}A(t),">"===n?O(t):t.state=Q.ATTRIB;continue;case Q.CLOSE_TAG:if(t.tagName)">"===n?R(t):v(W,n)?t.tagName+=n:t.script?(t.script+="</"+t.tagName,t.tagName="",t.state=Q.SCRIPT):(g(q,n)&&S(t,"Invalid tagname in closing tag"),t.state=Q.CLOSE_TAG_SAW_WHITE);else{if(v(q,n))continue;g(V,n)?t.script?(t.script+="</"+n,t.state=Q.SCRIPT):S(t,"Invalid tagname in closing tag."):t.tagName=n}continue;case Q.CLOSE_TAG_SAW_WHITE:if(v(q,n))continue;">"===n?R(t):S(t,"Invalid characters in closing tag");continue;case Q.TEXT_ENTITY:case Q.ATTRIB_VALUE_ENTITY_Q:case Q.ATTRIB_VALUE_ENTITY_U:var s,u;switch(t.state){case Q.TEXT_ENTITY:s=Q.TEXT,u="textNode";break;case Q.ATTRIB_VALUE_ENTITY_Q:s=Q.ATTRIB_VALUE_QUOTED,u="attribValue";break;case Q.ATTRIB_VALUE_ENTITY_U:s=Q.ATTRIB_VALUE_UNQUOTED,u="attribValue"}";"===n?(t[u]+=I(t),t.entity="",t.state=s):v(t.entity.length?J:$,n)?t.entity+=n:(S(t,"Invalid character in entity name"),t[u]+="&"+t.entity+n,t.entity="",t.state=s);continue;default:throw new Error(t,"Unknown state: "+t.state)}}return t.position>=t.bufferCheckPosition&&i(t),t}r.parser=function(e,t){return new n(e,t)},r.SAXParser=n,r.SAXStream=f,r.createStream=l,r.MAX_BUFFER_LENGTH=65536;var N=["comment","sgmlDecl","textNode","tagName","doctype","procInstName","procInstBody","entity","attribName","attribValue","cdata","script"];r.EVENTS=["text","processinginstruction","sgmldeclaration","doctype","comment","opentagstart","attribute","opentag","closetag","opencdata","cdata","closecdata","error","end","ready","script","opennamespace","closenamespace"],m.default||(Object.create=function(e){function t(){}t.prototype=e;var r=new t;return r}),d.default||(Object.keys=function(e){var t=[];for(var r in e)e.hasOwnProperty(r)&&t.push(r);return t}),n.prototype={end:function(){j(this)},write:P,resume:function(){return this.error=null,this},close:function(){return this.write(null)},flush:function(){u(this)}};var D;try{D=e("stream").Stream}catch(e){D=function(){}}var L=r.EVENTS.filter(function(e){return"error"!==e&&"end"!==e});f.prototype=(0,m.default)(D.prototype,{constructor:{value:f}}),f.prototype.write=function(r){if("function"==typeof t&&"function"==typeof t.isBuffer&&t.isBuffer(r)){if(!this._decoder){var n=e("string_decoder").StringDecoder;this._decoder=new n("utf8")}r=this._decoder.write(r)}return this._parser.write(r.toString()),this.emit("data",r),!0},f.prototype.end=function(e){return e&&e.length&&this.write(e),this._parser.end(),!0},f.prototype.on=function(e,t){var r=this;return r._parser["on"+e]||L.indexOf(e)===-1||(r._parser["on"+e]=function(){var t=1===arguments.length?[arguments[0]]:Array.apply(null,arguments);t.splice(0,0,e),r.emit.apply(r,t)}),D.prototype.on.call(r,e,t)};var q="\r\n\t ",U="0124356789",B="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",F="'\"",z=q+">",G="[CDATA[",H="DOCTYPE",Y="http://www.w3.org/XML/1998/namespace",X="http://www.w3.org/2000/xmlns/",K={xml:Y,xmlns:X};q=h(q),U=h(U),B=h(B);var V=/[:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/,W=/[:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u00B7\u0300-\u036F\u203F-\u2040\.\d-]/,$=/[#:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/,J=/[#:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u00B7\u0300-\u036F\u203F-\u2040\.\d-]/;F=h(F),z=h(z);var Q=0;r.STATE={BEGIN:Q++,BEGIN_WHITESPACE:Q++,TEXT:Q++,TEXT_ENTITY:Q++,OPEN_WAKA:Q++,SGML_DECL:Q++,SGML_DECL_QUOTED:Q++,DOCTYPE:Q++,DOCTYPE_QUOTED:Q++,DOCTYPE_DTD:Q++,DOCTYPE_DTD_QUOTED:Q++,COMMENT_STARTING:Q++,COMMENT:Q++,COMMENT_ENDING:Q++,COMMENT_ENDED:Q++,CDATA:Q++,CDATA_ENDING:Q++,CDATA_ENDING_2:Q++,PROC_INST:Q++,PROC_INST_BODY:Q++,PROC_INST_ENDING:Q++,OPEN_TAG:Q++,OPEN_TAG_SLASH:Q++,ATTRIB:Q++,ATTRIB_NAME:Q++,ATTRIB_NAME_SAW_WHITE:Q++,ATTRIB_VALUE:Q++,ATTRIB_VALUE_QUOTED:Q++,ATTRIB_VALUE_CLOSED:Q++,ATTRIB_VALUE_UNQUOTED:Q++,ATTRIB_VALUE_ENTITY_Q:Q++,ATTRIB_VALUE_ENTITY_U:Q++,CLOSE_TAG:Q++,CLOSE_TAG_SAW_WHITE:Q++,SCRIPT:Q++,SCRIPT_ENDING:Q++},r.XML_ENTITIES={amp:"&",gt:">",lt:"<",quot:'"',apos:"'"},r.ENTITIES={amp:"&",gt:">",lt:"<",quot:'"',apos:"'",AElig:198,Aacute:193,Acirc:194,Agrave:192,Aring:197,Atilde:195,Auml:196,Ccedil:199,ETH:208,Eacute:201,Ecirc:202,Egrave:200,Euml:203,Iacute:205,Icirc:206,Igrave:204,Iuml:207,Ntilde:209,Oacute:211,Ocirc:212,Ograve:210,Oslash:216,Otilde:213,Ouml:214,THORN:222,Uacute:218,Ucirc:219,Ugrave:217,Uuml:220,Yacute:221,aacute:225,acirc:226,aelig:230,agrave:224,aring:229,atilde:227,auml:228,ccedil:231,eacute:233,ecirc:234,egrave:232,eth:240,euml:235,iacute:237,icirc:238,igrave:236,iuml:239,ntilde:241,oacute:243,ocirc:244,ograve:242,oslash:248,otilde:245,ouml:246,szlig:223,thorn:254,uacute:250,ucirc:251,ugrave:249,uuml:252,yacute:253,yuml:255,copy:169,reg:174,nbsp:160,iexcl:161,cent:162,pound:163,curren:164,yen:165,brvbar:166,sect:167,uml:168,ordf:170,laquo:171,not:172,shy:173,macr:175,deg:176,plusmn:177,sup1:185,sup2:178,sup3:179,acute:180,micro:181,para:182,middot:183,cedil:184,ordm:186,raquo:187,frac14:188,frac12:189,frac34:190,iquest:191,times:215,divide:247,OElig:338,oelig:339,Scaron:352,scaron:353,Yuml:376,fnof:402,circ:710,tilde:732,Alpha:913,Beta:914,Gamma:915,Delta:916,Epsilon:917,Zeta:918,Eta:919,Theta:920,Iota:921,Kappa:922,Lambda:923,Mu:924,Nu:925,Xi:926,Omicron:927,Pi:928,Rho:929,Sigma:931,Tau:932,Upsilon:933,Phi:934,Chi:935,Psi:936,Omega:937,alpha:945,beta:946,gamma:947,delta:948,epsilon:949,zeta:950,eta:951,theta:952,iota:953,kappa:954,lambda:955,mu:956,nu:957,xi:958,omicron:959,pi:960,rho:961,sigmaf:962,sigma:963,tau:964,upsilon:965,phi:966,chi:967,psi:968,omega:969,thetasym:977,upsih:978,piv:982,ensp:8194,emsp:8195,thinsp:8201,zwnj:8204,zwj:8205,lrm:8206,rlm:8207,ndash:8211,mdash:8212,lsquo:8216,rsquo:8217,sbquo:8218,ldquo:8220,rdquo:8221,bdquo:8222,dagger:8224,Dagger:8225,bull:8226,hellip:8230,permil:8240,prime:8242,Prime:8243,lsaquo:8249,rsaquo:8250,oline:8254,frasl:8260,euro:8364,image:8465,weierp:8472,real:8476,trade:8482,alefsym:8501,larr:8592,uarr:8593,rarr:8594,darr:8595,harr:8596,crarr:8629,lArr:8656,uArr:8657,rArr:8658,dArr:8659,hArr:8660,forall:8704,part:8706,exist:8707,empty:8709,nabla:8711,isin:8712,notin:8713,ni:8715,prod:8719,sum:8721,minus:8722,lowast:8727,radic:8730,prop:8733,infin:8734,ang:8736,and:8743,or:8744,cap:8745,cup:8746,int:8747,there4:8756,sim:8764,cong:8773,asymp:8776,ne:8800,equiv:8801,le:8804,ge:8805,sub:8834,sup:8835,nsub:8836,sube:8838,supe:8839,oplus:8853,otimes:8855,perp:8869,sdot:8901,lceil:8968,rceil:8969,lfloor:8970,rfloor:8971,lang:9001,rang:9002,loz:9674,spades:9824,clubs:9827,hearts:9829,diams:9830},(0,d.default)(r.ENTITIES).forEach(function(e){var t=r.ENTITIES[e],n="number"==typeof t?String.fromCharCode(t):t;r.ENTITIES[e]=n});for(var Z in r.STATE)r.STATE[r.STATE[Z]]=Z;Q=r.STATE,o.default||!function(){var e=String.fromCharCode,t=Math.floor,r=function(){var r,n,i=16384,o=[],a=-1,s=arguments.length;if(!s)return"";for(var u="";++a<s;){var c=Number(arguments[a]);if(!isFinite(c)||c<0||c>1114111||t(c)!==c)throw RangeError("Invalid code point: "+c);c<=65535?o.push(c):(c-=65536,r=(c>>10)+55296,n=c%1024+56320,o.push(r,n)),(a+1===s||o.length>i)&&(u+=e.apply(null,o),o.length=0)}return u};p.default?Object.defineProperty(String,"fromCodePoint",{value:r,configurable:!0,writable:!0}):String.fromCodePoint=r}()}("undefined"==typeof r?(void 0).sax={}:r)}).call(this,e("buffer").Buffer)},{"babel-runtime/core-js/json/stringify":18,"babel-runtime/core-js/object/create":22,"babel-runtime/core-js/object/define-property":24,"babel-runtime/core-js/object/keys":30,"babel-runtime/core-js/string/from-code-point":35,"babel-runtime/helpers/typeof":39,buffer:45,stream:369,string_decoder:374}],365:[function(e,t,r){(function(r,n){"use strict";function i(){a.call(this),this.on("error",this.defaultErrorHandler.bind(this))}var o=e("get-ready"),a=e("events").EventEmitter,s=e("util");t.exports=i,s.inherits(i,a),o.mixin(i.prototype),i.prototype.defaultErrorHandler=function(e){if(!(this.listeners("error").length>1)){console.error("\n[%s][pid: %s][%s][%s] %s: %s \nError Stack:\n  %s",Date(),r.pid,this.constructor.name,n,e.name,e.message,e.stack);var t=[];for(var i in e)"name"!==i&&"message"!==i&&t.push(s.format("  %s: %j",i,e[i]));t.length&&console.error("Error Additions:\n%s",t.join("\n")),console.error()}}}).call(this,e("_process"),"/node_modules/sdk-base/index.js")},{_process:345,events:193,"get-ready":194,util:384}],366:[function(e,t,r){(function(n){"use strict";function i(e){return e&&e.__esModule?e:{default:e}}function o(e,t){if(e instanceof u)return e;if("string"!=typeof e)return null;if(e.length>te)return null;var r=t?ne[_e]:ne[ve];if(!r.test(e))return null;try{return new u(e,t)}catch(e){return null}}function a(e,t){var r=o(e,t);return r?r.version:null}function s(e,t){var r=o(e.trim().replace(/^[=v]+/,""),t);return r?r.version:null}function u(e,t){if(e instanceof u){if(e.loose===t)return e;e=e.version}else if("string"!=typeof e)throw new TypeError("Invalid Version: "+e);if(e.length>te)throw new TypeError("version is longer than "+te+" characters");if(!(this instanceof u))return new u(e,t);ee("SemVer",e,t),this.loose=t;var r=e.trim().match(t?ne[_e]:ne[ve]);if(!r)throw new TypeError("Invalid Version: "+e);if(this.raw=e,this.major=+r[1],this.minor=+r[2],this.patch=+r[3],this.major>re||this.major<0)throw new TypeError("Invalid major version");if(this.minor>re||this.minor<0)throw new TypeError("Invalid minor version");if(this.patch>re||this.patch<0)throw new TypeError("Invalid patch version");r[4]?this.prerelease=r[4].split(".").map(function(e){if(/^[0-9]+$/.test(e)){var t=+e;if(t>=0&&t<re)return t}return e}):this.prerelease=[],this.build=r[5]?r[5].split("."):[],this.format()}function c(e,t,r,n){"string"==typeof r&&(n=r,r=void 0);try{return new u(e,r).inc(t,n).version}catch(e){return null}}function l(e,t){if(E(e,t))return null;var r=o(e),n=o(t);if(r.prerelease.length||n.prerelease.length){for(var i in r)if(("major"===i||"minor"===i||"patch"===i)&&r[i]!==n[i])return"pre"+i;return"prerelease"}for(var i in r)if(("major"===i||"minor"===i||"patch"===i)&&r[i]!==n[i])return i}function p(e,t){var r=Xe.test(e),n=Xe.test(t);return r&&n&&(e=+e,t=+t),r&&!n?-1:n&&!r?1:e<t?-1:e>t?1:0}function f(e,t){return p(t,e)}function d(e,t){return new u(e,t).major}function h(e,t){return new u(e,t).minor}function m(e,t){return new u(e,t).patch}function b(e,t,r){return new u(e,r).compare(t)}function v(e,t){return b(e,t,!0)}function g(e,t,r){return b(t,e,r)}function y(e,t){return e.sort(function(e,n){return r.compare(e,n,t)})}function _(e,t){return e.sort(function(e,n){return r.rcompare(e,n,t)})}function x(e,t,r){return b(e,t,r)>0}function w(e,t,r){return b(e,t,r)<0}function E(e,t,r){return 0===b(e,t,r)}function j(e,t,r){return 0!==b(e,t,r)}function S(e,t,r){return b(e,t,r)>=0}function T(e,t,r){return b(e,t,r)<=0}function k(e,t,r,n){var i;switch(t){case"===":"object"===("undefined"==typeof e?"undefined":(0,Z.default)(e))&&(e=e.version),"object"===("undefined"==typeof r?"undefined":(0,Z.default)(r))&&(r=r.version),i=e===r;break;case"!==":"object"===("undefined"==typeof e?"undefined":(0,Z.default)(e))&&(e=e.version),"object"===("undefined"==typeof r?"undefined":(0,Z.default)(r))&&(r=r.version),i=e!==r;break;case"":case"=":case"==":i=E(e,r,n);break;case"!=":i=j(e,r,n);break;case">":i=x(e,r,n);break;case">=":i=S(e,r,n);break;case"<":i=w(e,r,n);break;case"<=":i=T(e,r,n);break;default:throw new TypeError("Invalid operator: "+t)}return i}function A(e,t){if(e instanceof A){if(e.loose===t)return e;e=e.value}return this instanceof A?(ee("comparator",e,t),this.loose=t,this.parse(e),this.semver===Ke?this.value="":this.value=this.operator+this.semver.version,void ee("comp",this)):new A(e,t)}function O(e,t){if(e instanceof O&&e.loose===t)return e;if(!(this instanceof O))return new O(e,t);if(this.loose=t,this.raw=e,this.set=e.split(/\s*\|\|\s*/).map(function(e){return this.parseRange(e.trim())},this).filter(function(e){return e.length}),!this.set.length)throw new TypeError("Invalid SemVer Range: "+e);this.format()}function R(e,t){return new O(e,t).set.map(function(e){return e.map(function(e){return e.value}).join(" ").trim().split(" ")})}function I(e,t){return ee("comp",e),e=N(e,t),ee("caret",e),e=M(e,t),ee("tildes",e),e=L(e,t),ee("xrange",e),e=U(e,t),ee("stars",e),e}function C(e){return!e||"x"===e.toLowerCase()||"*"===e}function M(e,t){return e.trim().split(/\s+/).map(function(e){return P(e,t)}).join(" ")}function P(e,t){var r=t?ne[Ce]:ne[Ie];return e.replace(r,function(t,r,n,i,o){ee("tilde",e,t,r,n,i,o);var a;return C(r)?a="":C(n)?a=">="+r+".0.0 <"+(+r+1)+".0.0":C(i)?a=">="+r+"."+n+".0 <"+r+"."+(+n+1)+".0":o?(ee("replaceTilde pr",o),"-"!==o.charAt(0)&&(o="-"+o),a=">="+r+"."+n+"."+i+o+" <"+r+"."+(+n+1)+".0"):a=">="+r+"."+n+"."+i+" <"+r+"."+(+n+1)+".0",ee("tilde return",a),a})}function N(e,t){return e.trim().split(/\s+/).map(function(e){return D(e,t)}).join(" ")}function D(e,t){ee("caret",e,t);var r=t?ne[Le]:ne[De];return e.replace(r,function(t,r,n,i,o){ee("caret",e,t,r,n,i,o);var a;return C(r)?a="":C(n)?a=">="+r+".0.0 <"+(+r+1)+".0.0":C(i)?a="0"===r?">="+r+"."+n+".0 <"+r+"."+(+n+1)+".0":">="+r+"."+n+".0 <"+(+r+1)+".0.0":o?(ee("replaceCaret pr",o),"-"!==o.charAt(0)&&(o="-"+o),a="0"===r?"0"===n?">="+r+"."+n+"."+i+o+" <"+r+"."+n+"."+(+i+1):">="+r+"."+n+"."+i+o+" <"+r+"."+(+n+1)+".0":">="+r+"."+n+"."+i+o+" <"+(+r+1)+".0.0"):(ee("no pr"),a="0"===r?"0"===n?">="+r+"."+n+"."+i+" <"+r+"."+n+"."+(+i+1):">="+r+"."+n+"."+i+" <"+r+"."+(+n+1)+".0":">="+r+"."+n+"."+i+" <"+(+r+1)+".0.0"),ee("caret return",a),a})}function L(e,t){return ee("replaceXRanges",e,t),e.split(/\s+/).map(function(e){return q(e,t)}).join(" ")}function q(e,t){e=e.trim();var r=t?ne[ke]:ne[Te];return e.replace(r,function(t,r,n,i,o,a){ee("xRange",e,t,r,n,i,o,a);var s=C(n),u=s||C(i),c=u||C(o),l=c;return"="===r&&l&&(r=""),s?t=">"===r||"<"===r?"<0.0.0":"*":r&&l?(u&&(i=0),c&&(o=0),">"===r?(r=">=",u?(n=+n+1,i=0,o=0):c&&(i=+i+1,o=0)):"<="===r&&(r="<",u?n=+n+1:i=+i+1),t=r+n+"."+i+"."+o):u?t=">="+n+".0.0 <"+(+n+1)+".0.0":c&&(t=">="+n+"."+i+".0 <"+n+"."+(+i+1)+".0"),ee("xRange return",t),t})}function U(e,t){return ee("replaceStars",e,t),e.trim().replace(ne[He],"")}function B(e,t,r,n,i,o,a,s,u,c,l,p,f){return t=C(r)?"":C(n)?">="+r+".0.0":C(i)?">="+r+"."+n+".0":">="+t,s=C(u)?"":C(c)?"<"+(+u+1)+".0.0":C(l)?"<"+u+"."+(+c+1)+".0":p?"<="+u+"."+c+"."+l+"-"+p:"<="+s,(t+" "+s).trim()}function F(e,t){for(var r=0;r<e.length;r++)if(!e[r].test(t))return!1;if(t.prerelease.length){for(var r=0;r<e.length;r++)if(ee(e[r].semver),e[r].semver!==Ke&&e[r].semver.prerelease.length>0){var n=e[r].semver;if(n.major===t.major&&n.minor===t.minor&&n.patch===t.patch)return!0}return!1}return!0}function z(e,t,r){try{t=new O(t,r)}catch(e){return!1}return t.test(e)}function G(e,t,r){return e.filter(function(e){return z(e,t,r)}).sort(function(e,t){return g(e,t,r)})[0]||null}function H(e,t,r){return e.filter(function(e){return z(e,t,r)}).sort(function(e,t){return b(e,t,r)})[0]||null}function Y(e,t){try{return new O(e,t).range||"*"}catch(e){return null}}function X(e,t,r){return V(e,t,"<",r)}function K(e,t,r){return V(e,t,">",r)}function V(e,t,r,n){e=new u(e,n),t=new O(t,n);var i,o,a,s,c;switch(r){case">":i=x,o=T,a=w,s=">",c=">=";break;case"<":i=w,o=S,a=x,s="<",c="<=";break;default:throw new TypeError('Must provide a hilo val of "<" or ">"')}if(z(e,t,n))return!1;for(var l=0;l<t.set.length;++l){var p=t.set[l],f=null,d=null;if(p.forEach(function(e){e.semver===Ke&&(e=new A(">=0.0.0")),f=f||e,d=d||e,i(e.semver,f.semver,n)?f=e:a(e.semver,d.semver,n)&&(d=e)}),f.operator===s||f.operator===c)return!1;if((!d.operator||d.operator===s)&&o(e,d.semver))return!1;if(d.operator===c&&a(e,d.semver))return!1}return!0}function W(e,t){var r=o(e,t);return r&&r.prerelease.length?r.prerelease:null}var $=e("babel-runtime/core-js/number/max-safe-integer"),J=i($),Q=e("babel-runtime/helpers/typeof"),Z=i(Q);r=t.exports=u;var ee;ee="object"===("undefined"==typeof n?"undefined":(0,Z.default)(n))&&n.env&&n.env.NODE_DEBUG&&/\bsemver\b/i.test(n.env.NODE_DEBUG)?function(){var e=Array.prototype.slice.call(arguments,0);e.unshift("SEMVER"),console.log.apply(console,e)}:function(){},r.SEMVER_SPEC_VERSION="2.0.0";var te=256,re=J.default||9007199254740991,ne=r.re=[],ie=r.src=[],oe=0,ae=oe++;ie[ae]="0|[1-9]\\d*";var se=oe++;ie[se]="[0-9]+";var ue=oe++;ie[ue]="\\d*[a-zA-Z-][a-zA-Z0-9-]*";var ce=oe++;ie[ce]="("+ie[ae]+")\\.("+ie[ae]+")\\.("+ie[ae]+")";var le=oe++;ie[le]="("+ie[se]+")\\.("+ie[se]+")\\.("+ie[se]+")";var pe=oe++;ie[pe]="(?:"+ie[ae]+"|"+ie[ue]+")";var fe=oe++;ie[fe]="(?:"+ie[se]+"|"+ie[ue]+")";var de=oe++;ie[de]="(?:-("+ie[pe]+"(?:\\."+ie[pe]+")*))";var he=oe++;ie[he]="(?:-?("+ie[fe]+"(?:\\."+ie[fe]+")*))";var me=oe++;ie[me]="[0-9A-Za-z-]+";var be=oe++;ie[be]="(?:\\+("+ie[me]+"(?:\\."+ie[me]+")*))";var ve=oe++,ge="v?"+ie[ce]+ie[de]+"?"+ie[be]+"?";ie[ve]="^"+ge+"$";var ye="[v=\\s]*"+ie[le]+ie[he]+"?"+ie[be]+"?",_e=oe++;ie[_e]="^"+ye+"$";var xe=oe++;ie[xe]="((?:<|>)?=?)";var we=oe++;ie[we]=ie[se]+"|x|X|\\*";var Ee=oe++;ie[Ee]=ie[ae]+"|x|X|\\*";var je=oe++;ie[je]="[v=\\s]*("+ie[Ee]+")(?:\\.("+ie[Ee]+")(?:\\.("+ie[Ee]+")(?:"+ie[de]+")?"+ie[be]+"?)?)?";var Se=oe++;ie[Se]="[v=\\s]*("+ie[we]+")(?:\\.("+ie[we]+")(?:\\.("+ie[we]+")(?:"+ie[he]+")?"+ie[be]+"?)?)?";var Te=oe++;ie[Te]="^"+ie[xe]+"\\s*"+ie[je]+"$";var ke=oe++;ie[ke]="^"+ie[xe]+"\\s*"+ie[Se]+"$";var Ae=oe++;ie[Ae]="(?:~>?)";var Oe=oe++;ie[Oe]="(\\s*)"+ie[Ae]+"\\s+",ne[Oe]=new RegExp(ie[Oe],"g");var Re="$1~",Ie=oe++;ie[Ie]="^"+ie[Ae]+ie[je]+"$";var Ce=oe++;ie[Ce]="^"+ie[Ae]+ie[Se]+"$";var Me=oe++;ie[Me]="(?:\\^)";var Pe=oe++;ie[Pe]="(\\s*)"+ie[Me]+"\\s+",ne[Pe]=new RegExp(ie[Pe],"g");var Ne="$1^",De=oe++;ie[De]="^"+ie[Me]+ie[je]+"$";var Le=oe++;ie[Le]="^"+ie[Me]+ie[Se]+"$";var qe=oe++;ie[qe]="^"+ie[xe]+"\\s*("+ye+")$|^$";var Ue=oe++;ie[Ue]="^"+ie[xe]+"\\s*("+ge+")$|^$";var Be=oe++;ie[Be]="(\\s*)"+ie[xe]+"\\s*("+ye+"|"+ie[je]+")",ne[Be]=new RegExp(ie[Be],"g");var Fe="$1$2$3",ze=oe++;ie[ze]="^\\s*("+ie[je]+")\\s+-\\s+("+ie[je]+")\\s*$";var Ge=oe++;ie[Ge]="^\\s*("+ie[Se]+")\\s+-\\s+("+ie[Se]+")\\s*$";var He=oe++;ie[He]="(<|>)?=?\\s*\\*";for(var Ye=0;Ye<oe;Ye++)ee(Ye,ie[Ye]),ne[Ye]||(ne[Ye]=new RegExp(ie[Ye]));r.parse=o,r.valid=a,r.clean=s,r.SemVer=u,u.prototype.format=function(){return this.version=this.major+"."+this.minor+"."+this.patch,this.prerelease.length&&(this.version+="-"+this.prerelease.join(".")),this.version},u.prototype.toString=function(){return this.version},u.prototype.compare=function(e){return ee("SemVer.compare",this.version,this.loose,e),e instanceof u||(e=new u(e,this.loose)),this.compareMain(e)||this.comparePre(e)},u.prototype.compareMain=function(e){return e instanceof u||(e=new u(e,this.loose)),p(this.major,e.major)||p(this.minor,e.minor)||p(this.patch,e.patch)},u.prototype.comparePre=function(e){if(e instanceof u||(e=new u(e,this.loose)),this.prerelease.length&&!e.prerelease.length)return-1;if(!this.prerelease.length&&e.prerelease.length)return 1;if(!this.prerelease.length&&!e.prerelease.length)return 0;var t=0;do{var r=this.prerelease[t],n=e.prerelease[t];if(ee("prerelease compare",t,r,n),void 0===r&&void 0===n)return 0;if(void 0===n)return 1;if(void 0===r)return-1;if(r!==n)return p(r,n)}while(++t)},u.prototype.inc=function(e,t){switch(e){case"premajor":this.prerelease.length=0,this.patch=0,this.minor=0,this.major++,this.inc("pre",t);break;case"preminor":this.prerelease.length=0,this.patch=0,this.minor++,this.inc("pre",t);break;case"prepatch":this.prerelease.length=0,this.inc("patch",t),this.inc("pre",t);break;case"prerelease":0===this.prerelease.length&&this.inc("patch",t),this.inc("pre",t);break;case"major":0===this.minor&&0===this.patch&&0!==this.prerelease.length||this.major++,this.minor=0,this.patch=0,this.prerelease=[];break;case"minor":0===this.patch&&0!==this.prerelease.length||this.minor++,this.patch=0,this.prerelease=[];break;case"patch":0===this.prerelease.length&&this.patch++,this.prerelease=[];break;case"pre":if(0===this.prerelease.length)this.prerelease=[0];else{for(var r=this.prerelease.length;--r>=0;)"number"==typeof this.prerelease[r]&&(this.prerelease[r]++,r=-2);r===-1&&this.prerelease.push(0)}t&&(this.prerelease[0]===t?isNaN(this.prerelease[1])&&(this.prerelease=[t,0]):this.prerelease=[t,0]);break;default:throw new Error("invalid increment argument: "+e)}return this.format(),this.raw=this.version,this},r.inc=c,r.diff=l,r.compareIdentifiers=p;var Xe=/^[0-9]+$/;r.rcompareIdentifiers=f,r.major=d,r.minor=h,r.patch=m,r.compare=b,r.compareLoose=v,r.rcompare=g,r.sort=y,r.rsort=_,r.gt=x,r.lt=w,r.eq=E,r.neq=j,r.gte=S,r.lte=T,r.cmp=k,r.Comparator=A;var Ke={};A.prototype.parse=function(e){var t=this.loose?ne[qe]:ne[Ue],r=e.match(t);if(!r)throw new TypeError("Invalid comparator: "+e);this.operator=r[1],"="===this.operator&&(this.operator=""),r[2]?this.semver=new u(r[2],this.loose):this.semver=Ke},A.prototype.toString=function(){return this.value},A.prototype.test=function(e){return ee("Comparator.test",e,this.loose),this.semver===Ke||("string"==typeof e&&(e=new u(e,this.loose)),k(e,this.operator,this.semver,this.loose))},r.Range=O,O.prototype.format=function(){return this.range=this.set.map(function(e){return e.join(" ").trim()}).join("||").trim(),this.range},O.prototype.toString=function(){return this.range},O.prototype.parseRange=function(e){var t=this.loose;e=e.trim(),ee("range",e,t);var r=t?ne[Ge]:ne[ze];e=e.replace(r,B),ee("hyphen replace",e),e=e.replace(ne[Be],Fe),ee("comparator trim",e,ne[Be]),e=e.replace(ne[Oe],Re),e=e.replace(ne[Pe],Ne),e=e.split(/\s+/).join(" ");var n=t?ne[qe]:ne[Ue],i=e.split(" ").map(function(e){return I(e,t)}).join(" ").split(/\s+/);return this.loose&&(i=i.filter(function(e){return!!e.match(n)})),i=i.map(function(e){return new A(e,t)})},r.toComparators=R,O.prototype.test=function(e){if(!e)return!1;"string"==typeof e&&(e=new u(e,this.loose));for(var t=0;t<this.set.length;t++)if(F(this.set[t],e))return!0;return!1},r.satisfies=z,r.maxSatisfying=G,r.minSatisfying=H,r.validRange=Y,r.ltr=X,r.gtr=K,r.outside=V,r.prerelease=W}).call(this,e("_process"))},{_process:345,"babel-runtime/core-js/number/max-safe-integer":21,"babel-runtime/helpers/typeof":39}],367:[function(e,t,r){t.exports={100:"Continue",101:"Switching Protocols",102:"Processing",200:"OK",201:"Created",202:"Accepted",203:"Non-Authoritative Information",204:"No Content",205:"Reset Content",206:"Partial Content",207:"Multi-Status",208:"Already Reported",226:"IM Used",300:"Multiple Choices",301:"Moved Permanently",302:"Found",303:"See Other",304:"Not Modified",305:"Use Proxy",306:"(Unused)",307:"Temporary Redirect",308:"Permanent Redirect",400:"Bad Request",401:"Unauthorized",402:"Payment Required",403:"Forbidden",404:"Not Found",405:"Method Not Allowed",406:"Not Acceptable",407:"Proxy Authentication Required",408:"Request Timeout",409:"Conflict",410:"Gone",411:"Length Required",412:"Precondition Failed",413:"Payload Too Large",414:"URI Too Long",415:"Unsupported Media Type",416:"Range Not Satisfiable",417:"Expectation Failed",418:"I'm a teapot",421:"Misdirected Request",422:"Unprocessable Entity",423:"Locked",424:"Failed Dependency",425:"Unordered Collection",426:"Upgrade Required",428:"Precondition Required",429:"Too Many Requests",431:"Request Header Fields Too Large",451:"Unavailable For Legal Reasons",500:"Internal Server Error",501:"Not Implemented",502:"Bad Gateway",503:"Service Unavailable",504:"Gateway Timeout",505:"HTTP Version Not Supported",506:"Variant Also Negotiates",507:"Insufficient Storage",508:"Loop Detected",509:"Bandwidth Limit Exceeded",510:"Not Extended",511:"Network Authentication Required"}},{}],368:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}function i(e,t){var r=[];return(0,s.default)(t).forEach(function(n){var i=t[n],o=Number(n);e[o]=i,e[i]=o,e[i.toLowerCase()]=o,r.push(o)}),r}function o(e){if("number"==typeof e){if(!o[e])throw new Error("invalid status code: "+e);return e}if("string"!=typeof e)throw new TypeError("code must be a number or string");var t=parseInt(e,10);if(!isNaN(t)){if(!o[t])throw new Error("invalid status code: "+t);return t}if(t=o[e.toLowerCase()],!t)throw new Error('invalid status message: "'+e+'"');return t}var a=e("babel-runtime/core-js/object/keys"),s=n(a),u=e("./codes.json");t.exports=o,o.codes=i(o,u),o.redirect={300:!0,301:!0,302:!0,303:!0,305:!0,307:!0,308:!0},o.empty={204:!0,205:!0,304:!0},o.retry={502:!0,503:!0,504:!0}},{"./codes.json":367,"babel-runtime/core-js/object/keys":30}],369:[function(e,t,r){"use strict";function n(){i.call(this)}t.exports=n;var i=e("events").EventEmitter,o=e("inherits");o(n,i),n.Readable=e("readable-stream/readable.js"),n.Writable=e("readable-stream/writable.js"),n.Duplex=e("readable-stream/duplex.js"),n.Transform=e("readable-stream/transform.js"),n.PassThrough=e("readable-stream/passthrough.js"),n.Stream=n,n.prototype.pipe=function(e,t){function r(t){e.writable&&!1===e.write(t)&&c.pause&&c.pause()}function n(){c.readable&&c.resume&&c.resume()}function o(){l||(l=!0,e.end())}function a(){l||(l=!0,"function"==typeof e.destroy&&e.destroy())}function s(e){if(u(),0===i.listenerCount(this,"error"))throw e}function u(){c.removeListener("data",r),e.removeListener("drain",n),c.removeListener("end",o),c.removeListener("close",a),c.removeListener("error",s),e.removeListener("error",s),
+c.removeListener("end",u),c.removeListener("close",u),e.removeListener("close",u)}var c=this;c.on("data",r),e.on("drain",n),e._isStdio||t&&t.end===!1||(c.on("end",o),c.on("close",a));var l=!1;return c.on("error",s),e.on("error",s),c.on("end",u),c.on("close",u),e.on("close",u),e.emit("pipe",c),e}},{events:193,inherits:198,"readable-stream/duplex.js":350,"readable-stream/passthrough.js":358,"readable-stream/readable.js":359,"readable-stream/transform.js":360,"readable-stream/writable.js":361}],370:[function(e,t,r){(function(t){"use strict";var n=e("./lib/request"),i=e("xtend"),o=e("builtin-status-codes"),a=e("url"),s=r;s.request=function(e,r){e="string"==typeof e?a.parse(e):i(e);var o=t.location.protocol.search(/^https?:$/)===-1?"http:":"",s=e.protocol||o,u=e.hostname||e.host,c=e.port,l=e.path||"/";u&&u.indexOf(":")!==-1&&(u="["+u+"]"),e.url=(u?s+"//"+u:"")+(c?":"+c:"")+l,e.method=(e.method||"GET").toUpperCase(),e.headers=e.headers||{};var p=new n(e);return r&&p.on("response",r),p},s.get=function(e,t){var r=s.request(e,t);return r.end(),r},s.Agent=function(){},s.Agent.defaultMaxSockets=4,s.STATUS_CODES=o,s.METHODS=["CHECKOUT","CONNECT","COPY","DELETE","GET","HEAD","LOCK","M-SEARCH","MERGE","MKACTIVITY","MKCOL","MOVE","NOTIFY","OPTIONS","PATCH","POST","PROPFIND","PROPPATCH","PURGE","PUT","REPORT","SEARCH","SUBSCRIBE","TRACE","UNLOCK","UNSUBSCRIBE"]}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{"./lib/request":372,"builtin-status-codes":47,url:377,xtend:418}],371:[function(e,t,r){(function(e){"use strict";function t(e){try{return i.responseType=e,i.responseType===e}catch(e){}return!1}function n(e){return"function"==typeof e}r.fetch=n(e.fetch)&&n(e.ReadableStream),r.blobConstructor=!1;try{new Blob([new ArrayBuffer(1)]),r.blobConstructor=!0}catch(e){}var i=new e.XMLHttpRequest;i.open("GET",e.location.host?"/":"https://example.com");var o="undefined"!=typeof e.ArrayBuffer,a=o&&n(e.ArrayBuffer.prototype.slice);r.arraybuffer=o&&t("arraybuffer"),r.msstream=!r.fetch&&a&&t("ms-stream"),r.mozchunkedarraybuffer=!r.fetch&&o&&t("moz-chunked-arraybuffer"),r.overrideMimeType=n(i.overrideMimeType),r.vbArray=n(e.VBArray),i=null}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{}],372:[function(e,t,r){(function(r,n,i){"use strict";function o(e){return e&&e.__esModule?e:{default:e}}function a(e,t){return l.fetch&&t?"fetch":l.mozchunkedarraybuffer?"moz-chunked-arraybuffer":l.msstream?"ms-stream":l.arraybuffer&&e?"arraybuffer":l.vbArray&&e?"text:vbarray":"text"}function s(e){try{var t=e.status;return null!==t&&0!==t}catch(e){return!1}}var u=e("babel-runtime/core-js/object/keys"),c=o(u),l=e("./capability"),p=e("inherits"),f=e("./response"),d=e("readable-stream"),h=e("to-arraybuffer"),m=f.IncomingMessage,b=f.readyStates,v=t.exports=function(e){var t=this;d.Writable.call(t),t._opts=e,t._body=[],t._headers={},e.auth&&t.setHeader("Authorization","Basic "+new i(e.auth).toString("base64")),(0,c.default)(e.headers).forEach(function(r){t.setHeader(r,e.headers[r])});var r,n=!0;if("disable-fetch"===e.mode)n=!1,r=!0;else if("prefer-streaming"===e.mode)r=!1;else if("allow-wrong-content-type"===e.mode)r=!l.overrideMimeType;else{if(e.mode&&"default"!==e.mode&&"prefer-fast"!==e.mode)throw new Error("Invalid value for opts.mode");r=!0}t._mode=a(r,n),t.on("finish",function(){t._onFinish()})};p(v,d.Writable),v.prototype.setHeader=function(e,t){var r=this,n=e.toLowerCase();g.indexOf(n)===-1&&(r._headers[n]={name:e,value:t})},v.prototype.getHeader=function(e){var t=this;return t._headers[e.toLowerCase()].value},v.prototype.removeHeader=function(e){var t=this;delete t._headers[e.toLowerCase()]},v.prototype._onFinish=function(){var e=this;if(!e._destroyed){var t,o=e._opts,a=e._headers;if("POST"!==o.method&&"PUT"!==o.method&&"PATCH"!==o.method||(t=l.blobConstructor?new n.Blob(e._body.map(function(e){return h(e)}),{type:(a["content-type"]||{}).value||""}):i.concat(e._body).toString()),"fetch"===e._mode){var s=(0,c.default)(a).map(function(e){return[a[e].name,a[e].value]});n.fetch(e._opts.url,{method:e._opts.method,headers:s,body:t,mode:"cors",credentials:o.withCredentials?"include":"same-origin"}).then(function(t){e._fetchResponse=t,e._connect()},function(t){e.emit("error",t)})}else{var u=e._xhr=new n.XMLHttpRequest;try{u.open(e._opts.method,e._opts.url,!0)}catch(t){return void r.nextTick(function(){e.emit("error",t)})}"responseType"in u&&(u.responseType=e._mode.split(":")[0]),"withCredentials"in u&&(u.withCredentials=!!o.withCredentials),"text"===e._mode&&"overrideMimeType"in u&&u.overrideMimeType("text/plain; charset=x-user-defined"),(0,c.default)(a).forEach(function(e){u.setRequestHeader(a[e].name,a[e].value)}),e._response=null,u.onreadystatechange=function(){switch(u.readyState){case b.LOADING:case b.DONE:e._onXHRProgress()}},"moz-chunked-arraybuffer"===e._mode&&(u.onprogress=function(){e._onXHRProgress()}),u.onerror=function(){e._destroyed||e.emit("error",new Error("XHR error"))};try{u.send(t)}catch(t){return void r.nextTick(function(){e.emit("error",t)})}}}},v.prototype._onXHRProgress=function(){var e=this;s(e._xhr)&&!e._destroyed&&(e._response||e._connect(),e._response._onXHRProgress())},v.prototype._connect=function(){var e=this;e._destroyed||(e._response=new m(e._xhr,e._fetchResponse,e._mode),e.emit("response",e._response))},v.prototype._write=function(e,t,r){var n=this;n._body.push(e),r()},v.prototype.abort=v.prototype.destroy=function(){var e=this;e._destroyed=!0,e._response&&(e._response._destroyed=!0),e._xhr&&e._xhr.abort()},v.prototype.end=function(e,t,r){var n=this;"function"==typeof e&&(r=e,e=void 0),d.Writable.prototype.end.call(n,e,t,r)},v.prototype.flushHeaders=function(){},v.prototype.setTimeout=function(){},v.prototype.setNoDelay=function(){},v.prototype.setSocketKeepAlive=function(){};var g=["accept-charset","accept-encoding","access-control-request-headers","access-control-request-method","connection","content-length","cookie","cookie2","date","dnt","expect","host","keep-alive","origin","referer","te","trailer","transfer-encoding","upgrade","user-agent","via"]}).call(this,e("_process"),"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{},e("buffer").Buffer)},{"./capability":371,"./response":373,_process:345,"babel-runtime/core-js/object/keys":30,buffer:45,inherits:198,"readable-stream":359,"to-arraybuffer":376}],373:[function(e,t,r){(function(t,n,i){"use strict";function o(e){return e&&e.__esModule?e:{default:e}}var a=e("babel-runtime/core-js/get-iterator"),s=o(a),u=e("./capability"),c=e("inherits"),l=e("readable-stream"),p=r.readyStates={UNSENT:0,OPENED:1,HEADERS_RECEIVED:2,LOADING:3,DONE:4},f=r.IncomingMessage=function(e,r,n){var o=this;if(l.Readable.call(o),o._mode=n,o.headers={},o.rawHeaders=[],o.trailers={},o.rawTrailers=[],o.on("end",function(){t.nextTick(function(){o.emit("close")})}),"fetch"===n){var a,c,p,f;!function(){var e=function e(){f.read().then(function(t){if(!o._destroyed){if(t.done)return void o.push(null);o.push(new i(t.value)),e()}})};for(o._fetchResponse=r,o.url=r.url,o.statusCode=r.status,o.statusMessage=r.statusText,p=(0,s.default)(r.headers);a=(c=p.next()).value,!c.done;)o.headers[a[0].toLowerCase()]=a[1],o.rawHeaders.push(a[0],a[1]);f=r.body.getReader(),e()}()}else{o._xhr=e,o._pos=0,o.url=e.responseURL,o.statusCode=e.status,o.statusMessage=e.statusText;var d=e.getAllResponseHeaders().split(/\r?\n/);if(d.forEach(function(e){var t=e.match(/^([^:]+):\s*(.*)/);if(t){var r=t[1].toLowerCase();"set-cookie"===r?(void 0===o.headers[r]&&(o.headers[r]=[]),o.headers[r].push(t[2])):void 0!==o.headers[r]?o.headers[r]+=", "+t[2]:o.headers[r]=t[2],o.rawHeaders.push(t[1],t[2])}}),o._charset="x-user-defined",!u.overrideMimeType){var h=o.rawHeaders["mime-type"];if(h){var m=h.match(/;\s*charset=([^;])(;|$)/);m&&(o._charset=m[1].toLowerCase())}o._charset||(o._charset="utf-8")}}};c(f,l.Readable),f.prototype._read=function(){},f.prototype._onXHRProgress=function(){var e=this,t=e._xhr,r=null;switch(e._mode){case"text:vbarray":if(t.readyState!==p.DONE)break;try{r=new n.VBArray(t.responseBody).toArray()}catch(e){}if(null!==r){e.push(new i(r));break}case"text":try{r=t.responseText}catch(t){e._mode="text:vbarray";break}if(r.length>e._pos){var o=r.substr(e._pos);if("x-user-defined"===e._charset){for(var a=new i(o.length),s=0;s<o.length;s++)a[s]=255&o.charCodeAt(s);e.push(a)}else e.push(o,e._charset);e._pos=r.length}break;case"arraybuffer":if(t.readyState!==p.DONE||!t.response)break;r=t.response,e.push(new i(new Uint8Array(r)));break;case"moz-chunked-arraybuffer":if(r=t.response,t.readyState!==p.LOADING||!r)break;e.push(new i(new Uint8Array(r)));break;case"ms-stream":if(r=t.response,t.readyState!==p.LOADING)break;var u=new n.MSStreamReader;u.onprogress=function(){u.result.byteLength>e._pos&&(e.push(new i(new Uint8Array(u.result.slice(e._pos)))),e._pos=u.result.byteLength)},u.onload=function(){e.push(null)},u.readAsArrayBuffer(r)}e._xhr.readyState===p.DONE&&"ms-stream"!==e._mode&&e.push(null)}}).call(this,e("_process"),"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{},e("buffer").Buffer)},{"./capability":371,_process:345,"babel-runtime/core-js/get-iterator":17,buffer:45,inherits:198,"readable-stream":359}],374:[function(e,t,r){"use strict";function n(e){if(e&&!u(e))throw new Error("Unknown encoding: "+e)}function i(e){return e.toString(this.encoding)}function o(e){this.charReceived=e.length%2,this.charLength=this.charReceived?2:0}function a(e){this.charReceived=e.length%3,this.charLength=this.charReceived?3:0}var s=e("buffer").Buffer,u=s.isEncoding||function(e){switch(e&&e.toLowerCase()){case"hex":case"utf8":case"utf-8":case"ascii":case"binary":case"base64":case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":case"raw":return!0;default:return!1}},c=r.StringDecoder=function(e){switch(this.encoding=(e||"utf8").toLowerCase().replace(/[-_]/,""),n(e),this.encoding){case"utf8":this.surrogateSize=3;break;case"ucs2":case"utf16le":this.surrogateSize=2,this.detectIncompleteChar=o;break;case"base64":this.surrogateSize=3,this.detectIncompleteChar=a;break;default:return void(this.write=i)}this.charBuffer=new s(6),this.charReceived=0,this.charLength=0};c.prototype.write=function(e){for(var t="";this.charLength;){var r=e.length>=this.charLength-this.charReceived?this.charLength-this.charReceived:e.length;if(e.copy(this.charBuffer,this.charReceived,0,r),this.charReceived+=r,this.charReceived<this.charLength)return"";e=e.slice(r,e.length),t=this.charBuffer.slice(0,this.charLength).toString(this.encoding);var n=t.charCodeAt(t.length-1);if(!(n>=55296&&n<=56319)){if(this.charReceived=this.charLength=0,0===e.length)return t;break}this.charLength+=this.surrogateSize,t=""}this.detectIncompleteChar(e);var i=e.length;this.charLength&&(e.copy(this.charBuffer,0,e.length-this.charReceived,i),i-=this.charReceived),t+=e.toString(this.encoding,0,i);var i=t.length-1,n=t.charCodeAt(i);if(n>=55296&&n<=56319){var o=this.surrogateSize;return this.charLength+=o,this.charReceived+=o,this.charBuffer.copy(this.charBuffer,o,0,o),e.copy(this.charBuffer,0,0,o),t.substring(0,i)}return t},c.prototype.detectIncompleteChar=function(e){for(var t=e.length>=3?3:e.length;t>0;t--){var r=e[e.length-t];if(1==t&&r>>5==6){this.charLength=2;break}if(t<=2&&r>>4==14){this.charLength=3;break}if(t<=3&&r>>3==30){this.charLength=4;break}}this.charReceived=t},c.prototype.end=function(e){var t="";if(e&&e.length&&(t=this.write(e)),this.charReceived){var r=this.charReceived,n=this.charBuffer,i=this.encoding;t+=n.slice(0,r).toString(i)}return t}},{buffer:45}],375:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}function i(e,t){this._id=e,this._clearFn=t}var o=e("babel-runtime/core-js/clear-immediate"),a=n(o),s=e("babel-runtime/core-js/set-immediate"),u=n(s),c=e("process/browser.js").nextTick,l=Function.prototype.apply,p=Array.prototype.slice,f={},d=0;r.setTimeout=function(){return new i(l.call(setTimeout,window,arguments),clearTimeout)},r.setInterval=function(){return new i(l.call(setInterval,window,arguments),clearInterval)},r.clearTimeout=r.clearInterval=function(e){e.close()},i.prototype.unref=i.prototype.ref=function(){},i.prototype.close=function(){this._clearFn.call(window,this._id)},r.enroll=function(e,t){clearTimeout(e._idleTimeoutId),e._idleTimeout=t},r.unenroll=function(e){clearTimeout(e._idleTimeoutId),e._idleTimeout=-1},r._unrefActive=r.active=function(e){clearTimeout(e._idleTimeoutId);var t=e._idleTimeout;t>=0&&(e._idleTimeoutId=setTimeout(function(){e._onTimeout&&e._onTimeout()},t))},r.setImmediate="function"==typeof u.default?u.default:function(e){var t=d++,n=!(arguments.length<2)&&p.call(arguments,1);return f[t]=!0,c(function(){f[t]&&(n?e.apply(null,n):e.call(null),r.clearImmediate(t))}),t},r.clearImmediate="function"==typeof a.default?a.default:function(e){delete f[e]}},{"babel-runtime/core-js/clear-immediate":16,"babel-runtime/core-js/set-immediate":34,"process/browser.js":345}],376:[function(e,t,r){"use strict";var n=e("buffer").Buffer;t.exports=function(e){if(e instanceof Uint8Array){if(0===e.byteOffset&&e.byteLength===e.buffer.byteLength)return e.buffer;if("function"==typeof e.buffer.slice)return e.buffer.slice(e.byteOffset,e.byteOffset+e.byteLength)}if(n.isBuffer(e)){for(var t=new Uint8Array(e.length),r=e.length,i=0;i<r;i++)t[i]=e[i];return t.buffer}throw new Error("Argument must be a Buffer")}},{buffer:45}],377:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}function i(){this.protocol=null,this.slashes=null,this.auth=null,this.host=null,this.port=null,this.hostname=null,this.hash=null,this.search=null,this.query=null,this.pathname=null,this.path=null,this.href=null}function o(e,t,r){if(e&&h.isObject(e)&&e instanceof i)return e;var n=new i;return n.parse(e,t,r),n}function a(e){return h.isString(e)&&(e=o(e)),e instanceof i?e.format():i.prototype.format.call(e)}function s(e,t){return o(e,!1,!0).resolve(t)}function u(e,t){return e?o(e,!1,!0).resolveObject(t):t}var c=e("babel-runtime/core-js/object/keys"),l=n(c),p=e("babel-runtime/helpers/typeof"),f=n(p),d=e("punycode"),h=e("./util");r.parse=o,r.resolve=s,r.resolveObject=u,r.format=a,r.Url=i;var m=/^([a-z0-9.+-]+:)/i,b=/:[0-9]*$/,v=/^(\/\/?(?!\/)[^\?\s]*)(\?[^\s]*)?$/,g=["<",">",'"',"`"," ","\r","\n","\t"],y=["{","}","|","\\","^","`"].concat(g),_=["'"].concat(y),x=["%","/","?",";","#"].concat(_),w=["/","?","#"],E=255,j=/^[+a-z0-9A-Z_-]{0,63}$/,S=/^([+a-z0-9A-Z_-]{0,63})(.*)$/,T={javascript:!0,"javascript:":!0},k={javascript:!0,"javascript:":!0},A={http:!0,https:!0,ftp:!0,gopher:!0,file:!0,"http:":!0,"https:":!0,"ftp:":!0,"gopher:":!0,"file:":!0},O=e("querystring");i.prototype.parse=function(e,t,r){if(!h.isString(e))throw new TypeError("Parameter 'url' must be a string, not "+("undefined"==typeof e?"undefined":(0,f.default)(e)));var n=e.indexOf("?"),i=n!==-1&&n<e.indexOf("#")?"?":"#",o=e.split(i),a=/\\/g;o[0]=o[0].replace(a,"/"),e=o.join(i);var s=e;if(s=s.trim(),!r&&1===e.split("#").length){var u=v.exec(s);if(u)return this.path=s,this.href=s,this.pathname=u[1],u[2]?(this.search=u[2],t?this.query=O.parse(this.search.substr(1)):this.query=this.search.substr(1)):t&&(this.search="",this.query={}),this}var c=m.exec(s);if(c){c=c[0];var l=c.toLowerCase();this.protocol=l,s=s.substr(c.length)}if(r||c||s.match(/^\/\/[^@\/]+@[^@\/]+/)){var p="//"===s.substr(0,2);!p||c&&k[c]||(s=s.substr(2),this.slashes=!0)}if(!k[c]&&(p||c&&!A[c])){for(var b=-1,g=0;g<w.length;g++){var y=s.indexOf(w[g]);y!==-1&&(b===-1||y<b)&&(b=y)}var R,I;I=b===-1?s.lastIndexOf("@"):s.lastIndexOf("@",b),I!==-1&&(R=s.slice(0,I),s=s.slice(I+1),this.auth=decodeURIComponent(R)),b=-1;for(var g=0;g<x.length;g++){var y=s.indexOf(x[g]);y!==-1&&(b===-1||y<b)&&(b=y)}b===-1&&(b=s.length),this.host=s.slice(0,b),s=s.slice(b),this.parseHost(),this.hostname=this.hostname||"";var C="["===this.hostname[0]&&"]"===this.hostname[this.hostname.length-1];if(!C)for(var M=this.hostname.split(/\./),g=0,P=M.length;g<P;g++){var N=M[g];if(N&&!N.match(j)){for(var D="",L=0,q=N.length;L<q;L++)D+=N.charCodeAt(L)>127?"x":N[L];if(!D.match(j)){var U=M.slice(0,g),B=M.slice(g+1),F=N.match(S);F&&(U.push(F[1]),B.unshift(F[2])),B.length&&(s="/"+B.join(".")+s),this.hostname=U.join(".");break}}}this.hostname.length>E?this.hostname="":this.hostname=this.hostname.toLowerCase(),C||(this.hostname=d.toASCII(this.hostname));var z=this.port?":"+this.port:"",G=this.hostname||"";this.host=G+z,this.href+=this.host,C&&(this.hostname=this.hostname.substr(1,this.hostname.length-2),"/"!==s[0]&&(s="/"+s))}if(!T[l])for(var g=0,P=_.length;g<P;g++){var H=_[g];if(s.indexOf(H)!==-1){var Y=encodeURIComponent(H);Y===H&&(Y=escape(H)),s=s.split(H).join(Y)}}var X=s.indexOf("#");X!==-1&&(this.hash=s.substr(X),s=s.slice(0,X));var K=s.indexOf("?");if(K!==-1?(this.search=s.substr(K),this.query=s.substr(K+1),t&&(this.query=O.parse(this.query)),s=s.slice(0,K)):t&&(this.search="",this.query={}),s&&(this.pathname=s),A[l]&&this.hostname&&!this.pathname&&(this.pathname="/"),this.pathname||this.search){var z=this.pathname||"",V=this.search||"";this.path=z+V}return this.href=this.format(),this},i.prototype.format=function(){var e=this.auth||"";e&&(e=encodeURIComponent(e),e=e.replace(/%3A/i,":"),e+="@");var t=this.protocol||"",r=this.pathname||"",n=this.hash||"",i=!1,o="";this.host?i=e+this.host:this.hostname&&(i=e+(this.hostname.indexOf(":")===-1?this.hostname:"["+this.hostname+"]"),this.port&&(i+=":"+this.port)),this.query&&h.isObject(this.query)&&(0,l.default)(this.query).length&&(o=O.stringify(this.query));var a=this.search||o&&"?"+o||"";return t&&":"!==t.substr(-1)&&(t+=":"),this.slashes||(!t||A[t])&&i!==!1?(i="//"+(i||""),r&&"/"!==r.charAt(0)&&(r="/"+r)):i||(i=""),n&&"#"!==n.charAt(0)&&(n="#"+n),a&&"?"!==a.charAt(0)&&(a="?"+a),r=r.replace(/[?#]/g,function(e){return encodeURIComponent(e)}),a=a.replace("#","%23"),t+i+r+a+n},i.prototype.resolve=function(e){return this.resolveObject(o(e,!1,!0)).format()},i.prototype.resolveObject=function(e){if(h.isString(e)){var t=new i;t.parse(e,!1,!0),e=t}for(var r=new i,n=(0,l.default)(this),o=0;o<n.length;o++){var a=n[o];r[a]=this[a]}if(r.hash=e.hash,""===e.href)return r.href=r.format(),r;if(e.slashes&&!e.protocol){for(var s=(0,l.default)(e),u=0;u<s.length;u++){var c=s[u];"protocol"!==c&&(r[c]=e[c])}return A[r.protocol]&&r.hostname&&!r.pathname&&(r.path=r.pathname="/"),r.href=r.format(),r}if(e.protocol&&e.protocol!==r.protocol){if(!A[e.protocol]){for(var p=(0,l.default)(e),f=0;f<p.length;f++){var d=p[f];r[d]=e[d]}return r.href=r.format(),r}if(r.protocol=e.protocol,e.host||k[e.protocol])r.pathname=e.pathname;else{for(var m=(e.pathname||"").split("/");m.length&&!(e.host=m.shift()););e.host||(e.host=""),e.hostname||(e.hostname=""),""!==m[0]&&m.unshift(""),m.length<2&&m.unshift(""),r.pathname=m.join("/")}if(r.search=e.search,r.query=e.query,r.host=e.host||"",r.auth=e.auth,r.hostname=e.hostname||e.host,r.port=e.port,r.pathname||r.search){var b=r.pathname||"",v=r.search||"";r.path=b+v}return r.slashes=r.slashes||e.slashes,r.href=r.format(),r}var g=r.pathname&&"/"===r.pathname.charAt(0),y=e.host||e.pathname&&"/"===e.pathname.charAt(0),_=y||g||r.host&&e.pathname,x=_,w=r.pathname&&r.pathname.split("/")||[],m=e.pathname&&e.pathname.split("/")||[],E=r.protocol&&!A[r.protocol];if(E&&(r.hostname="",r.port=null,r.host&&(""===w[0]?w[0]=r.host:w.unshift(r.host)),r.host="",e.protocol&&(e.hostname=null,e.port=null,e.host&&(""===m[0]?m[0]=e.host:m.unshift(e.host)),e.host=null),_=_&&(""===m[0]||""===w[0])),y)r.host=e.host||""===e.host?e.host:r.host,r.hostname=e.hostname||""===e.hostname?e.hostname:r.hostname,r.search=e.search,r.query=e.query,w=m;else if(m.length)w||(w=[]),w.pop(),w=w.concat(m),r.search=e.search,r.query=e.query;else if(!h.isNullOrUndefined(e.search)){if(E){r.hostname=r.host=w.shift();var j=!!(r.host&&r.host.indexOf("@")>0)&&r.host.split("@");j&&(r.auth=j.shift(),r.host=r.hostname=j.shift())}return r.search=e.search,r.query=e.query,h.isNull(r.pathname)&&h.isNull(r.search)||(r.path=(r.pathname?r.pathname:"")+(r.search?r.search:"")),r.href=r.format(),r}if(!w.length)return r.pathname=null,r.search?r.path="/"+r.search:r.path=null,r.href=r.format(),r;for(var S=w.slice(-1)[0],T=(r.host||e.host||w.length>1)&&("."===S||".."===S)||""===S,O=0,R=w.length;R>=0;R--)S=w[R],"."===S?w.splice(R,1):".."===S?(w.splice(R,1),O++):O&&(w.splice(R,1),O--);if(!_&&!x)for(;O--;O)w.unshift("..");!_||""===w[0]||w[0]&&"/"===w[0].charAt(0)||w.unshift(""),T&&"/"!==w.join("/").substr(-1)&&w.push("");var I=""===w[0]||w[0]&&"/"===w[0].charAt(0);if(E){r.hostname=r.host=I?"":w.length?w.shift():"";var j=!!(r.host&&r.host.indexOf("@")>0)&&r.host.split("@");j&&(r.auth=j.shift(),r.host=r.hostname=j.shift())}return _=_||r.host&&w.length,_&&!I&&w.unshift(""),w.length?r.pathname=w.join("/"):(r.pathname=null,r.path=null),h.isNull(r.pathname)&&h.isNull(r.search)||(r.path=(r.pathname?r.pathname:"")+(r.search?r.search:"")),r.auth=e.auth||r.auth,r.slashes=r.slashes||e.slashes,r.href=r.format(),r},i.prototype.parseHost=function(){var e=this.host,t=b.exec(e);t&&(t=t[0],":"!==t&&(this.port=t.substr(1)),e=e.substr(0,e.length-t.length)),e&&(this.hostname=e)}},{"./util":378,"babel-runtime/core-js/object/keys":30,"babel-runtime/helpers/typeof":39,punycode:346,querystring:349}],378:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}var i=e("babel-runtime/helpers/typeof"),o=n(i);t.exports={isString:function(e){return"string"==typeof e},isObject:function(e){return"object"===("undefined"==typeof e?"undefined":(0,o.default)(e))&&null!==e},isNull:function(e){return null===e},isNullOrUndefined:function(e){return null==e}}},{"babel-runtime/helpers/typeof":39}],379:[function(e,t,r){(function(t,n){"use strict";function i(e){return e&&e.__esModule?e:{default:e}}function o(e,t){return function(r,n,i){return r?t(r):void e({data:n,status:i.statusCode,headers:i.headers,res:i})}}function a(e){return U[e]||"\\u"+(e.charCodeAt(0)+65536).toString(16).substr(1)}function s(e){return e.replace(B,a)}function u(e,t){var r={error:null,data:null};t&&(e=s(e));try{r.data=JSON.parse(e)}catch(t){"SyntaxError"===t.name&&(t.name="JSONResponseFormatError"),e.length>1024?t.message+=" (data json format: "+(0,b.default)(e.slice(0,512))+" ...skip... "+(0,b.default)(e.slice(e.length-512))+")":t.message+=" (data json format: "+(0,b.default)(e)+")",r.error=t}return r}function c(e){A.call(this),e=e||{},void 0!==e.agent?(this.agent=e.agent,this.hasCustomAgent=!0):(this.agent=r.agent,this.hasCustomAgent=!1),void 0!==e.httpsAgent?(this.httpsAgent=e.httpsAgent,this.hasCustomHttpsAgent=!0):(this.httpsAgent=r.httpsAgent,this.hasCustomHttpsAgent=!1)}function l(e,t){var r=t.headers["content-type"];if(!r)return e.toString();var r=f(r),i=r.parameters.charset||"utf-8";return n.isEncoding(i)?e.toString(i):(h||(h={}),h.decode(e,i))}function p(e,t){return void 0===e?t:e}function f(e){try{return I.parse(e)}catch(e){return{parameters:{}}}}var d,h,m=e("babel-runtime/core-js/json/stringify"),b=i(m),v=e("babel-runtime/helpers/typeof"),g=i(v),y=e("debug")("urllib"),_=e("http"),x=e("https"),w=e("url"),E=e("util"),j=e("querystring"),S={},T=e("default-user-agent"),k=e("digest-header"),E=e("util"),A=e("events").EventEmitter,O=e("humanize-ms"),R=e("statuses"),I=e("content-type"),C=e("../package.json"),M=r.USER_AGENT=T("node-urllib",C.version);r.agent=new _.Agent,r.agent.maxSockets=1e3,r.httpsAgent=new x.Agent,r.httpsAgent.maxSockets=1e3,r.TIMEOUT=O("5s"),r.TIMEOUTS=[O("5s"),O("5s")];var P=0,N=Math.pow(2,31)-10,D=/^v0\.10\.\d+$/.test(t.version),L=["json","text"],q=/^https?:\/\//i;r.request=function(t,n,i){return 2===arguments.length&&"function"==typeof n&&(i=n,n=null),"function"==typeof i?r.requestWithCallback(t,n,i):(d||(d=e("any-promise")),new d(function(e,i){r.requestWithCallback(t,n,o(e,i))}))},r.curl=r.request,r.requestThunk=function(e,t){return function(n){r.requestWithCallback(e,t,function(e,t,r){return e?n(e):void n(null,{data:t,status:r.statusCode,headers:r.headers,res:r})})}},r.requestWithCallback=function(i,o,a){function s(){ne&&(clearTimeout(ne),ne=null)}function c(){ie&&(clearTimeout(ie),ie=null)}function d(e,n,s){if(c(),!a)return console.warn("[urllib:warn] [%s] [worker:%s] %s %s callback twice!!!",Date(),t.pid,K.method,i),void(e&&console.warn("[urllib:warn] [%s] [worker:%s] %s: %s\nstack: %s",Date(),t.pid,e.name,e.message,e.stack));var u=a;a=null;var l={};if(s&&(ce=s.statusCode,l=s.headers),401===ce&&l["www-authenticate"]&&(!o.headers||!o.headers.Authorization)&&o.digestAuth){var p=l["www-authenticate"];if(p.indexOf("Digest ")>=0)return y("Request#%d %s: got digest auth header WWW-Authenticate: %s",U,i,p),o.headers=o.headers||{},o.headers.Authorization=k(K.method,K.path,p,o.digestAuth),y("Request#%d %s: auth with digest header: %s",U,i,o.headers.Authorization),s.headers["set-cookie"]&&(o.headers.Cookie=s.headers["set-cookie"].join(";")),r.requestWithCallback(i,o,u)}var f=Date.now()-F;de&&(de.contentDownload=f),y("[%sms] done, %s bytes HTTP %s %s %s %s, keepAliveSocket: %s, timing: %j",f,ue,ce,K.method,K.host,K.path,se,de);var d={status:ce,statusCode:ce,headers:l,size:ue,aborted:le,rt:f,keepAliveSocket:se,data:n,requestUrls:o.requestUrls,timing:de,remoteAddress:pe,remotePort:fe};if(e){var h="";Y&&"function"==typeof Y.getCurrentStatus&&(h=", agent status: "+(0,b.default)(Y.getCurrentStatus())),e.message+=", "+K.method+" "+i+" "+ce+" (connected: "+ae+", keepalive socket: "+se+h+")\nheaders: "+(0,b.default)(l),e.data=n,e.path=K.path,e.status=ce,e.headers=l,e.res=d}u(e,n,o.streaming?s:d),o.emitter&&o.emitter.emit("response",{requestId:U,error:e,ctx:o.ctx,req:{url:i,socket:ve&&ve.connection,options:K,size:te},res:d})}function h(e){var t=null;if(o.followRedirect&&R.redirect[e.statusCode]){o._followRedirectCount=(o._followRedirectCount||0)+1;var n=e.headers.location;if(n){if(!(o._followRedirectCount>o.maxRedirects)){var s=o.formatRedirectUrl?o.formatRedirectUrl(i,n):w.resolve(i,n);y("Request#%d %s: `redirected` from %s to %s",U,K.path,i,s),c(),o.headers&&o.headers.Host&&q.test(n)&&(o.headers.Host=null);var u=a;return a=null,r.requestWithCallback(s,o,u),{redirect:!0,error:null}}t=new Error("Exceeded maxRedirects. Probably stuck in a redirect loop "+i),t.name="MaxRedirectError"}else t=new Error("Got statusCode "+e.statusCode+" but cannot resolve next location from headers"),t.name="FollowRedirectError"}return{redirect:!1,error:t}}function m(e,t,r){var n=e.headers["content-encoding"];return 0===t.length?r(null,t,n):n&&"gzip"===n.toLowerCase()?(y("gunzip %d length body",t.length),void S.gunzip(t,r)):r(null,t,n)}function v(e){if(de&&(de.waiting=Date.now()-F),y("Request#%d %s `req response` event emit: status %d, headers: %j",U,i,e.statusCode,e.headers),o.streaming){var t=h(e);return t.redirect?void e.resume():t.error?(e.resume(),d(t.error,null,e)):d(null,null,e)}if(he){var t=h(e);return t.redirect?void e.resume():t.error?(e.resume(),he.end(),d(t.error,null,e)):(o.consumeWriteStream===!1?e.on("end",d.bind(null,null,null,e)):he.on("close",d.bind(null,null,null,e)),e.pipe(he))}var r=[];e.on("data",function(e){y("Request#%d %s: `res data` event emit, size %d",U,i,e.length),ue+=e.length,r.push(e)}),e.on("aborted",function(){le=!0,y("Request#%d %s: `res aborted` event emit, total size %d",U,i,ue)}),e.on("end",function(){var t=n.concat(r,ue);if(y("Request#%d %s: `res end` event emit, total size %d, _dumped: %s",U,i,ue,e._dumped),oe)return d(oe,t,e);var a=h(e);return a.error?d(a.error,t,e):void(a.redirect||m(e,t,function(r,n,a){if(r)return d(r,t,e);if(!a&&L.indexOf(o.dataType)>=0){try{n=l(n,e)}catch(t){return y("decodeBodyByCharset error: %s",t),d(null,n,e)}if("json"===o.dataType)if(0===ue)n=null;else{var s=u(n,X);s.error?r=s.error:n=s.data}}le&&y("Request#%d %s: Remote socket was terminated before `response.end()` was called",U,i),d(r,n,e)}))})}function T(){y("Connect timer ticking, timeout: %d",me),ne=setTimeout(function(){ne=null,ce===-1&&(ce=-2);var e="Connect timeout for "+me+"ms",t="ConnectionTimeoutError";ve.socket||(t="SocketAssignTimeoutError",e+=", working sockets is full"),oe=new Error(e),oe.name=t,oe.requestId=U,y("ConnectTimeout: Request#%d %s %s: %s, connected: %s",U,i,oe.name,e,ae),I()},me)}function A(){y("Response timer ticking, timeout: %d",be),ie=setTimeout(function(){ie=null;var e="Response timeout for "+be+"ms",t="ResponseTimeoutError";oe=new Error(e),oe.name=t,oe.requestId=U,y("ResponseTimeout: Request#%d %s %s: %s, connected: %s",U,i,oe.name,e,ae),I()},be)}function I(){y("Request#%d %s abort, connected: %s",U,i,ae),ve.socket||(oe.noSocket=!0,d(oe)),ve.abort()}if(!i||"string"!=typeof i&&"object"!==("undefined"==typeof i?"undefined":(0,g.default)(i))){var C=E.format("expect request url to be a string or a http request options, but got %j",i);throw new Error(C)}2===arguments.length&&"function"==typeof o&&(a=o,o=null),o=o||{},P>=N&&(P=0);var U=++P;o.requestUrls=o.requestUrls||[],o.emitter&&o.emitter.emit("request",{requestId:U,url:i,args:o,ctx:o.ctx}),o.timeout=o.timeout||r.TIMEOUTS,o.maxRedirects=o.maxRedirects||10,o.streaming=o.streaming||o.customResponse;var B,F=Date.now();"string"==typeof i?(q.test(i)||(i="http://"+i),B=w.parse(i)):B=i;var z=(o.type||o.method||B.method||"GET").toUpperCase(),G=B.port||80,H=_,Y=p(o.agent,r.agent),X=!!o.fixJSONCtlChars;"https:"===B.protocol&&(H=x,Y=p(o.httpsAgent,r.httpsAgent),B.port||(G=443));for(var K={host:B.hostname||B.host||"localhost",path:B.path||"/",method:z,port:G,agent:Y,headers:o.headers||{},lookup:o.lookup},V=["pfx","key","passphrase","cert","ca","ciphers","rejectUnauthorized","secureProtocol","secureOptions"],W=0;W<V.length;W++){var $=V[W];o.hasOwnProperty($)&&(K[$]=o[$])}K.rejectUnauthorized!==!1||K.hasOwnProperty("secureOptions")||(K.secureOptions=e("constants").SSL_OP_NO_TLSv1_2);var J=o.auth||B.auth;J&&(K.auth=J);var Q=o.content||o.data,Z="GET"===z||"HEAD"===z;if(!o.content&&Q&&"string"!=typeof Q&&!n.isBuffer(Q))if(Z)Q=j.stringify(Q);else{var ee=K.headers["Content-Type"]||K.headers["content-type"];ee||(ee="json"===o.contentType?"application/json":"application/x-www-form-urlencoded",K.headers["Content-Type"]=ee),Q="application/json"===f(ee).type?(0,b.default)(Q):j.stringify(Q)}Z&&Q&&(K.path+=(B.query?"&":"?")+Q,Q=null);var te=0;if(Q){var re=Q.length;n.isBuffer(Q)||(re=n.byteLength(Q)),te=K.headers["Content-Length"]=re}"json"===o.dataType&&(K.headers.Accept="application/json"),"function"==typeof o.beforeRequest&&o.beforeRequest(K);var ne=null,ie=null,oe=null,ae=!1,se=!1,ue=0,ce=-1,le=!1,pe="",fe="",de=null;o.timing&&(de={queuing:0,dnslookup:0,connected:0,requestSent:0,waiting:0,contentDownload:0}),K.headers["User-Agent"]||K.headers["user-agent"]||(K.headers["User-Agent"]=M),o.gzip&&(K.headers["Accept-Encoding"]||K.headers["accept-encoding"]||(K.headers["Accept-Encoding"]="gzip"));var he=o.writeStream;y("Request#%d %s %s with headers %j, options.path: %s",U,z,i,K.headers,K.path),o.requestUrls.push(i);var me,be;Array.isArray(o.timeout)?(me=O(o.timeout[0]),be=O(o.timeout[1])):me=be=O(o.timeout),y("ConnectTimeout: %d, ResponseTimeout: %d",me,be);var ve;try{ve=H.request(K,v)}catch(e){return d(e)}return T(),de&&ve.on("finish",function(){de.requestSent=Date.now()-F}),ve.once("socket",function(e){de&&(de.queuing=Date.now()-F),D&&e.socket&&(e=e.socket);var t=e.readyState;return"opening"===t?(e.once("lookup",function(e,t,r){y("Request#%d %s lookup: %s, %s, %s",U,i,e,t,r),de&&(de.dnslookup=Date.now()-F),t&&(pe=t)}),void e.once("connect",function(){de&&(de.connected=Date.now()-F),s(),A(),y("Request#%d %s new socket connected",U,i),ae=!0,pe||(pe=e.remoteAddress),fe=e.remotePort})):(y("Request#%d %s reuse socket connected, readyState: %s",U,i,t),ae=!0,se=!0,pe||(pe=e.remoteAddress),fe=e.remotePort,s(),void A())}),ve.on("error",function(e){"Error"===e.name&&(e.name=ae?"ResponseError":"RequestError"),e.message+=' (req "error")',y("Request#%d %s `req error` event emit, %s: %s",U,i,e.name,e.message),
+d(oe||e)}),he&&he.once("error",function(e){e.message+=' (writeStream "error")',oe=e,y("Request#%d %s `writeStream error` event emit, %s: %s",U,i,e.name,e.message),I()}),o.stream?(o.stream.pipe(ve),o.stream.once("error",function(e){e.message+=' (stream "error")',oe=e,y("Request#%d %s `readStream error` event emit, %s: %s",U,i,e.name,e.message),I()})):ve.end(Q),ve.requestId=U,ve};var U={'"':'\\"',"\\":"\\\\","\b":"\\b","\f":"\\f","\n":"\\n","\r":"\\r","\t":"\\t"},B=/[\u0000-\u001F\u005C]/g;E.inherits(c,A),c.prototype.request=c.prototype.curl=function(e,t,n){return"function"==typeof t&&(n=t,t=null),t=t||{},t.emitter=this,t.agent=p(t.agent,this.agent),t.httpsAgent=p(t.httpsAgent,this.httpsAgent),r.request(e,t,n)},c.prototype.requestThunk=function(e,t){return t=t||{},t.emitter=this,t.agent=p(t.agent,this.agent),t.httpsAgent=p(t.httpsAgent,this.httpsAgent),r.requestThunk(e,t)},r.HttpClient=c,r.create=function(e){return new c(e)}}).call(this,e("_process"),e("buffer").Buffer)},{"../package.json":380,_process:345,"any-promise":12,"babel-runtime/core-js/json/stringify":18,"babel-runtime/helpers/typeof":39,buffer:45,constants:52,"content-type":53,debug:184,"default-user-agent":186,"digest-header":188,events:193,http:370,https:195,"humanize-ms":196,querystring:349,statuses:368,url:377,util:384}],380:[function(e,t,r){t.exports={_args:[[{raw:"urllib@^2.16.1",scope:null,escapedName:"urllib",name:"urllib",rawSpec:"^2.16.1",spec:">=2.16.1 <3.0.0",type:"range"},"/Users/deadhorse/git/ali-oss"]],_cnpm_publish_time:1476348058960,_from:"urllib@>=2.16.1 <3.0.0",_id:"urllib@2.17.0",_inCache:!0,_location:"/urllib",_nodeVersion:"4.4.7",_npmOperationalInternal:{host:"packages-16-east.internal.npmjs.com",tmp:"tmp/urllib-2.17.0.tgz_1476348057935_0.42674178583547473"},_npmUser:{name:"dead_horse",email:"dead_horse@qq.com"},_npmVersion:"3.10.3",_phantomChildren:{},_requested:{raw:"urllib@^2.16.1",scope:null,escapedName:"urllib",name:"urllib",rawSpec:"^2.16.1",spec:">=2.16.1 <3.0.0",type:"range"},_requiredBy:["/","/autod"],_resolved:"http://registry.npm.taobao.org/urllib/download/urllib-2.17.0.tgz",_shasum:"062264d52f1713deddecc7dd8e0e9000864099a9",_shrinkwrap:null,_spec:"urllib@^2.16.1",_where:"/Users/deadhorse/git/ali-oss",author:{name:"fengmk2",email:"m@fengmk2.com",url:"http://fengmk2.com"},bugs:{url:"https://github.com/node-modules/urllib/issues"},contributors:[{name:"fengmk2",email:"fengmk2@gmail.com",url:"http://fengmk2.com"},{name:"aleafs",email:"zhangxc83@gmail.com",url:"https://github.com/aleafs"},{name:"Jackson Tian",email:"shyvo1987@gmail.com",url:"https://github.com/JacksonTian"},{name:"ibigbug",email:"x1aoba@icloud.com",url:"https://github.com/ibigbug"},{name:"XiNGRZ",email:"chenxingyu92@gmail.com",url:"https://github.com/XiNGRZ"},{name:"dead_horse",email:"dead_horse@qq.com",url:"http://deadhorse.me/"},{name:"coderhaoxin",email:"coderhaoxin@outlook.com",url:"https://github.com/coderhaoxin"},{name:"alsotang",email:"alsotang@gmail.com",url:"https://github.com/alsotang"},{name:"Jonathan Dahan",email:"jonathan@jedahan.com",url:"https://github.com/jedahan"},{name:"popomore",email:"sakura9515@gmail.com",url:"https://github.com/popomore"},{name:"fishbar",email:"zhengxinlin@gmail.com",url:"https://github.com/fishbar"},{name:"coolme200",email:"tangyao@taobao.com",url:"https://github.com/coolme200"},{name:"amunu",email:"panyilinlove@qq.com",url:"https://github.com/Amunu"},{name:"Yuwei Ba",email:"xiaobayuwei@gmail.com",url:"https://github.com/ibigbug"}],dependencies:{"any-promise":"^1.2.0","content-type":"^1.0.2",debug:"^2.2.0","default-user-agent":"^1.0.0","digest-header":"^0.0.1","humanize-ms":"^1.2.0","iconv-lite":"^0.4.13",statuses:"^1.3.0"},description:"Help in opening URLs (mostly HTTP) in a complex world — basic and digest authentication, redirections, cookies and more.",devDependencies:{agentkeepalive:"2",autod:"*",bluebird:"*",co:"*",coffee:"1",formstream:"1","intelli-espower-loader":"^1.0.1",istanbul:"*",jshint:"*",mocha:"*",pedding:"1","power-assert":"^1.4.1",semver:"5",should:"8","should-http":"*",tar:"2",through2:"2"},directories:{},dist:{shasum:"062264d52f1713deddecc7dd8e0e9000864099a9",size:16235,noattachment:!1,tarball:"http://registry.npm.taobao.org/urllib/download/urllib-2.17.0.tgz"},engines:{node:">= 0.10.0"},files:["lib"],gitHead:"13662ea1367bc7fac6bff9950c638f53a6d9207b",homepage:"http://github.com/node-modules/urllib",keywords:["urllib","http","urlopen","curl","wget","request","https"],license:"MIT",main:"lib/urllib.js",maintainers:[{name:"dead_horse",email:"dead_horse@qq.com"},{name:"fengmk2",email:"fengmk2@gmail.com"}],name:"urllib",optionalDependencies:{},publish_time:1476348058960,readme:"ERROR: No README data found!",repository:{type:"git",url:"git://github.com/node-modules/urllib.git"},scripts:{autod:"autod -w --prefix '^' -t test -e examples",ci:"npm run lint && npm run test-cov",lint:"jshint .",test:"mocha -R spec -t 30000 -r should -r should-http -r intelli-espower-loader test/*.test.js","test-cov":"istanbul cover node_modules/mocha/bin/_mocha -- -t 30000 -r should -r should-http -r intelli-espower-loader test/*.test.js"},version:"2.17.0"}},{}],381:[function(e,t,r){(function(e){"use strict";function r(e,t){function r(){if(!i){if(n("throwDeprecation"))throw new Error(t);n("traceDeprecation")?console.trace(t):console.warn(t),i=!0}return e.apply(this,arguments)}if(n("noDeprecation"))return e;var i=!1;return r}function n(t){try{if(!e.localStorage)return!1}catch(e){return!1}var r=e.localStorage[t];return null!=r&&"true"===String(r).toLowerCase()}t.exports=r}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{}],382:[function(e,t,r){arguments[4][198][0].apply(r,arguments)},{"babel-runtime/core-js/object/create":22,dup:198}],383:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}var i=e("babel-runtime/helpers/typeof"),o=n(i);t.exports=function(e){return e&&"object"===("undefined"==typeof e?"undefined":(0,o.default)(e))&&"function"==typeof e.copy&&"function"==typeof e.fill&&"function"==typeof e.readUInt8}},{"babel-runtime/helpers/typeof":39}],384:[function(e,t,r){(function(t,n){"use strict";function i(e){return e&&e.__esModule?e:{default:e}}function o(e,t){var n={seen:[],stylize:s};return arguments.length>=3&&(n.depth=arguments[2]),arguments.length>=4&&(n.colors=arguments[3]),b(t)?n.showHidden=t:t&&r._extend(n,t),w(n.showHidden)&&(n.showHidden=!1),w(n.depth)&&(n.depth=2),w(n.colors)&&(n.colors=!1),w(n.customInspect)&&(n.customInspect=!0),n.colors&&(n.stylize=a),c(n,e,n.depth)}function a(e,t){var r=o.styles[t];return r?"["+o.colors[r][0]+"m"+e+"["+o.colors[r][1]+"m":e}function s(e,t){return e}function u(e){var t={};return e.forEach(function(e,r){t[e]=!0}),t}function c(e,t,n){if(e.customInspect&&t&&k(t.inspect)&&t.inspect!==r.inspect&&(!t.constructor||t.constructor.prototype!==t)){var i=t.inspect(n,e);return _(i)||(i=c(e,i,n)),i}var o=l(e,t);if(o)return o;var a=(0,B.default)(t),s=u(a);if(e.showHidden&&(a=(0,q.default)(t)),T(t)&&(a.indexOf("message")>=0||a.indexOf("description")>=0))return p(t);if(0===a.length){if(k(t)){var b=t.name?": "+t.name:"";return e.stylize("[Function"+b+"]","special")}if(E(t))return e.stylize(RegExp.prototype.toString.call(t),"regexp");if(S(t))return e.stylize(Date.prototype.toString.call(t),"date");if(T(t))return p(t)}var v="",g=!1,y=["{","}"];if(m(t)&&(g=!0,y=["[","]"]),k(t)){var x=t.name?": "+t.name:"";v=" [Function"+x+"]"}if(E(t)&&(v=" "+RegExp.prototype.toString.call(t)),S(t)&&(v=" "+Date.prototype.toUTCString.call(t)),T(t)&&(v=" "+p(t)),0===a.length&&(!g||0==t.length))return y[0]+v+y[1];if(n<0)return E(t)?e.stylize(RegExp.prototype.toString.call(t),"regexp"):e.stylize("[Object]","special");e.seen.push(t);var w;return w=g?f(e,t,n,s,a):a.map(function(r){return d(e,t,n,s,r,g)}),e.seen.pop(),h(w,v,y)}function l(e,t){if(w(t))return e.stylize("undefined","undefined");if(_(t)){var r="'"+(0,z.default)(t).replace(/^"|"$/g,"").replace(/'/g,"\\'").replace(/\\"/g,'"')+"'";return e.stylize(r,"string")}return y(t)?e.stylize(""+t,"number"):b(t)?e.stylize(""+t,"boolean"):v(t)?e.stylize("null","null"):void 0}function p(e){return"["+Error.prototype.toString.call(e)+"]"}function f(e,t,r,n,i){for(var o=[],a=0,s=t.length;a<s;++a)C(t,String(a))?o.push(d(e,t,r,n,String(a),!0)):o.push("");return i.forEach(function(i){i.match(/^\d+$/)||o.push(d(e,t,r,n,i,!0))}),o}function d(e,t,r,n,i,o){var a,s,u;if(u=(0,D.default)(t,i)||{value:t[i]},u.get?s=u.set?e.stylize("[Getter/Setter]","special"):e.stylize("[Getter]","special"):u.set&&(s=e.stylize("[Setter]","special")),C(n,i)||(a="["+i+"]"),s||(e.seen.indexOf(u.value)<0?(s=v(r)?c(e,u.value,null):c(e,u.value,r-1),s.indexOf("\n")>-1&&(s=o?s.split("\n").map(function(e){return"  "+e}).join("\n").substr(2):"\n"+s.split("\n").map(function(e){return"   "+e}).join("\n"))):s=e.stylize("[Circular]","special")),w(a)){if(o&&i.match(/^\d+$/))return s;a=(0,z.default)(""+i),a.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)?(a=a.substr(1,a.length-2),a=e.stylize(a,"name")):(a=a.replace(/'/g,"\\'").replace(/\\"/g,'"').replace(/(^"|"$)/g,"'"),a=e.stylize(a,"string"))}return a+": "+s}function h(e,t,r){var n=0,i=e.reduce(function(e,t){return n++,t.indexOf("\n")>=0&&n++,e+t.replace(/\u001b\[\d\d?m/g,"").length+1},0);return i>60?r[0]+(""===t?"":t+"\n ")+" "+e.join(",\n  ")+" "+r[1]:r[0]+t+" "+e.join(", ")+" "+r[1]}function m(e){return Array.isArray(e)}function b(e){return"boolean"==typeof e}function v(e){return null===e}function g(e){return null==e}function y(e){return"number"==typeof e}function _(e){return"string"==typeof e}function x(e){return"symbol"===("undefined"==typeof e?"undefined":(0,P.default)(e))}function w(e){return void 0===e}function E(e){return j(e)&&"[object RegExp]"===O(e)}function j(e){return"object"===("undefined"==typeof e?"undefined":(0,P.default)(e))&&null!==e}function S(e){return j(e)&&"[object Date]"===O(e)}function T(e){return j(e)&&("[object Error]"===O(e)||e instanceof Error)}function k(e){return"function"==typeof e}function A(e){return null===e||"boolean"==typeof e||"number"==typeof e||"string"==typeof e||"symbol"===("undefined"==typeof e?"undefined":(0,P.default)(e))||"undefined"==typeof e}function O(e){return Object.prototype.toString.call(e)}function R(e){return e<10?"0"+e.toString(10):e.toString(10)}function I(){var e=new Date,t=[R(e.getHours()),R(e.getMinutes()),R(e.getSeconds())].join(":");return[e.getDate(),X[e.getMonth()],t].join(" ")}function C(e,t){return Object.prototype.hasOwnProperty.call(e,t)}var M=e("babel-runtime/helpers/typeof"),P=i(M),N=e("babel-runtime/core-js/object/get-own-property-descriptor"),D=i(N),L=e("babel-runtime/core-js/object/get-own-property-names"),q=i(L),U=e("babel-runtime/core-js/object/keys"),B=i(U),F=e("babel-runtime/core-js/json/stringify"),z=i(F),G=/%[sdj%]/g;r.format=function(e){if(!_(e)){for(var t=[],r=0;r<arguments.length;r++)t.push(o(arguments[r]));return t.join(" ")}for(var r=1,n=arguments,i=n.length,a=String(e).replace(G,function(e){if("%%"===e)return"%";if(r>=i)return e;switch(e){case"%s":return String(n[r++]);case"%d":return Number(n[r++]);case"%j":try{return(0,z.default)(n[r++])}catch(e){return"[Circular]"}default:return e}}),s=n[r];r<i;s=n[++r])a+=v(s)||!j(s)?" "+s:" "+o(s);return a},r.deprecate=function(e,i){function o(){if(!a){if(t.throwDeprecation)throw new Error(i);t.traceDeprecation?console.trace(i):console.error(i),a=!0}return e.apply(this,arguments)}if(w(n.process))return function(){return r.deprecate(e,i).apply(this,arguments)};if(t.noDeprecation===!0)return e;var a=!1;return o};var H,Y={};r.debuglog=function(e){if(w(H)&&(H=t.env.NODE_DEBUG||""),e=e.toUpperCase(),!Y[e])if(new RegExp("\\b"+e+"\\b","i").test(H)){var n=t.pid;Y[e]=function(){var t=r.format.apply(r,arguments);console.error("%s %d: %s",e,n,t)}}else Y[e]=function(){};return Y[e]},r.inspect=o,o.colors={bold:[1,22],italic:[3,23],underline:[4,24],inverse:[7,27],white:[37,39],grey:[90,39],black:[30,39],blue:[34,39],cyan:[36,39],green:[32,39],magenta:[35,39],red:[31,39],yellow:[33,39]},o.styles={special:"cyan",number:"yellow",boolean:"yellow",undefined:"grey",null:"bold",string:"green",date:"magenta",regexp:"red"},r.isArray=m,r.isBoolean=b,r.isNull=v,r.isNullOrUndefined=g,r.isNumber=y,r.isString=_,r.isSymbol=x,r.isUndefined=w,r.isRegExp=E,r.isObject=j,r.isDate=S,r.isError=T,r.isFunction=k,r.isPrimitive=A,r.isBuffer=e("./support/isBuffer");var X=["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"];r.log=function(){console.log("%s - %s",I(),r.format.apply(r,arguments))},r.inherits=e("inherits"),r._extend=function(e,t){if(!t||!j(t))return e;for(var r=(0,B.default)(t),n=r.length;n--;)e[r[n]]=t[r[n]];return e}}).call(this,e("_process"),"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{"./support/isBuffer":383,_process:345,"babel-runtime/core-js/json/stringify":18,"babel-runtime/core-js/object/get-own-property-descriptor":25,"babel-runtime/core-js/object/get-own-property-names":26,"babel-runtime/core-js/object/keys":30,"babel-runtime/helpers/typeof":39,inherits:382}],385:[function(e,t,r){"use strict";r.randomSlice=function(e,t){if(!t||t>=e.length)return e.slice();for(var r=Math.floor(Math.random()*e.length),n=[],i=0,o=r;i<t;i++)n.push(e[o++]),o===e.length&&(o=0);return n},r.spliceOne=function(e,t){if(t<0&&(t=e.length+t,t<0))return e;if(t>=e.length)return e;for(var r=t,n=r+1,i=e.length;n<i;r+=1,n+=1)e[r]=e[n];return e.pop(),e}},{}],386:[function(e,t,r){(function(t){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}function i(e){if(!e||Array.isArray(e)||"object"!==("undefined"==typeof e?"undefined":(0,l.default)(e)))return e;var t=(0,a.default)(e);t.sort();for(var r=[],n=0;n<t.length;n++){var o=t[n];r.push([o,i(e[o])])}return r}var o=e("babel-runtime/core-js/object/keys"),a=n(o),s=e("babel-runtime/core-js/json/stringify"),u=n(s),c=e("babel-runtime/helpers/typeof"),l=n(c),p=e("./../../../shims/crypto.js");r.hash=function(e,r,n){var o=p.createHash(e),a=t.isBuffer(r);return a||"object"!==("undefined"==typeof r?"undefined":(0,l.default)(r))||(r=(0,u.default)(i(r))),o.update(r,a?"binary":"utf8"),o.digest(n||"hex")},r.md5=function(e,t){return r.hash("md5",e,t)},r.sha1=function(e,t){return r.hash("sha1",e,t)},r.sha256=function(e,t){return r.hash("sha256",e,t)},r.hmac=function e(r,n,i,o){o=o||"base64";var e=p.createHmac(r,n);return e.update(i,t.isBuffer(i)?"binary":"utf8"),e.digest(o)},r.base64encode=function(e,r){t.isBuffer(e)||(e=new t(e));var n=e.toString("base64");return r&&(n=n.replace(/\+/g,"-").replace(/\//g,"_")),n},r.base64decode=function(e,r,n){r&&(e=e.replace(/\-/g,"+").replace(/_/g,"/"));var i=new t(e,"base64");return"buffer"===n?i:i.toString(n||"utf8")}}).call(this,e("buffer").Buffer)},{"./../../../shims/crypto.js":420,"babel-runtime/core-js/json/stringify":18,"babel-runtime/core-js/object/keys":30,"babel-runtime/helpers/typeof":39,buffer:45}],387:[function(e,t,r){"use strict";var n=["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"],i=" ",o=parseInt(-(new Date).getTimezoneOffset()/60,10);i+=o>=0?"+":"-",o=Math.abs(o),o<10&&(o="0"+o),i+=o+"00",r.accessLogDate=function(e){e=e||new Date;var t=e.getDate();t<10&&(t="0"+t);var r=e.getHours();r<10&&(r="0"+r);var o=e.getMinutes();o<10&&(o="0"+o);var a=e.getSeconds();return a<10&&(a="0"+a),t+"/"+n[e.getMonth()]+"/"+e.getFullYear()+":"+r+":"+o+":"+a+i},r.logDate=r.YYYYMMDDHHmmssSSS=function(e,t){"string"==typeof e?(t=e,e=new Date):e=e||new Date;var r=e.getDate();r<10&&(r="0"+r);var n=e.getMonth()+1;n<10&&(n="0"+n);var i=e.getHours();i<10&&(i="0"+i);var o=e.getMinutes();o<10&&(o="0"+o);var a=e.getSeconds();a<10&&(a="0"+a);var s=e.getMilliseconds();return s<10?s="00"+s:s<100&&(s="0"+s),e.getFullYear()+"-"+n+"-"+r+" "+i+":"+o+":"+a+(t||".")+s},r.YYYYMMDDHHmmss=function(e,t){e=e||new Date,e instanceof Date||(e=new Date(e));var r="-",n=":";t&&(t.dateSep&&(r=t.dateSep),t.timeSep&&(n=t.timeSep));var i=e.getDate();i<10&&(i="0"+i);var o=e.getMonth()+1;o<10&&(o="0"+o);var a=e.getHours();a<10&&(a="0"+a);var s=e.getMinutes();s<10&&(s="0"+s);var u=e.getSeconds();return u<10&&(u="0"+u),e.getFullYear()+r+o+r+i+" "+a+n+s+n+u},r.YYYYMMDD=function(e,t){"string"==typeof e?(t=e,e=new Date):(e=e||new Date,"string"!=typeof t&&(t="-"));var r=e.getDate();r<10&&(r="0"+r);var n=e.getMonth()+1;return n<10&&(n="0"+n),e.getFullYear()+t+n+t+r},r.datestruct=function(e){return e=e||new Date,{YYYYMMDD:1e4*e.getFullYear()+100*(e.getMonth()+1)+e.getDate(),H:e.getHours()}},r.timestamp=function(e){if(e){var t=e;return"string"==typeof t&&(t=Number(t)),10===String(e).length&&(t*=1e3),new Date(t)}return Math.round(Date.now()/1e3)}},{}],388:[function(e,t,r){"use strict";r.noop=function(){},r.getParamNames=function(e,t){if(t=t!==!1,t&&e.__cache_names)return e.__cache_names;var r=e.toString(),n=r.slice(r.indexOf("(")+1,r.indexOf(")")).match(/([^\s,]+)/g)||[];return e.__cache_names=n,n}},{}],389:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}var i=e("babel-runtime/helpers/typeof"),o=n(i);r.strictJSONParse=function(e){var t=JSON.parse(e);if(!t||"object"!==("undefined"==typeof t?"undefined":(0,o.default)(t)))throw new Error("JSON string is not object");return t}},{"babel-runtime/helpers/typeof":39}],390:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}function i(){}var o=e("babel-runtime/core-js/object/create"),a=n(o);r.has=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},r.map=function e(t){var e=new i;if(!t)return e;for(var r in t)e[r]=t[r];return e},i.prototype=(0,a.default)(null)},{"babel-runtime/core-js/object/create":22}],391:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}var i=e("babel-runtime/core-js/number/max-safe-integer"),o=n(i);r.MAX_SAFE_INTEGER=o.default||Math.pow(2,53)-1,r.MIN_SAFE_INTEGER=-r.MAX_SAFE_INTEGER;var a=r.MAX_SAFE_INTEGER_STR=String(r.MAX_SAFE_INTEGER),s=a.length;r.isSafeNumberString=function(e){return"-"===e[0]&&(e=e.substring(1)),e.length<s||e.length===s&&e<=a},r.toSafeNumber=function(e){return"number"==typeof e?e:r.isSafeNumberString(e)?Number(e):e}},{"babel-runtime/core-js/number/max-safe-integer":21}],392:[function(e,t,r){"use strict";r.try=function(e){var t={error:void 0,value:void 0};try{t.value=e()}catch(e){t.error=e instanceof Error?e:new Error(e)}return t},r.dig=function(e){if(e){if(arguments.length<=1)return e;for(var t=e[arguments[1]],r=2;r<arguments.length&&t;r++)t=t[arguments[r]];return t}},r.argumentsToArray=function(e){for(var t=new Array(e.length),r=0;r<e.length;r++)t[r]=e[r];return t}},{}],393:[function(e,t,r){(function(t){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}var i=e("babel-runtime/core-js/set-immediate"),o=n(i);r.setImmediate="function"==typeof o.default?o.default:function(e){t.nextTick(e.bind.apply(e,arguments))}}).call(this,e("_process"))},{_process:345,"babel-runtime/core-js/set-immediate":34}],394:[function(e,t,r){"use strict";r.randomString=function(e,t){var r=[];for(e=e||16,t=t||"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";e--;)r.push(t[Math.floor(Math.random()*t.length)]);return r.join("")},r.split=function(e,t){e=e||"",t=t||",";for(var r=e.split(t),n=[],i=0;i<r.length;i++){var o=r[i].trim();o.length>0&&n.push(o)}return n},r.splitAlwaysOptimized=function(){var e="",t=",";1===arguments.length?e=arguments[0]||"":2===arguments.length&&(e=arguments[0]||"",t=arguments[1]||",");for(var r=e.split(t),n=[],i=0;i<r.length;i++){var o=r[i].trim();o.length>0&&n.push(o)}return n},r.replace=function(e,t,r){var n=r;return"function"!=typeof n&&(n=function(){return r}),e.replace(t,n)}},{}],395:[function(e,t,r){"use strict";var n=e("copy-to");n(e("./function")).and(e("./polyfill")).and(e("./optimize")).and(e("./crypto")).and(e("./number")).and(e("./string")).and(e("./array")).and(e("./json")).and(e("./date")).and(e("./map")).and(e("./web")).to(t.exports)},{"./array":385,"./crypto":386,"./date":387,"./function":388,"./json":389,"./map":390,"./number":391,"./optimize":392,"./polyfill":393,"./string":394,"./web":396,"copy-to":54}],396:[function(e,t,r){"use strict";r.escape=e("escape-html"),r.encodeURIComponent=function(e){try{return encodeURIComponent(e)}catch(t){return e}},r.decodeURIComponent=function(e){try{return decodeURIComponent(e)}catch(t){return e}}},{"escape-html":192}],397:[function(e,t,r){(function(r){"use strict";var n=e("os"),i=e("semver"),o={"10.0":"10",6.3:"8.1",6.2:"8",6.1:"7","6.0":"Vista",5.1:"XP","5.0":"2000",4.9:"ME",4.1:"98","4.0":"95"};t.exports=function(t){var a=/\d+\.\d+/,s=a.exec(t||n.release());if(!t&&"win32"===r.platform&&i.satisfies(r.version,">=0.12.0 <3.1.0"))try{s=a.exec(String(e("child_process").execSync("ver.exe",{timeout:2e3})))}catch(e){}if(t&&!s)throw new Error("`release` argument doesn't match `n.n`");return o[(s||[])[0]]}}).call(this,e("_process"))},{_process:345,child_process:43,os:339,semver:366}],398:[function(e,t,r){"use strict";(function(){r.stripBOM=function(e){return"\ufeff"===e[0]?e.substring(1):e}}).call(void 0)},{}],399:[function(e,t,r){"use strict";(function(){var e;e=new RegExp(/(?!xmlns)^.*:/),r.normalize=function(e){return e.toLowerCase()},r.firstCharLowerCase=function(e){return e.charAt(0).toLowerCase()+e.slice(1)},r.stripPrefix=function(t){return t.replace(e,"")},r.parseNumbers=function(e){return isNaN(e)||(e=e%1===0?parseInt(e,10):parseFloat(e)),e},r.parseBooleans=function(e){return/^(?:true|false)$/i.test(e)&&(e="true"===e.toLowerCase()),e}}).call(void 0)},{}],400:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}var i=e("babel-runtime/core-js/object/get-own-property-names"),o=n(i),a=e("babel-runtime/core-js/object/keys"),s=n(a),u=e("babel-runtime/helpers/typeof"),c=n(u);(function(){var t,n,i,a,u,l,p,f,d,h,m,b=function(e,t){function r(){this.constructor=e}for(var n in t)v.call(t,n)&&(e[n]=t[n]);return r.prototype=t.prototype,e.prototype=new r,e.__super__=t.prototype,e},v={}.hasOwnProperty,g=function(e,t){return function(){return e.apply(t,arguments)}};d=e("sax"),a=e("events"),n=e("xmlbuilder"),t=e("./bom"),p=e("./processors"),h=e("timers").setImmediate,u=function(e){return"object"===("undefined"==typeof e?"undefined":(0,c.default)(e))&&null!=e&&0===(0,s.default)(e).length},l=function(e,t){var r,n,i;for(r=0,n=e.length;r<n;r++)i=e[r],t=i(t);return t},f=function(e){return e.indexOf("&")>=0||e.indexOf(">")>=0||e.indexOf("<")>=0},m=function(e){return"<![CDATA["+i(e)+"]]>"},i=function(e){return e.replace("]]>","]]]]><![CDATA[>")},r.processors=p,r.defaults={.1:{explicitCharkey:!1,trim:!0,normalize:!0,normalizeTags:!1,attrkey:"@",charkey:"#",explicitArray:!1,ignoreAttrs:!1,mergeAttrs:!1,explicitRoot:!1,validator:null,xmlns:!1,explicitChildren:!1,childkey:"@@",charsAsChildren:!1,includeWhiteChars:!1,async:!1,strict:!0,attrNameProcessors:null,attrValueProcessors:null,tagNameProcessors:null,valueProcessors:null,emptyTag:""},.2:{explicitCharkey:!1,trim:!1,normalize:!1,normalizeTags:!1,attrkey:"$",charkey:"_",explicitArray:!0,ignoreAttrs:!1,mergeAttrs:!1,explicitRoot:!0,validator:null,xmlns:!1,explicitChildren:!1,preserveChildrenOrder:!1,childkey:"$$",charsAsChildren:!1,includeWhiteChars:!1,async:!1,strict:!0,attrNameProcessors:null,attrValueProcessors:null,tagNameProcessors:null,valueProcessors:null,rootName:"root",xmldec:{version:"1.0",encoding:"UTF-8",standalone:!0},doctype:null,renderOpts:{pretty:!0,indent:"  ",newline:"\n"},headless:!1,chunkSize:1e4,emptyTag:"",cdata:!1}},r.ValidationError=function(e){function t(e){this.message=e}return b(t,e),t}(Error),r.Builder=function(){function e(e){var t,n,i;this.options={},n=r.defaults[.2];for(t in n)v.call(n,t)&&(i=n[t],this.options[t]=i);for(t in e)v.call(e,t)&&(i=e[t],this.options[t]=i)}return e.prototype.buildObject=function(e){var t,i,o,a,u;return t=this.options.attrkey,i=this.options.charkey,1===(0,s.default)(e).length&&this.options.rootName===r.defaults[.2].rootName?(u=(0,s.default)(e)[0],e=e[u]):u=this.options.rootName,o=function(e){return function(r,n){var a,s,u,l,p,d;if("object"!==("undefined"==typeof n?"undefined":(0,c.default)(n)))e.options.cdata&&f(n)?r.raw(m(n)):r.txt(n);else for(p in n)if(v.call(n,p))if(s=n[p],p===t){if("object"===("undefined"==typeof s?"undefined":(0,c.default)(s)))for(a in s)d=s[a],r=r.att(a,d)}else if(p===i)r=e.options.cdata&&f(s)?r.raw(m(s)):r.txt(s);else if(Array.isArray(s))for(l in s)v.call(s,l)&&(u=s[l],r="string"==typeof u?e.options.cdata&&f(u)?r.ele(p).raw(m(u)).up():r.ele(p,u).up():o(r.ele(p),u).up());else"object"===("undefined"==typeof s?"undefined":(0,c.default)(s))?r=o(r.ele(p),s).up():"string"==typeof s&&e.options.cdata&&f(s)?r=r.ele(p).raw(m(s)).up():(null==s&&(s=""),r=r.ele(p,s.toString()).up());return r}}(this),a=n.create(u,this.options.xmldec,this.options.doctype,{headless:this.options.headless,allowSurrogateChars:this.options.allowSurrogateChars}),o(a,e).end(this.options.renderOpts)},e}(),r.Parser=function(e){function n(e){this.parseString=g(this.parseString,this),this.reset=g(this.reset,this),this.assignOrPush=g(this.assignOrPush,this),this.processAsync=g(this.processAsync,this);var t,n,i;if(!(this instanceof r.Parser))return new r.Parser(e);this.options={},n=r.defaults[.2];for(t in n)v.call(n,t)&&(i=n[t],this.options[t]=i);for(t in e)v.call(e,t)&&(i=e[t],this.options[t]=i);this.options.xmlns&&(this.options.xmlnskey=this.options.attrkey+"ns"),this.options.normalizeTags&&(this.options.tagNameProcessors||(this.options.tagNameProcessors=[]),this.options.tagNameProcessors.unshift(p.normalize)),this.reset()}return b(n,e),n.prototype.processAsync=function(){var e,t;try{return this.remaining.length<=this.options.chunkSize?(e=this.remaining,this.remaining="",this.saxParser=this.saxParser.write(e),this.saxParser.close()):(e=this.remaining.substr(0,this.options.chunkSize),this.remaining=this.remaining.substr(this.options.chunkSize,this.remaining.length),this.saxParser=this.saxParser.write(e),h(this.processAsync))}catch(e){if(t=e,!this.saxParser.errThrown)return this.saxParser.errThrown=!0,this.emit(t)}},n.prototype.assignOrPush=function(e,t,r){return t in e?(e[t]instanceof Array||(e[t]=[e[t]]),e[t].push(r)):this.options.explicitArray?e[t]=[r]:e[t]=r},n.prototype.reset=function(){var e,t,r,n;return this.removeAllListeners(),this.saxParser=d.parser(this.options.strict,{trim:!1,normalize:!1,xmlns:this.options.xmlns}),this.saxParser.errThrown=!1,this.saxParser.onerror=function(e){return function(t){if(e.saxParser.resume(),!e.saxParser.errThrown)return e.saxParser.errThrown=!0,e.emit("error",t)}}(this),this.saxParser.onend=function(e){return function(){if(!e.saxParser.ended)return e.saxParser.ended=!0,e.emit("end",e.resultObject)}}(this),this.saxParser.ended=!1,this.EXPLICIT_CHARKEY=this.options.explicitCharkey,this.resultObject=null,n=[],e=this.options.attrkey,t=this.options.charkey,this.saxParser.onopentag=function(r){return function(i){var o,a,s,u,c;if(s={},s[t]="",!r.options.ignoreAttrs){c=i.attributes;for(o in c)v.call(c,o)&&(e in s||r.options.mergeAttrs||(s[e]={}),a=r.options.attrValueProcessors?l(r.options.attrValueProcessors,i.attributes[o]):i.attributes[o],u=r.options.attrNameProcessors?l(r.options.attrNameProcessors,o):o,r.options.mergeAttrs?r.assignOrPush(s,u,a):s[e][u]=a)}return s["#name"]=r.options.tagNameProcessors?l(r.options.tagNameProcessors,i.name):i.name,r.options.xmlns&&(s[r.options.xmlnskey]={uri:i.uri,local:i.local}),n.push(s)}}(this),this.saxParser.onclosetag=function(e){return function(){var r,i,a,p,f,d,h,m,b,g,y;if(h=n.pop(),d=h["#name"],e.options.explicitChildren&&e.options.preserveChildrenOrder||delete h["#name"],h.cdata===!0&&(r=h.cdata,delete h.cdata),g=n[n.length-1],h[t].match(/^\s*$/)&&!r?(i=h[t],delete h[t]):(e.options.trim&&(h[t]=h[t].trim()),e.options.normalize&&(h[t]=h[t].replace(/\s{2,}/g," ").trim()),h[t]=e.options.valueProcessors?l(e.options.valueProcessors,h[t]):h[t],1===(0,s.default)(h).length&&t in h&&!e.EXPLICIT_CHARKEY&&(h=h[t])),u(h)&&(h=""!==e.options.emptyTag?e.options.emptyTag:i),null!=e.options.validator){y="/"+function(){var e,t,r;for(r=[],e=0,t=n.length;e<t;e++)f=n[e],r.push(f["#name"]);return r}().concat(d).join("/");try{h=e.options.validator(y,g&&g[d],h)}catch(t){a=t,e.emit("error",a)}}if(e.options.explicitChildren&&!e.options.mergeAttrs&&"object"===("undefined"==typeof h?"undefined":(0,c.default)(h)))if(e.options.preserveChildrenOrder){if(g){g[e.options.childkey]=g[e.options.childkey]||[],m={};for(p in h)v.call(h,p)&&(m[p]=h[p]);g[e.options.childkey].push(m),delete h["#name"],1===(0,s.default)(h).length&&t in h&&!e.EXPLICIT_CHARKEY&&(h=h[t])}}else f={},e.options.attrkey in h&&(f[e.options.attrkey]=h[e.options.attrkey],delete h[e.options.attrkey]),!e.options.charsAsChildren&&e.options.charkey in h&&(f[e.options.charkey]=h[e.options.charkey],delete h[e.options.charkey]),(0,o.default)(h).length>0&&(f[e.options.childkey]=h),h=f;return n.length>0?e.assignOrPush(g,d,h):(e.options.explicitRoot&&(b=h,h={},h[d]=b),e.resultObject=h,e.saxParser.ended=!0,e.emit("end",e.resultObject))}}(this),r=function(e){return function(r){var i,o;if(o=n[n.length-1])return o[t]+=r,e.options.explicitChildren&&e.options.preserveChildrenOrder&&e.options.charsAsChildren&&(e.options.includeWhiteChars||""!==r.replace(/\\n/g,"").trim())&&(o[e.options.childkey]=o[e.options.childkey]||[],i={"#name":"__text__"},i[t]=r,e.options.normalize&&(i[t]=i[t].replace(/\s{2,}/g," ").trim()),o[e.options.childkey].push(i)),o}}(this),this.saxParser.ontext=r,this.saxParser.oncdata=function(e){return function(e){var t;if(t=r(e))return t.cdata=!0}}(this)},n.prototype.parseString=function(e,r){var n;null!=r&&"function"==typeof r&&(this.on("end",function(e){return this.reset(),r(null,e)}),this.on("error",function(e){return this.reset(),r(e)}));try{return e=e.toString(),""===e.trim()?(this.emit("end",null),!0):(e=t.stripBOM(e),this.options.async?(this.remaining=e,h(this.processAsync),this.saxParser):this.saxParser.write(e).close())}catch(e){if(n=e,!this.saxParser.errThrown&&!this.saxParser.ended)return this.emit("error",n),this.saxParser.errThrown=!0;if(this.saxParser.ended)throw n}},n}(a.EventEmitter),r.parseString=function(e,t,n){var i,o,a;return null!=n?("function"==typeof n&&(i=n),"object"===("undefined"==typeof t?"undefined":(0,c.default)(t))&&(o=t)):("function"==typeof t&&(i=t),o={}),a=new r.Parser(o),a.parseString(e,i)}}).call(void 0)},{"./bom":398,"./processors":399,"babel-runtime/core-js/object/get-own-property-names":26,"babel-runtime/core-js/object/keys":30,"babel-runtime/helpers/typeof":39,events:193,sax:364,timers:375,xmlbuilder:417}],401:[function(e,t,r){"use strict";(function(){var r,n;n=e("lodash/create"),t.exports=r=function(){function e(e,t,r){if(this.stringify=e.stringify,null==t)throw new Error("Missing attribute name of element "+e.name);if(null==r)throw new Error("Missing attribute value for attribute "+t+" of element "+e.name);this.name=this.stringify.attName(t),this.value=this.stringify.attValue(r)}return e.prototype.clone=function(){return n(e.prototype,this)},e.prototype.toString=function(e,t){return" "+this.name+'="'+this.value+'"'},e}()}).call(void 0)},{"lodash/create":313}],402:[function(e,t,r){"use strict";(function(){var r,n,i,o,a;a=e("./XMLStringifier"),n=e("./XMLDeclaration"),i=e("./XMLDocType"),o=e("./XMLElement"),t.exports=r=function(){function e(e,t){var r,n;if(null==e)throw new Error("Root element needs a name");null==t&&(t={}),this.options=t,this.stringify=new a(t),n=new o(this,"doc"),r=n.element(e),r.isRoot=!0,r.documentObject=this,this.rootObject=r,t.headless||(r.declaration(t),null==t.pubID&&null==t.sysID||r.doctype(t))}return e.prototype.root=function(){return this.rootObject},e.prototype.end=function(e){return this.toString(e)},e.prototype.toString=function(e){var t,r,n,i,o,a,s,u;return i=(null!=e?e.pretty:void 0)||!1,t=null!=(a=null!=e?e.indent:void 0)?a:"  ",n=null!=(s=null!=e?e.offset:void 0)?s:0,r=null!=(u=null!=e?e.newline:void 0)?u:"\n",o="",null!=this.xmldec&&(o+=this.xmldec.toString(e)),
+null!=this.doctype&&(o+=this.doctype.toString(e)),o+=this.rootObject.toString(e),i&&o.slice(-r.length)===r&&(o=o.slice(0,-r.length)),o},e}()}).call(void 0)},{"./XMLDeclaration":409,"./XMLDocType":410,"./XMLElement":411,"./XMLStringifier":415}],403:[function(e,t,r){"use strict";(function(){var r,n,i,o=function(e,t){function r(){this.constructor=e}for(var n in t)a.call(t,n)&&(e[n]=t[n]);return r.prototype=t.prototype,e.prototype=new r,e.__super__=t.prototype,e},a={}.hasOwnProperty;i=e("lodash/create"),n=e("./XMLNode"),t.exports=r=function(e){function t(e,r){if(t.__super__.constructor.call(this,e),null==r)throw new Error("Missing CDATA text");this.text=this.stringify.cdata(r)}return o(t,e),t.prototype.clone=function(){return i(t.prototype,this)},t.prototype.toString=function(e,t){var r,n,i,o,a,s,u,c,l;return o=(null!=e?e.pretty:void 0)||!1,r=null!=(s=null!=e?e.indent:void 0)?s:"  ",i=null!=(u=null!=e?e.offset:void 0)?u:0,n=null!=(c=null!=e?e.newline:void 0)?c:"\n",t||(t=0),l=new Array(t+i+1).join(r),a="",o&&(a+=l),a+="<![CDATA["+this.text+"]]>",o&&(a+=n),a},t}(n)}).call(void 0)},{"./XMLNode":412,"lodash/create":313}],404:[function(e,t,r){"use strict";(function(){var r,n,i,o=function(e,t){function r(){this.constructor=e}for(var n in t)a.call(t,n)&&(e[n]=t[n]);return r.prototype=t.prototype,e.prototype=new r,e.__super__=t.prototype,e},a={}.hasOwnProperty;i=e("lodash/create"),n=e("./XMLNode"),t.exports=r=function(e){function t(e,r){if(t.__super__.constructor.call(this,e),null==r)throw new Error("Missing comment text");this.text=this.stringify.comment(r)}return o(t,e),t.prototype.clone=function(){return i(t.prototype,this)},t.prototype.toString=function(e,t){var r,n,i,o,a,s,u,c,l;return o=(null!=e?e.pretty:void 0)||!1,r=null!=(s=null!=e?e.indent:void 0)?s:"  ",i=null!=(u=null!=e?e.offset:void 0)?u:0,n=null!=(c=null!=e?e.newline:void 0)?c:"\n",t||(t=0),l=new Array(t+i+1).join(r),a="",o&&(a+=l),a+="<!-- "+this.text+" -->",o&&(a+=n),a},t}(n)}).call(void 0)},{"./XMLNode":412,"lodash/create":313}],405:[function(e,t,r){"use strict";(function(){var r,n;n=e("lodash/create"),t.exports=r=function(){function e(e,t,r,n,i,o){if(this.stringify=e.stringify,null==t)throw new Error("Missing DTD element name");if(null==r)throw new Error("Missing DTD attribute name");if(!n)throw new Error("Missing DTD attribute type");if(!i)throw new Error("Missing DTD attribute default");if(0!==i.indexOf("#")&&(i="#"+i),!i.match(/^(#REQUIRED|#IMPLIED|#FIXED|#DEFAULT)$/))throw new Error("Invalid default value type; expected: #REQUIRED, #IMPLIED, #FIXED or #DEFAULT");if(o&&!i.match(/^(#FIXED|#DEFAULT)$/))throw new Error("Default value only applies to #FIXED or #DEFAULT");this.elementName=this.stringify.eleName(t),this.attributeName=this.stringify.attName(r),this.attributeType=this.stringify.dtdAttType(n),this.defaultValue=this.stringify.dtdAttDefault(o),this.defaultValueType=i}return e.prototype.toString=function(e,t){var r,n,i,o,a,s,u,c,l;return o=(null!=e?e.pretty:void 0)||!1,r=null!=(s=null!=e?e.indent:void 0)?s:"  ",i=null!=(u=null!=e?e.offset:void 0)?u:0,n=null!=(c=null!=e?e.newline:void 0)?c:"\n",t||(t=0),l=new Array(t+i+1).join(r),a="",o&&(a+=l),a+="<!ATTLIST "+this.elementName+" "+this.attributeName+" "+this.attributeType,"#DEFAULT"!==this.defaultValueType&&(a+=" "+this.defaultValueType),this.defaultValue&&(a+=' "'+this.defaultValue+'"'),a+=">",o&&(a+=n),a},e}()}).call(void 0)},{"lodash/create":313}],406:[function(e,t,r){"use strict";(function(){var r,n;n=e("lodash/create"),t.exports=r=function(){function e(e,t,r){if(this.stringify=e.stringify,null==t)throw new Error("Missing DTD element name");r||(r="(#PCDATA)"),Array.isArray(r)&&(r="("+r.join(",")+")"),this.name=this.stringify.eleName(t),this.value=this.stringify.dtdElementValue(r)}return e.prototype.toString=function(e,t){var r,n,i,o,a,s,u,c,l;return o=(null!=e?e.pretty:void 0)||!1,r=null!=(s=null!=e?e.indent:void 0)?s:"  ",i=null!=(u=null!=e?e.offset:void 0)?u:0,n=null!=(c=null!=e?e.newline:void 0)?c:"\n",t||(t=0),l=new Array(t+i+1).join(r),a="",o&&(a+=l),a+="<!ELEMENT "+this.name+" "+this.value+">",o&&(a+=n),a},e}()}).call(void 0)},{"lodash/create":313}],407:[function(e,t,r){"use strict";(function(){var r,n,i;n=e("lodash/create"),i=e("lodash/isObject"),t.exports=r=function(){function e(e,t,r,n){if(this.stringify=e.stringify,null==r)throw new Error("Missing entity name");if(null==n)throw new Error("Missing entity value");if(this.pe=!!t,this.name=this.stringify.eleName(r),i(n)){if(!n.pubID&&!n.sysID)throw new Error("Public and/or system identifiers are required for an external entity");if(n.pubID&&!n.sysID)throw new Error("System identifier is required for a public external entity");if(null!=n.pubID&&(this.pubID=this.stringify.dtdPubID(n.pubID)),null!=n.sysID&&(this.sysID=this.stringify.dtdSysID(n.sysID)),null!=n.nData&&(this.nData=this.stringify.dtdNData(n.nData)),this.pe&&this.nData)throw new Error("Notation declaration is not allowed in a parameter entity")}else this.value=this.stringify.dtdEntityValue(n)}return e.prototype.toString=function(e,t){var r,n,i,o,a,s,u,c,l;return o=(null!=e?e.pretty:void 0)||!1,r=null!=(s=null!=e?e.indent:void 0)?s:"  ",i=null!=(u=null!=e?e.offset:void 0)?u:0,n=null!=(c=null!=e?e.newline:void 0)?c:"\n",t||(t=0),l=new Array(t+i+1).join(r),a="",o&&(a+=l),a+="<!ENTITY",this.pe&&(a+=" %"),a+=" "+this.name,this.value?a+=' "'+this.value+'"':(this.pubID&&this.sysID?a+=' PUBLIC "'+this.pubID+'" "'+this.sysID+'"':this.sysID&&(a+=' SYSTEM "'+this.sysID+'"'),this.nData&&(a+=" NDATA "+this.nData)),a+=">",o&&(a+=n),a},e}()}).call(void 0)},{"lodash/create":313,"lodash/isObject":326}],408:[function(e,t,r){"use strict";(function(){var r,n;n=e("lodash/create"),t.exports=r=function(){function e(e,t,r){if(this.stringify=e.stringify,null==t)throw new Error("Missing notation name");if(!r.pubID&&!r.sysID)throw new Error("Public or system identifiers are required for an external entity");this.name=this.stringify.eleName(t),null!=r.pubID&&(this.pubID=this.stringify.dtdPubID(r.pubID)),null!=r.sysID&&(this.sysID=this.stringify.dtdSysID(r.sysID))}return e.prototype.toString=function(e,t){var r,n,i,o,a,s,u,c,l;return o=(null!=e?e.pretty:void 0)||!1,r=null!=(s=null!=e?e.indent:void 0)?s:"  ",i=null!=(u=null!=e?e.offset:void 0)?u:0,n=null!=(c=null!=e?e.newline:void 0)?c:"\n",t||(t=0),l=new Array(t+i+1).join(r),a="",o&&(a+=l),a+="<!NOTATION "+this.name,this.pubID&&this.sysID?a+=' PUBLIC "'+this.pubID+'" "'+this.sysID+'"':this.pubID?a+=' PUBLIC "'+this.pubID+'"':this.sysID&&(a+=' SYSTEM "'+this.sysID+'"'),a+=">",o&&(a+=n),a},e}()}).call(void 0)},{"lodash/create":313}],409:[function(e,t,r){"use strict";(function(){var r,n,i,o,a=function(e,t){function r(){this.constructor=e}for(var n in t)s.call(t,n)&&(e[n]=t[n]);return r.prototype=t.prototype,e.prototype=new r,e.__super__=t.prototype,e},s={}.hasOwnProperty;i=e("lodash/create"),o=e("lodash/isObject"),n=e("./XMLNode"),t.exports=r=function(e){function t(e,r,n,i){var a;t.__super__.constructor.call(this,e),o(r)&&(a=r,r=a.version,n=a.encoding,i=a.standalone),r||(r="1.0"),this.version=this.stringify.xmlVersion(r),null!=n&&(this.encoding=this.stringify.xmlEncoding(n)),null!=i&&(this.standalone=this.stringify.xmlStandalone(i))}return a(t,e),t.prototype.toString=function(e,t){var r,n,i,o,a,s,u,c,l;return o=(null!=e?e.pretty:void 0)||!1,r=null!=(s=null!=e?e.indent:void 0)?s:"  ",i=null!=(u=null!=e?e.offset:void 0)?u:0,n=null!=(c=null!=e?e.newline:void 0)?c:"\n",t||(t=0),l=new Array(t+i+1).join(r),a="",o&&(a+=l),a+="<?xml",a+=' version="'+this.version+'"',null!=this.encoding&&(a+=' encoding="'+this.encoding+'"'),null!=this.standalone&&(a+=' standalone="'+this.standalone+'"'),a+="?>",o&&(a+=n),a},t}(n)}).call(void 0)},{"./XMLNode":412,"lodash/create":313,"lodash/isObject":326}],410:[function(e,t,r){"use strict";(function(){var r,n,i,o,a,s,u,c,l,p;l=e("lodash/create"),p=e("lodash/isObject"),r=e("./XMLCData"),n=e("./XMLComment"),i=e("./XMLDTDAttList"),a=e("./XMLDTDEntity"),o=e("./XMLDTDElement"),s=e("./XMLDTDNotation"),c=e("./XMLProcessingInstruction"),t.exports=u=function(){function e(e,t,r){var n,i;this.documentObject=e,this.stringify=this.documentObject.stringify,this.children=[],p(t)&&(n=t,t=n.pubID,r=n.sysID),null==r&&(i=[t,r],r=i[0],t=i[1]),null!=t&&(this.pubID=this.stringify.dtdPubID(t)),null!=r&&(this.sysID=this.stringify.dtdSysID(r))}return e.prototype.element=function(e,t){var r;return r=new o(this,e,t),this.children.push(r),this},e.prototype.attList=function(e,t,r,n,o){var a;return a=new i(this,e,t,r,n,o),this.children.push(a),this},e.prototype.entity=function(e,t){var r;return r=new a(this,!1,e,t),this.children.push(r),this},e.prototype.pEntity=function(e,t){var r;return r=new a(this,!0,e,t),this.children.push(r),this},e.prototype.notation=function(e,t){var r;return r=new s(this,e,t),this.children.push(r),this},e.prototype.cdata=function(e){var t;return t=new r(this,e),this.children.push(t),this},e.prototype.comment=function(e){var t;return t=new n(this,e),this.children.push(t),this},e.prototype.instruction=function(e,t){var r;return r=new c(this,e,t),this.children.push(r),this},e.prototype.root=function(){return this.documentObject.root()},e.prototype.document=function(){return this.documentObject},e.prototype.toString=function(e,t){var r,n,i,o,a,s,u,c,l,p,f,d,h;if(u=(null!=e?e.pretty:void 0)||!1,i=null!=(l=null!=e?e.indent:void 0)?l:"  ",s=null!=(p=null!=e?e.offset:void 0)?p:0,a=null!=(f=null!=e?e.newline:void 0)?f:"\n",t||(t=0),h=new Array(t+s+1).join(i),c="",u&&(c+=h),c+="<!DOCTYPE "+this.root().name,this.pubID&&this.sysID?c+=' PUBLIC "'+this.pubID+'" "'+this.sysID+'"':this.sysID&&(c+=' SYSTEM "'+this.sysID+'"'),this.children.length>0){for(c+=" [",u&&(c+=a),d=this.children,n=0,o=d.length;n<o;n++)r=d[n],c+=r.toString(e,t+1);c+="]"}return c+=">",u&&(c+=a),c},e.prototype.ele=function(e,t){return this.element(e,t)},e.prototype.att=function(e,t,r,n,i){return this.attList(e,t,r,n,i)},e.prototype.ent=function(e,t){return this.entity(e,t)},e.prototype.pent=function(e,t){return this.pEntity(e,t)},e.prototype.not=function(e,t){return this.notation(e,t)},e.prototype.dat=function(e){return this.cdata(e)},e.prototype.com=function(e){return this.comment(e)},e.prototype.ins=function(e,t){return this.instruction(e,t)},e.prototype.up=function(){return this.root()},e.prototype.doc=function(){return this.document()},e}()}).call(void 0)},{"./XMLCData":403,"./XMLComment":404,"./XMLDTDAttList":405,"./XMLDTDElement":406,"./XMLDTDEntity":407,"./XMLDTDNotation":408,"./XMLProcessingInstruction":413,"lodash/create":313,"lodash/isObject":326}],411:[function(e,t,r){"use strict";(function(){var r,n,i,o,a,s,u,c,l=function(e,t){function r(){this.constructor=e}for(var n in t)p.call(t,n)&&(e[n]=t[n]);return r.prototype=t.prototype,e.prototype=new r,e.__super__=t.prototype,e},p={}.hasOwnProperty;a=e("lodash/create"),c=e("lodash/isObject"),u=e("lodash/isFunction"),s=e("lodash/every"),i=e("./XMLNode"),r=e("./XMLAttribute"),o=e("./XMLProcessingInstruction"),t.exports=n=function(e){function t(e,r,n){if(t.__super__.constructor.call(this,e),null==r)throw new Error("Missing element name");this.name=this.stringify.eleName(r),this.children=[],this.instructions=[],this.attributes={},null!=n&&this.attribute(n)}return l(t,e),t.prototype.clone=function(){var e,r,n,i,o,s,u,c;n=a(t.prototype,this),n.isRoot&&(n.documentObject=null),n.attributes={},u=this.attributes;for(r in u)p.call(u,r)&&(e=u[r],n.attributes[r]=e.clone());for(n.instructions=[],c=this.instructions,i=0,o=c.length;i<o;i++)s=c[i],n.instructions.push(s.clone());return n.children=[],this.children.forEach(function(e){var t;return t=e.clone(),t.parent=n,n.children.push(t)}),n},t.prototype.attribute=function(e,t){var n,i;if(null!=e&&(e=e.valueOf()),c(e))for(n in e)p.call(e,n)&&(i=e[n],this.attribute(n,i));else u(t)&&(t=t.apply()),this.options.skipNullAttributes&&null==t||(this.attributes[e]=new r(this,e,t));return this},t.prototype.removeAttribute=function(e){var t,r,n;if(null==e)throw new Error("Missing attribute name");if(e=e.valueOf(),Array.isArray(e))for(r=0,n=e.length;r<n;r++)t=e[r],delete this.attributes[t];else delete this.attributes[e];return this},t.prototype.instruction=function(e,t){var r,n,i,a,s;if(null!=e&&(e=e.valueOf()),null!=t&&(t=t.valueOf()),Array.isArray(e))for(r=0,s=e.length;r<s;r++)n=e[r],this.instruction(n);else if(c(e))for(n in e)p.call(e,n)&&(i=e[n],this.instruction(n,i));else u(t)&&(t=t.apply()),a=new o(this,e,t),this.instructions.push(a);return this},t.prototype.toString=function(e,t){var r,n,i,o,a,u,c,l,f,d,h,m,b,v,g,y,_,x,w,E;for(m=(null!=e?e.pretty:void 0)||!1,o=null!=(v=null!=e?e.indent:void 0)?v:"  ",h=null!=(g=null!=e?e.offset:void 0)?g:0,d=null!=(y=null!=e?e.newline:void 0)?y:"\n",t||(t=0),E=new Array(t+h+1).join(o),b="",_=this.instructions,i=0,c=_.length;i<c;i++)a=_[i],b+=a.toString(e,t);m&&(b+=E),b+="<"+this.name,x=this.attributes;for(f in x)p.call(x,f)&&(r=x[f],b+=r.toString(e));if(0===this.children.length||s(this.children,function(e){return""===e.value}))b+="/>",m&&(b+=d);else if(m&&1===this.children.length&&null!=this.children[0].value)b+=">",b+=this.children[0].value,b+="</"+this.name+">",b+=d;else{for(b+=">",m&&(b+=d),w=this.children,u=0,l=w.length;u<l;u++)n=w[u],b+=n.toString(e,t+1);m&&(b+=E),b+="</"+this.name+">",m&&(b+=d)}return b},t.prototype.att=function(e,t){return this.attribute(e,t)},t.prototype.ins=function(e,t){return this.instruction(e,t)},t.prototype.a=function(e,t){return this.attribute(e,t)},t.prototype.i=function(e,t){return this.instruction(e,t)},t}(i)}).call(void 0)},{"./XMLAttribute":401,"./XMLNode":412,"./XMLProcessingInstruction":413,"lodash/create":313,"lodash/every":315,"lodash/isFunction":324,"lodash/isObject":326}],412:[function(e,t,r){"use strict";(function(){var r,n,i,o,a,s,u,c,l,p,f,d={}.hasOwnProperty;f=e("lodash/isObject"),p=e("lodash/isFunction"),l=e("lodash/isEmpty"),a=null,r=null,n=null,i=null,o=null,u=null,c=null,t.exports=s=function(){function t(t){this.parent=t,this.options=this.parent.options,this.stringify=this.parent.stringify,null===a&&(a=e("./XMLElement"),r=e("./XMLCData"),n=e("./XMLComment"),i=e("./XMLDeclaration"),o=e("./XMLDocType"),u=e("./XMLRaw"),c=e("./XMLText"))}return t.prototype.element=function(e,t,r){var n,i,o,a,s,u,c,h,m,b;if(u=null,null==t&&(t={}),t=t.valueOf(),f(t)||(m=[t,r],r=m[0],t=m[1]),null!=e&&(e=e.valueOf()),Array.isArray(e))for(o=0,c=e.length;o<c;o++)i=e[o],u=this.element(i);else if(p(e))u=this.element(e.apply());else if(f(e)){for(s in e)if(d.call(e,s))if(b=e[s],p(b)&&(b=b.apply()),f(b)&&l(b)&&(b=null),!this.options.ignoreDecorators&&this.stringify.convertAttKey&&0===s.indexOf(this.stringify.convertAttKey))u=this.attribute(s.substr(this.stringify.convertAttKey.length),b);else if(!this.options.ignoreDecorators&&this.stringify.convertPIKey&&0===s.indexOf(this.stringify.convertPIKey))u=this.instruction(s.substr(this.stringify.convertPIKey.length),b);else if(!this.options.separateArrayItems&&Array.isArray(b))for(a=0,h=b.length;a<h;a++)i=b[a],n={},n[s]=i,u=this.element(n);else f(b)?(u=this.element(s),u.element(b)):u=this.element(s,b)}else u=!this.options.ignoreDecorators&&this.stringify.convertTextKey&&0===e.indexOf(this.stringify.convertTextKey)?this.text(r):!this.options.ignoreDecorators&&this.stringify.convertCDataKey&&0===e.indexOf(this.stringify.convertCDataKey)?this.cdata(r):!this.options.ignoreDecorators&&this.stringify.convertCommentKey&&0===e.indexOf(this.stringify.convertCommentKey)?this.comment(r):!this.options.ignoreDecorators&&this.stringify.convertRawKey&&0===e.indexOf(this.stringify.convertRawKey)?this.raw(r):this.node(e,t,r);if(null==u)throw new Error("Could not create any elements with: "+e);return u},t.prototype.insertBefore=function(e,t,r){var n,i,o;if(this.isRoot)throw new Error("Cannot insert elements at root level");return i=this.parent.children.indexOf(this),o=this.parent.children.splice(i),n=this.parent.element(e,t,r),Array.prototype.push.apply(this.parent.children,o),n},t.prototype.insertAfter=function(e,t,r){var n,i,o;if(this.isRoot)throw new Error("Cannot insert elements at root level");return i=this.parent.children.indexOf(this),o=this.parent.children.splice(i+1),n=this.parent.element(e,t,r),Array.prototype.push.apply(this.parent.children,o),n},t.prototype.remove=function(){var e,t;if(this.isRoot)throw new Error("Cannot remove the root element");return e=this.parent.children.indexOf(this),[].splice.apply(this.parent.children,[e,e-e+1].concat(t=[])),t,this.parent},t.prototype.node=function(e,t,r){var n,i;return null!=e&&(e=e.valueOf()),null==t&&(t={}),t=t.valueOf(),f(t)||(i=[t,r],r=i[0],t=i[1]),n=new a(this,e,t),null!=r&&n.text(r),this.children.push(n),n},t.prototype.text=function(e){var t;return t=new c(this,e),this.children.push(t),this},t.prototype.cdata=function(e){var t;return t=new r(this,e),this.children.push(t),this},t.prototype.comment=function(e){var t;return t=new n(this,e),this.children.push(t),this},t.prototype.raw=function(e){var t;return t=new u(this,e),this.children.push(t),this},t.prototype.declaration=function(e,t,r){var n,o;return n=this.document(),o=new i(n,e,t,r),n.xmldec=o,n.root()},t.prototype.doctype=function(e,t){var r,n;return r=this.document(),n=new o(r,e,t),r.doctype=n,n},t.prototype.up=function(){if(this.isRoot)throw new Error("The root node has no parent. Use doc() if you need to get the document object.");return this.parent},t.prototype.root=function(){var e;if(this.isRoot)return this;for(e=this.parent;!e.isRoot;)e=e.parent;return e},t.prototype.document=function(){return this.root().documentObject},t.prototype.end=function(e){return this.document().toString(e)},t.prototype.prev=function(){var e;if(this.isRoot)throw new Error("Root node has no siblings");if(e=this.parent.children.indexOf(this),e<1)throw new Error("Already at the first node");return this.parent.children[e-1]},t.prototype.next=function(){var e;if(this.isRoot)throw new Error("Root node has no siblings");if(e=this.parent.children.indexOf(this),e===-1||e===this.parent.children.length-1)throw new Error("Already at the last node");return this.parent.children[e+1]},t.prototype.importXMLBuilder=function(e){var t;return t=e.root().clone(),t.parent=this,t.isRoot=!1,this.children.push(t),this},t.prototype.ele=function(e,t,r){return this.element(e,t,r)},t.prototype.nod=function(e,t,r){return this.node(e,t,r)},t.prototype.txt=function(e){return this.text(e)},t.prototype.dat=function(e){return this.cdata(e)},t.prototype.com=function(e){return this.comment(e)},t.prototype.doc=function(){return this.document()},t.prototype.dec=function(e,t,r){return this.declaration(e,t,r)},t.prototype.dtd=function(e,t){return this.doctype(e,t)},t.prototype.e=function(e,t,r){return this.element(e,t,r)},t.prototype.n=function(e,t,r){return this.node(e,t,r)},t.prototype.t=function(e){return this.text(e)},t.prototype.d=function(e){return this.cdata(e)},t.prototype.c=function(e){return this.comment(e)},t.prototype.r=function(e){return this.raw(e)},t.prototype.u=function(){return this.up()},t}()}).call(void 0)},{"./XMLCData":403,"./XMLComment":404,"./XMLDeclaration":409,"./XMLDocType":410,"./XMLElement":411,"./XMLRaw":414,"./XMLText":416,"lodash/isEmpty":323,"lodash/isFunction":324,"lodash/isObject":326}],413:[function(e,t,r){"use strict";(function(){var r,n;n=e("lodash/create"),t.exports=r=function(){function e(e,t,r){if(this.stringify=e.stringify,null==t)throw new Error("Missing instruction target");this.target=this.stringify.insTarget(t),r&&(this.value=this.stringify.insValue(r))}return e.prototype.clone=function(){return n(e.prototype,this)},e.prototype.toString=function(e,t){var r,n,i,o,a,s,u,c,l;return o=(null!=e?e.pretty:void 0)||!1,r=null!=(s=null!=e?e.indent:void 0)?s:"  ",i=null!=(u=null!=e?e.offset:void 0)?u:0,n=null!=(c=null!=e?e.newline:void 0)?c:"\n",t||(t=0),l=new Array(t+i+1).join(r),a="",o&&(a+=l),a+="<?",a+=this.target,this.value&&(a+=" "+this.value),a+="?>",o&&(a+=n),a},e}()}).call(void 0)},{"lodash/create":313}],414:[function(e,t,r){"use strict";(function(){var r,n,i,o=function(e,t){function r(){this.constructor=e}for(var n in t)a.call(t,n)&&(e[n]=t[n]);return r.prototype=t.prototype,e.prototype=new r,e.__super__=t.prototype,e},a={}.hasOwnProperty;i=e("lodash/create"),r=e("./XMLNode"),t.exports=n=function(e){function t(e,r){if(t.__super__.constructor.call(this,e),null==r)throw new Error("Missing raw text");this.value=this.stringify.raw(r)}return o(t,e),t.prototype.clone=function(){return i(t.prototype,this)},t.prototype.toString=function(e,t){var r,n,i,o,a,s,u,c,l;return o=(null!=e?e.pretty:void 0)||!1,r=null!=(s=null!=e?e.indent:void 0)?s:"  ",i=null!=(u=null!=e?e.offset:void 0)?u:0,n=null!=(c=null!=e?e.newline:void 0)?c:"\n",t||(t=0),l=new Array(t+i+1).join(r),a="",o&&(a+=l),a+=this.value,o&&(a+=n),a},t}(r)}).call(void 0)},{"./XMLNode":412,"lodash/create":313}],415:[function(e,t,r){"use strict";(function(){var e,r=function(e,t){return function(){return e.apply(t,arguments)}},n={}.hasOwnProperty;t.exports=e=function(){function e(e){this.assertLegalChar=r(this.assertLegalChar,this);var t,i,o;this.allowSurrogateChars=null!=e?e.allowSurrogateChars:void 0,this.noDoubleEncoding=null!=e?e.noDoubleEncoding:void 0,i=(null!=e?e.stringify:void 0)||{};for(t in i)n.call(i,t)&&(o=i[t],this[t]=o)}return e.prototype.eleName=function(e){return e=""+e||"",this.assertLegalChar(e)},e.prototype.eleText=function(e){return e=""+e||"",this.assertLegalChar(this.elEscape(e))},e.prototype.cdata=function(e){if(e=""+e||"",e.match(/]]>/))throw new Error("Invalid CDATA text: "+e);return this.assertLegalChar(e)},e.prototype.comment=function(e){if(e=""+e||"",e.match(/--/))throw new Error("Comment text cannot contain double-hypen: "+e);return this.assertLegalChar(e)},e.prototype.raw=function(e){return""+e||""},e.prototype.attName=function(e){return""+e||""},e.prototype.attValue=function(e){return e=""+e||"",this.attEscape(e)},e.prototype.insTarget=function(e){return""+e||""},e.prototype.insValue=function(e){if(e=""+e||"",e.match(/\?>/))throw new Error("Invalid processing instruction value: "+e);return e},e.prototype.xmlVersion=function(e){if(e=""+e||"",!e.match(/1\.[0-9]+/))throw new Error("Invalid version number: "+e);return e},e.prototype.xmlEncoding=function(e){if(e=""+e||"",!e.match(/^[A-Za-z](?:[A-Za-z0-9._-]|-)*$/))throw new Error("Invalid encoding: "+e);return e},e.prototype.xmlStandalone=function(e){return e?"yes":"no"},e.prototype.dtdPubID=function(e){return""+e||""},e.prototype.dtdSysID=function(e){return""+e||""},e.prototype.dtdElementValue=function(e){return""+e||""},e.prototype.dtdAttType=function(e){return""+e||""},e.prototype.dtdAttDefault=function(e){return null!=e?""+e||"":e},e.prototype.dtdEntityValue=function(e){return""+e||""},e.prototype.dtdNData=function(e){return""+e||""},e.prototype.convertAttKey="@",e.prototype.convertPIKey="?",e.prototype.convertTextKey="#text",e.prototype.convertCDataKey="#cdata",e.prototype.convertCommentKey="#comment",e.prototype.convertRawKey="#raw",e.prototype.assertLegalChar=function(e){var t,r;if(t=this.allowSurrogateChars?/[\u0000-\u0008\u000B-\u000C\u000E-\u001F\uFFFE-\uFFFF]/:/[\u0000-\u0008\u000B-\u000C\u000E-\u001F\uD800-\uDFFF\uFFFE-\uFFFF]/,r=e.match(t))throw new Error("Invalid character ("+r+") in string: "+e+" at index "+r.index);return e},e.prototype.elEscape=function(e){var t;return t=this.noDoubleEncoding?/(?!&\S+;)&/g:/&/g,e.replace(t,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/\r/g,"&#xD;")},e.prototype.attEscape=function(e){var t;return t=this.noDoubleEncoding?/(?!&\S+;)&/g:/&/g,e.replace(t,"&amp;").replace(/</g,"&lt;").replace(/"/g,"&quot;")},e}()}).call(void 0)},{}],416:[function(e,t,r){"use strict";(function(){var r,n,i,o=function(e,t){function r(){this.constructor=e}for(var n in t)a.call(t,n)&&(e[n]=t[n]);return r.prototype=t.prototype,e.prototype=new r,e.__super__=t.prototype,e},a={}.hasOwnProperty;i=e("lodash/create"),r=e("./XMLNode"),t.exports=n=function(e){function t(e,r){if(t.__super__.constructor.call(this,e),null==r)throw new Error("Missing element text");this.value=this.stringify.eleText(r)}return o(t,e),t.prototype.clone=function(){return i(t.prototype,this)},t.prototype.toString=function(e,t){var r,n,i,o,a,s,u,c,l;return o=(null!=e?e.pretty:void 0)||!1,r=null!=(s=null!=e?e.indent:void 0)?s:"  ",i=null!=(u=null!=e?e.offset:void 0)?u:0,n=null!=(c=null!=e?e.newline:void 0)?c:"\n",t||(t=0),l=new Array(t+i+1).join(r),a="",o&&(a+=l),a+=this.value,o&&(a+=n),a},t}(r)}).call(void 0)},{"./XMLNode":412,"lodash/create":313}],417:[function(e,t,r){"use strict";(function(){var r,n;n=e("lodash/assign"),r=e("./XMLBuilder"),t.exports.create=function(e,t,i,o){return o=n({},t,i,o),new r(e,o).root()}}).call(void 0)},{"./XMLBuilder":402,"lodash/assign":311}],418:[function(e,t,r){"use strict";function n(){for(var e={},t=0;t<arguments.length;t++){var r=arguments[t];for(var n in r)i.call(r,n)&&(e[n]=r[n])}return e}t.exports=n;var i=Object.prototype.hasOwnProperty},{}],419:[function(e,t,r){t.exports={name:"ali-oss",version:"4.6.0",description:"aliyun oss(open storage service) node client",main:"lib/client.js",files:["lib"],scripts:{test:"mocha -t 30000 -r thunk-mocha -r should test/*.test.js","test-cov":"istanbul cover node_modules/.bin/_mocha -- -R dot -t 60000 -r thunk-mocha -r should test/*.test.js",jshint:"jshint .",autod:"autod","build-dist":"node browser-build.js > dist/aliyun-oss-sdk.js && MINIFY=1 node browser-build.js > dist/aliyun-oss-sdk.min.js","publish-to-cdn":"node publish.js"},"git-pre-hooks":{"pre-release":"npm run build-dist","post-release":["npm publish","npm run publish-to-cdn"]},repository:{type:"git",url:"git://github.com/aliyun/oss-nodejs-sdk.git"},keywords:["oss","client","file","aliyun"],author:"dead_horse",license:"MIT",bugs:{url:"https://github.com/aliyun/oss-nodejs-sdk/issues"},engines:{node:">=4"},homepage:"https://github.com/aliyun/oss-nodejs-sdk",devDependencies:{aliasify:"^2.0.0",autod:"^2.6.1","babel-plugin-transform-runtime":"^6.8.0","babel-preset-es2015":"^6.3.13","babel-runtime":"^6.6.1",babelify:"^7.3.0","beautify-benchmark":"^0.2.4",benchmark:"^2.1.1",bluebird:"^3.1.5",browserify:"^13.0.1","co-fs":"^1.2.0","crypto-browserify":"^1.0.9",filereader:"^0.10.3","git-pre-hooks":"^1.2.0",istanbul:"^0.4.3",mm:"^2.0.0",mocha:"^3.0.0",should:"^11.0.0","thunk-mocha":"^1.0.3","uglify-js":"^2.7.1"},dependencies:{address:"^1.0.0",agentkeepalive:"^2.1.1",co:"^4.6.0","co-defer":"^1.0.0","co-gather":"^0.0.1","copy-to":"^2.0.1",dateformat:"^1.0.12",debug:"^2.2.0",destroy:"^1.0.4","end-or-error":"^1.0.1","get-ready":"^1.0.0","humanize-ms":"^1.2.0","is-type-of":"^1.0.0","merge-descriptors":"^1.0.1",mime:"^1.3.4",platform:"^1.3.1","sdk-base":"^2.0.1",urllib:"^2.16.1",utility:"^1.8.0",xml2js:"^0.4.16"}}},{}],420:[function(e,t,r){"use strict";t.exports=e("crypto-browserify")},{"crypto-browserify":178}]},{},[1])(1)});