七牛上传图片或者视频以及删除

@@ -15,7 +15,15 @@
         <view class="text-df margin-bottom-xs text-blue">#{{post.eval_label}}</view>
         <view class="text-df margin-bottom-xs text-blue">#{{post.eval_label}}</view>
         <view class="grid col-3 grid-square" wx:if="{{enclosure.length>0}}">
         <view class="grid col-3 grid-square" wx:if="{{enclosure.length>0}}">
             <block wx:for="{{enclosure}}" wx:key="enclosure">
             <block wx:for="{{enclosure}}" wx:key="enclosure">
-                <view class="bg-image" style="background-image: url('{{item.url}}.lim.jpg')" catchtap="displayImage" data-index="{{index}}">
+                <view wx:if="{{!item.avinfo}}" class="bg-image" style="background-image: url('{{item.url}}')" catchtap="displayImage" data-index="{{index}}">
+                </view>
+                <view wx:else class="bg-image" catchtap="displayImage" data-index="{{index}}">
+                    <video 
+                        class="videoBox" 
+                        src="{{item.url}}"
+                        controls='{{false}}'
+                        enable-progress-gesture='{{false}}'
+                    />
                     <view class="bg-image-video view" wx:if="{{item.avinfo}}"></view>
                     <view class="bg-image-video view" wx:if="{{item.avinfo}}"></view>
                 </view>
                 </view>
             </block>
             </block>

@@ -13,6 +13,10 @@
     top:calc(50% - 30rpx);
     top:calc(50% - 30rpx);
     left:calc(50% - 30rpx);
     left:calc(50% - 30rpx);
 }
 }
+.videoBox{
+    width: 100%;
+    height: 170rpx;
+}
 .hasStatus{
 .hasStatus{
     position: relative;
     position: relative;
 }
 }

+// components/tpupload/tpupload.js
+import util from '../../utils/util'
+import App from '../../utils/api'
+Component({
+  /**
+   * 组件的属性列表
+   */
+  properties: {
+    uploadDesc: String,
+    tpKey: String,
+    tpNum: Number,
+    files: Array,
+  },
+
+  /**
+   * 组件的初始数据
+   */
+  data: {
+    files: [],
+    filesHttps: [],
+    token: '',
+  },
+  lifetimes: {
+    attached: function () {},
+    detached: function () {},
+  },
+  pageLifetimes: {
+    show() {
+      App.Qiniu.GetUploadToken().then(res => {
+        let token = res.data.token
+        this.setData({
+          token
+        })
+      })
+    }
+  },
+  /**
+   * 组件的方法列表
+   */
+  methods: {
+    // 删除图片或者视频
+    deleteFun(e) {
+      var files = this.data.files;
+      var that = this;
+      var index = e.currentTarget.dataset.index;
+      let filesHttps = this.data.filesHttps;
+      util.deletelUpload(filesHttps[index].url, this.data.token, (res => {
+        filesHttps.splice(index, 1)
+        files.splice(index, 1)
+        this.setData({
+          filesHttps,
+          files
+        })
+      }))
+      that.triggerEvent('tpupload', {
+        files,
+        filesHttps
+      })
+    },
+    // 预览图片
+    previewImg(e) {
+      var index = e.currentTarget.dataset.index;
+      var files = this.data.files;
+      let arr = []
+      files.forEach(i => {
+        arr.push(i.path)
+      })
+      wx.previewImage({
+        current: files[index].path,
+        urls: arr
+      })
+    },
+    // 选择视频  上传视频  chooseMedia方法一次只能上传一个视频
+    uploadVideos() {
+      var that = this;
+      var files = that.data.files;
+      wx.chooseMedia({
+        mediaType: ['video'],
+        count: 1, // 默认9
+        sourceType: ['camera', 'album'],
+        success: function (res) {
+          var tempFilePaths = res.tempFiles;
+          if (files.length + tempFilePaths.length > that.data.tpNum) {
+            wx.showToast({
+              icon: 'none',
+              title: "最多可上传" + that.data.tpNum + "张"
+            })
+            return
+          }
+          let arr = []
+          for (var i = 0; i < tempFilePaths.length; i++) {
+            arr.push(tempFilePaths[i].tempFilePath);
+          }
+          that.addFun('videoNew', arr, 'video', tempFilePaths)
+        }
+      })
+    },
+    // 上传文件或者视频
+    // path：上传到七牛的路径名称
+    // arr:要上传的文件
+    // type：video或者image
+    // tempFilePaths:上传成功才能给页面加上传的图片或者视频
+    addFun(path, arr, type, tempFilePaths) {
+      var that = this;
+      var files = that.data.files;
+      var filesHttps = that.data.filesHttps;
+      let uploadPromises = arr.map(i => {
+        return util.uploadFile(i, this.data.token, path).then(res => {
+          return res;
+        });
+      });
+      Promise.all(uploadPromises).then(results => {
+        results.forEach(i => {
+          filesHttps.push({
+            url: i,
+            avinfo: type == 'video' ? true : false
+          })
+        })
+        for (var i = 0; i < tempFilePaths.length; i++) {
+          files.push({
+            path: tempFilePaths[i].tempFilePath,
+            type
+          });
+        }
+        that.triggerEvent('tpupload', {
+          files,
+          filesHttps
+        })
+        that.setData({
+          filesHttps,
+          files
+        });
+      });
+    },
+    // 选择图片  上传图片
+    uploadImages() {
+      var that = this;
+      var files = that.data.files;
+      wx.chooseMedia({
+        mediaType: ['image'],
+        count: this.data.tpNum, // 默认9
+        sizeType: ['original', 'compressed'], // 可以指定是原图还是压缩图，默认二者都有
+        sourceType: ['album', 'camera'], // 可以指定来源是相册还是相机，默认二者都有
+        success: function (res) {
+          var tempFilePaths = res.tempFiles;
+          if (files.length + tempFilePaths.length > that.data.tpNum) {
+            wx.showToast({
+              icon: 'none',
+              title: "最多可上传" + that.data.tpNum + "张"
+            })
+            return
+          }
+          let arr = []
+          for (var i = 0; i < tempFilePaths.length; i++) {
+            arr.push(tempFilePaths[i].tempFilePath);
+          }
+          that.addFun('imagesNew', arr, 'image', tempFilePaths)
+        }
+      });
+    },
+  }
+})

+{
+    "component": true,
+    "usingComponents": {}
+}

+<!--components/tpupload/tpupload.wxml-->
+<scroll-view class="uploader__bd" scroll-x="{{true}}" style="flex-wrap: nowrap; display: flex;height: 180rpx;width: auto;white-space: nowrap;">
+	<view class="uploade">
+		<view class="weui_uploader__file" wx:for="{{files}}">
+			<image wx:if="{{item.type=='image'}}" class="weui_uploader__img" src="{{item.path}}" bindtap="previewImg" mode="aspectFill" data-index="{{index}}">
+			</image>
+			<video wx:if="{{item.type=='video'}}" class="weui_uploader__img" src="{{item.path}}" controls picture-in-picture-mode="{{['push', 'pop']}}" />
+			<image class="delete-btn" src="http://nosqn.colorcun.com/pinglun/p%20%286%29.png" data-index="{{index}}" catchtap="deleteFun"></image>
+		</view>
+		<view class="uploader__input">
+			<view class="uploader__input addimage" bindtap="uploadImages" wx:if="{{files.length < tpNum}}">
+				<image src="http://nosqn.colorcun.com/pinglun/p%20%2817%29.png" mode="aspectFit"></image>
+				<view class="texts">上传图片</view>
+			</view>
+		</view>
+		<view class="uploader__input">
+			<view class="uploader__input addimage" bindtap="uploadVideos" wx:if="{{files.length*1 < tpNum}}">
+				<image src="http://nosqn.colorcun.com/pinglun/p%20%2818%29.png" mode="aspectFit"></image>
+				<view class="texts">上传视频</view>
+			</view>
+		</view>
+	</view>
+</scroll-view>

+/* components/tpupload/tpupload.wxss */
+.uploader__bd {
+	padding: 0 20rpx;
+}
+
+.uploader__input {
+	margin-right: 10rpx;
+}
+
+.uploade {
+	flex-wrap: nowrap;
+	display: flex;
+	overflow-x: scroll;
+	width: fit-content;
+}
+
+.addimage {
+	width: 180rpx;
+	height: 180rpx;
+	border-radius: 16rpx;
+	background: #F1F1F1;
+	display: flex;
+	flex-direction: column;
+	align-items: center;
+	justify-content: center;
+}
+
+.addimage image {
+	width: 78rpx;
+	height: 78rpx;
+}
+
+.delete-btn {
+	position: absolute !important;
+	top: 0;
+	right: 0;
+	width: 60rpx;
+	height: 60rpx;
+}
+
+.weui_uploader__file {
+	width: 180rpx;
+	height: 180rpx;
+	border-radius: 16rpx;
+	position: relative;
+	margin-right: 10rpx;
+}
+
+.weui_uploader__img {
+	width: 100%;
+	height: 100%;
+	border-radius: 16rpx;
+}
+
+.texts {
+	font-size: 24rpx;
+	font-weight: 400;
+}

@@ -49,7 +49,8 @@ Page({
     },
     },
     files:[], //组件数据放入这里展示到页面上
     files:[], //组件数据放入这里展示到页面上
     hasAddFile:true,//出现上传加号
     hasAddFile:true,//出现上传加号
-	isnoshow:1,   //是否匿名
+    isnoshow:1,   //是否匿名
+    filesHttps:[],
   },
   },
 
 
   /**
   /**
@@ -123,24 +124,11 @@ Page({
     //console.log('statEvent',e.detail.value)
     //console.log('statEvent',e.detail.value)
     this.statVal=e.detail.value
     this.statVal=e.detail.value
   },
   },
-
-  qnevent(e){
-    console.log('qnevent',e.detail);
-    let files=e.detail.data
-    if(e.detail.act=='uploadFail'){
-      files[e.detail.fileCurrent].progress=Math.random().toFixed(2)
-    }
-    files.forEach(f=>{
-      if(f.progress==100){
-        if(!f.remote || !f.remote.url){
-          f.progress=(90+Math.random()*9).toFixed(2)
-        }
-      }
-    })
+  // 获取上传的图片或者视频
+  tpupload(e){
     this.setData({
     this.setData({
-      files:files,
-      hasAddFile:files.length<this.data.upConf.count,
-      scrollIntoView:'scrollIntoView',
+      filesHttps:e.detail.filesHttps,
+      files:e.detail.files,
     })
     })
   },
   },
   displayImage(e){
   displayImage(e){
@@ -153,16 +141,6 @@ Page({
       urls:[path],
       urls:[path],
     })
     })
   },
   },
-  deleteImage(e){
-    let index=util.attr(e,'index')
-    let files=this.data.files
-    files.splice(index,1)
-    this.setData({
-      files:files,
-      hasAddFile:files.length<6
-    })
-    util.toast('图片已删除','none')
-  },
   labelTap(e){
   labelTap(e){
     let labels=this.data.labels
     let labels=this.data.labels
     labels[util.attr(e,'index')].active=!labels[util.attr(e,'index')].active
     labels[util.attr(e,'index')].active=!labels[util.attr(e,'index')].active
@@ -174,9 +152,7 @@ Page({
   textareaInput(e){
   textareaInput(e){
     this.text=util.val(e).trim();
     this.text=util.val(e).trim();
   },
   },
-  submitIng:false,
   submit(){
   submit(){
-    if(this.submitIng) return;
     let eval_label=[]
     let eval_label=[]
     this.data.labels.some(l=>{
     this.data.labels.some(l=>{
       if(l.active){
       if(l.active){
@@ -184,22 +160,12 @@ Page({
       }
       }
     })
     })
     if(eval_label.length<1) return util.toast('请选择标签','none')
     if(eval_label.length<1) return util.toast('请选择标签','none')
-    let enclosure=[];
-    this.data.files.some(attr=>{
-      if(attr.remote){
-        enclosure.push(attr.remote)
-      }else{
-        util.toast('请等待上传完成','none')
-        throw new Error('请等待上传完成')
-      }
-    })
-    this.submitIng=true
     let params={
     let params={
       sid:this.options.sid,
       sid:this.options.sid,
       rid:this.options.oid,
       rid:this.options.oid,
       eval_label:eval_label.toString(),
       eval_label:eval_label.toString(),
       author_openid:getApp().openid,
       author_openid:getApp().openid,
-      enclosure:JSON.stringify(enclosure),
+      enclosure:JSON.stringify(this.data.filesHttps),
       identity:1,
       identity:1,
       text:this.text||'',
       text:this.text||'',
       types:this.data.types,//types为1时  rid就是预订ID   types为2时   rid就是套餐ID  types为3时  rid就是卡券ID
       types:this.data.types,//types为1时  rid就是预订ID   types为2时   rid就是套餐ID  types为3时  rid就是卡券ID
@@ -219,7 +185,7 @@ Page({
         })
         })
       }
       }
     }).catch(e=>{
     }).catch(e=>{
-      this.submitIng=false
+      console.log('catch',e);
     })
     })
   },
   },
   // 设置券订单评论状态	
   // 设置券订单评论状态	

@@ -4,6 +4,6 @@
   "usingComponents": {
   "usingComponents": {
     "nav":"/components/nav/nav",
     "nav":"/components/nav/nav",
     "stat": "/components/2.0/pinglun/stat",
     "stat": "/components/2.0/pinglun/stat",
-    "qnupload": "plugin://vktool/qnupload"
+    "tpupload": "/components/tpupload/tpupload"
   }
   }
 }
 }

@@ -25,47 +25,8 @@
                     bindinput="textareaInput"
                     bindinput="textareaInput"
                     placeholder="从包间环境、菜品口味、服务来评价餐厅，可以帮助更多想要订这家餐厅的人哦～" placeholder-style="color:#999999;font-size:30rpx;"></textarea>
                     placeholder="从包间环境、菜品口味、服务来评价餐厅，可以帮助更多想要订这家餐厅的人哦～" placeholder-style="color:#999999;font-size:30rpx;"></textarea>
         </view>
         </view>
-        <scroll-view class="view"
-                     scroll-into-view="{{scrollIntoView}}"
-                     scroll-x="true" style="height: 100%;width: 100%;white-space: nowrap;">
-            <block wx:for="{{files}}" wx:key="fileskey">
-                <qnupload qnConf="{{qnConf}}" upConf="{{upConf}}"
-                          file="{{item}}" files="{{files}}"
-                          bindevent="qnevent" class="view qnupload">
-                    <view class="view scroll-block flex flex-direction justify-center align-center"
-                          catchtap="displayImage" data-path="{{item.path}}" data-duration="{{item.duration}}">
-                        <image class="view image" src="{{item.thumbTempFilePath||item.path}}"></image>
-                        <view class="view image-delete" catchtap="deleteImage" data-index="{{index}}"></view>
-                        <image class="view image-up" src=""></image>
-                        <view class="view image-text"></view>
-                        <view class="bg-image-video view" wx:if="{{item.duration>0}}"></view>
-                    </view>
-                </qnupload>
-            </block>
-            <block wx:if="{{hasAddFile}}">
-                <qnupload
-                        qnConf="{{qnConf}}" upConf="{{upConf}}"
-                        file="{{item}}" files="{{files}}"
-                        bindevent="qnevent" class="view qnupload">
-                    <view class="view scroll-block flex flex-direction justify-center align-center">
-                        <image class="view image-up" src="http://nosqn.colorcun.com/pinglun/p%20%2817%29.png"></image>
-                        <view class="view image-text">上传图片</view>
-                    </view>
-                </qnupload>
-                <qnupload
-                        qnConf="{{qnConfVideo}}" upConf="{{upConfVideo}}"
-                        file="{{item}}" files="{{files}}"
-                        bindevent="qnevent" class="view qnupload">
-                    <view class="view scroll-block flex flex-direction justify-center align-center">
-                        <image class="view image" src="{{item.path}}"></image>
-                        <image class="view image-up" src="http://nosqn.colorcun.com/pinglun/p%20%2818%29.png"></image>
-                        <view class="view image-text">上传视频</view>
-                    </view>
-                </qnupload>
-            </block>
-
-            <view id="scrollIntoView" class="qnupload" style="width: 0;"></view>
-        </scroll-view>
+        <tpupload bind:tpupload="tpupload" tpNum='6' ></tpupload>
+        <view id="scrollIntoView" class="qnupload" style="width: 0;"></view>
 		<view class="flex-ll reamrk-noshow">
 		<view class="flex-ll reamrk-noshow">
 			<view class="remark-ratio flex-cc {{isnoshow==1 ? 'active' : 'border'}}" bindtap="setnoshow">
 			<view class="remark-ratio flex-cc {{isnoshow==1 ? 'active' : 'border'}}" bindtap="setnoshow">
 				<image src="http://nosqn.colorcun.com/right.jpg" wx:if="isnoshow==1"></image>
 				<image src="http://nosqn.colorcun.com/right.jpg" wx:if="isnoshow==1"></image>

@@ -115,4 +115,12 @@
 .reamrk-noshow{
 .reamrk-noshow{
 	padding: 44rpx 40rpx 0;
 	padding: 44rpx 40rpx 0;
 	box-sizing: border-box;
 	box-sizing: border-box;
+}
+.uploadimg{
+    width: 100rpx;
+    height: 100rpx;
+}
+.deleteIcon{
+    width: 60rpx;
+    height: 60rpx;
 }
 }

@@ -715,4 +715,10 @@ export default {
   'App.PlanCook.GetPlanCookByRid':{
   'App.PlanCook.GetPlanCookByRid':{
 		openid:'openid'
 		openid:'openid'
   },
   },
+  
+  // 获取七牛上传token信息
+  'App.Qiniu.GetUploadToken':{
+		openid:'openid'
+  },
+
 }
 }

+'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
+}
+
+// Support decoding URL-safe base64 strings, as Node.js does.
+// See: https://en.wikipedia.org/wiki/Base64#URL_applications
+revLookup['-'.charCodeAt(0)] = 62
+revLookup['_'.charCodeAt(0)] = 63
+
+function getLens(b64) {
+  var len = b64.length
+
+  if (len % 4 > 0) {
+    throw new Error('Invalid string. Length must be a multiple of 4')
+  }
+
+  // Trim off extra bytes after placeholder bytes are found
+  // See: https://github.com/beatgammit/base64-js/issues/42
+  var validLen = b64.indexOf('=')
+  if (validLen === -1) validLen = len
+
+  var placeHoldersLen = validLen === len ?
+    0 :
+    4 - (validLen % 4)
+
+  return [validLen, placeHoldersLen]
+}
+
+// base64 is 4/3 + up to two characters of the original data
+function byteLength(b64) {
+  var lens = getLens(b64)
+  var validLen = lens[0]
+  var placeHoldersLen = lens[1]
+  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
+}
+
+function _byteLength(b64, validLen, placeHoldersLen) {
+  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
+}
+
+function toByteArray(b64) {
+  var tmp
+  var lens = getLens(b64)
+  var validLen = lens[0]
+  var placeHoldersLen = lens[1]
+
+  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))
+
+  var curByte = 0
+
+  // if there are placeholders, only get up to the last complete 4 chars
+  var len = placeHoldersLen > 0 ?
+    validLen - 4 :
+    validLen
+
+  var i
+  for (i = 0; i < len; i += 4) {
+    tmp =
+      (revLookup[b64.charCodeAt(i)] << 18) |
+      (revLookup[b64.charCodeAt(i + 1)] << 12) |
+      (revLookup[b64.charCodeAt(i + 2)] << 6) |
+      revLookup[b64.charCodeAt(i + 3)]
+    arr[curByte++] = (tmp >> 16) & 0xFF
+    arr[curByte++] = (tmp >> 8) & 0xFF
+    arr[curByte++] = tmp & 0xFF
+  }
+
+  if (placeHoldersLen === 2) {
+    tmp =
+      (revLookup[b64.charCodeAt(i)] << 2) |
+      (revLookup[b64.charCodeAt(i + 1)] >> 4)
+    arr[curByte++] = tmp & 0xFF
+  }
+
+  if (placeHoldersLen === 1) {
+    tmp =
+      (revLookup[b64.charCodeAt(i)] << 10) |
+      (revLookup[b64.charCodeAt(i + 1)] << 4) |
+      (revLookup[b64.charCodeAt(i + 2)] >> 2)
+    arr[curByte++] = (tmp >> 8) & 0xFF
+    arr[curByte++] = 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) & 0xFF0000) +
+      ((uint8[i + 1] << 8) & 0xFF00) +
+      (uint8[i + 2] & 0xFF)
+    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 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]
+    parts.push(
+      lookup[tmp >> 2] +
+      lookup[(tmp << 4) & 0x3F] +
+      '=='
+    )
+  } else if (extraBytes === 2) {
+    tmp = (uint8[len - 2] << 8) + uint8[len - 1]
+    parts.push(
+      lookup[tmp >> 10] +
+      lookup[(tmp >> 4) & 0x3F] +
+      lookup[(tmp << 2) & 0x3F] +
+      '='
+    )
+  }
+
+  return parts.join('')
+}

+/*!
+ * The buffer module from node.js, for the browser.
+ *
+ * @author   Feross Aboukhadijeh <https://feross.org>
+ * @license  MIT
+ */
+/* eslint-disable no-proto */
+
+'use strict'
+
+var base64 = require('base64-js')
+var ieee754 = require('ieee754')
+var customInspectSymbol =
+  (typeof Symbol === 'function' && typeof Symbol.for === 'function') ?
+  Symbol.for('nodejs.util.inspect.custom') :
+  null
+
+exports.Buffer = Buffer
+exports.SlowBuffer = SlowBuffer
+exports.INSPECT_MAX_BYTES = 50
+
+var K_MAX_LENGTH = 0x7fffffff
+exports.kMaxLength = K_MAX_LENGTH
+
+/**
+ * If `Buffer.TYPED_ARRAY_SUPPORT`:
+ *   === true    Use Uint8Array implementation (fastest)
+ *   === false   Print warning and recommend using `buffer` v4.x which has an 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+.
+ *
+ * We report that the browser does not support typed arrays if the are not subclassable
+ * using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array`
+ * (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support
+ * for __proto__ and has a buggy typed array implementation.
+ */
+Buffer.TYPED_ARRAY_SUPPORT = typedArraySupport()
+
+if (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== 'undefined' &&
+  typeof console.error === 'function') {
+  console.error(
+    'This browser lacks typed array (Uint8Array) support which is required by ' +
+    '`buffer` v5.x. Use `buffer` v4.x if you require old browser support.'
+  )
+}
+
+function typedArraySupport() {
+  // Can typed array instances can be augmented?
+  try {
+    var arr = new Uint8Array(1)
+    var proto = {
+      foo: function () {
+        return 42
+      }
+    }
+    Object.setPrototypeOf(proto, Uint8Array.prototype)
+    Object.setPrototypeOf(arr, proto)
+    return arr.foo() === 42
+  } catch (e) {
+    return false
+  }
+}
+
+Object.defineProperty(Buffer.prototype, 'parent', {
+  enumerable: true,
+  get: function () {
+    if (!Buffer.isBuffer(this)) return undefined
+    return this.buffer
+  }
+})
+
+Object.defineProperty(Buffer.prototype, 'offset', {
+  enumerable: true,
+  get: function () {
+    if (!Buffer.isBuffer(this)) return undefined
+    return this.byteOffset
+  }
+})
+
+function createBuffer(length) {
+  if (length > K_MAX_LENGTH) {
+    throw new RangeError('The value "' + length + '" is invalid for option "size"')
+  }
+  // Return an augmented `Uint8Array` instance
+  var buf = new Uint8Array(length)
+  Object.setPrototypeOf(buf, Buffer.prototype)
+  return buf
+}
+
+/**
+ * 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) {
+  // Common case.
+  if (typeof arg === 'number') {
+    if (typeof encodingOrOffset === 'string') {
+      throw new TypeError(
+        'The "string" argument must be of type string. Received type number'
+      )
+    }
+    return allocUnsafe(arg)
+  }
+  return from(arg, encodingOrOffset, length)
+}
+
+// Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97
+if (typeof Symbol !== 'undefined' && Symbol.species != null &&
+  Buffer[Symbol.species] === Buffer) {
+  Object.defineProperty(Buffer, Symbol.species, {
+    value: null,
+    configurable: true,
+    enumerable: false,
+    writable: false
+  })
+}
+
+Buffer.poolSize = 8192 // not used by this implementation
+
+function from(value, encodingOrOffset, length) {
+  if (typeof value === 'string') {
+    return fromString(value, encodingOrOffset)
+  }
+
+  if (ArrayBuffer.isView(value)) {
+    return fromArrayLike(value)
+  }
+
+  if (value == null) {
+    throw new TypeError(
+      'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +
+      'or Array-like Object. Received type ' + (typeof value)
+    )
+  }
+
+  if (isInstance(value, ArrayBuffer) ||
+    (value && isInstance(value.buffer, ArrayBuffer))) {
+    return fromArrayBuffer(value, encodingOrOffset, length)
+  }
+
+  if (typeof value === 'number') {
+    throw new TypeError(
+      'The "value" argument must not be of type number. Received type number'
+    )
+  }
+
+  var valueOf = value.valueOf && value.valueOf()
+  if (valueOf != null && valueOf !== value) {
+    return Buffer.from(valueOf, encodingOrOffset, length)
+  }
+
+  var b = fromObject(value)
+  if (b) return b
+
+  if (typeof Symbol !== 'undefined' && Symbol.toPrimitive != null &&
+    typeof value[Symbol.toPrimitive] === 'function') {
+    return Buffer.from(
+      value[Symbol.toPrimitive]('string'), encodingOrOffset, length
+    )
+  }
+
+  throw new TypeError(
+    'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +
+    'or Array-like Object. Received type ' + (typeof 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(value, encodingOrOffset, length)
+}
+
+// Note: Change prototype *after* Buffer.from is defined to workaround Chrome bug:
+// https://github.com/feross/buffer/pull/148
+Object.setPrototypeOf(Buffer.prototype, Uint8Array.prototype)
+Object.setPrototypeOf(Buffer, Uint8Array)
+
+function assertSize(size) {
+  if (typeof size !== 'number') {
+    throw new TypeError('"size" argument must be of type number')
+  } else if (size < 0) {
+    throw new RangeError('The value "' + size + '" is invalid for option "size"')
+  }
+}
+
+function alloc(size, fill, encoding) {
+  assertSize(size)
+  if (size <= 0) {
+    return createBuffer(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(size).fill(fill, encoding) :
+      createBuffer(size).fill(fill)
+  }
+  return createBuffer(size)
+}
+
+/**
+ * Creates a new filled Buffer instance.
+ * alloc(size[, fill[, encoding]])
+ **/
+Buffer.alloc = function (size, fill, encoding) {
+  return alloc(size, fill, encoding)
+}
+
+function allocUnsafe(size) {
+  assertSize(size)
+  return createBuffer(size < 0 ? 0 : checked(size) | 0)
+}
+
+/**
+ * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
+ * */
+Buffer.allocUnsafe = function (size) {
+  return allocUnsafe(size)
+}
+/**
+ * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
+ */
+Buffer.allocUnsafeSlow = function (size) {
+  return allocUnsafe(size)
+}
+
+function fromString(string, encoding) {
+  if (typeof encoding !== 'string' || encoding === '') {
+    encoding = 'utf8'
+  }
+
+  if (!Buffer.isEncoding(encoding)) {
+    throw new TypeError('Unknown encoding: ' + encoding)
+  }
+
+  var length = byteLength(string, encoding) | 0
+  var buf = createBuffer(length)
+
+  var actual = buf.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')
+    buf = buf.slice(0, actual)
+  }
+
+  return buf
+}
+
+function fromArrayLike(array) {
+  var length = array.length < 0 ? 0 : checked(array.length) | 0
+  var buf = createBuffer(length)
+  for (var i = 0; i < length; i += 1) {
+    buf[i] = array[i] & 255
+  }
+  return buf
+}
+
+function fromArrayBuffer(array, byteOffset, length) {
+  if (byteOffset < 0 || array.byteLength < byteOffset) {
+    throw new RangeError('"offset" is outside of buffer bounds')
+  }
+
+  if (array.byteLength < byteOffset + (length || 0)) {
+    throw new RangeError('"length" is outside of buffer bounds')
+  }
+
+  var buf
+  if (byteOffset === undefined && length === undefined) {
+    buf = new Uint8Array(array)
+  } else if (length === undefined) {
+    buf = new Uint8Array(array, byteOffset)
+  } else {
+    buf = new Uint8Array(array, byteOffset, length)
+  }
+
+  // Return an augmented `Uint8Array` instance
+  Object.setPrototypeOf(buf, Buffer.prototype)
+
+  return buf
+}
+
+function fromObject(obj) {
+  if (Buffer.isBuffer(obj)) {
+    var len = checked(obj.length) | 0
+    var buf = createBuffer(len)
+
+    if (buf.length === 0) {
+      return buf
+    }
+
+    obj.copy(buf, 0, 0, len)
+    return buf
+  }
+
+  if (obj.length !== undefined) {
+    if (typeof obj.length !== 'number' || numberIsNaN(obj.length)) {
+      return createBuffer(0)
+    }
+    return fromArrayLike(obj)
+  }
+
+  if (obj.type === 'Buffer' && Array.isArray(obj.data)) {
+    return fromArrayLike(obj.data)
+  }
+}
+
+function checked(length) {
+  // Note: cannot use `length < K_MAX_LENGTH` here because that fails when
+  // length is NaN (which is otherwise coerced to zero.)
+  if (length >= K_MAX_LENGTH) {
+    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
+      'size: 0x' + K_MAX_LENGTH.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 === true &&
+    b !== Buffer.prototype // so Buffer.isBuffer(Buffer.prototype) will be false
+}
+
+Buffer.compare = function compare(a, b) {
+  if (isInstance(a, Uint8Array)) a = Buffer.from(a, a.offset, a.byteLength)
+  if (isInstance(b, Uint8Array)) b = Buffer.from(b, b.offset, b.byteLength)
+  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
+    throw new TypeError(
+      'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array'
+    )
+  }
+
+  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 (!Array.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 (isInstance(buf, Uint8Array)) {
+      buf = Buffer.from(buf)
+    }
+    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 (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {
+    return string.byteLength
+  }
+  if (typeof string !== 'string') {
+    throw new TypeError(
+      'The "string" argument must be one of type string, Buffer, or ArrayBuffer. ' +
+      'Received type ' + typeof string
+    )
+  }
+
+  var len = string.length
+  var mustMatch = (arguments.length > 2 && arguments[2] === true)
+  if (!mustMatch && 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':
+        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 mustMatch ? -1 : 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
+    }
+  }
+}
+
+// This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package)
+// to detect a Buffer instance. It's not possible to use `instanceof Buffer`
+// reliably in a browserify context because there could be multiple different
+// copies of the 'buffer' package in use. This method works even for Buffer
+// instances that were created from another copy of the `buffer` package.
+// See: https://github.com/feross/buffer/issues/154
+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
+  if (length === 0) return ''
+  if (arguments.length === 0) return utf8Slice(this, 0, length)
+  return slowToString.apply(this, arguments)
+}
+
+Buffer.prototype.toLocaleString = Buffer.prototype.toString
+
+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
+  str = this.toString('hex', 0, max).replace(/(.{2})/g, '$1 ').trim()
+  if (this.length > max) str += ' ... '
+  return '<Buffer ' + str + '>'
+}
+if (customInspectSymbol) {
+  Buffer.prototype[customInspectSymbol] = Buffer.prototype.inspect
+}
+
+Buffer.prototype.compare = function compare(target, start, end, thisStart, thisEnd) {
+  if (isInstance(target, Uint8Array)) {
+    target = Buffer.from(target, target.offset, target.byteLength)
+  }
+  if (!Buffer.isBuffer(target)) {
+    throw new TypeError(
+      'The "target" argument must be one of type Buffer or Uint8Array. ' +
+      'Received type ' + (typeof target)
+    )
+  }
+
+  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 (numberIsNaN(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 (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
+    }
+  }
+
+  var strLen = string.length
+
+  if (length > strLen / 2) {
+    length = strLen / 2
+  }
+  for (var i = 0; i < length; ++i) {
+    var parsed = parseInt(string.substr(i * 2, 2), 16)
+    if (numberIsNaN(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
+    }
+  } 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 += hexSliceLookupTable[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 = this.subarray(start, end)
+  // Return an augmented `Uint8Array` instance
+  Object.setPrototypeOf(newBuf, Buffer.prototype)
+
+  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) {
+  offset = offset >>> 0
+  if (!noAssert) checkOffset(offset, 1, this.length)
+  return this[offset]
+}
+
+Buffer.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {
+  offset = offset >>> 0
+  if (!noAssert) checkOffset(offset, 2, this.length)
+  return this[offset] | (this[offset + 1] << 8)
+}
+
+Buffer.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {
+  offset = offset >>> 0
+  if (!noAssert) checkOffset(offset, 2, this.length)
+  return (this[offset] << 8) | this[offset + 1]
+}
+
+Buffer.prototype.readUInt32LE = function readUInt32LE(offset, noAssert) {
+  offset = offset >>> 0
+  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) {
+  offset = offset >>> 0
+  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) {
+  offset = offset >>> 0
+  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) {
+  offset = offset >>> 0
+  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) {
+  offset = offset >>> 0
+  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) {
+  offset = offset >>> 0
+  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) {
+  offset = offset >>> 0
+  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) {
+  offset = offset >>> 0
+  if (!noAssert) checkOffset(offset, 4, this.length)
+  return ieee754.read(this, offset, true, 23, 4)
+}
+
+Buffer.prototype.readFloatBE = function readFloatBE(offset, noAssert) {
+  offset = offset >>> 0
+  if (!noAssert) checkOffset(offset, 4, this.length)
+  return ieee754.read(this, offset, false, 23, 4)
+}
+
+Buffer.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) {
+  offset = offset >>> 0
+  if (!noAssert) checkOffset(offset, 8, this.length)
+  return ieee754.read(this, offset, true, 52, 8)
+}
+
+Buffer.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) {
+  offset = offset >>> 0
+  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)
+  this[offset] = (value & 0xff)
+  return offset + 1
+}
+
+Buffer.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) {
+  value = +value
+  offset = offset >>> 0
+  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
+  this[offset] = (value & 0xff)
+  this[offset + 1] = (value >>> 8)
+  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)
+  this[offset] = (value >>> 8)
+  this[offset + 1] = (value & 0xff)
+  return offset + 2
+}
+
+Buffer.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) {
+  value = +value
+  offset = offset >>> 0
+  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
+  this[offset + 3] = (value >>> 24)
+  this[offset + 2] = (value >>> 16)
+  this[offset + 1] = (value >>> 8)
+  this[offset] = (value & 0xff)
+  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)
+  this[offset] = (value >>> 24)
+  this[offset + 1] = (value >>> 16)
+  this[offset + 2] = (value >>> 8)
+  this[offset + 3] = (value & 0xff)
+  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 (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)
+  this[offset] = (value & 0xff)
+  this[offset + 1] = (value >>> 8)
+  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)
+  this[offset] = (value >>> 8)
+  this[offset + 1] = (value & 0xff)
+  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)
+  this[offset] = (value & 0xff)
+  this[offset + 1] = (value >>> 8)
+  this[offset + 2] = (value >>> 16)
+  this[offset + 3] = (value >>> 24)
+  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
+  this[offset] = (value >>> 24)
+  this[offset + 1] = (value >>> 16)
+  this[offset + 2] = (value >>> 8)
+  this[offset + 3] = (value & 0xff)
+  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) {
+  value = +value
+  offset = offset >>> 0
+  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) {
+  value = +value
+  offset = offset >>> 0
+  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 (!Buffer.isBuffer(target)) throw new TypeError('argument should be a Buffer')
+  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('Index out of range')
+  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
+
+  if (this === target && typeof Uint8Array.prototype.copyWithin === 'function') {
+    // Use built-in when available, missing from IE11
+    this.copyWithin(targetStart, start, end)
+  } else if (this === target && start < targetStart && targetStart < end) {
+    // descending copy from end
+    for (var i = len - 1; i >= 0; --i) {
+      target[i + targetStart] = this[i + start]
+    }
+  } else {
+    Uint8Array.prototype.set.call(
+      target,
+      this.subarray(start, end),
+      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 (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)
+    }
+    if (val.length === 1) {
+      var code = val.charCodeAt(0)
+      if ((encoding === 'utf8' && code < 128) ||
+        encoding === 'latin1') {
+        // Fast path: If `val` fits into a single byte, use that numeric value.
+        val = code
+      }
+    }
+  } else if (typeof val === 'number') {
+    val = val & 255
+  } else if (typeof val === 'boolean') {
+    val = Number(val)
+  }
+
+  // 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 :
+      Buffer.from(val, encoding)
+    var len = bytes.length
+    if (len === 0) {
+      throw new TypeError('The value "' + val +
+        '" is invalid for argument "value"')
+    }
+    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 takes equal signs as end of the Base64 encoding
+  str = str.split('=')[0]
+  // Node strips out invalid characters like \n and \t from the string, base64-js does not
+  str = str.trim().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 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
+}
+
+// ArrayBuffer or Uint8Array objects from other contexts (i.e. iframes) do not pass
+// the `instanceof` check but they should be treated as of that type.
+// See: https://github.com/feross/buffer/issues/166
+function isInstance(obj, type) {
+  return obj instanceof type ||
+    (obj != null && obj.constructor != null && obj.constructor.name != null &&
+      obj.constructor.name === type.name)
+}
+
+function numberIsNaN(obj) {
+  // For IE11 support
+  return obj !== obj // eslint-disable-line no-self-compare
+}
+
+// Create lookup table for `toString('hex')`
+// See: https://github.com/feross/buffer/issues/219
+var hexSliceLookupTable = (function () {
+  var alphabet = '0123456789abcdef'
+  var table = new Array(256)
+  for (var i = 0; i < 16; ++i) {
+    var i16 = i * 16
+    for (var j = 0; j < 16; ++j) {
+      table[i16 + j] = alphabet[i] + alphabet[j]
+    }
+  }
+  return table
+})()
+module.exports = Buffer;

+;
+(function (root, factory) {
+	if (typeof exports === "object") {
+		// CommonJS
+		module.exports = exports = factory();
+	} else if (typeof define === "function" && define.amd) {
+		// AMD
+		define([], factory);
+	} else {
+		// Global (browser)
+		root.CryptoJS = factory();
+	}
+}(this, function () {
+
+	/**
+	 * CryptoJS core components.
+	 */
+	var CryptoJS = CryptoJS || (function (Math, undefined) {
+		/*
+		 * Local polyfil of Object.create
+		 */
+		var create = Object.create || (function () {
+			function F() {};
+
+			return function (obj) {
+				var subtype;
+
+				F.prototype = obj;
+
+				subtype = new F();
+
+				F.prototype = null;
+
+				return subtype;
+			};
+		}())
+
+		/**
+		 * CryptoJS namespace.
+		 */
+		var C = {};
+
+		/**
+		 * Library namespace.
+		 */
+		var C_lib = C.lib = {};
+
+		/**
+		 * Base object for prototypal inheritance.
+		 */
+		var Base = C_lib.Base = (function () {
+
+
+			return {
+				/**
+				 * Creates a new object that inherits from this object.
+				 *
+				 * @param {Object} overrides Properties to copy into the new object.
+				 *
+				 * @return {Object} The new object.
+				 *
+				 * @static
+				 *
+				 * @example
+				 *
+				 *     var MyType = CryptoJS.lib.Base.extend({
+				 *         field: 'value',
+				 *
+				 *         method: function () {
+				 *         }
+				 *     });
+				 */
+				extend: function (overrides) {
+					// Spawn
+					var subtype = create(this);
+
+					// Augment
+					if (overrides) {
+						subtype.mixIn(overrides);
+					}
+
+					// Create default initializer
+					if (!subtype.hasOwnProperty('init') || this.init === subtype.init) {
+						subtype.init = function () {
+							subtype.$super.init.apply(this, arguments);
+						};
+					}
+
+					// Initializer's prototype is the subtype object
+					subtype.init.prototype = subtype;
+
+					// Reference supertype
+					subtype.$super = this;
+
+					return subtype;
+				},
+
+				/**
+				 * Extends this object and runs the init method.
+				 * Arguments to create() will be passed to init().
+				 *
+				 * @return {Object} The new object.
+				 *
+				 * @static
+				 *
+				 * @example
+				 *
+				 *     var instance = MyType.create();
+				 */
+				create: function () {
+					var instance = this.extend();
+					instance.init.apply(instance, arguments);
+
+					return instance;
+				},
+
+				/**
+				 * Initializes a newly created object.
+				 * Override this method to add some logic when your objects are created.
+				 *
+				 * @example
+				 *
+				 *     var MyType = CryptoJS.lib.Base.extend({
+				 *         init: function () {
+				 *             // ...
+				 *         }
+				 *     });
+				 */
+				init: function () {},
+
+				/**
+				 * Copies properties into this object.
+				 *
+				 * @param {Object} properties The properties to mix in.
+				 *
+				 * @example
+				 *
+				 *     MyType.mixIn({
+				 *         field: 'value'
+				 *     });
+				 */
+				mixIn: function (properties) {
+					for (var propertyName in properties) {
+						if (properties.hasOwnProperty(propertyName)) {
+							this[propertyName] = properties[propertyName];
+						}
+					}
+
+					// IE won't copy toString using the loop above
+					if (properties.hasOwnProperty('toString')) {
+						this.toString = properties.toString;
+					}
+				},
+
+				/**
+				 * Creates a copy of this object.
+				 *
+				 * @return {Object} The clone.
+				 *
+				 * @example
+				 *
+				 *     var clone = instance.clone();
+				 */
+				clone: function () {
+					return this.init.prototype.extend(this);
+				}
+			};
+		}());
+
+		/**
+		 * An array of 32-bit words.
+		 *
+		 * @property {Array} words The array of 32-bit words.
+		 * @property {number} sigBytes The number of significant bytes in this word array.
+		 */
+		var WordArray = C_lib.WordArray = Base.extend({
+			/**
+			 * Initializes a newly created word array.
+			 *
+			 * @param {Array} words (Optional) An array of 32-bit words.
+			 * @param {number} sigBytes (Optional) The number of significant bytes in the words.
+			 *
+			 * @example
+			 *
+			 *     var wordArray = CryptoJS.lib.WordArray.create();
+			 *     var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607]);
+			 *     var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607], 6);
+			 */
+			init: function (words, sigBytes) {
+				words = this.words = words || [];
+
+				if (sigBytes != undefined) {
+					this.sigBytes = sigBytes;
+				} else {
+					this.sigBytes = words.length * 4;
+				}
+			},
+
+			/**
+			 * Converts this word array to a string.
+			 *
+			 * @param {Encoder} encoder (Optional) The encoding strategy to use. Default: CryptoJS.enc.Hex
+			 *
+			 * @return {string} The stringified word array.
+			 *
+			 * @example
+			 *
+			 *     var string = wordArray + '';
+			 *     var string = wordArray.toString();
+			 *     var string = wordArray.toString(CryptoJS.enc.Utf8);
+			 */
+			toString: function (encoder) {
+				return (encoder || Hex).stringify(this);
+			},
+
+			/**
+			 * Concatenates a word array to this word array.
+			 *
+			 * @param {WordArray} wordArray The word array to append.
+			 *
+			 * @return {WordArray} This word array.
+			 *
+			 * @example
+			 *
+			 *     wordArray1.concat(wordArray2);
+			 */
+			concat: function (wordArray) {
+				// Shortcuts
+				var thisWords = this.words;
+				var thatWords = wordArray.words;
+				var thisSigBytes = this.sigBytes;
+				var thatSigBytes = wordArray.sigBytes;
+
+				// Clamp excess bits
+				this.clamp();
+
+				// Concat
+				if (thisSigBytes % 4) {
+					// Copy one byte at a time
+					for (var i = 0; i < thatSigBytes; i++) {
+						var thatByte = (thatWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
+						thisWords[(thisSigBytes + i) >>> 2] |= thatByte << (24 - ((thisSigBytes + i) % 4) * 8);
+					}
+				} else {
+					// Copy one word at a time
+					for (var i = 0; i < thatSigBytes; i += 4) {
+						thisWords[(thisSigBytes + i) >>> 2] = thatWords[i >>> 2];
+					}
+				}
+				this.sigBytes += thatSigBytes;
+
+				// Chainable
+				return this;
+			},
+
+			/**
+			 * Removes insignificant bits.
+			 *
+			 * @example
+			 *
+			 *     wordArray.clamp();
+			 */
+			clamp: function () {
+				// Shortcuts
+				var words = this.words;
+				var sigBytes = this.sigBytes;
+
+				// Clamp
+				words[sigBytes >>> 2] &= 0xffffffff << (32 - (sigBytes % 4) * 8);
+				words.length = Math.ceil(sigBytes / 4);
+			},
+
+			/**
+			 * Creates a copy of this word array.
+			 *
+			 * @return {WordArray} The clone.
+			 *
+			 * @example
+			 *
+			 *     var clone = wordArray.clone();
+			 */
+			clone: function () {
+				var clone = Base.clone.call(this);
+				clone.words = this.words.slice(0);
+
+				return clone;
+			},
+
+			/**
+			 * Creates a word array filled with random bytes.
+			 *
+			 * @param {number} nBytes The number of random bytes to generate.
+			 *
+			 * @return {WordArray} The random word array.
+			 *
+			 * @static
+			 *
+			 * @example
+			 *
+			 *     var wordArray = CryptoJS.lib.WordArray.random(16);
+			 */
+			random: function (nBytes) {
+				var words = [];
+
+				var r = (function (m_w) {
+					var m_w = m_w;
+					var m_z = 0x3ade68b1;
+					var mask = 0xffffffff;
+
+					return function () {
+						m_z = (0x9069 * (m_z & 0xFFFF) + (m_z >> 0x10)) & mask;
+						m_w = (0x4650 * (m_w & 0xFFFF) + (m_w >> 0x10)) & mask;
+						var result = ((m_z << 0x10) + m_w) & mask;
+						result /= 0x100000000;
+						result += 0.5;
+						return result * (Math.random() > .5 ? 1 : -1);
+					}
+				});
+
+				for (var i = 0, rcache; i < nBytes; i += 4) {
+					var _r = r((rcache || Math.random()) * 0x100000000);
+
+					rcache = _r() * 0x3ade67b7;
+					words.push((_r() * 0x100000000) | 0);
+				}
+
+				return new WordArray.init(words, nBytes);
+			}
+		});
+
+		/**
+		 * Encoder namespace.
+		 */
+		var C_enc = C.enc = {};
+
+		/**
+		 * Hex encoding strategy.
+		 */
+		var Hex = C_enc.Hex = {
+			/**
+			 * Converts a word array to a hex string.
+			 *
+			 * @param {WordArray} wordArray The word array.
+			 *
+			 * @return {string} The hex string.
+			 *
+			 * @static
+			 *
+			 * @example
+			 *
+			 *     var hexString = CryptoJS.enc.Hex.stringify(wordArray);
+			 */
+			stringify: function (wordArray) {
+				// Shortcuts
+				var words = wordArray.words;
+				var sigBytes = wordArray.sigBytes;
+
+				// Convert
+				var hexChars = [];
+				for (var i = 0; i < sigBytes; i++) {
+					var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
+					hexChars.push((bite >>> 4).toString(16));
+					hexChars.push((bite & 0x0f).toString(16));
+				}
+
+				return hexChars.join('');
+			},
+
+			/**
+			 * Converts a hex string to a word array.
+			 *
+			 * @param {string} hexStr The hex string.
+			 *
+			 * @return {WordArray} The word array.
+			 *
+			 * @static
+			 *
+			 * @example
+			 *
+			 *     var wordArray = CryptoJS.enc.Hex.parse(hexString);
+			 */
+			parse: function (hexStr) {
+				// Shortcut
+				var hexStrLength = hexStr.length;
+
+				// Convert
+				var words = [];
+				for (var i = 0; i < hexStrLength; i += 2) {
+					words[i >>> 3] |= parseInt(hexStr.substr(i, 2), 16) << (24 - (i % 8) * 4);
+				}
+
+				return new WordArray.init(words, hexStrLength / 2);
+			}
+		};
+
+		/**
+		 * Latin1 encoding strategy.
+		 */
+		var Latin1 = C_enc.Latin1 = {
+			/**
+			 * Converts a word array to a Latin1 string.
+			 *
+			 * @param {WordArray} wordArray The word array.
+			 *
+			 * @return {string} The Latin1 string.
+			 *
+			 * @static
+			 *
+			 * @example
+			 *
+			 *     var latin1String = CryptoJS.enc.Latin1.stringify(wordArray);
+			 */
+			stringify: function (wordArray) {
+				// Shortcuts
+				var words = wordArray.words;
+				var sigBytes = wordArray.sigBytes;
+
+				// Convert
+				var latin1Chars = [];
+				for (var i = 0; i < sigBytes; i++) {
+					var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
+					latin1Chars.push(String.fromCharCode(bite));
+				}
+
+				return latin1Chars.join('');
+			},
+
+			/**
+			 * Converts a Latin1 string to a word array.
+			 *
+			 * @param {string} latin1Str The Latin1 string.
+			 *
+			 * @return {WordArray} The word array.
+			 *
+			 * @static
+			 *
+			 * @example
+			 *
+			 *     var wordArray = CryptoJS.enc.Latin1.parse(latin1String);
+			 */
+			parse: function (latin1Str) {
+				// Shortcut
+				var latin1StrLength = latin1Str.length;
+
+				// Convert
+				var words = [];
+				for (var i = 0; i < latin1StrLength; i++) {
+					words[i >>> 2] |= (latin1Str.charCodeAt(i) & 0xff) << (24 - (i % 4) * 8);
+				}
+
+				return new WordArray.init(words, latin1StrLength);
+			}
+		};
+
+		/**
+		 * UTF-8 encoding strategy.
+		 */
+		var Utf8 = C_enc.Utf8 = {
+			/**
+			 * Converts a word array to a UTF-8 string.
+			 *
+			 * @param {WordArray} wordArray The word array.
+			 *
+			 * @return {string} The UTF-8 string.
+			 *
+			 * @static
+			 *
+			 * @example
+			 *
+			 *     var utf8String = CryptoJS.enc.Utf8.stringify(wordArray);
+			 */
+			stringify: function (wordArray) {
+				try {
+					return decodeURIComponent(escape(Latin1.stringify(wordArray)));
+				} catch (e) {
+					throw new Error('Malformed UTF-8 data');
+				}
+			},
+
+			/**
+			 * Converts a UTF-8 string to a word array.
+			 *
+			 * @param {string} utf8Str The UTF-8 string.
+			 *
+			 * @return {WordArray} The word array.
+			 *
+			 * @static
+			 *
+			 * @example
+			 *
+			 *     var wordArray = CryptoJS.enc.Utf8.parse(utf8String);
+			 */
+			parse: function (utf8Str) {
+				return Latin1.parse(unescape(encodeURIComponent(utf8Str)));
+			}
+		};
+
+		/**
+		 * Abstract buffered block algorithm template.
+		 *
+		 * The property blockSize must be implemented in a concrete subtype.
+		 *
+		 * @property {number} _minBufferSize The number of blocks that should be kept unprocessed in the buffer. Default: 0
+		 */
+		var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm = Base.extend({
+			/**
+			 * Resets this block algorithm's data buffer to its initial state.
+			 *
+			 * @example
+			 *
+			 *     bufferedBlockAlgorithm.reset();
+			 */
+			reset: function () {
+				// Initial values
+				this._data = new WordArray.init();
+				this._nDataBytes = 0;
+			},
+
+			/**
+			 * Adds new data to this block algorithm's buffer.
+			 *
+			 * @param {WordArray|string} data The data to append. Strings are converted to a WordArray using UTF-8.
+			 *
+			 * @example
+			 *
+			 *     bufferedBlockAlgorithm._append('data');
+			 *     bufferedBlockAlgorithm._append(wordArray);
+			 */
+			_append: function (data) {
+				// Convert string to WordArray, else assume WordArray already
+				if (typeof data == 'string') {
+					data = Utf8.parse(data);
+				}
+
+				// Append
+				this._data.concat(data);
+				this._nDataBytes += data.sigBytes;
+			},
+
+			/**
+			 * Processes available data blocks.
+			 *
+			 * This method invokes _doProcessBlock(offset), which must be implemented by a concrete subtype.
+			 *
+			 * @param {boolean} doFlush Whether all blocks and partial blocks should be processed.
+			 *
+			 * @return {WordArray} The processed data.
+			 *
+			 * @example
+			 *
+			 *     var processedData = bufferedBlockAlgorithm._process();
+			 *     var processedData = bufferedBlockAlgorithm._process(!!'flush');
+			 */
+			_process: function (doFlush) {
+				// Shortcuts
+				var data = this._data;
+				var dataWords = data.words;
+				var dataSigBytes = data.sigBytes;
+				var blockSize = this.blockSize;
+				var blockSizeBytes = blockSize * 4;
+
+				// Count blocks ready
+				var nBlocksReady = dataSigBytes / blockSizeBytes;
+				if (doFlush) {
+					// Round up to include partial blocks
+					nBlocksReady = Math.ceil(nBlocksReady);
+				} else {
+					// Round down to include only full blocks,
+					// less the number of blocks that must remain in the buffer
+					nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0);
+				}
+
+				// Count words ready
+				var nWordsReady = nBlocksReady * blockSize;
+
+				// Count bytes ready
+				var nBytesReady = Math.min(nWordsReady * 4, dataSigBytes);
+
+				// Process blocks
+				if (nWordsReady) {
+					for (var offset = 0; offset < nWordsReady; offset += blockSize) {
+						// Perform concrete-algorithm logic
+						this._doProcessBlock(dataWords, offset);
+					}
+
+					// Remove processed words
+					var processedWords = dataWords.splice(0, nWordsReady);
+					data.sigBytes -= nBytesReady;
+				}
+
+				// Return processed words
+				return new WordArray.init(processedWords, nBytesReady);
+			},
+
+			/**
+			 * Creates a copy of this object.
+			 *
+			 * @return {Object} The clone.
+			 *
+			 * @example
+			 *
+			 *     var clone = bufferedBlockAlgorithm.clone();
+			 */
+			clone: function () {
+				var clone = Base.clone.call(this);
+				clone._data = this._data.clone();
+
+				return clone;
+			},
+
+			_minBufferSize: 0
+		});
+
+		/**
+		 * Abstract hasher template.
+		 *
+		 * @property {number} blockSize The number of 32-bit words this hasher operates on. Default: 16 (512 bits)
+		 */
+		var Hasher = C_lib.Hasher = BufferedBlockAlgorithm.extend({
+			/**
+			 * Configuration options.
+			 */
+			cfg: Base.extend(),
+
+			/**
+			 * Initializes a newly created hasher.
+			 *
+			 * @param {Object} cfg (Optional) The configuration options to use for this hash computation.
+			 *
+			 * @example
+			 *
+			 *     var hasher = CryptoJS.algo.SHA256.create();
+			 */
+			init: function (cfg) {
+				// Apply config defaults
+				this.cfg = this.cfg.extend(cfg);
+
+				// Set initial values
+				this.reset();
+			},
+
+			/**
+			 * Resets this hasher to its initial state.
+			 *
+			 * @example
+			 *
+			 *     hasher.reset();
+			 */
+			reset: function () {
+				// Reset data buffer
+				BufferedBlockAlgorithm.reset.call(this);
+
+				// Perform concrete-hasher logic
+				this._doReset();
+			},
+
+			/**
+			 * Updates this hasher with a message.
+			 *
+			 * @param {WordArray|string} messageUpdate The message to append.
+			 *
+			 * @return {Hasher} This hasher.
+			 *
+			 * @example
+			 *
+			 *     hasher.update('message');
+			 *     hasher.update(wordArray);
+			 */
+			update: function (messageUpdate) {
+				// Append
+				this._append(messageUpdate);
+
+				// Update the hash
+				this._process();
+
+				// Chainable
+				return this;
+			},
+
+			/**
+			 * Finalizes the hash computation.
+			 * Note that the finalize operation is effectively a destructive, read-once operation.
+			 *
+			 * @param {WordArray|string} messageUpdate (Optional) A final message update.
+			 *
+			 * @return {WordArray} The hash.
+			 *
+			 * @example
+			 *
+			 *     var hash = hasher.finalize();
+			 *     var hash = hasher.finalize('message');
+			 *     var hash = hasher.finalize(wordArray);
+			 */
+			finalize: function (messageUpdate) {
+				// Final message update
+				if (messageUpdate) {
+					this._append(messageUpdate);
+				}
+
+				// Perform concrete-hasher logic
+				var hash = this._doFinalize();
+
+				return hash;
+			},
+
+			blockSize: 512 / 32,
+
+			/**
+			 * Creates a shortcut function to a hasher's object interface.
+			 *
+			 * @param {Hasher} hasher The hasher to create a helper for.
+			 *
+			 * @return {Function} The shortcut function.
+			 *
+			 * @static
+			 *
+			 * @example
+			 *
+			 *     var SHA256 = CryptoJS.lib.Hasher._createHelper(CryptoJS.algo.SHA256);
+			 */
+			_createHelper: function (hasher) {
+				return function (message, cfg) {
+					return new hasher.init(cfg).finalize(message);
+				};
+			},
+
+			/**
+			 * Creates a shortcut function to the HMAC's object interface.
+			 *
+			 * @param {Hasher} hasher The hasher to use in this HMAC helper.
+			 *
+			 * @return {Function} The shortcut function.
+			 *
+			 * @static
+			 *
+			 * @example
+			 *
+			 *     var HmacSHA256 = CryptoJS.lib.Hasher._createHmacHelper(CryptoJS.algo.SHA256);
+			 */
+			_createHmacHelper: function (hasher) {
+				return function (message, key) {
+					return new C_algo.HMAC.init(hasher, key).finalize(message);
+				};
+			}
+		});
+
+		/**
+		 * Algorithm namespace.
+		 */
+		var C_algo = C.algo = {};
+
+		return C;
+	}(Math));
+
+
+	return CryptoJS;
+
+}));

+;
+(function (root, factory) {
+	if (typeof exports === "object") {
+		// CommonJS
+		module.exports = exports = factory(require("./core"));
+	} else if (typeof define === "function" && define.amd) {
+		// AMD
+		define(["./core"], factory);
+	} else {
+		// Global (browser)
+		factory(root.CryptoJS);
+	}
+}(this, function (CryptoJS) {
+
+	(function () {
+		// Shortcuts
+		var C = CryptoJS;
+		var C_lib = C.lib;
+		var WordArray = C_lib.WordArray;
+		var C_enc = C.enc;
+
+		/**
+		 * Base64 encoding strategy.
+		 */
+		var Base64 = C_enc.Base64 = {
+			/**
+			 * Converts a word array to a Base64 string.
+			 *
+			 * @param {WordArray} wordArray The word array.
+			 *
+			 * @return {string} The Base64 string.
+			 *
+			 * @static
+			 *
+			 * @example
+			 *
+			 *     var base64String = CryptoJS.enc.Base64.stringify(wordArray);
+			 */
+			stringify: function (wordArray) {
+				// Shortcuts
+				var words = wordArray.words;
+				var sigBytes = wordArray.sigBytes;
+				var map = this._map;
+
+				// Clamp excess bits
+				wordArray.clamp();
+
+				// Convert
+				var base64Chars = [];
+				for (var i = 0; i < sigBytes; i += 3) {
+					var byte1 = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
+					var byte2 = (words[(i + 1) >>> 2] >>> (24 - ((i + 1) % 4) * 8)) & 0xff;
+					var byte3 = (words[(i + 2) >>> 2] >>> (24 - ((i + 2) % 4) * 8)) & 0xff;
+
+					var triplet = (byte1 << 16) | (byte2 << 8) | byte3;
+
+					for (var j = 0;
+						(j < 4) && (i + j * 0.75 < sigBytes); j++) {
+						base64Chars.push(map.charAt((triplet >>> (6 * (3 - j))) & 0x3f));
+					}
+				}
+
+				// Add padding
+				var paddingChar = map.charAt(64);
+				if (paddingChar) {
+					while (base64Chars.length % 4) {
+						base64Chars.push(paddingChar);
+					}
+				}
+
+				return base64Chars.join('');
+			},
+
+			/**
+			 * Converts a Base64 string to a word array.
+			 *
+			 * @param {string} base64Str The Base64 string.
+			 *
+			 * @return {WordArray} The word array.
+			 *
+			 * @static
+			 *
+			 * @example
+			 *
+			 *     var wordArray = CryptoJS.enc.Base64.parse(base64String);
+			 */
+			parse: function (base64Str) {
+				// Shortcuts
+				var base64StrLength = base64Str.length;
+				var map = this._map;
+				var reverseMap = this._reverseMap;
+
+				if (!reverseMap) {
+					reverseMap = this._reverseMap = [];
+					for (var j = 0; j < map.length; j++) {
+						reverseMap[map.charCodeAt(j)] = j;
+					}
+				}
+
+				// Ignore padding
+				var paddingChar = map.charAt(64);
+				if (paddingChar) {
+					var paddingIndex = base64Str.indexOf(paddingChar);
+					if (paddingIndex !== -1) {
+						base64StrLength = paddingIndex;
+					}
+				}
+
+				// Convert
+				return parseLoop(base64Str, base64StrLength, reverseMap);
+
+			},
+
+			_map: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='
+		};
+
+		function parseLoop(base64Str, base64StrLength, reverseMap) {
+			var words = [];
+			var nBytes = 0;
+			for (var i = 0; i < base64StrLength; i++) {
+				if (i % 4) {
+					var bits1 = reverseMap[base64Str.charCodeAt(i - 1)] << ((i % 4) * 2);
+					var bits2 = reverseMap[base64Str.charCodeAt(i)] >>> (6 - (i % 4) * 2);
+					words[nBytes >>> 2] |= (bits1 | bits2) << (24 - (nBytes % 4) * 8);
+					nBytes++;
+				}
+			}
+			return WordArray.create(words, nBytes);
+		}
+	}());
+
+
+	return CryptoJS.enc.Base64;
+
+}));

+/*
+CryptoJS v3.1.2
+code.google.com/p/crypto-js
+(c) 2009-2013 by Jeff Mott. All rights reserved.
+code.google.com/p/crypto-js/wiki/License
+*/
+var CryptoJS = CryptoJS || function (g, l) {
+  var e = {},
+    d = e.lib = {},
+    m = function () {},
+    k = d.Base = {
+      extend: function (a) {
+        m.prototype = this;
+        var c = new m;
+        a && c.mixIn(a);
+        c.hasOwnProperty("init") || (c.init = function () {
+          c.$super.init.apply(this, arguments)
+        });
+        c.init.prototype = c;
+        c.$super = this;
+        return c
+      },
+      create: function () {
+        var a = this.extend();
+        a.init.apply(a, arguments);
+        return a
+      },
+      init: function () {},
+      mixIn: function (a) {
+        for (var c in a) a.hasOwnProperty(c) && (this[c] = a[c]);
+        a.hasOwnProperty("toString") && (this.toString = a.toString)
+      },
+      clone: function () {
+        return this.init.prototype.extend(this)
+      }
+    },
+    p = d.WordArray = k.extend({
+      init: function (a, c) {
+        a = this.words = a || [];
+        this.sigBytes = c != l ? c : 4 * a.length
+      },
+      toString: function (a) {
+        return (a || n).stringify(this)
+      },
+      concat: function (a) {
+        var c = this.words,
+          q = a.words,
+          f = this.sigBytes;
+        a = a.sigBytes;
+        this.clamp();
+        if (f % 4)
+          for (var b = 0; b < a; b++) c[f + b >>> 2] |= (q[b >>> 2] >>> 24 - 8 * (b % 4) & 255) << 24 - 8 * ((f + b) % 4);
+        else if (65535 < q.length)
+          for (b = 0; b < a; b += 4) c[f + b >>> 2] = q[b >>> 2];
+        else c.push.apply(c, q);
+        this.sigBytes += a;
+        return this
+      },
+      clamp: function () {
+        var a = this.words,
+          c = this.sigBytes;
+        a[c >>> 2] &= 4294967295 <<
+          32 - 8 * (c % 4);
+        a.length = g.ceil(c / 4)
+      },
+      clone: function () {
+        var a = k.clone.call(this);
+        a.words = this.words.slice(0);
+        return a
+      },
+      random: function (a) {
+        for (var c = [], b = 0; b < a; b += 4) c.push(4294967296 * g.random() | 0);
+        return new p.init(c, a)
+      }
+    }),
+    b = e.enc = {},
+    n = b.Hex = {
+      stringify: function (a) {
+        var c = a.words;
+        a = a.sigBytes;
+        for (var b = [], f = 0; f < a; f++) {
+          var d = c[f >>> 2] >>> 24 - 8 * (f % 4) & 255;
+          b.push((d >>> 4).toString(16));
+          b.push((d & 15).toString(16))
+        }
+        return b.join("")
+      },
+      parse: function (a) {
+        for (var c = a.length, b = [], f = 0; f < c; f += 2) b[f >>> 3] |= parseInt(a.substr(f,
+          2), 16) << 24 - 4 * (f % 8);
+        return new p.init(b, c / 2)
+      }
+    },
+    j = b.Latin1 = {
+      stringify: function (a) {
+        var c = a.words;
+        a = a.sigBytes;
+        for (var b = [], f = 0; f < a; f++) b.push(String.fromCharCode(c[f >>> 2] >>> 24 - 8 * (f % 4) & 255));
+        return b.join("")
+      },
+      parse: function (a) {
+        for (var c = a.length, b = [], f = 0; f < c; f++) b[f >>> 2] |= (a.charCodeAt(f) & 255) << 24 - 8 * (f % 4);
+        return new p.init(b, c)
+      }
+    },
+    h = b.Utf8 = {
+      stringify: function (a) {
+        try {
+          return decodeURIComponent(escape(j.stringify(a)))
+        } catch (c) {
+          throw Error("Malformed UTF-8 data");
+        }
+      },
+      parse: function (a) {
+        return j.parse(unescape(encodeURIComponent(a)))
+      }
+    },
+    r = d.BufferedBlockAlgorithm = k.extend({
+      reset: function () {
+        this._data = new p.init;
+        this._nDataBytes = 0
+      },
+      _append: function (a) {
+        "string" == typeof a && (a = h.parse(a));
+        this._data.concat(a);
+        this._nDataBytes += a.sigBytes
+      },
+      _process: function (a) {
+        var c = this._data,
+          b = c.words,
+          f = c.sigBytes,
+          d = this.blockSize,
+          e = f / (4 * d),
+          e = a ? g.ceil(e) : g.max((e | 0) - this._minBufferSize, 0);
+        a = e * d;
+        f = g.min(4 * a, f);
+        if (a) {
+          for (var k = 0; k < a; k += d) this._doProcessBlock(b, k);
+          k = b.splice(0, a);
+          c.sigBytes -= f
+        }
+        return new p.init(k, f)
+      },
+      clone: function () {
+        var a = k.clone.call(this);
+        a._data = this._data.clone();
+        return a
+      },
+      _minBufferSize: 0
+    });
+  d.Hasher = r.extend({
+    cfg: k.extend(),
+    init: function (a) {
+      this.cfg = this.cfg.extend(a);
+      this.reset()
+    },
+    reset: function () {
+      r.reset.call(this);
+      this._doReset()
+    },
+    update: function (a) {
+      this._append(a);
+      this._process();
+      return this
+    },
+    finalize: function (a) {
+      a && this._append(a);
+      return this._doFinalize()
+    },
+    blockSize: 16,
+    _createHelper: function (a) {
+      return function (b, d) {
+        return (new a.init(d)).finalize(b)
+      }
+    },
+    _createHmacHelper: function (a) {
+      return function (b, d) {
+        return (new s.HMAC.init(a,
+          d)).finalize(b)
+      }
+    }
+  });
+  var s = e.algo = {};
+  return e
+}(Math);
+(function () {
+  var g = CryptoJS,
+    l = g.lib,
+    e = l.WordArray,
+    d = l.Hasher,
+    m = [],
+    l = g.algo.SHA1 = d.extend({
+      _doReset: function () {
+        this._hash = new e.init([1732584193, 4023233417, 2562383102, 271733878, 3285377520])
+      },
+      _doProcessBlock: function (d, e) {
+        for (var b = this._hash.words, n = b[0], j = b[1], h = b[2], g = b[3], l = b[4], a = 0; 80 > a; a++) {
+          if (16 > a) m[a] = d[e + a] | 0;
+          else {
+            var c = m[a - 3] ^ m[a - 8] ^ m[a - 14] ^ m[a - 16];
+            m[a] = c << 1 | c >>> 31
+          }
+          c = (n << 5 | n >>> 27) + l + m[a];
+          c = 20 > a ? c + ((j & h | ~j & g) + 1518500249) : 40 > a ? c + ((j ^ h ^ g) + 1859775393) : 60 > a ? c + ((j & h | j & g | h & g) - 1894007588) : c + ((j ^ h ^
+            g) - 899497514);
+          l = g;
+          g = h;
+          h = j << 30 | j >>> 2;
+          j = n;
+          n = c
+        }
+        b[0] = b[0] + n | 0;
+        b[1] = b[1] + j | 0;
+        b[2] = b[2] + h | 0;
+        b[3] = b[3] + g | 0;
+        b[4] = b[4] + l | 0
+      },
+      _doFinalize: function () {
+        var d = this._data,
+          e = d.words,
+          b = 8 * this._nDataBytes,
+          g = 8 * d.sigBytes;
+        e[g >>> 5] |= 128 << 24 - g % 32;
+        e[(g + 64 >>> 9 << 4) + 14] = Math.floor(b / 4294967296);
+        e[(g + 64 >>> 9 << 4) + 15] = b;
+        d.sigBytes = 4 * e.length;
+        this._process();
+        return this._hash
+      },
+      clone: function () {
+        var e = d.clone.call(this);
+        e._hash = this._hash.clone();
+        return e
+      }
+    });
+  g.SHA1 = d._createHelper(l);
+  g.HmacSHA1 = d._createHmacHelper(l)
+})();
+(function () {
+  var g = CryptoJS,
+    l = g.enc.Utf8;
+  g.algo.HMAC = g.lib.Base.extend({
+    init: function (e, d) {
+      e = this._hasher = new e.init;
+      "string" == typeof d && (d = l.parse(d));
+      var g = e.blockSize,
+        k = 4 * g;
+      d.sigBytes > k && (d = e.finalize(d));
+      d.clamp();
+      for (var p = this._oKey = d.clone(), b = this._iKey = d.clone(), n = p.words, j = b.words, h = 0; h < g; h++) n[h] ^= 1549556828, j[h] ^= 909522486;
+      p.sigBytes = b.sigBytes = k;
+      this.reset()
+    },
+    reset: function () {
+      var e = this._hasher;
+      e.reset();
+      e.update(this._iKey)
+    },
+    update: function (e) {
+      this._hasher.update(e);
+      return this
+    },
+    finalize: function (e) {
+      var d =
+        this._hasher;
+      e = d.finalize(e);
+      d.reset();
+      return d.finalize(this._oKey.clone().concat(e))
+    }
+  })
+})();
+module.exports = CryptoJS

+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
+}

+(function () {
+  var config = {
+    qiniuRegion: '',
+    qiniuImageURLPrefix: '',
+    qiniuUploadToken: '',
+    qiniuUploadTokenURL: '',
+    qiniuUploadTokenFunction: null,
+    qiniuShouldUseQiniuFileName: false
+  }
+
+  module.exports = {
+    init: init,
+    upload: upload,
+  }
+
+  // 在整个程序生命周期中，只需要 init 一次即可
+  // 如果需要变更参数，再调用 init 即可
+  function init(options) {
+    config = {
+      qiniuRegion: '',
+      qiniuImageURLPrefix: '',
+      qiniuUploadToken: '',
+      qiniuUploadTokenURL: '',
+      qiniuUploadTokenFunction: null,
+      qiniuShouldUseQiniuFileName: false
+    };
+    updateConfigWithOptions(options);
+  }
+
+  function updateConfigWithOptions(options) {
+    if (options.region) {
+      config.qiniuRegion = options.region;
+    } else {
+      console.error('qiniu uploader need your bucket region');
+    }
+    if (options.uptoken) {
+      config.qiniuUploadToken = options.uptoken;
+    } else if (options.uptokenURL) {
+      config.qiniuUploadTokenURL = options.uptokenURL;
+    } else if (options.uptokenFunc) {
+      config.qiniuUploadTokenFunction = options.uptokenFunc;
+    }
+    if (options.domain) {
+      config.qiniuImageURLPrefix = options.domain;
+    }
+    config.qiniuShouldUseQiniuFileName = options.shouldUseQiniuFileName
+  }
+
+  function upload(filePath, success, fail, options, progress, cancelTask, before, complete) {
+    if (null == filePath) {
+      console.error('qiniu uploader need filePath to upload');
+      return;
+    }
+    if (options) {
+      updateConfigWithOptions(options);
+    }
+    if (config.qiniuUploadToken) {
+      doUpload(filePath, success, fail, options, progress, cancelTask, before, complete);
+    } else if (config.qiniuUploadTokenURL) {
+      getQiniuToken(function () {
+        doUpload(filePath, success, fail, options, progress, cancelTask, before, complete);
+      });
+    } else if (config.qiniuUploadTokenFunction) {
+      config.qiniuUploadToken = config.qiniuUploadTokenFunction();
+      if (null == config.qiniuUploadToken && config.qiniuUploadToken.length > 0) {
+        console.error('qiniu UploadTokenFunction result is null, please check the return value');
+        return
+      }
+      doUpload(filePath, success, fail, options, progress, cancelTask, before, complete);
+    } else {
+      console.error('qiniu uploader need one of [uptoken, uptokenURL, uptokenFunc]');
+      return;
+    }
+  }
+
+  function doUpload(filePath, success, fail, options, progress, cancelTask, before, complete) {
+    if (null == config.qiniuUploadToken && config.qiniuUploadToken.length > 0) {
+      console.error('qiniu UploadToken is null, please check the init config or networking');
+      return
+    }
+    var url = uploadURLFromRegionCode(config.qiniuRegion);
+    console.log('filePathfilePathfilePath', filePath);
+    var fileName = filePath[0].split('//')[1];
+    if (options && options.key) {
+      fileName = options.key;
+    }
+    var formData = {
+      'token': config.qiniuUploadToken
+    };
+    if (!config.qiniuShouldUseQiniuFileName) {
+      formData['key'] = fileName
+    }
+    before && before();
+    var uploadTask = wx.uploadFile({
+      url: url,
+      filePath: filePath,
+      name: 'file',
+      formData: formData,
+      success: function (res) {
+        var dataString = res.data
+        //   // this if case is a compatibility with wechat server returned a charcode, but was fixed
+        //   if(res.data.hasOwnProperty('type') && res.data.type === 'Buffer'){
+        //     dataString = String.fromCharCode.apply(null, res.data.data)
+        //   }
+        try {
+          var dataObject = JSON.parse(dataString);
+          //do something
+          var fileUrl = config.qiniuImageURLPrefix + '/' + dataObject.key;
+          dataObject.fileUrl = fileUrl
+          dataObject.imageURL = fileUrl;
+          // console.log(dataObject);
+          if (success) {
+            success(dataObject);
+          }
+        } catch (e) {
+          console.log('parse JSON failed, origin String is: ' + dataString)
+          if (fail) {
+            fail(e);
+          }
+        }
+      },
+      fail: function (error) {
+        console.error(error);
+        if (fail) {
+          fail(error);
+        }
+      },
+      complete: function (err) {
+        complete && complete(err);
+      }
+    })
+
+    uploadTask.onProgressUpdate((res) => {
+      progress && progress(res)
+    })
+
+    cancelTask && cancelTask(() => {
+      uploadTask.abort()
+    })
+  }
+
+  function getQiniuToken(callback) {
+    console.log('urlurl', config.qiniuUploadTokenURL);
+    wx.request({
+      url: config.qiniuUploadTokenURL,
+      header: {
+        'Content-Type': "application/json",
+        //   'Cookie': 'vertx-web.session=' + wx.getStorageSync("sessionId")
+      },
+      success: function (res) {
+        var token = res.data.message;
+        if (token && token.length > 0) {
+          config.qiniuUploadToken = token;
+          if (callback) {
+            callback();
+          }
+        } else {
+          console.error('qiniuUploader cannot get your token, please check the uptokenURL or server')
+        }
+      },
+      fail: function (error) {
+        console.error('qiniu UploadToken is null, please check the init config or networking: ' + error);
+      }
+    })
+  }
+
+  function uploadURLFromRegionCode(code) {
+    var uploadURL = null;
+    switch (code) {
+      case 'ECN':
+        uploadURL = 'https://up.qiniup.com';
+        break;
+      case 'NCN':
+        uploadURL = 'https://up-z1.qiniup.com';
+        break;
+      case 'z2':
+        uploadURL = 'https://up-z0.qiniup.com';
+        break;
+      case 'NA':
+        uploadURL = 'https://up-na0.qiniup.com';
+        break;
+      case 'ASG':
+        uploadURL = 'https://up-as0.qiniup.com';
+        break;
+      default:
+        console.error('please make the region is with one of [ECN, SCN, NCN, NA, ASG]');
+    }
+    return uploadURL;
+  }
+
+})();

 var uri = require('uri.js')
 var uri = require('uri.js')
+const Buffer = require('./buffer.js');
+const CryptoJS = require('./copyto/hmac-sha1.js');
+const base64 = require('./copyto/enc-base64.js');
+import qiniuUploader from "./qiniuUploader"; 
 
 
 function formatTime(date, type, connect) {
 function formatTime(date, type, connect) {
   var year = date.getFullYear()
   var year = date.getFullYear()
@@ -182,7 +186,75 @@ function objCompare (obj1, obj2,key){
 // 判断是数组还是对象 返回 object 或者 array
 // 判断是数组还是对象 返回 object 或者 array
 function getType(variable) {  
 function getType(variable) {  
   return ({}).toString.call(variable).match(/\s([a-zA-Z]+)/)[1].toLowerCase();  
   return ({}).toString.call(variable).match(/\s([a-zA-Z]+)/)[1].toLowerCase();  
-}  
+}
+// 上传图片
+function uploadFile(imgArr, token,type){
+  let path = imgArr.split('//')[1]
+  let promisevariable = new Promise(function (resolve, reject) {
+    qiniuUploader.upload(
+      imgArr, //上传的图片
+      (res) => {  //回调 success
+        console.log(res, '七牛云返回')
+        resolve(res.imageURL)
+      }, (error) => { //回调 fail
+        reject('error');
+      },
+      { // 参数设置  地区代码 token domain 和直传的链接 注意七牛四个不同地域的链接不一样，我使用的是华南地区
+        uptokenURL: token,
+        uploadURL: 'http://nosqn.colorcun.com',
+        region: 'ECN',	//服务器区域号
+        domain: 'http://nosqn.colorcun.com',//七牛云域名
+        key: `pinglun/${type}/${path}`, // 上传到七牛云图片就是这路径
+        uptoken: token,
+        uptokeFunc:'',
+      })
+  })
+  return promisevariable;
+}
+function base64ToUrlSafe(v) {
+  return v.replace(/\//g, '_').replace(/\+/g, '-');
+};
+// 删除
+function deletelUpload(filename,token,cb) {
+  var secretkey = 'oZMMVN6phk49lG0J1xwmi1Ju0ETT15EnAEWcU9Cs';  //你的sk
+  var accessKey = 'uva-aaonM8dukeR6phc9yuPBrOXk9brrNW_PxLD7';  
+  var bucket = 'colorcun-attr' //你的空间名
+  var cdn = 'http://nosqn.colorcun.com' //CDN 测试域名
+  var str = bucket + ':' + filename.split( cdn + '/')[1];
+  var encoded = Buffer.from(str).toString('base64'); //字符串64编码
+  var encodedEntryURI = base64ToUrlSafe(encoded);  //安全编码就是替换掉一些符号看
+  var signingStr = '/delete/' + encodedEntryURI + '\n'
+  var sign = CryptoJS.HmacSHA1(signingStr, secretkey); //HmacSHA1签名
+  var cod = base64.stringify(sign);  //HmacSHA1的64编码
+  var encodedSign = base64ToUrlSafe(cod);
+  // 拼接accessToken
+  var accessToken = accessKey + ":" + encodedSign
+  wx.request({
+    url: "https://rs.qiniuapi.com/delete/" + encodedEntryURI,
+    method: "POST",
+    header: {
+      "Content-Type": "application/x-www-form-urlencoded",
+      "Authorization":  'QBox '+accessToken
+    },
+    success: function (res) {
+      wx.showToast({
+        title: '删除成功！',
+        icon: 'none',
+        duration: 500
+      })
+      return typeof cb == "function" && cb(res.data) //更具返回数据判断
+    },
+    fail: function (fail) {
+      console.log('删除失败',fail);
+      wx.showToast({
+        title: '删除失败',
+        icon: 'none',
+        duration: 500
+      })
+      return typeof cb == "function" && cb(false)
+    }
+  })
+};
 module.exports = {
 module.exports = {
   formatTime: formatTime,
   formatTime: formatTime,
   unixtoTime: unixtoTime,
   unixtoTime: unixtoTime,
@@ -192,6 +264,8 @@ module.exports = {
   objCompare,
   objCompare,
   getType,
   getType,
   imageZoomHeightUtil,
   imageZoomHeightUtil,
+  uploadFile,
+  deletelUpload,
   cgi: function (act) {
   cgi: function (act) {
     return uri.HOST__LINE + act   //正式
     return uri.HOST__LINE + act   //正式
     //return uri.HOST__TEST+act     //测试
     //return uri.HOST__TEST+act     //测试