|
- {"version":3,"sources":["webpack:///static/js/2.45ccce1cdc165fb5bb8d.js","webpack:///./~/readable-stream/lib/internal/streams/BufferList.js","webpack:///./~/readable-stream/passthrough.js","webpack:///./src/api/ota/version.js","webpack:///./~/readable-stream/transform.js","webpack:///./src/views/ota/version/add.vue?840c","webpack:///./~/readable-stream/lib/_stream_writable.js","webpack:///./~/readable-stream/writable-browser.js","webpack:///./~/stream-browserify/index.js","webpack:///./src/views/ota/version/add.vue?5ca2","webpack:///./~/browser-md5-file/src/browser-md5-file.js","webpack:///./~/readable-stream/lib/_stream_transform.js","webpack:///./~/readable-stream/lib/_stream_duplex.js","webpack:///./~/spark-md5/spark-md5.js","webpack:///./~/inherits/inherits_browser.js","webpack:///./~/readable-stream/lib/_stream_readable.js","webpack:///./~/readable-stream/duplex-browser.js","webpack:///./~/readable-stream/lib/internal/streams/stream-browser.js","webpack:///./src/api/comm.js?57ca","webpack:///./~/safe-buffer/index.js","webpack:///./~/string_decoder/lib/string_decoder.js","webpack:///./~/readable-stream/readable-browser.js","webpack:///./~/md5.js/index.js","webpack:///./~/readable-stream/lib/_stream_passthrough.js","webpack:///./src/views/ota/version/add.vue?d2ca","webpack:///./~/util-deprecate/browser.js","webpack:///./~/browser-md5-file/index.js","webpack:///./~/core-util-is/lib/util.js","webpack:///src/views/ota/version/add.vue","webpack:///./~/events/events.js","webpack:///./~/md5.js/~/hash-base/index.js","webpack:///./~/readable-stream/lib/internal/streams/destroy.js","webpack:///./~/process-nextick-args/index.js","webpack:///./src/views/ota/version/add.vue"],"names":["webpackJsonp","+HRN","module","exports","__webpack_require__","_classCallCheck","instance","Constructor","TypeError","copyBuffer","src","target","offset","copy","Buffer","BufferList","this","head","tail","length","prototype","push","v","entry","data","next","unshift","shift","ret","clear","join","s","p","concat","n","alloc","allocUnsafe","i","/MLu","PassThrough","1","3eLu","__webpack_exports__","versionList","params","__WEBPACK_IMPORTED_MODULE_0__utils_fetch__","url","method","versionAdd","versionUpdatestatus","versionDel","id","4/4u","Transform","4lE3","content","locals","7dSG","process","setImmediate","global","CorkedRequest","state","_this","finish","onCorkedFinish","_uint8ArrayToBuffer","chunk","from","_isUint8Array","obj","isBuffer","OurUint8Array","nop","WritableState","options","stream","Duplex","objectMode","writableObjectMode","hwm","highWaterMark","defaultHwm","Math","floor","finalCalled","needDrain","ending","ended","finished","destroyed","noDecode","decodeStrings","defaultEncoding","writing","corked","sync","bufferProcessing","onwrite","er","writecb","writelen","bufferedRequest","lastBufferedRequest","pendingcb","prefinished","errorEmitted","bufferedRequestCount","corkedRequestsFree","Writable","realHasInstance","call","_writableState","writable","write","_write","writev","_writev","destroy","_destroy","final","_final","Stream","writeAfterEnd","cb","Error","emit","processNextTick","validChunk","valid","undefined","decodeChunk","encoding","writeOrBuffer","isBuf","newChunk","len","last","callback","doWrite","onwriteError","finishMaybe","onwriteStateUpdate","needFinish","clearBuffer","asyncWrite","afterWrite","onwriteDrain","l","buffer","Array","holder","count","allBuffers","callFinal","err","prefinish","need","endWritable","once","corkReq","browser","indexOf","version","slice","util","inherits","internalUtil","deprecate","Uint8Array","destroyImpl","getBuffer","current","out","Object","defineProperty","get","_","Symbol","hasInstance","Function","value","object","pipe","cork","uncork","setDefaultEncoding","toLowerCase","end","set","_undestroy","undestroy","87vf","9DG0","EE","EventEmitter","Readable","dest","ondata","source","pause","ondrain","readable","resume","onend","didOnEnd","onclose","onerror","cleanup","listenerCount","removeListener","on","_isStdio","9bCr","render","_vm","_h","$createElement","_c","_self","staticClass","ref","attrs","model","ruleForm","rules","label-width","label","prop","type","_v","action","updata","show-file-list","on-success","handleAvatarSuccess","before-upload","beforeAvatarUpload","fileList","on-remove","handleRemove","plain","staticStyle","width","$$v","$set","expression","placeholder","_l","item","key","disabled","click","$event","submitForm","resetForm","staticRenderFns","esExports","CBWy","SparkMD5","file","loadNext","start","currentChunk","chunkSize","size","reader","readAsArrayBuffer","blobSlice","File","mozSlice","webkitSlice","chunks","ceil","spark","ArrayBuffer","FileReader","onloadend","e","append","result","D1Va","TransformState","afterTransform","needTransform","transforming","writechunk","writeencoding","ts","_transformState","rs","_readableState","reading","needReadable","_read","transform","_transform","flush","_flush","done","ws","err2","DsFX","allowHalfOpen","onEndNT","self","objectKeys","keys","JSQk","factory","cmn","q","a","b","x","t","add32","ff","c","d","gg","hh","ii","md5cycle","k","md5blk","md5blks","charCodeAt","md5blk_array","md51","tmp","lo","hi","substring","toString","match","parseInt","md51_array","subarray","rhex","j","hex_chr","hex","toUtf8","str","test","unescape","encodeURIComponent","utf8Str2ArrayBuffer","returnUInt8Array","buff","arr","arrayBuffer2Utf8Str","String","fromCharCode","apply","concatenateArrayBuffers","first","second","byteLength","hexToBinaryString","bytes","substr","reset","y","lsw","clamp","val","max","min","to","num","targetArray","sourceArray","begin","appendBinary","contents","_buff","_length","_hash","raw","_finish","getState","hash","setState","hashBinary","LC74","create","ctor","superCtor","super_","constructor","enumerable","configurable","TempCtor","Rt1F","prependListener","emitter","event","fn","_events","isArray","ReadableState","readableObjectMode","pipes","pipesCount","flowing","endEmitted","emittedReadable","readableListening","resumeScheduled","awaitDrain","readingMore","decoder","StringDecoder","read","readableAddChunk","addToFront","skipChunkCheck","onEofChunk","chunkInvalid","getPrototypeOf","addChunk","maybeReadMore","needMoreData","emitReadable","computeNewHighWaterMark","MAX_HWM","howMuchToRead","debug","emitReadable_","flow","maybeReadMore_","pipeOnDrain","EElistenerCount","nReadingNextTick","resume_","fromList","fromListPartial","list","hasStrings","copyFromBufferString","copyFromBuffer","nb","buf","endReadable","endReadableNT","xs","listeners","debugUtil","debuglog","kProxyEvents","isPaused","setEncoding","enc","nOrig","doRead","pipeOpts","onunpipe","unpipeInfo","hasUnpiped","onfinish","unpipe","cleanedUp","increasedAwaitDrain","doEnd","stdout","stderr","endFn","dests","index","splice","ev","res","addListener","wrap","paused","arguments","bind","_fromList","SDM6","UcPO","V8q2","getOSSSignature","dir","withCredentials","getMediaResoures","getPackageResoures","getConfigResoures","getLogoResoures","qrcodeResoures","getImgResoures","getApkResoures","getCitys","X3l8","copyProps","dst","SafeBuffer","arg","encodingOrOffset","allocUnsafeSlow","fill","SlowBuffer","X4X3","_normalizeEncoding","retried","normalizeEncoding","nenc","isEncoding","text","utf16Text","utf16End","fillLast","utf8FillLast","base64Text","base64End","simpleWrite","simpleEnd","lastNeed","lastTotal","lastChar","utf8CheckByte","byte","utf8CheckIncomplete","utf8CheckExtraBytes","repeat","r","utf8Text","total","utf8End","cSWu","eCz2","MD5","HashBase","_a","_b","_d","rotl","fnF","m","fnG","fnH","fnI","ARRAY16","_update","M","_block","readInt32LE","_digest","_blockOffset","writeUInt32LE","writeInt32LE","f48b","fNc5","sources","names","mappings","sourcesContent","sourceRoot","iP15","msg","deprecated","warned","config","console","trace","warn","name","localStorage","iVxu","jOgh","objectToString","isBoolean","isNull","isNullOrUndefined","isNumber","isString","isSymbol","isUndefined","isRegExp","re","isObject","isDate","isError","isFunction","isPrimitive","o","t7x4","__WEBPACK_IMPORTED_MODULE_0__api_comm__","__WEBPACK_IMPORTED_MODULE_1__api_ota_version__","__WEBPACK_IMPORTED_MODULE_2_md5_js__","__WEBPACK_IMPORTED_MODULE_3_browser_md5_file__","__WEBPACK_IMPORTED_MODULE_3_browser_md5_file___default","__WEBPACK_IMPORTED_MODULE_4_element_ui__","created","then","response","policy","OSSAccessKeyId","accessid","success_action_status","signature","host","mediaUrl","loadingInstance","fileName","filePath","md5Code","fileSize","versionCode","manufacturer","deviceType","deviceModel","customer","fileType","releaseNote","required","message","trigger","selected","methods","formName","_this2","$refs","validate","router","$router","$message","duration","onClose","path","resetFields","log","packageType","findPackageType","split","lastIndexOf","error","md5","packageName","packageNameArray","vzCy","_maxListeners","defaultMaxListeners","setMaxListeners","isNaN","handler","args","context","listener","newListener","g","fired","position","removeAllListeners","evlistener","wVeK","throwIfNotStringOrBuffer","prefix","blockSize","_blockSize","_finalized","update","digest","block","carry","x0Ha","readableDestroyed","writableDestroyed","emitErrorNT","ypnx","nextTick","arg1","arg2","arg3","yq/Z","injectStyle","ssrContext","__WEBPACK_IMPORTED_MODULE_0__babel_loader_node_modules_vue_loader_lib_selector_type_script_index_0_add_vue__","__WEBPACK_IMPORTED_MODULE_1__node_modules_vue_loader_lib_template_compiler_index_id_data_v_94cc7036_hasScoped_false_node_modules_vue_loader_lib_selector_type_template_index_0_add_vue__","normalizeComponent","__vue_styles__","Component"],"mappings":"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6jB,OAASD,EAAS5T,O4BxsIhD6T,O5BysIYthB,EAAMyK,OAAOhN,KAAK8jB,eAAiBF,EAAS5T,O4BxsIxD+T,S5BysIYxhB,EAAMyK,OAAOhN,KAAKgkB,sB4BxsI9B,M5BysIYzhB,EAAMyK,OAAOhN,KAAKikB,UAAYL,EAAS5T,O4BxsInDiU,U5BysIY1hB,EAAMyK,OAAO1L,IAAMsiB,EAAS5T,O4BxsIxCkU,O5B0sIQtlB,EAAoBiC,EAAEuiB,EAAoE,KAAKO,KAAK,SAAU1H,GAC1G1Z,EAAM4hB,SAAWlI,E4BxsI7BjM,U5B2sIIhQ,KAAM,WACF,OACIsN,YACA8W,gB4BxsIZ,K5BysIYjhB,UACI0G,M4BvsIhB,I5BwsIgB8C,M4BtsIhB,Q5BwsIgB9C,M4BtsIhB,I5BusIgB8C,M4BpsIhB,Q5BssIYH,UACI6X,S4BrsIhB,G5BssIgBC,S4BrsIhB,G5BssIgBC,Q4BrsIhB,G5BssIgBC,S4BrsIhB,G5BssIgBC,Y4BrsIhB,G5BssIgBC,a4BrsIhB,G5BssIgBC,W4BrsIhB,G5BssIgBC,Y4BrsIhB,G5BssIgBC,S4BrsIhB,G5BssIgBC,S4BrsIhB,G5BssIgBC,Y4BpsIhB,I5BssIYtY,OACIgY,c4BrsIhBO,UAAA,EAAAC,QAAA,QAAAC,QAEA,S5BosIgBJ,W4BnsIhBE,UAAA,EAAAC,QAAA,UAAAC,QAGA,U5BksIYlY,QACI1L,I4BjsIhB,G5BksIgBtB,SAEJmlB,YACAhB,S4BhsIZ,K5BosIIiB,SACI5X,aAAc,SAAsBoB,EAAMtB,GACtC9N,KAAKgN,UACD6X,S4BlsIhB,G5BmsIgBC,S4BlsIhB,G5BmsIgBC,Q4BlsIhB,G5BmsIgBC,S4BlsIhB,G5BmsIgBC,Y4BlsIhB,G5BmsIgBC,a4BlsIhB,G5BmsIgBC,W4BlsIhB,G5BmsIgBC,Y4BlsIhB,G5BmsIgBC,S4BlsIhB,G5BmsIgBC,S4BlsIhB,G5BmsIgBC,Y4BjsIhB,K5BosIQzW,WAAY,SAAoB+W,G4BlsIxC,GAAAC,GAAA9lB,I5BqsIYA,MAAK+lB,MAAMF,GAAUG,SAAS,SAAU/e,GACpC,IAAIA,EAaA,O4BnsIpB,C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","file":"static/js/2.45ccce1cdc165fb5bb8d.js","sourcesContent":["webpackJsonp([2],{\n\n/***/ \"+HRN\":\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n/*<replacement>*/\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar Buffer = __webpack_require__(\"X3l8\").Buffer;\n/*</replacement>*/\n\nfunction copyBuffer(src, target, offset) {\n src.copy(target, offset);\n}\n\nmodule.exports = function () {\n function BufferList() {\n _classCallCheck(this, BufferList);\n\n this.head = null;\n this.tail = null;\n this.length = 0;\n }\n\n BufferList.prototype.push = function push(v) {\n var entry = { data: v, next: null };\n if (this.length > 0) this.tail.next = entry;else this.head = entry;\n this.tail = entry;\n ++this.length;\n };\n\n BufferList.prototype.unshift = function unshift(v) {\n var entry = { data: v, next: this.head };\n if (this.length === 0) this.tail = entry;\n this.head = entry;\n ++this.length;\n };\n\n BufferList.prototype.shift = function shift() {\n if (this.length === 0) return;\n var ret = this.head.data;\n if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next;\n --this.length;\n return ret;\n };\n\n BufferList.prototype.clear = function clear() {\n this.head = this.tail = null;\n this.length = 0;\n };\n\n BufferList.prototype.join = function join(s) {\n if (this.length === 0) return '';\n var p = this.head;\n var ret = '' + p.data;\n while (p = p.next) {\n ret += s + p.data;\n }return ret;\n };\n\n BufferList.prototype.concat = function concat(n) {\n if (this.length === 0) return Buffer.alloc(0);\n if (this.length === 1) return this.head.data;\n var ret = Buffer.allocUnsafe(n >>> 0);\n var p = this.head;\n var i = 0;\n while (p) {\n copyBuffer(p.data, ret, i);\n i += p.data.length;\n p = p.next;\n }\n return ret;\n };\n\n return BufferList;\n}();\n\n/***/ }),\n\n/***/ \"/MLu\":\n/***/ (function(module, exports, __webpack_require__) {\n\nmodule.exports = __webpack_require__(\"cSWu\").PassThrough\n\n\n/***/ }),\n\n/***/ 1:\n/***/ (function(module, exports) {\n\n/* (ignored) */\n\n/***/ }),\n\n/***/ \"3eLu\":\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (immutable) */ __webpack_exports__[\"a\"] = versionList;\n/* harmony export (immutable) */ __webpack_exports__[\"d\"] = versionAdd;\n/* harmony export (immutable) */ __webpack_exports__[\"b\"] = versionUpdatestatus;\n/* harmony export (immutable) */ __webpack_exports__[\"c\"] = versionDel;\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__utils_fetch__ = __webpack_require__(\"Vo7i\");\n\n\n//列表\nfunction versionList(params) {\n return __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0__utils_fetch__[\"a\" /* default */])({\n url: '/service-ota/upgradePackages',\n method: 'post',\n data: params\n });\n}\n\n//添加\nfunction versionAdd(params) {\n return __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0__utils_fetch__[\"a\" /* default */])({\n url: '/service-ota/upgradePackage',\n method: 'post',\n data: params\n });\n}\n\n//修改状态\nfunction versionUpdatestatus(params) {\n return __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0__utils_fetch__[\"a\" /* default */])({\n url: '/service-ota/upgradePackage',\n method: 'delete',\n data: params\n // params: params\n });\n} //删除版本\nfunction versionDel(id) {\n return __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0__utils_fetch__[\"a\" /* default */])({\n url: '/service-ota/upgradePackage/' + id,\n method: 'delete'\n });\n}\n\n/***/ }),\n\n/***/ \"4/4u\":\n/***/ (function(module, exports, __webpack_require__) {\n\nmodule.exports = __webpack_require__(\"cSWu\").Transform\n\n\n/***/ }),\n\n/***/ \"4lE3\":\n/***/ (function(module, exports, __webpack_require__) {\n\n// style-loader: Adds some css to the DOM by adding a <style> tag\n\n// load the styles\nvar content = __webpack_require__(\"fNc5\");\nif(typeof content === 'string') content = [[module.i, content, '']];\nif(content.locals) module.exports = content.locals;\n// add the styles to the DOM\nvar update = __webpack_require__(\"rjj0\")(\"aad91ca2\", content, true);\n\n/***/ }),\n\n/***/ \"7dSG\":\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(process, setImmediate, global) {// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// A bit simpler than readable streams.\n// Implement an async ._write(chunk, encoding, cb), and it'll handle all\n// the drain event emission and buffering.\n\n\n\n/*<replacement>*/\n\nvar processNextTick = __webpack_require__(\"ypnx\");\n/*</replacement>*/\n\nmodule.exports = Writable;\n\n/* <replacement> */\nfunction WriteReq(chunk, encoding, cb) {\n this.chunk = chunk;\n this.encoding = encoding;\n this.callback = cb;\n this.next = null;\n}\n\n// It seems a linked list but it is not\n// there will be only 2 of these for each stream\nfunction CorkedRequest(state) {\n var _this = this;\n\n this.next = null;\n this.entry = null;\n this.finish = function () {\n onCorkedFinish(_this, state);\n };\n}\n/* </replacement> */\n\n/*<replacement>*/\nvar asyncWrite = !process.browser && ['v0.10', 'v0.9.'].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : processNextTick;\n/*</replacement>*/\n\n/*<replacement>*/\nvar Duplex;\n/*</replacement>*/\n\nWritable.WritableState = WritableState;\n\n/*<replacement>*/\nvar util = __webpack_require__(\"jOgh\");\nutil.inherits = __webpack_require__(\"LC74\");\n/*</replacement>*/\n\n/*<replacement>*/\nvar internalUtil = {\n deprecate: __webpack_require__(\"iP15\")\n};\n/*</replacement>*/\n\n/*<replacement>*/\nvar Stream = __webpack_require__(\"UcPO\");\n/*</replacement>*/\n\n/*<replacement>*/\nvar Buffer = __webpack_require__(\"X3l8\").Buffer;\nvar OurUint8Array = global.Uint8Array || function () {};\nfunction _uint8ArrayToBuffer(chunk) {\n return Buffer.from(chunk);\n}\nfunction _isUint8Array(obj) {\n return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n/*</replacement>*/\n\nvar destroyImpl = __webpack_require__(\"x0Ha\");\n\nutil.inherits(Writable, Stream);\n\nfunction nop() {}\n\nfunction WritableState(options, stream) {\n Duplex = Duplex || __webpack_require__(\"DsFX\");\n\n options = options || {};\n\n // object stream flag to indicate whether or not this stream\n // contains buffers or objects.\n this.objectMode = !!options.objectMode;\n\n if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.writableObjectMode;\n\n // the point at which write() starts returning false\n // Note: 0 is a valid value, means that we always return false if\n // the entire buffer is not flushed immediately on write()\n var hwm = options.highWaterMark;\n var defaultHwm = this.objectMode ? 16 : 16 * 1024;\n this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm;\n\n // cast to ints.\n this.highWaterMark = Math.floor(this.highWaterMark);\n\n // if _final has been called\n this.finalCalled = false;\n\n // drain event flag.\n this.needDrain = false;\n // at the start of calling end()\n this.ending = false;\n // when end() has been called, and returned\n this.ended = false;\n // when 'finish' is emitted\n this.finished = false;\n\n // has it been destroyed\n this.destroyed = false;\n\n // should we decode strings into buffers before passing to _write?\n // this is here so that some node-core streams can optimize string\n // handling at a lower level.\n var noDecode = options.decodeStrings === false;\n this.decodeStrings = !noDecode;\n\n // Crypto is kind of old and crusty. Historically, its default string\n // encoding is 'binary' so we have to make this configurable.\n // Everything else in the universe uses 'utf8', though.\n this.defaultEncoding = options.defaultEncoding || 'utf8';\n\n // not an actual buffer we keep track of, but a measurement\n // of how much we're waiting to get pushed to some underlying\n // socket or file.\n this.length = 0;\n\n // a flag to see when we're in the middle of a write.\n this.writing = false;\n\n // when true all writes will be buffered until .uncork() call\n this.corked = 0;\n\n // a flag to be able to tell if the onwrite cb is called immediately,\n // or on a later tick. We set this to true at first, because any\n // actions that shouldn't happen until \"later\" should generally also\n // not happen before the first write call.\n this.sync = true;\n\n // a flag to know if we're processing previously buffered items, which\n // may call the _write() callback in the same tick, so that we don't\n // end up in an overlapped onwrite situation.\n this.bufferProcessing = false;\n\n // the callback that's passed to _write(chunk,cb)\n this.onwrite = function (er) {\n onwrite(stream, er);\n };\n\n // the callback that the user supplies to write(chunk,encoding,cb)\n this.writecb = null;\n\n // the amount that is being written when _write is called.\n this.writelen = 0;\n\n this.bufferedRequest = null;\n this.lastBufferedRequest = null;\n\n // number of pending user-supplied write callbacks\n // this must be 0 before 'finish' can be emitted\n this.pendingcb = 0;\n\n // emit prefinish if the only thing we're waiting for is _write cbs\n // This is relevant for synchronous Transform streams\n this.prefinished = false;\n\n // True if the error was already emitted and should not be thrown again\n this.errorEmitted = false;\n\n // count buffered requests\n this.bufferedRequestCount = 0;\n\n // allocate the first CorkedRequest, there is always\n // one allocated and free to use, and we maintain at most two\n this.corkedRequestsFree = new CorkedRequest(this);\n}\n\nWritableState.prototype.getBuffer = function getBuffer() {\n var current = this.bufferedRequest;\n var out = [];\n while (current) {\n out.push(current);\n current = current.next;\n }\n return out;\n};\n\n(function () {\n try {\n Object.defineProperty(WritableState.prototype, 'buffer', {\n get: internalUtil.deprecate(function () {\n return this.getBuffer();\n }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')\n });\n } catch (_) {}\n})();\n\n// Test _writableState for inheritance to account for Duplex streams,\n// whose prototype chain only points to Readable.\nvar realHasInstance;\nif (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {\n realHasInstance = Function.prototype[Symbol.hasInstance];\n Object.defineProperty(Writable, Symbol.hasInstance, {\n value: function (object) {\n if (realHasInstance.call(this, object)) return true;\n\n return object && object._writableState instanceof WritableState;\n }\n });\n} else {\n realHasInstance = function (object) {\n return object instanceof this;\n };\n}\n\nfunction Writable(options) {\n Duplex = Duplex || __webpack_require__(\"DsFX\");\n\n // Writable ctor is applied to Duplexes, too.\n // `realHasInstance` is necessary because using plain `instanceof`\n // would return false, as no `_writableState` property is attached.\n\n // Trying to use the custom `instanceof` for Writable here will also break the\n // Node.js LazyTransform implementation, which has a non-trivial getter for\n // `_writableState` that would lead to infinite recursion.\n if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) {\n return new Writable(options);\n }\n\n this._writableState = new WritableState(options, this);\n\n // legacy.\n this.writable = true;\n\n if (options) {\n if (typeof options.write === 'function') this._write = options.write;\n\n if (typeof options.writev === 'function') this._writev = options.writev;\n\n if (typeof options.destroy === 'function') this._destroy = options.destroy;\n\n if (typeof options.final === 'function') this._final = options.final;\n }\n\n Stream.call(this);\n}\n\n// Otherwise people can pipe Writable streams, which is just wrong.\nWritable.prototype.pipe = function () {\n this.emit('error', new Error('Cannot pipe, not readable'));\n};\n\nfunction writeAfterEnd(stream, cb) {\n var er = new Error('write after end');\n // TODO: defer error events consistently everywhere, not just the cb\n stream.emit('error', er);\n processNextTick(cb, er);\n}\n\n// Checks that a user-supplied chunk is valid, especially for the particular\n// mode the stream is in. Currently this means that `null` is never accepted\n// and undefined/non-string values are only allowed in object mode.\nfunction validChunk(stream, state, chunk, cb) {\n var valid = true;\n var er = false;\n\n if (chunk === null) {\n er = new TypeError('May not write null values to stream');\n } else if (typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {\n er = new TypeError('Invalid non-string/buffer chunk');\n }\n if (er) {\n stream.emit('error', er);\n processNextTick(cb, er);\n valid = false;\n }\n return valid;\n}\n\nWritable.prototype.write = function (chunk, encoding, cb) {\n var state = this._writableState;\n var ret = false;\n var isBuf = _isUint8Array(chunk) && !state.objectMode;\n\n if (isBuf && !Buffer.isBuffer(chunk)) {\n chunk = _uint8ArrayToBuffer(chunk);\n }\n\n if (typeof encoding === 'function') {\n cb = encoding;\n encoding = null;\n }\n\n if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;\n\n if (typeof cb !== 'function') cb = nop;\n\n if (state.ended) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {\n state.pendingcb++;\n ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);\n }\n\n return ret;\n};\n\nWritable.prototype.cork = function () {\n var state = this._writableState;\n\n state.corked++;\n};\n\nWritable.prototype.uncork = function () {\n var state = this._writableState;\n\n if (state.corked) {\n state.corked--;\n\n if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);\n }\n};\n\nWritable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {\n // node::ParseEncoding() requires lower case.\n if (typeof encoding === 'string') encoding = encoding.toLowerCase();\n if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new TypeError('Unknown encoding: ' + encoding);\n this._writableState.defaultEncoding = encoding;\n return this;\n};\n\nfunction decodeChunk(state, chunk, encoding) {\n if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {\n chunk = Buffer.from(chunk, encoding);\n }\n return chunk;\n}\n\n// if we're already writing something, then just put this\n// in the queue, and wait our turn. Otherwise, call _write\n// If we return false, then we need a drain event, so set that flag.\nfunction writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {\n if (!isBuf) {\n var newChunk = decodeChunk(state, chunk, encoding);\n if (chunk !== newChunk) {\n isBuf = true;\n encoding = 'buffer';\n chunk = newChunk;\n }\n }\n var len = state.objectMode ? 1 : chunk.length;\n\n state.length += len;\n\n var ret = state.length < state.highWaterMark;\n // we must ensure that previous needDrain will not be reset to false.\n if (!ret) state.needDrain = true;\n\n if (state.writing || state.corked) {\n var last = state.lastBufferedRequest;\n state.lastBufferedRequest = {\n chunk: chunk,\n encoding: encoding,\n isBuf: isBuf,\n callback: cb,\n next: null\n };\n if (last) {\n last.next = state.lastBufferedRequest;\n } else {\n state.bufferedRequest = state.lastBufferedRequest;\n }\n state.bufferedRequestCount += 1;\n } else {\n doWrite(stream, state, false, len, chunk, encoding, cb);\n }\n\n return ret;\n}\n\nfunction doWrite(stream, state, writev, len, chunk, encoding, cb) {\n state.writelen = len;\n state.writecb = cb;\n state.writing = true;\n state.sync = true;\n if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);\n state.sync = false;\n}\n\nfunction onwriteError(stream, state, sync, er, cb) {\n --state.pendingcb;\n\n if (sync) {\n // defer the callback if we are being called synchronously\n // to avoid piling up things on the stack\n processNextTick(cb, er);\n // this can emit finish, and it will always happen\n // after error\n processNextTick(finishMaybe, stream, state);\n stream._writableState.errorEmitted = true;\n stream.emit('error', er);\n } else {\n // the caller expect this to happen before if\n // it is async\n cb(er);\n stream._writableState.errorEmitted = true;\n stream.emit('error', er);\n // this can emit finish, but finish must\n // always follow error\n finishMaybe(stream, state);\n }\n}\n\nfunction onwriteStateUpdate(state) {\n state.writing = false;\n state.writecb = null;\n state.length -= state.writelen;\n state.writelen = 0;\n}\n\nfunction onwrite(stream, er) {\n var state = stream._writableState;\n var sync = state.sync;\n var cb = state.writecb;\n\n onwriteStateUpdate(state);\n\n if (er) onwriteError(stream, state, sync, er, cb);else {\n // Check if we're actually ready to finish, but don't emit yet\n var finished = needFinish(state);\n\n if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {\n clearBuffer(stream, state);\n }\n\n if (sync) {\n /*<replacement>*/\n asyncWrite(afterWrite, stream, state, finished, cb);\n /*</replacement>*/\n } else {\n afterWrite(stream, state, finished, cb);\n }\n }\n}\n\nfunction afterWrite(stream, state, finished, cb) {\n if (!finished) onwriteDrain(stream, state);\n state.pendingcb--;\n cb();\n finishMaybe(stream, state);\n}\n\n// Must force callback to be called on nextTick, so that we don't\n// emit 'drain' before the write() consumer gets the 'false' return\n// value, and has a chance to attach a 'drain' listener.\nfunction onwriteDrain(stream, state) {\n if (state.length === 0 && state.needDrain) {\n state.needDrain = false;\n stream.emit('drain');\n }\n}\n\n// if there's something in the buffer waiting, then process it\nfunction clearBuffer(stream, state) {\n state.bufferProcessing = true;\n var entry = state.bufferedRequest;\n\n if (stream._writev && entry && entry.next) {\n // Fast case, write everything using _writev()\n var l = state.bufferedRequestCount;\n var buffer = new Array(l);\n var holder = state.corkedRequestsFree;\n holder.entry = entry;\n\n var count = 0;\n var allBuffers = true;\n while (entry) {\n buffer[count] = entry;\n if (!entry.isBuf) allBuffers = false;\n entry = entry.next;\n count += 1;\n }\n buffer.allBuffers = allBuffers;\n\n doWrite(stream, state, true, state.length, buffer, '', holder.finish);\n\n // doWrite is almost always async, defer these to save a bit of time\n // as the hot path ends with doWrite\n state.pendingcb++;\n state.lastBufferedRequest = null;\n if (holder.next) {\n state.corkedRequestsFree = holder.next;\n holder.next = null;\n } else {\n state.corkedRequestsFree = new CorkedRequest(state);\n }\n } else {\n // Slow case, write chunks one-by-one\n while (entry) {\n var chunk = entry.chunk;\n var encoding = entry.encoding;\n var cb = entry.callback;\n var len = state.objectMode ? 1 : chunk.length;\n\n doWrite(stream, state, false, len, chunk, encoding, cb);\n entry = entry.next;\n // if we didn't call the onwrite immediately, then\n // it means that we need to wait until it does.\n // also, that means that the chunk and cb are currently\n // being processed, so move the buffer counter past them.\n if (state.writing) {\n break;\n }\n }\n\n if (entry === null) state.lastBufferedRequest = null;\n }\n\n state.bufferedRequestCount = 0;\n state.bufferedRequest = entry;\n state.bufferProcessing = false;\n}\n\nWritable.prototype._write = function (chunk, encoding, cb) {\n cb(new Error('_write() is not implemented'));\n};\n\nWritable.prototype._writev = null;\n\nWritable.prototype.end = function (chunk, encoding, cb) {\n var state = this._writableState;\n\n if (typeof chunk === 'function') {\n cb = chunk;\n chunk = null;\n encoding = null;\n } else if (typeof encoding === 'function') {\n cb = encoding;\n encoding = null;\n }\n\n if (chunk !== null && chunk !== undefined) this.write(chunk, encoding);\n\n // .end() fully uncorks\n if (state.corked) {\n state.corked = 1;\n this.uncork();\n }\n\n // ignore unnecessary end() calls.\n if (!state.ending && !state.finished) endWritable(this, state, cb);\n};\n\nfunction needFinish(state) {\n return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;\n}\nfunction callFinal(stream, state) {\n stream._final(function (err) {\n state.pendingcb--;\n if (err) {\n stream.emit('error', err);\n }\n state.prefinished = true;\n stream.emit('prefinish');\n finishMaybe(stream, state);\n });\n}\nfunction prefinish(stream, state) {\n if (!state.prefinished && !state.finalCalled) {\n if (typeof stream._final === 'function') {\n state.pendingcb++;\n state.finalCalled = true;\n processNextTick(callFinal, stream, state);\n } else {\n state.prefinished = true;\n stream.emit('prefinish');\n }\n }\n}\n\nfunction finishMaybe(stream, state) {\n var need = needFinish(state);\n if (need) {\n prefinish(stream, state);\n if (state.pendingcb === 0) {\n state.finished = true;\n stream.emit('finish');\n }\n }\n return need;\n}\n\nfunction endWritable(stream, state, cb) {\n state.ending = true;\n finishMaybe(stream, state);\n if (cb) {\n if (state.finished) processNextTick(cb);else stream.once('finish', cb);\n }\n state.ended = true;\n stream.writable = false;\n}\n\nfunction onCorkedFinish(corkReq, state, err) {\n var entry = corkReq.entry;\n corkReq.entry = null;\n while (entry) {\n var cb = entry.callback;\n state.pendingcb--;\n cb(err);\n entry = entry.next;\n }\n if (state.corkedRequestsFree) {\n state.corkedRequestsFree.next = corkReq;\n } else {\n state.corkedRequestsFree = corkReq;\n }\n}\n\nObject.defineProperty(Writable.prototype, 'destroyed', {\n get: function () {\n if (this._writableState === undefined) {\n return false;\n }\n return this._writableState.destroyed;\n },\n set: function (value) {\n // we ignore the value if the stream\n // has not been initialized yet\n if (!this._writableState) {\n return;\n }\n\n // backward compatibility, the user is explicitly\n // managing destroyed\n this._writableState.destroyed = value;\n }\n});\n\nWritable.prototype.destroy = destroyImpl.destroy;\nWritable.prototype._undestroy = destroyImpl.undestroy;\nWritable.prototype._destroy = function (err, cb) {\n this.end();\n cb(err);\n};\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(\"W2nU\"), __webpack_require__(\"162o\").setImmediate, __webpack_require__(\"DuR2\")))\n\n/***/ }),\n\n/***/ \"87vf\":\n/***/ (function(module, exports, __webpack_require__) {\n\nmodule.exports = __webpack_require__(\"7dSG\");\n\n\n/***/ }),\n\n/***/ \"9DG0\":\n/***/ (function(module, exports, __webpack_require__) {\n\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nmodule.exports = Stream;\n\nvar EE = __webpack_require__(\"vzCy\").EventEmitter;\nvar inherits = __webpack_require__(\"LC74\");\n\ninherits(Stream, EE);\nStream.Readable = __webpack_require__(\"cSWu\");\nStream.Writable = __webpack_require__(\"87vf\");\nStream.Duplex = __webpack_require__(\"SDM6\");\nStream.Transform = __webpack_require__(\"4/4u\");\nStream.PassThrough = __webpack_require__(\"/MLu\");\n\n// Backwards-compat with node 0.4.x\nStream.Stream = Stream;\n\n\n\n// old-style streams. Note that the pipe method (the only relevant\n// part of this class) is overridden in the Readable class.\n\nfunction Stream() {\n EE.call(this);\n}\n\nStream.prototype.pipe = function(dest, options) {\n var source = this;\n\n function ondata(chunk) {\n if (dest.writable) {\n if (false === dest.write(chunk) && source.pause) {\n source.pause();\n }\n }\n }\n\n source.on('data', ondata);\n\n function ondrain() {\n if (source.readable && source.resume) {\n source.resume();\n }\n }\n\n dest.on('drain', ondrain);\n\n // If the 'end' option is not supplied, dest.end() will be called when\n // source gets the 'end' or 'close' events. Only dest.end() once.\n if (!dest._isStdio && (!options || options.end !== false)) {\n source.on('end', onend);\n source.on('close', onclose);\n }\n\n var didOnEnd = false;\n function onend() {\n if (didOnEnd) return;\n didOnEnd = true;\n\n dest.end();\n }\n\n\n function onclose() {\n if (didOnEnd) return;\n didOnEnd = true;\n\n if (typeof dest.destroy === 'function') dest.destroy();\n }\n\n // don't leave dangling pipes when there are errors.\n function onerror(er) {\n cleanup();\n if (EE.listenerCount(this, 'error') === 0) {\n throw er; // Unhandled stream error in pipe.\n }\n }\n\n source.on('error', onerror);\n dest.on('error', onerror);\n\n // remove all the event listeners that were added.\n function cleanup() {\n source.removeListener('data', ondata);\n dest.removeListener('drain', ondrain);\n\n source.removeListener('end', onend);\n source.removeListener('close', onclose);\n\n source.removeListener('error', onerror);\n dest.removeListener('error', onerror);\n\n source.removeListener('end', cleanup);\n source.removeListener('close', cleanup);\n\n dest.removeListener('close', cleanup);\n }\n\n source.on('end', cleanup);\n source.on('close', cleanup);\n\n dest.on('close', cleanup);\n\n dest.emit('pipe', source);\n\n // Allow for unix-like usage: A.pipe(B).pipe(C)\n return dest;\n};\n\n\n/***/ }),\n\n/***/ \"9bCr\":\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\nvar render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;\n return _c('div', {\n staticClass: \"app-container\"\n }, [_c('el-form', {\n ref: \"ruleForm\",\n staticClass: \"demo-ruleForm\",\n attrs: {\n \"model\": _vm.ruleForm,\n \"rules\": _vm.rules,\n \"label-width\": \"100px\"\n }\n }, [_c('el-form-item', {\n attrs: {\n \"label\": \"上传文件\",\n \"prop\": \"mediaUuid\"\n }\n }, [_c('el-tag', {\n attrs: {\n \"type\": \"danger\"\n }\n }, [_vm._v(\"请上传zip文件升级包,文件传输过程中请勿操作页面\")]), _vm._v(\" \"), _c('el-upload', {\n attrs: {\n \"action\": _vm.updata.url,\n \"show-file-list\": true,\n \"on-success\": _vm.handleAvatarSuccess,\n \"before-upload\": _vm.beforeAvatarUpload,\n \"data\": _vm.updata.data,\n \"fileList\": _vm.fileList,\n \"on-remove\": _vm.handleRemove\n }\n }, [_c('el-button', {\n attrs: {\n \"plain\": \"\",\n \"type\": \"primary\"\n }\n }, [_vm._v(\"点击上传\")])], 1)], 1), _vm._v(\" \"), _c('el-form-item', {\n attrs: {\n \"label\": \"版本\",\n \"prop\": \"versionCode\"\n }\n }, [_c('el-input', {\n staticStyle: {\n \"width\": \"50%\"\n },\n model: {\n value: (_vm.ruleForm.versionCode),\n callback: function($$v) {\n _vm.$set(_vm.ruleForm, \"versionCode\", $$v)\n },\n expression: \"ruleForm.versionCode\"\n }\n })], 1), _vm._v(\" \"), _c('el-form-item', {\n attrs: {\n \"label\": \"包类型\",\n \"prop\": \"fileType\"\n }\n }, [_c('el-select', {\n attrs: {\n \"placeholder\": \"请选择\"\n },\n model: {\n value: (_vm.ruleForm.fileType),\n callback: function($$v) {\n _vm.$set(_vm.ruleForm, \"fileType\", $$v)\n },\n expression: \"ruleForm.fileType\"\n }\n }, _vm._l((_vm.options), function(item) {\n return _c('el-option', {\n key: item.value,\n attrs: {\n \"label\": item.label,\n \"value\": item.value\n }\n })\n }))], 1), _vm._v(\" \"), _c('el-form-item', {\n attrs: {\n \"label\": \"文件名\",\n \"prop\": \"fileName\"\n }\n }, [_c('el-input', {\n staticStyle: {\n \"width\": \"50%\"\n },\n attrs: {\n \"disabled\": true\n },\n model: {\n value: (_vm.ruleForm.fileName),\n callback: function($$v) {\n _vm.$set(_vm.ruleForm, \"fileName\", $$v)\n },\n expression: \"ruleForm.fileName\"\n }\n })], 1), _vm._v(\" \"), _c('el-form-item', {\n attrs: {\n \"label\": \"路径\",\n \"prop\": \"filePath\"\n }\n }, [_c('el-input', {\n staticStyle: {\n \"width\": \"50%\"\n },\n attrs: {\n \"disabled\": true\n },\n model: {\n value: (_vm.ruleForm.filePath),\n callback: function($$v) {\n _vm.$set(_vm.ruleForm, \"filePath\", $$v)\n },\n expression: \"ruleForm.filePath\"\n }\n })], 1), _vm._v(\" \"), _c('el-form-item', {\n attrs: {\n \"label\": \"MD5\",\n \"prop\": \"md5Code\"\n }\n }, [_c('el-input', {\n staticStyle: {\n \"width\": \"50%\"\n },\n attrs: {\n \"disabled\": true\n },\n model: {\n value: (_vm.ruleForm.md5Code),\n callback: function($$v) {\n _vm.$set(_vm.ruleForm, \"md5Code\", $$v)\n },\n expression: \"ruleForm.md5Code\"\n }\n })], 1), _vm._v(\" \"), _c('el-form-item', {\n attrs: {\n \"label\": \"大小\",\n \"prop\": \"fileSize\"\n }\n }, [_c('el-input', {\n staticStyle: {\n \"width\": \"50%\"\n },\n attrs: {\n \"disabled\": true\n },\n model: {\n value: (_vm.ruleForm.fileSize),\n callback: function($$v) {\n _vm.$set(_vm.ruleForm, \"fileSize\", $$v)\n },\n expression: \"ruleForm.fileSize\"\n }\n })], 1), _vm._v(\" \"), _c('el-form-item', {\n attrs: {\n \"label\": \"厂商\",\n \"prop\": \"manufacturer\"\n }\n }, [_c('el-input', {\n staticStyle: {\n \"width\": \"50%\"\n },\n model: {\n value: (_vm.ruleForm.manufacturer),\n callback: function($$v) {\n _vm.$set(_vm.ruleForm, \"manufacturer\", $$v)\n },\n expression: \"ruleForm.manufacturer\"\n }\n })], 1), _vm._v(\" \"), _c('el-form-item', {\n attrs: {\n \"label\": \"设备\",\n \"prop\": \"deviceType\"\n }\n }, [_c('el-input', {\n staticStyle: {\n \"width\": \"50%\"\n },\n model: {\n value: (_vm.ruleForm.deviceType),\n callback: function($$v) {\n _vm.$set(_vm.ruleForm, \"deviceType\", $$v)\n },\n expression: \"ruleForm.deviceType\"\n }\n })], 1), _vm._v(\" \"), _c('el-form-item', {\n attrs: {\n \"label\": \"型号\",\n \"prop\": \"deviceModel\"\n }\n }, [_c('el-input', {\n staticStyle: {\n \"width\": \"50%\"\n },\n model: {\n value: (_vm.ruleForm.deviceModel),\n callback: function($$v) {\n _vm.$set(_vm.ruleForm, \"deviceModel\", $$v)\n },\n expression: \"ruleForm.deviceModel\"\n }\n })], 1), _vm._v(\" \"), _c('el-form-item', {\n attrs: {\n \"label\": \"客户\",\n \"prop\": \"customer\"\n }\n }, [_c('el-input', {\n staticStyle: {\n \"width\": \"50%\"\n },\n model: {\n value: (_vm.ruleForm.customer),\n callback: function($$v) {\n _vm.$set(_vm.ruleForm, \"customer\", $$v)\n },\n expression: \"ruleForm.customer\"\n }\n })], 1), _vm._v(\" \"), _c('el-form-item', {\n attrs: {\n \"label\": \"ReleaseNote\",\n \"prop\": \"releaseNote\"\n }\n }, [_c('el-input', {\n staticStyle: {\n \"width\": \"50%\"\n },\n attrs: {\n \"type\": \"textarea\"\n },\n model: {\n value: (_vm.ruleForm.releaseNote),\n callback: function($$v) {\n _vm.$set(_vm.ruleForm, \"releaseNote\", $$v)\n },\n expression: \"ruleForm.releaseNote\"\n }\n })], 1), _vm._v(\" \"), _c('el-form-item', [_c('el-button', {\n attrs: {\n \"type\": \"primary\"\n },\n on: {\n \"click\": function($event) {\n _vm.submitForm('ruleForm')\n }\n }\n }, [_vm._v(\"立即创建\")]), _vm._v(\" \"), _c('el-button', {\n on: {\n \"click\": function($event) {\n _vm.resetForm('ruleForm')\n }\n }\n }, [_vm._v(\"重置\")])], 1)], 1)], 1)\n}\nvar staticRenderFns = []\nvar esExports = { render: render, staticRenderFns: staticRenderFns }\n/* harmony default export */ __webpack_exports__[\"a\"] = (esExports);\n\n/***/ }),\n\n/***/ \"CBWy\":\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar SparkMD5 = __webpack_require__(\"JSQk\");\n\nmodule.exports = function (file, callback) {\n var blobSlice = File.prototype.slice || File.prototype.mozSlice || File.prototype.webkitSlice;\n var chunkSize = 2097152;\n var chunks = Math.ceil(file.size / chunkSize);\n var currentChunk = 0;\n var spark = new SparkMD5.ArrayBuffer();\n var reader = new FileReader();\n\n loadNext();\n\n reader.onloadend = function (e) {\n spark.append(e.target.result); // Append array buffer\n currentChunk++;\n\n if (currentChunk < chunks) {\n loadNext();\n } else {\n callback(null, spark.end());\n }\n };\n\n reader.onerror = function () {\n callback('oops, something went wrong.');\n };\n\n /////////////////////////\n function loadNext() {\n var start = currentChunk * chunkSize;\n var end = ((start + chunkSize) >= file.size) ? file.size : start + chunkSize;\n\n reader.readAsArrayBuffer(blobSlice.call(file, start, end));\n }\n\n};\n\n\n/***/ }),\n\n/***/ \"D1Va\":\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a transform stream is a readable/writable stream where you do\n// something with the data. Sometimes it's called a \"filter\",\n// but that's not a great name for it, since that implies a thing where\n// some bits pass through, and others are simply ignored. (That would\n// be a valid example of a transform, of course.)\n//\n// While the output is causally related to the input, it's not a\n// necessarily symmetric or synchronous transformation. For example,\n// a zlib stream might take multiple plain-text writes(), and then\n// emit a single compressed chunk some time in the future.\n//\n// Here's how this works:\n//\n// The Transform stream has all the aspects of the readable and writable\n// stream classes. When you write(chunk), that calls _write(chunk,cb)\n// internally, and returns false if there's a lot of pending writes\n// buffered up. When you call read(), that calls _read(n) until\n// there's enough pending readable data buffered up.\n//\n// In a transform stream, the written data is placed in a buffer. When\n// _read(n) is called, it transforms the queued up data, calling the\n// buffered _write cb's as it consumes chunks. If consuming a single\n// written chunk would result in multiple output chunks, then the first\n// outputted bit calls the readcb, and subsequent chunks just go into\n// the read buffer, and will cause it to emit 'readable' if necessary.\n//\n// This way, back-pressure is actually determined by the reading side,\n// since _read has to be called to start processing a new chunk. However,\n// a pathological inflate type of transform can cause excessive buffering\n// here. For example, imagine a stream where every byte of input is\n// interpreted as an integer from 0-255, and then results in that many\n// bytes of output. Writing the 4 bytes {ff,ff,ff,ff} would result in\n// 1kb of data being output. In this case, you could write a very small\n// amount of input, and end up with a very large amount of output. In\n// such a pathological inflating mechanism, there'd be no way to tell\n// the system to stop doing the transform. A single 4MB write could\n// cause the system to run out of memory.\n//\n// However, even in such a pathological case, only a single written chunk\n// would be consumed, and then the rest would wait (un-transformed) until\n// the results of the previous transformed chunk were consumed.\n\n\n\nmodule.exports = Transform;\n\nvar Duplex = __webpack_require__(\"DsFX\");\n\n/*<replacement>*/\nvar util = __webpack_require__(\"jOgh\");\nutil.inherits = __webpack_require__(\"LC74\");\n/*</replacement>*/\n\nutil.inherits(Transform, Duplex);\n\nfunction TransformState(stream) {\n this.afterTransform = function (er, data) {\n return afterTransform(stream, er, data);\n };\n\n this.needTransform = false;\n this.transforming = false;\n this.writecb = null;\n this.writechunk = null;\n this.writeencoding = null;\n}\n\nfunction afterTransform(stream, er, data) {\n var ts = stream._transformState;\n ts.transforming = false;\n\n var cb = ts.writecb;\n\n if (!cb) {\n return stream.emit('error', new Error('write callback called multiple times'));\n }\n\n ts.writechunk = null;\n ts.writecb = null;\n\n if (data !== null && data !== undefined) stream.push(data);\n\n cb(er);\n\n var rs = stream._readableState;\n rs.reading = false;\n if (rs.needReadable || rs.length < rs.highWaterMark) {\n stream._read(rs.highWaterMark);\n }\n}\n\nfunction Transform(options) {\n if (!(this instanceof Transform)) return new Transform(options);\n\n Duplex.call(this, options);\n\n this._transformState = new TransformState(this);\n\n var stream = this;\n\n // start out asking for a readable event once data is transformed.\n this._readableState.needReadable = true;\n\n // we have implemented the _read method, and done the other things\n // that Readable wants before the first _read call, so unset the\n // sync guard flag.\n this._readableState.sync = false;\n\n if (options) {\n if (typeof options.transform === 'function') this._transform = options.transform;\n\n if (typeof options.flush === 'function') this._flush = options.flush;\n }\n\n // When the writable side finishes, then flush out anything remaining.\n this.once('prefinish', function () {\n if (typeof this._flush === 'function') this._flush(function (er, data) {\n done(stream, er, data);\n });else done(stream);\n });\n}\n\nTransform.prototype.push = function (chunk, encoding) {\n this._transformState.needTransform = false;\n return Duplex.prototype.push.call(this, chunk, encoding);\n};\n\n// This is the part where you do stuff!\n// override this function in implementation classes.\n// 'chunk' is an input chunk.\n//\n// Call `push(newChunk)` to pass along transformed output\n// to the readable side. You may call 'push' zero or more times.\n//\n// Call `cb(err)` when you are done with this chunk. If you pass\n// an error, then that'll put the hurt on the whole operation. If you\n// never call cb(), then you'll never get another chunk.\nTransform.prototype._transform = function (chunk, encoding, cb) {\n throw new Error('_transform() is not implemented');\n};\n\nTransform.prototype._write = function (chunk, encoding, cb) {\n var ts = this._transformState;\n ts.writecb = cb;\n ts.writechunk = chunk;\n ts.writeencoding = encoding;\n if (!ts.transforming) {\n var rs = this._readableState;\n if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);\n }\n};\n\n// Doesn't matter what the args are here.\n// _transform does all the work.\n// That we got here means that the readable side wants more data.\nTransform.prototype._read = function (n) {\n var ts = this._transformState;\n\n if (ts.writechunk !== null && ts.writecb && !ts.transforming) {\n ts.transforming = true;\n this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);\n } else {\n // mark that we need a transform, so that any data that comes in\n // will get processed, now that we've asked for it.\n ts.needTransform = true;\n }\n};\n\nTransform.prototype._destroy = function (err, cb) {\n var _this = this;\n\n Duplex.prototype._destroy.call(this, err, function (err2) {\n cb(err2);\n _this.emit('close');\n });\n};\n\nfunction done(stream, er, data) {\n if (er) return stream.emit('error', er);\n\n if (data !== null && data !== undefined) stream.push(data);\n\n // if there's nothing in the write buffer, then that means\n // that nothing more will ever be provided\n var ws = stream._writableState;\n var ts = stream._transformState;\n\n if (ws.length) throw new Error('Calling transform done when ws.length != 0');\n\n if (ts.transforming) throw new Error('Calling transform done when still transforming');\n\n return stream.push(null);\n}\n\n/***/ }),\n\n/***/ \"DsFX\":\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a duplex stream is just a stream that is both readable and writable.\n// Since JS doesn't have multiple prototypal inheritance, this class\n// prototypally inherits from Readable, and then parasitically from\n// Writable.\n\n\n\n/*<replacement>*/\n\nvar processNextTick = __webpack_require__(\"ypnx\");\n/*</replacement>*/\n\n/*<replacement>*/\nvar objectKeys = Object.keys || function (obj) {\n var keys = [];\n for (var key in obj) {\n keys.push(key);\n }return keys;\n};\n/*</replacement>*/\n\nmodule.exports = Duplex;\n\n/*<replacement>*/\nvar util = __webpack_require__(\"jOgh\");\nutil.inherits = __webpack_require__(\"LC74\");\n/*</replacement>*/\n\nvar Readable = __webpack_require__(\"Rt1F\");\nvar Writable = __webpack_require__(\"7dSG\");\n\nutil.inherits(Duplex, Readable);\n\nvar keys = objectKeys(Writable.prototype);\nfor (var v = 0; v < keys.length; v++) {\n var method = keys[v];\n if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];\n}\n\nfunction Duplex(options) {\n if (!(this instanceof Duplex)) return new Duplex(options);\n\n Readable.call(this, options);\n Writable.call(this, options);\n\n if (options && options.readable === false) this.readable = false;\n\n if (options && options.writable === false) this.writable = false;\n\n this.allowHalfOpen = true;\n if (options && options.allowHalfOpen === false) this.allowHalfOpen = false;\n\n this.once('end', onend);\n}\n\n// the no-half-open enforcer\nfunction onend() {\n // if we allow half-open state, or if the writable side ended,\n // then we're ok.\n if (this.allowHalfOpen || this._writableState.ended) return;\n\n // no more data can be written.\n // But allow more writes to happen in this tick.\n processNextTick(onEndNT, this);\n}\n\nfunction onEndNT(self) {\n self.end();\n}\n\nObject.defineProperty(Duplex.prototype, 'destroyed', {\n get: function () {\n if (this._readableState === undefined || this._writableState === undefined) {\n return false;\n }\n return this._readableState.destroyed && this._writableState.destroyed;\n },\n set: function (value) {\n // we ignore the value if the stream\n // has not been initialized yet\n if (this._readableState === undefined || this._writableState === undefined) {\n return;\n }\n\n // backward compatibility, the user is explicitly\n // managing destroyed\n this._readableState.destroyed = value;\n this._writableState.destroyed = value;\n }\n});\n\nDuplex.prototype._destroy = function (err, cb) {\n this.push(null);\n this.end();\n\n processNextTick(cb, err);\n};\n\nfunction forEach(xs, f) {\n for (var i = 0, l = xs.length; i < l; i++) {\n f(xs[i], i);\n }\n}\n\n/***/ }),\n\n/***/ \"JSQk\":\n/***/ (function(module, exports, __webpack_require__) {\n\n(function (factory) {\n if (true) {\n // Node/CommonJS\n module.exports = factory();\n } else if (typeof define === 'function' && define.amd) {\n // AMD\n define(factory);\n } else {\n // Browser globals (with support for web workers)\n var glob;\n\n try {\n glob = window;\n } catch (e) {\n glob = self;\n }\n\n glob.SparkMD5 = factory();\n }\n}(function (undefined) {\n\n 'use strict';\n\n /*\n * Fastest md5 implementation around (JKM md5).\n * Credits: Joseph Myers\n *\n * @see http://www.myersdaily.org/joseph/javascript/md5-text.html\n * @see http://jsperf.com/md5-shootout/7\n */\n\n /* this function is much faster,\n so if possible we use it. Some IEs\n are the only ones I know of that\n need the idiotic second function,\n generated by an if clause. */\n var add32 = function (a, b) {\n return (a + b) & 0xFFFFFFFF;\n },\n hex_chr = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'];\n\n\n function cmn(q, a, b, x, s, t) {\n a = add32(add32(a, q), add32(x, t));\n return add32((a << s) | (a >>> (32 - s)), b);\n }\n\n function ff(a, b, c, d, x, s, t) {\n return cmn((b & c) | ((~b) & d), a, b, x, s, t);\n }\n\n function gg(a, b, c, d, x, s, t) {\n return cmn((b & d) | (c & (~d)), a, b, x, s, t);\n }\n\n function hh(a, b, c, d, x, s, t) {\n return cmn(b ^ c ^ d, a, b, x, s, t);\n }\n\n function ii(a, b, c, d, x, s, t) {\n return cmn(c ^ (b | (~d)), a, b, x, s, t);\n }\n\n function md5cycle(x, k) {\n var a = x[0],\n b = x[1],\n c = x[2],\n d = x[3];\n\n a = ff(a, b, c, d, k[0], 7, -680876936);\n d = ff(d, a, b, c, k[1], 12, -389564586);\n c = ff(c, d, a, b, k[2], 17, 606105819);\n b = ff(b, c, d, a, k[3], 22, -1044525330);\n a = ff(a, b, c, d, k[4], 7, -176418897);\n d = ff(d, a, b, c, k[5], 12, 1200080426);\n c = ff(c, d, a, b, k[6], 17, -1473231341);\n b = ff(b, c, d, a, k[7], 22, -45705983);\n a = ff(a, b, c, d, k[8], 7, 1770035416);\n d = ff(d, a, b, c, k[9], 12, -1958414417);\n c = ff(c, d, a, b, k[10], 17, -42063);\n b = ff(b, c, d, a, k[11], 22, -1990404162);\n a = ff(a, b, c, d, k[12], 7, 1804603682);\n d = ff(d, a, b, c, k[13], 12, -40341101);\n c = ff(c, d, a, b, k[14], 17, -1502002290);\n b = ff(b, c, d, a, k[15], 22, 1236535329);\n\n a = gg(a, b, c, d, k[1], 5, -165796510);\n d = gg(d, a, b, c, k[6], 9, -1069501632);\n c = gg(c, d, a, b, k[11], 14, 643717713);\n b = gg(b, c, d, a, k[0], 20, -373897302);\n a = gg(a, b, c, d, k[5], 5, -701558691);\n d = gg(d, a, b, c, k[10], 9, 38016083);\n c = gg(c, d, a, b, k[15], 14, -660478335);\n b = gg(b, c, d, a, k[4], 20, -405537848);\n a = gg(a, b, c, d, k[9], 5, 568446438);\n d = gg(d, a, b, c, k[14], 9, -1019803690);\n c = gg(c, d, a, b, k[3], 14, -187363961);\n b = gg(b, c, d, a, k[8], 20, 1163531501);\n a = gg(a, b, c, d, k[13], 5, -1444681467);\n d = gg(d, a, b, c, k[2], 9, -51403784);\n c = gg(c, d, a, b, k[7], 14, 1735328473);\n b = gg(b, c, d, a, k[12], 20, -1926607734);\n\n a = hh(a, b, c, d, k[5], 4, -378558);\n d = hh(d, a, b, c, k[8], 11, -2022574463);\n c = hh(c, d, a, b, k[11], 16, 1839030562);\n b = hh(b, c, d, a, k[14], 23, -35309556);\n a = hh(a, b, c, d, k[1], 4, -1530992060);\n d = hh(d, a, b, c, k[4], 11, 1272893353);\n c = hh(c, d, a, b, k[7], 16, -155497632);\n b = hh(b, c, d, a, k[10], 23, -1094730640);\n a = hh(a, b, c, d, k[13], 4, 681279174);\n d = hh(d, a, b, c, k[0], 11, -358537222);\n c = hh(c, d, a, b, k[3], 16, -722521979);\n b = hh(b, c, d, a, k[6], 23, 76029189);\n a = hh(a, b, c, d, k[9], 4, -640364487);\n d = hh(d, a, b, c, k[12], 11, -421815835);\n c = hh(c, d, a, b, k[15], 16, 530742520);\n b = hh(b, c, d, a, k[2], 23, -995338651);\n\n a = ii(a, b, c, d, k[0], 6, -198630844);\n d = ii(d, a, b, c, k[7], 10, 1126891415);\n c = ii(c, d, a, b, k[14], 15, -1416354905);\n b = ii(b, c, d, a, k[5], 21, -57434055);\n a = ii(a, b, c, d, k[12], 6, 1700485571);\n d = ii(d, a, b, c, k[3], 10, -1894986606);\n c = ii(c, d, a, b, k[10], 15, -1051523);\n b = ii(b, c, d, a, k[1], 21, -2054922799);\n a = ii(a, b, c, d, k[8], 6, 1873313359);\n d = ii(d, a, b, c, k[15], 10, -30611744);\n c = ii(c, d, a, b, k[6], 15, -1560198380);\n b = ii(b, c, d, a, k[13], 21, 1309151649);\n a = ii(a, b, c, d, k[4], 6, -145523070);\n d = ii(d, a, b, c, k[11], 10, -1120210379);\n c = ii(c, d, a, b, k[2], 15, 718787259);\n b = ii(b, c, d, a, k[9], 21, -343485551);\n\n x[0] = add32(a, x[0]);\n x[1] = add32(b, x[1]);\n x[2] = add32(c, x[2]);\n x[3] = add32(d, x[3]);\n }\n\n function md5blk(s) {\n var md5blks = [],\n i; /* Andy King said do it this way. */\n\n for (i = 0; i < 64; i += 4) {\n md5blks[i >> 2] = s.charCodeAt(i) + (s.charCodeAt(i + 1) << 8) + (s.charCodeAt(i + 2) << 16) + (s.charCodeAt(i + 3) << 24);\n }\n return md5blks;\n }\n\n function md5blk_array(a) {\n var md5blks = [],\n i; /* Andy King said do it this way. */\n\n for (i = 0; i < 64; i += 4) {\n md5blks[i >> 2] = a[i] + (a[i + 1] << 8) + (a[i + 2] << 16) + (a[i + 3] << 24);\n }\n return md5blks;\n }\n\n function md51(s) {\n var n = s.length,\n state = [1732584193, -271733879, -1732584194, 271733878],\n i,\n length,\n tail,\n tmp,\n lo,\n hi;\n\n for (i = 64; i <= n; i += 64) {\n md5cycle(state, md5blk(s.substring(i - 64, i)));\n }\n s = s.substring(i - 64);\n length = s.length;\n tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];\n for (i = 0; i < length; i += 1) {\n tail[i >> 2] |= s.charCodeAt(i) << ((i % 4) << 3);\n }\n tail[i >> 2] |= 0x80 << ((i % 4) << 3);\n if (i > 55) {\n md5cycle(state, tail);\n for (i = 0; i < 16; i += 1) {\n tail[i] = 0;\n }\n }\n\n // Beware that the final length might not fit in 32 bits so we take care of that\n tmp = n * 8;\n tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);\n lo = parseInt(tmp[2], 16);\n hi = parseInt(tmp[1], 16) || 0;\n\n tail[14] = lo;\n tail[15] = hi;\n\n md5cycle(state, tail);\n return state;\n }\n\n function md51_array(a) {\n var n = a.length,\n state = [1732584193, -271733879, -1732584194, 271733878],\n i,\n length,\n tail,\n tmp,\n lo,\n hi;\n\n for (i = 64; i <= n; i += 64) {\n md5cycle(state, md5blk_array(a.subarray(i - 64, i)));\n }\n\n // Not sure if it is a bug, however IE10 will always produce a sub array of length 1\n // containing the last element of the parent array if the sub array specified starts\n // beyond the length of the parent array - weird.\n // https://connect.microsoft.com/IE/feedback/details/771452/typed-array-subarray-issue\n a = (i - 64) < n ? a.subarray(i - 64) : new Uint8Array(0);\n\n length = a.length;\n tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];\n for (i = 0; i < length; i += 1) {\n tail[i >> 2] |= a[i] << ((i % 4) << 3);\n }\n\n tail[i >> 2] |= 0x80 << ((i % 4) << 3);\n if (i > 55) {\n md5cycle(state, tail);\n for (i = 0; i < 16; i += 1) {\n tail[i] = 0;\n }\n }\n\n // Beware that the final length might not fit in 32 bits so we take care of that\n tmp = n * 8;\n tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);\n lo = parseInt(tmp[2], 16);\n hi = parseInt(tmp[1], 16) || 0;\n\n tail[14] = lo;\n tail[15] = hi;\n\n md5cycle(state, tail);\n\n return state;\n }\n\n function rhex(n) {\n var s = '',\n j;\n for (j = 0; j < 4; j += 1) {\n s += hex_chr[(n >> (j * 8 + 4)) & 0x0F] + hex_chr[(n >> (j * 8)) & 0x0F];\n }\n return s;\n }\n\n function hex(x) {\n var i;\n for (i = 0; i < x.length; i += 1) {\n x[i] = rhex(x[i]);\n }\n return x.join('');\n }\n\n // In some cases the fast add32 function cannot be used..\n if (hex(md51('hello')) !== '5d41402abc4b2a76b9719d911017c592') {\n add32 = function (x, y) {\n var lsw = (x & 0xFFFF) + (y & 0xFFFF),\n msw = (x >> 16) + (y >> 16) + (lsw >> 16);\n return (msw << 16) | (lsw & 0xFFFF);\n };\n }\n\n // ---------------------------------------------------\n\n /**\n * ArrayBuffer slice polyfill.\n *\n * @see https://github.com/ttaubert/node-arraybuffer-slice\n */\n\n if (typeof ArrayBuffer !== 'undefined' && !ArrayBuffer.prototype.slice) {\n (function () {\n function clamp(val, length) {\n val = (val | 0) || 0;\n\n if (val < 0) {\n return Math.max(val + length, 0);\n }\n\n return Math.min(val, length);\n }\n\n ArrayBuffer.prototype.slice = function (from, to) {\n var length = this.byteLength,\n begin = clamp(from, length),\n end = length,\n num,\n target,\n targetArray,\n sourceArray;\n\n if (to !== undefined) {\n end = clamp(to, length);\n }\n\n if (begin > end) {\n return new ArrayBuffer(0);\n }\n\n num = end - begin;\n target = new ArrayBuffer(num);\n targetArray = new Uint8Array(target);\n\n sourceArray = new Uint8Array(this, begin, num);\n targetArray.set(sourceArray);\n\n return target;\n };\n })();\n }\n\n // ---------------------------------------------------\n\n /**\n * Helpers.\n */\n\n function toUtf8(str) {\n if (/[\\u0080-\\uFFFF]/.test(str)) {\n str = unescape(encodeURIComponent(str));\n }\n\n return str;\n }\n\n function utf8Str2ArrayBuffer(str, returnUInt8Array) {\n var length = str.length,\n buff = new ArrayBuffer(length),\n arr = new Uint8Array(buff),\n i;\n\n for (i = 0; i < length; i += 1) {\n arr[i] = str.charCodeAt(i);\n }\n\n return returnUInt8Array ? arr : buff;\n }\n\n function arrayBuffer2Utf8Str(buff) {\n return String.fromCharCode.apply(null, new Uint8Array(buff));\n }\n\n function concatenateArrayBuffers(first, second, returnUInt8Array) {\n var result = new Uint8Array(first.byteLength + second.byteLength);\n\n result.set(new Uint8Array(first));\n result.set(new Uint8Array(second), first.byteLength);\n\n return returnUInt8Array ? result : result.buffer;\n }\n\n function hexToBinaryString(hex) {\n var bytes = [],\n length = hex.length,\n x;\n\n for (x = 0; x < length - 1; x += 2) {\n bytes.push(parseInt(hex.substr(x, 2), 16));\n }\n\n return String.fromCharCode.apply(String, bytes);\n }\n\n // ---------------------------------------------------\n\n /**\n * SparkMD5 OOP implementation.\n *\n * Use this class to perform an incremental md5, otherwise use the\n * static methods instead.\n */\n\n function SparkMD5() {\n // call reset to init the instance\n this.reset();\n }\n\n /**\n * Appends a string.\n * A conversion will be applied if an utf8 string is detected.\n *\n * @param {String} str The string to be appended\n *\n * @return {SparkMD5} The instance itself\n */\n SparkMD5.prototype.append = function (str) {\n // Converts the string to utf8 bytes if necessary\n // Then append as binary\n this.appendBinary(toUtf8(str));\n\n return this;\n };\n\n /**\n * Appends a binary string.\n *\n * @param {String} contents The binary string to be appended\n *\n * @return {SparkMD5} The instance itself\n */\n SparkMD5.prototype.appendBinary = function (contents) {\n this._buff += contents;\n this._length += contents.length;\n\n var length = this._buff.length,\n i;\n\n for (i = 64; i <= length; i += 64) {\n md5cycle(this._hash, md5blk(this._buff.substring(i - 64, i)));\n }\n\n this._buff = this._buff.substring(i - 64);\n\n return this;\n };\n\n /**\n * Finishes the incremental computation, reseting the internal state and\n * returning the result.\n *\n * @param {Boolean} raw True to get the raw string, false to get the hex string\n *\n * @return {String} The result\n */\n SparkMD5.prototype.end = function (raw) {\n var buff = this._buff,\n length = buff.length,\n i,\n tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n ret;\n\n for (i = 0; i < length; i += 1) {\n tail[i >> 2] |= buff.charCodeAt(i) << ((i % 4) << 3);\n }\n\n this._finish(tail, length);\n ret = hex(this._hash);\n\n if (raw) {\n ret = hexToBinaryString(ret);\n }\n\n this.reset();\n\n return ret;\n };\n\n /**\n * Resets the internal state of the computation.\n *\n * @return {SparkMD5} The instance itself\n */\n SparkMD5.prototype.reset = function () {\n this._buff = '';\n this._length = 0;\n this._hash = [1732584193, -271733879, -1732584194, 271733878];\n\n return this;\n };\n\n /**\n * Gets the internal state of the computation.\n *\n * @return {Object} The state\n */\n SparkMD5.prototype.getState = function () {\n return {\n buff: this._buff,\n length: this._length,\n hash: this._hash\n };\n };\n\n /**\n * Gets the internal state of the computation.\n *\n * @param {Object} state The state\n *\n * @return {SparkMD5} The instance itself\n */\n SparkMD5.prototype.setState = function (state) {\n this._buff = state.buff;\n this._length = state.length;\n this._hash = state.hash;\n\n return this;\n };\n\n /**\n * Releases memory used by the incremental buffer and other additional\n * resources. If you plan to use the instance again, use reset instead.\n */\n SparkMD5.prototype.destroy = function () {\n delete this._hash;\n delete this._buff;\n delete this._length;\n };\n\n /**\n * Finish the final calculation based on the tail.\n *\n * @param {Array} tail The tail (will be modified)\n * @param {Number} length The length of the remaining buffer\n */\n SparkMD5.prototype._finish = function (tail, length) {\n var i = length,\n tmp,\n lo,\n hi;\n\n tail[i >> 2] |= 0x80 << ((i % 4) << 3);\n if (i > 55) {\n md5cycle(this._hash, tail);\n for (i = 0; i < 16; i += 1) {\n tail[i] = 0;\n }\n }\n\n // Do the final computation based on the tail and length\n // Beware that the final length may not fit in 32 bits so we take care of that\n tmp = this._length * 8;\n tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);\n lo = parseInt(tmp[2], 16);\n hi = parseInt(tmp[1], 16) || 0;\n\n tail[14] = lo;\n tail[15] = hi;\n md5cycle(this._hash, tail);\n };\n\n /**\n * Performs the md5 hash on a string.\n * A conversion will be applied if utf8 string is detected.\n *\n * @param {String} str The string\n * @param {Boolean} raw True to get the raw string, false to get the hex string\n *\n * @return {String} The result\n */\n SparkMD5.hash = function (str, raw) {\n // Converts the string to utf8 bytes if necessary\n // Then compute it using the binary function\n return SparkMD5.hashBinary(toUtf8(str), raw);\n };\n\n /**\n * Performs the md5 hash on a binary string.\n *\n * @param {String} content The binary string\n * @param {Boolean} raw True to get the raw string, false to get the hex string\n *\n * @return {String} The result\n */\n SparkMD5.hashBinary = function (content, raw) {\n var hash = md51(content),\n ret = hex(hash);\n\n return raw ? hexToBinaryString(ret) : ret;\n };\n\n // ---------------------------------------------------\n\n /**\n * SparkMD5 OOP implementation for array buffers.\n *\n * Use this class to perform an incremental md5 ONLY for array buffers.\n */\n SparkMD5.ArrayBuffer = function () {\n // call reset to init the instance\n this.reset();\n };\n\n /**\n * Appends an array buffer.\n *\n * @param {ArrayBuffer} arr The array to be appended\n *\n * @return {SparkMD5.ArrayBuffer} The instance itself\n */\n SparkMD5.ArrayBuffer.prototype.append = function (arr) {\n var buff = concatenateArrayBuffers(this._buff.buffer, arr, true),\n length = buff.length,\n i;\n\n this._length += arr.byteLength;\n\n for (i = 64; i <= length; i += 64) {\n md5cycle(this._hash, md5blk_array(buff.subarray(i - 64, i)));\n }\n\n this._buff = (i - 64) < length ? new Uint8Array(buff.buffer.slice(i - 64)) : new Uint8Array(0);\n\n return this;\n };\n\n /**\n * Finishes the incremental computation, reseting the internal state and\n * returning the result.\n *\n * @param {Boolean} raw True to get the raw string, false to get the hex string\n *\n * @return {String} The result\n */\n SparkMD5.ArrayBuffer.prototype.end = function (raw) {\n var buff = this._buff,\n length = buff.length,\n tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n i,\n ret;\n\n for (i = 0; i < length; i += 1) {\n tail[i >> 2] |= buff[i] << ((i % 4) << 3);\n }\n\n this._finish(tail, length);\n ret = hex(this._hash);\n\n if (raw) {\n ret = hexToBinaryString(ret);\n }\n\n this.reset();\n\n return ret;\n };\n\n /**\n * Resets the internal state of the computation.\n *\n * @return {SparkMD5.ArrayBuffer} The instance itself\n */\n SparkMD5.ArrayBuffer.prototype.reset = function () {\n this._buff = new Uint8Array(0);\n this._length = 0;\n this._hash = [1732584193, -271733879, -1732584194, 271733878];\n\n return this;\n };\n\n /**\n * Gets the internal state of the computation.\n *\n * @return {Object} The state\n */\n SparkMD5.ArrayBuffer.prototype.getState = function () {\n var state = SparkMD5.prototype.getState.call(this);\n\n // Convert buffer to a string\n state.buff = arrayBuffer2Utf8Str(state.buff);\n\n return state;\n };\n\n /**\n * Gets the internal state of the computation.\n *\n * @param {Object} state The state\n *\n * @return {SparkMD5.ArrayBuffer} The instance itself\n */\n SparkMD5.ArrayBuffer.prototype.setState = function (state) {\n // Convert string to buffer\n state.buff = utf8Str2ArrayBuffer(state.buff, true);\n\n return SparkMD5.prototype.setState.call(this, state);\n };\n\n SparkMD5.ArrayBuffer.prototype.destroy = SparkMD5.prototype.destroy;\n\n SparkMD5.ArrayBuffer.prototype._finish = SparkMD5.prototype._finish;\n\n /**\n * Performs the md5 hash on an array buffer.\n *\n * @param {ArrayBuffer} arr The array buffer\n * @param {Boolean} raw True to get the raw string, false to get the hex one\n *\n * @return {String} The result\n */\n SparkMD5.ArrayBuffer.hash = function (arr, raw) {\n var hash = md51_array(new Uint8Array(arr)),\n ret = hex(hash);\n\n return raw ? hexToBinaryString(ret) : ret;\n };\n\n return SparkMD5;\n}));\n\n\n/***/ }),\n\n/***/ \"LC74\":\n/***/ (function(module, exports) {\n\nif (typeof Object.create === 'function') {\n // implementation from standard node.js 'util' module\n module.exports = function inherits(ctor, superCtor) {\n ctor.super_ = superCtor\n ctor.prototype = Object.create(superCtor.prototype, {\n constructor: {\n value: ctor,\n enumerable: false,\n writable: true,\n configurable: true\n }\n });\n };\n} else {\n // old school shim for old browsers\n module.exports = function inherits(ctor, superCtor) {\n ctor.super_ = superCtor\n var TempCtor = function () {}\n TempCtor.prototype = superCtor.prototype\n ctor.prototype = new TempCtor()\n ctor.prototype.constructor = ctor\n }\n}\n\n\n/***/ }),\n\n/***/ \"Rt1F\":\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(global, process) {// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n\n\n/*<replacement>*/\n\nvar processNextTick = __webpack_require__(\"ypnx\");\n/*</replacement>*/\n\nmodule.exports = Readable;\n\n/*<replacement>*/\nvar isArray = __webpack_require__(\"sOR5\");\n/*</replacement>*/\n\n/*<replacement>*/\nvar Duplex;\n/*</replacement>*/\n\nReadable.ReadableState = ReadableState;\n\n/*<replacement>*/\nvar EE = __webpack_require__(\"vzCy\").EventEmitter;\n\nvar EElistenerCount = function (emitter, type) {\n return emitter.listeners(type).length;\n};\n/*</replacement>*/\n\n/*<replacement>*/\nvar Stream = __webpack_require__(\"UcPO\");\n/*</replacement>*/\n\n// TODO(bmeurer): Change this back to const once hole checks are\n// properly optimized away early in Ignition+TurboFan.\n/*<replacement>*/\nvar Buffer = __webpack_require__(\"X3l8\").Buffer;\nvar OurUint8Array = global.Uint8Array || function () {};\nfunction _uint8ArrayToBuffer(chunk) {\n return Buffer.from(chunk);\n}\nfunction _isUint8Array(obj) {\n return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n/*</replacement>*/\n\n/*<replacement>*/\nvar util = __webpack_require__(\"jOgh\");\nutil.inherits = __webpack_require__(\"LC74\");\n/*</replacement>*/\n\n/*<replacement>*/\nvar debugUtil = __webpack_require__(1);\nvar debug = void 0;\nif (debugUtil && debugUtil.debuglog) {\n debug = debugUtil.debuglog('stream');\n} else {\n debug = function () {};\n}\n/*</replacement>*/\n\nvar BufferList = __webpack_require__(\"+HRN\");\nvar destroyImpl = __webpack_require__(\"x0Ha\");\nvar StringDecoder;\n\nutil.inherits(Readable, Stream);\n\nvar kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];\n\nfunction prependListener(emitter, event, fn) {\n // Sadly this is not cacheable as some libraries bundle their own\n // event emitter implementation with them.\n if (typeof emitter.prependListener === 'function') {\n return emitter.prependListener(event, fn);\n } else {\n // This is a hack to make sure that our error handler is attached before any\n // userland ones. NEVER DO THIS. This is here only because this code needs\n // to continue to work with older versions of Node.js that do not include\n // the prependListener() method. The goal is to eventually remove this hack.\n if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]];\n }\n}\n\nfunction ReadableState(options, stream) {\n Duplex = Duplex || __webpack_require__(\"DsFX\");\n\n options = options || {};\n\n // object stream flag. Used to make read(n) ignore n and to\n // make all the buffer merging and length checks go away\n this.objectMode = !!options.objectMode;\n\n if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.readableObjectMode;\n\n // the point at which it stops calling _read() to fill the buffer\n // Note: 0 is a valid value, means \"don't call _read preemptively ever\"\n var hwm = options.highWaterMark;\n var defaultHwm = this.objectMode ? 16 : 16 * 1024;\n this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm;\n\n // cast to ints.\n this.highWaterMark = Math.floor(this.highWaterMark);\n\n // A linked list is used to store data chunks instead of an array because the\n // linked list can remove elements from the beginning faster than\n // array.shift()\n this.buffer = new BufferList();\n this.length = 0;\n this.pipes = null;\n this.pipesCount = 0;\n this.flowing = null;\n this.ended = false;\n this.endEmitted = false;\n this.reading = false;\n\n // a flag to be able to tell if the event 'readable'/'data' is emitted\n // immediately, or on a later tick. We set this to true at first, because\n // any actions that shouldn't happen until \"later\" should generally also\n // not happen before the first read call.\n this.sync = true;\n\n // whenever we return null, then we set a flag to say\n // that we're awaiting a 'readable' event emission.\n this.needReadable = false;\n this.emittedReadable = false;\n this.readableListening = false;\n this.resumeScheduled = false;\n\n // has it been destroyed\n this.destroyed = false;\n\n // Crypto is kind of old and crusty. Historically, its default string\n // encoding is 'binary' so we have to make this configurable.\n // Everything else in the universe uses 'utf8', though.\n this.defaultEncoding = options.defaultEncoding || 'utf8';\n\n // the number of writers that are awaiting a drain event in .pipe()s\n this.awaitDrain = 0;\n\n // if true, a maybeReadMore has been scheduled\n this.readingMore = false;\n\n this.decoder = null;\n this.encoding = null;\n if (options.encoding) {\n if (!StringDecoder) StringDecoder = __webpack_require__(\"X4X3\").StringDecoder;\n this.decoder = new StringDecoder(options.encoding);\n this.encoding = options.encoding;\n }\n}\n\nfunction Readable(options) {\n Duplex = Duplex || __webpack_require__(\"DsFX\");\n\n if (!(this instanceof Readable)) return new Readable(options);\n\n this._readableState = new ReadableState(options, this);\n\n // legacy\n this.readable = true;\n\n if (options) {\n if (typeof options.read === 'function') this._read = options.read;\n\n if (typeof options.destroy === 'function') this._destroy = options.destroy;\n }\n\n Stream.call(this);\n}\n\nObject.defineProperty(Readable.prototype, 'destroyed', {\n get: function () {\n if (this._readableState === undefined) {\n return false;\n }\n return this._readableState.destroyed;\n },\n set: function (value) {\n // we ignore the value if the stream\n // has not been initialized yet\n if (!this._readableState) {\n return;\n }\n\n // backward compatibility, the user is explicitly\n // managing destroyed\n this._readableState.destroyed = value;\n }\n});\n\nReadable.prototype.destroy = destroyImpl.destroy;\nReadable.prototype._undestroy = destroyImpl.undestroy;\nReadable.prototype._destroy = function (err, cb) {\n this.push(null);\n cb(err);\n};\n\n// Manually shove something into the read() buffer.\n// This returns true if the highWaterMark has not been hit yet,\n// similar to how Writable.write() returns true if you should\n// write() some more.\nReadable.prototype.push = function (chunk, encoding) {\n var state = this._readableState;\n var skipChunkCheck;\n\n if (!state.objectMode) {\n if (typeof chunk === 'string') {\n encoding = encoding || state.defaultEncoding;\n if (encoding !== state.encoding) {\n chunk = Buffer.from(chunk, encoding);\n encoding = '';\n }\n skipChunkCheck = true;\n }\n } else {\n skipChunkCheck = true;\n }\n\n return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);\n};\n\n// Unshift should *always* be something directly out of read()\nReadable.prototype.unshift = function (chunk) {\n return readableAddChunk(this, chunk, null, true, false);\n};\n\nfunction readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {\n var state = stream._readableState;\n if (chunk === null) {\n state.reading = false;\n onEofChunk(stream, state);\n } else {\n var er;\n if (!skipChunkCheck) er = chunkInvalid(state, chunk);\n if (er) {\n stream.emit('error', er);\n } else if (state.objectMode || chunk && chunk.length > 0) {\n if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {\n chunk = _uint8ArrayToBuffer(chunk);\n }\n\n if (addToFront) {\n if (state.endEmitted) stream.emit('error', new Error('stream.unshift() after end event'));else addChunk(stream, state, chunk, true);\n } else if (state.ended) {\n stream.emit('error', new Error('stream.push() after EOF'));\n } else {\n state.reading = false;\n if (state.decoder && !encoding) {\n chunk = state.decoder.write(chunk);\n if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state);\n } else {\n addChunk(stream, state, chunk, false);\n }\n }\n } else if (!addToFront) {\n state.reading = false;\n }\n }\n\n return needMoreData(state);\n}\n\nfunction addChunk(stream, state, chunk, addToFront) {\n if (state.flowing && state.length === 0 && !state.sync) {\n stream.emit('data', chunk);\n stream.read(0);\n } else {\n // update the buffer info.\n state.length += state.objectMode ? 1 : chunk.length;\n if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);\n\n if (state.needReadable) emitReadable(stream);\n }\n maybeReadMore(stream, state);\n}\n\nfunction chunkInvalid(state, chunk) {\n var er;\n if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {\n er = new TypeError('Invalid non-string/buffer chunk');\n }\n return er;\n}\n\n// if it's past the high water mark, we can push in some more.\n// Also, if we have no data yet, we can stand some\n// more bytes. This is to work around cases where hwm=0,\n// such as the repl. Also, if the push() triggered a\n// readable event, and the user called read(largeNumber) such that\n// needReadable was set, then we ought to push more, so that another\n// 'readable' event will be triggered.\nfunction needMoreData(state) {\n return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0);\n}\n\nReadable.prototype.isPaused = function () {\n return this._readableState.flowing === false;\n};\n\n// backwards compatibility.\nReadable.prototype.setEncoding = function (enc) {\n if (!StringDecoder) StringDecoder = __webpack_require__(\"X4X3\").StringDecoder;\n this._readableState.decoder = new StringDecoder(enc);\n this._readableState.encoding = enc;\n return this;\n};\n\n// Don't raise the hwm > 8MB\nvar MAX_HWM = 0x800000;\nfunction computeNewHighWaterMark(n) {\n if (n >= MAX_HWM) {\n n = MAX_HWM;\n } else {\n // Get the next highest power of 2 to prevent increasing hwm excessively in\n // tiny amounts\n n--;\n n |= n >>> 1;\n n |= n >>> 2;\n n |= n >>> 4;\n n |= n >>> 8;\n n |= n >>> 16;\n n++;\n }\n return n;\n}\n\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction howMuchToRead(n, state) {\n if (n <= 0 || state.length === 0 && state.ended) return 0;\n if (state.objectMode) return 1;\n if (n !== n) {\n // Only flow one buffer at a time\n if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;\n }\n // If we're asking for more than the current hwm, then raise the hwm.\n if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);\n if (n <= state.length) return n;\n // Don't have enough\n if (!state.ended) {\n state.needReadable = true;\n return 0;\n }\n return state.length;\n}\n\n// you can override either this method, or the async _read(n) below.\nReadable.prototype.read = function (n) {\n debug('read', n);\n n = parseInt(n, 10);\n var state = this._readableState;\n var nOrig = n;\n\n if (n !== 0) state.emittedReadable = false;\n\n // if we're doing read(0) to trigger a readable event, but we\n // already have a bunch of data in the buffer, then just trigger\n // the 'readable' event and move on.\n if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) {\n debug('read: emitReadable', state.length, state.ended);\n if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this);\n return null;\n }\n\n n = howMuchToRead(n, state);\n\n // if we've ended, and we're now clear, then finish it up.\n if (n === 0 && state.ended) {\n if (state.length === 0) endReadable(this);\n return null;\n }\n\n // All the actual chunk generation logic needs to be\n // *below* the call to _read. The reason is that in certain\n // synthetic stream cases, such as passthrough streams, _read\n // may be a completely synchronous operation which may change\n // the state of the read buffer, providing enough data when\n // before there was *not* enough.\n //\n // So, the steps are:\n // 1. Figure out what the state of things will be after we do\n // a read from the buffer.\n //\n // 2. If that resulting state will trigger a _read, then call _read.\n // Note that this may be asynchronous, or synchronous. Yes, it is\n // deeply ugly to write APIs this way, but that still doesn't mean\n // that the Readable class should behave improperly, as streams are\n // designed to be sync/async agnostic.\n // Take note if the _read call is sync or async (ie, if the read call\n // has returned yet), so that we know whether or not it's safe to emit\n // 'readable' etc.\n //\n // 3. Actually pull the requested chunks out of the buffer and return.\n\n // if we need a readable event, then we need to do some reading.\n var doRead = state.needReadable;\n debug('need readable', doRead);\n\n // if we currently have less than the highWaterMark, then also read some\n if (state.length === 0 || state.length - n < state.highWaterMark) {\n doRead = true;\n debug('length less than watermark', doRead);\n }\n\n // however, if we've ended, then there's no point, and if we're already\n // reading, then it's unnecessary.\n if (state.ended || state.reading) {\n doRead = false;\n debug('reading or ended', doRead);\n } else if (doRead) {\n debug('do read');\n state.reading = true;\n state.sync = true;\n // if the length is currently zero, then we *need* a readable event.\n if (state.length === 0) state.needReadable = true;\n // call internal read method\n this._read(state.highWaterMark);\n state.sync = false;\n // If _read pushed data synchronously, then `reading` will be false,\n // and we need to re-evaluate how much data we can return to the user.\n if (!state.reading) n = howMuchToRead(nOrig, state);\n }\n\n var ret;\n if (n > 0) ret = fromList(n, state);else ret = null;\n\n if (ret === null) {\n state.needReadable = true;\n n = 0;\n } else {\n state.length -= n;\n }\n\n if (state.length === 0) {\n // If we have nothing in the buffer, then we want to know\n // as soon as we *do* get something into the buffer.\n if (!state.ended) state.needReadable = true;\n\n // If we tried to read() past the EOF, then emit end on the next tick.\n if (nOrig !== n && state.ended) endReadable(this);\n }\n\n if (ret !== null) this.emit('data', ret);\n\n return ret;\n};\n\nfunction onEofChunk(stream, state) {\n if (state.ended) return;\n if (state.decoder) {\n var chunk = state.decoder.end();\n if (chunk && chunk.length) {\n state.buffer.push(chunk);\n state.length += state.objectMode ? 1 : chunk.length;\n }\n }\n state.ended = true;\n\n // emit 'readable' now to make sure it gets picked up.\n emitReadable(stream);\n}\n\n// Don't emit readable right away in sync mode, because this can trigger\n// another read() call => stack overflow. This way, it might trigger\n// a nextTick recursion warning, but that's not so bad.\nfunction emitReadable(stream) {\n var state = stream._readableState;\n state.needReadable = false;\n if (!state.emittedReadable) {\n debug('emitReadable', state.flowing);\n state.emittedReadable = true;\n if (state.sync) processNextTick(emitReadable_, stream);else emitReadable_(stream);\n }\n}\n\nfunction emitReadable_(stream) {\n debug('emit readable');\n stream.emit('readable');\n flow(stream);\n}\n\n// at this point, the user has presumably seen the 'readable' event,\n// and called read() to consume some data. that may have triggered\n// in turn another _read(n) call, in which case reading = true if\n// it's in progress.\n// However, if we're not ended, or reading, and the length < hwm,\n// then go ahead and try to read some more preemptively.\nfunction maybeReadMore(stream, state) {\n if (!state.readingMore) {\n state.readingMore = true;\n processNextTick(maybeReadMore_, stream, state);\n }\n}\n\nfunction maybeReadMore_(stream, state) {\n var len = state.length;\n while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) {\n debug('maybeReadMore read 0');\n stream.read(0);\n if (len === state.length)\n // didn't get any data, stop spinning.\n break;else len = state.length;\n }\n state.readingMore = false;\n}\n\n// abstract method. to be overridden in specific implementation classes.\n// call cb(er, data) where data is <= n in length.\n// for virtual (non-string, non-buffer) streams, \"length\" is somewhat\n// arbitrary, and perhaps not very meaningful.\nReadable.prototype._read = function (n) {\n this.emit('error', new Error('_read() is not implemented'));\n};\n\nReadable.prototype.pipe = function (dest, pipeOpts) {\n var src = this;\n var state = this._readableState;\n\n switch (state.pipesCount) {\n case 0:\n state.pipes = dest;\n break;\n case 1:\n state.pipes = [state.pipes, dest];\n break;\n default:\n state.pipes.push(dest);\n break;\n }\n state.pipesCount += 1;\n debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);\n\n var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;\n\n var endFn = doEnd ? onend : unpipe;\n if (state.endEmitted) processNextTick(endFn);else src.once('end', endFn);\n\n dest.on('unpipe', onunpipe);\n function onunpipe(readable, unpipeInfo) {\n debug('onunpipe');\n if (readable === src) {\n if (unpipeInfo && unpipeInfo.hasUnpiped === false) {\n unpipeInfo.hasUnpiped = true;\n cleanup();\n }\n }\n }\n\n function onend() {\n debug('onend');\n dest.end();\n }\n\n // when the dest drains, it reduces the awaitDrain counter\n // on the source. This would be more elegant with a .once()\n // handler in flow(), but adding and removing repeatedly is\n // too slow.\n var ondrain = pipeOnDrain(src);\n dest.on('drain', ondrain);\n\n var cleanedUp = false;\n function cleanup() {\n debug('cleanup');\n // cleanup event handlers once the pipe is broken\n dest.removeListener('close', onclose);\n dest.removeListener('finish', onfinish);\n dest.removeListener('drain', ondrain);\n dest.removeListener('error', onerror);\n dest.removeListener('unpipe', onunpipe);\n src.removeListener('end', onend);\n src.removeListener('end', unpipe);\n src.removeListener('data', ondata);\n\n cleanedUp = true;\n\n // if the reader is waiting for a drain event from this\n // specific writer, then it would cause it to never start\n // flowing again.\n // So, if this is awaiting a drain, then we just call it now.\n // If we don't know, then assume that we are waiting for one.\n if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();\n }\n\n // If the user pushes more data while we're writing to dest then we'll end up\n // in ondata again. However, we only want to increase awaitDrain once because\n // dest will only emit one 'drain' event for the multiple writes.\n // => Introduce a guard on increasing awaitDrain.\n var increasedAwaitDrain = false;\n src.on('data', ondata);\n function ondata(chunk) {\n debug('ondata');\n increasedAwaitDrain = false;\n var ret = dest.write(chunk);\n if (false === ret && !increasedAwaitDrain) {\n // If the user unpiped during `dest.write()`, it is possible\n // to get stuck in a permanently paused state if that write\n // also returned false.\n // => Check whether `dest` is still a piping destination.\n if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {\n debug('false write response, pause', src._readableState.awaitDrain);\n src._readableState.awaitDrain++;\n increasedAwaitDrain = true;\n }\n src.pause();\n }\n }\n\n // if the dest has an error, then stop piping into it.\n // however, don't suppress the throwing behavior for this.\n function onerror(er) {\n debug('onerror', er);\n unpipe();\n dest.removeListener('error', onerror);\n if (EElistenerCount(dest, 'error') === 0) dest.emit('error', er);\n }\n\n // Make sure our error handler is attached before userland ones.\n prependListener(dest, 'error', onerror);\n\n // Both close and finish should trigger unpipe, but only once.\n function onclose() {\n dest.removeListener('finish', onfinish);\n unpipe();\n }\n dest.once('close', onclose);\n function onfinish() {\n debug('onfinish');\n dest.removeListener('close', onclose);\n unpipe();\n }\n dest.once('finish', onfinish);\n\n function unpipe() {\n debug('unpipe');\n src.unpipe(dest);\n }\n\n // tell the dest that it's being piped to\n dest.emit('pipe', src);\n\n // start the flow if it hasn't been started already.\n if (!state.flowing) {\n debug('pipe resume');\n src.resume();\n }\n\n return dest;\n};\n\nfunction pipeOnDrain(src) {\n return function () {\n var state = src._readableState;\n debug('pipeOnDrain', state.awaitDrain);\n if (state.awaitDrain) state.awaitDrain--;\n if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {\n state.flowing = true;\n flow(src);\n }\n };\n}\n\nReadable.prototype.unpipe = function (dest) {\n var state = this._readableState;\n var unpipeInfo = { hasUnpiped: false };\n\n // if we're not piping anywhere, then do nothing.\n if (state.pipesCount === 0) return this;\n\n // just one destination. most common case.\n if (state.pipesCount === 1) {\n // passed in one, but it's not the right one.\n if (dest && dest !== state.pipes) return this;\n\n if (!dest) dest = state.pipes;\n\n // got a match.\n state.pipes = null;\n state.pipesCount = 0;\n state.flowing = false;\n if (dest) dest.emit('unpipe', this, unpipeInfo);\n return this;\n }\n\n // slow case. multiple pipe destinations.\n\n if (!dest) {\n // remove all.\n var dests = state.pipes;\n var len = state.pipesCount;\n state.pipes = null;\n state.pipesCount = 0;\n state.flowing = false;\n\n for (var i = 0; i < len; i++) {\n dests[i].emit('unpipe', this, unpipeInfo);\n }return this;\n }\n\n // try to find the right one.\n var index = indexOf(state.pipes, dest);\n if (index === -1) return this;\n\n state.pipes.splice(index, 1);\n state.pipesCount -= 1;\n if (state.pipesCount === 1) state.pipes = state.pipes[0];\n\n dest.emit('unpipe', this, unpipeInfo);\n\n return this;\n};\n\n// set up data events if they are asked for\n// Ensure readable listeners eventually get something\nReadable.prototype.on = function (ev, fn) {\n var res = Stream.prototype.on.call(this, ev, fn);\n\n if (ev === 'data') {\n // Start flowing on next tick if stream isn't explicitly paused\n if (this._readableState.flowing !== false) this.resume();\n } else if (ev === 'readable') {\n var state = this._readableState;\n if (!state.endEmitted && !state.readableListening) {\n state.readableListening = state.needReadable = true;\n state.emittedReadable = false;\n if (!state.reading) {\n processNextTick(nReadingNextTick, this);\n } else if (state.length) {\n emitReadable(this);\n }\n }\n }\n\n return res;\n};\nReadable.prototype.addListener = Readable.prototype.on;\n\nfunction nReadingNextTick(self) {\n debug('readable nexttick read 0');\n self.read(0);\n}\n\n// pause() and resume() are remnants of the legacy readable stream API\n// If the user uses them, then switch into old mode.\nReadable.prototype.resume = function () {\n var state = this._readableState;\n if (!state.flowing) {\n debug('resume');\n state.flowing = true;\n resume(this, state);\n }\n return this;\n};\n\nfunction resume(stream, state) {\n if (!state.resumeScheduled) {\n state.resumeScheduled = true;\n processNextTick(resume_, stream, state);\n }\n}\n\nfunction resume_(stream, state) {\n if (!state.reading) {\n debug('resume read 0');\n stream.read(0);\n }\n\n state.resumeScheduled = false;\n state.awaitDrain = 0;\n stream.emit('resume');\n flow(stream);\n if (state.flowing && !state.reading) stream.read(0);\n}\n\nReadable.prototype.pause = function () {\n debug('call pause flowing=%j', this._readableState.flowing);\n if (false !== this._readableState.flowing) {\n debug('pause');\n this._readableState.flowing = false;\n this.emit('pause');\n }\n return this;\n};\n\nfunction flow(stream) {\n var state = stream._readableState;\n debug('flow', state.flowing);\n while (state.flowing && stream.read() !== null) {}\n}\n\n// wrap an old-style stream as the async data source.\n// This is *not* part of the readable stream interface.\n// It is an ugly unfortunate mess of history.\nReadable.prototype.wrap = function (stream) {\n var state = this._readableState;\n var paused = false;\n\n var self = this;\n stream.on('end', function () {\n debug('wrapped end');\n if (state.decoder && !state.ended) {\n var chunk = state.decoder.end();\n if (chunk && chunk.length) self.push(chunk);\n }\n\n self.push(null);\n });\n\n stream.on('data', function (chunk) {\n debug('wrapped data');\n if (state.decoder) chunk = state.decoder.write(chunk);\n\n // don't skip over falsy values in objectMode\n if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;\n\n var ret = self.push(chunk);\n if (!ret) {\n paused = true;\n stream.pause();\n }\n });\n\n // proxy all the other methods.\n // important when wrapping filters and duplexes.\n for (var i in stream) {\n if (this[i] === undefined && typeof stream[i] === 'function') {\n this[i] = function (method) {\n return function () {\n return stream[method].apply(stream, arguments);\n };\n }(i);\n }\n }\n\n // proxy certain important events.\n for (var n = 0; n < kProxyEvents.length; n++) {\n stream.on(kProxyEvents[n], self.emit.bind(self, kProxyEvents[n]));\n }\n\n // when we try to consume some more bytes, simply unpause the\n // underlying stream.\n self._read = function (n) {\n debug('wrapped _read', n);\n if (paused) {\n paused = false;\n stream.resume();\n }\n };\n\n return self;\n};\n\n// exposed for testing purposes only.\nReadable._fromList = fromList;\n\n// Pluck off n bytes from an array of buffers.\n// Length is the combined lengths of all the buffers in the list.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction fromList(n, state) {\n // nothing buffered\n if (state.length === 0) return null;\n\n var ret;\n if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) {\n // read it all, truncate the list\n if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.head.data;else ret = state.buffer.concat(state.length);\n state.buffer.clear();\n } else {\n // read part of list\n ret = fromListPartial(n, state.buffer, state.decoder);\n }\n\n return ret;\n}\n\n// Extracts only enough buffered data to satisfy the amount requested.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction fromListPartial(n, list, hasStrings) {\n var ret;\n if (n < list.head.data.length) {\n // slice is the same for buffers and strings\n ret = list.head.data.slice(0, n);\n list.head.data = list.head.data.slice(n);\n } else if (n === list.head.data.length) {\n // first chunk is a perfect match\n ret = list.shift();\n } else {\n // result spans more than one buffer\n ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list);\n }\n return ret;\n}\n\n// Copies a specified amount of characters from the list of buffered data\n// chunks.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction copyFromBufferString(n, list) {\n var p = list.head;\n var c = 1;\n var ret = p.data;\n n -= ret.length;\n while (p = p.next) {\n var str = p.data;\n var nb = n > str.length ? str.length : n;\n if (nb === str.length) ret += str;else ret += str.slice(0, n);\n n -= nb;\n if (n === 0) {\n if (nb === str.length) {\n ++c;\n if (p.next) list.head = p.next;else list.head = list.tail = null;\n } else {\n list.head = p;\n p.data = str.slice(nb);\n }\n break;\n }\n ++c;\n }\n list.length -= c;\n return ret;\n}\n\n// Copies a specified amount of bytes from the list of buffered data chunks.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction copyFromBuffer(n, list) {\n var ret = Buffer.allocUnsafe(n);\n var p = list.head;\n var c = 1;\n p.data.copy(ret);\n n -= p.data.length;\n while (p = p.next) {\n var buf = p.data;\n var nb = n > buf.length ? buf.length : n;\n buf.copy(ret, ret.length - n, 0, nb);\n n -= nb;\n if (n === 0) {\n if (nb === buf.length) {\n ++c;\n if (p.next) list.head = p.next;else list.head = list.tail = null;\n } else {\n list.head = p;\n p.data = buf.slice(nb);\n }\n break;\n }\n ++c;\n }\n list.length -= c;\n return ret;\n}\n\nfunction endReadable(stream) {\n var state = stream._readableState;\n\n // If we get here before consuming all the bytes, then that is a\n // bug in node. Should never happen.\n if (state.length > 0) throw new Error('\"endReadable()\" called on non-empty stream');\n\n if (!state.endEmitted) {\n state.ended = true;\n processNextTick(endReadableNT, state, stream);\n }\n}\n\nfunction endReadableNT(state, stream) {\n // Check that we didn't get one last unshift.\n if (!state.endEmitted && state.length === 0) {\n state.endEmitted = true;\n stream.readable = false;\n stream.emit('end');\n }\n}\n\nfunction forEach(xs, f) {\n for (var i = 0, l = xs.length; i < l; i++) {\n f(xs[i], i);\n }\n}\n\nfunction indexOf(xs, x) {\n for (var i = 0, l = xs.length; i < l; i++) {\n if (xs[i] === x) return i;\n }\n return -1;\n}\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(\"DuR2\"), __webpack_require__(\"W2nU\")))\n\n/***/ }),\n\n/***/ \"SDM6\":\n/***/ (function(module, exports, __webpack_require__) {\n\nmodule.exports = __webpack_require__(\"DsFX\");\n\n\n/***/ }),\n\n/***/ \"UcPO\":\n/***/ (function(module, exports, __webpack_require__) {\n\nmodule.exports = __webpack_require__(\"vzCy\").EventEmitter;\n\n\n/***/ }),\n\n/***/ \"V8q2\":\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (immutable) */ __webpack_exports__[\"a\"] = getOSSSignature;\n/* harmony export (immutable) */ __webpack_exports__[\"g\"] = getMediaResoures;\n/* harmony export (immutable) */ __webpack_exports__[\"d\"] = getPackageResoures;\n/* harmony export (immutable) */ __webpack_exports__[\"e\"] = getConfigResoures;\n/* harmony export (immutable) */ __webpack_exports__[\"h\"] = getLogoResoures;\n/* harmony export (immutable) */ __webpack_exports__[\"i\"] = qrcodeResoures;\n/* harmony export (immutable) */ __webpack_exports__[\"b\"] = getImgResoures;\n/* harmony export (immutable) */ __webpack_exports__[\"f\"] = getApkResoures;\n/* harmony export (immutable) */ __webpack_exports__[\"c\"] = getCitys;\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__utils_fetch__ = __webpack_require__(\"Vo7i\");\n//全局通用 数据\n\n\n//获取上传授权\nfunction getOSSSignature(type) {\n return __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0__utils_fetch__[\"a\" /* default */])({\n url: '/unionService/AliOSS/signature',\n method: 'post',\n params: {\n dir: type\n },\n withCredentials: false\n });\n}\n//获取资源下载OSS地址接口\nfunction getMediaResoures() {\n return __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0__utils_fetch__[\"a\" /* default */])({\n url: '/unionService/AliOSS/mediaResource/oss/url',\n method: 'get'\n });\n}\n//获取更新包下载OSS地址接口\nfunction getPackageResoures() {\n return __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0__utils_fetch__[\"a\" /* default */])({\n url: '/unionService/AliOSS/upgradePackage/oss/url',\n method: 'get'\n });\n}\n\n//获取配置下载OSS地址接口\nfunction getConfigResoures() {\n return __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0__utils_fetch__[\"a\" /* default */])({\n url: '/unionService/AliOSS/deviceConfig/oss/url',\n method: 'get'\n });\n}\n//获取配置下载OSS地址接口\nfunction getLogoResoures() {\n return __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0__utils_fetch__[\"a\" /* default */])({\n url: '/unionService/AliOSS/store/logo/oss/url',\n method: 'get'\n });\n}\n//获取支付二维码下载OSS地址接口\nfunction qrcodeResoures() {\n return __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0__utils_fetch__[\"a\" /* default */])({\n url: '/unionService/AliOSS/trade/oss/url',\n method: 'get'\n });\n}\n//获取支付二维码下载OSS地址接口\nfunction getImgResoures() {\n return __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0__utils_fetch__[\"a\" /* default */])({\n url: '/unionService/AliOSS/goods/oss/url',\n method: 'get'\n });\n}\n//获取apk下载OSS地址接口\nfunction getApkResoures() {\n return __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0__utils_fetch__[\"a\" /* default */])({\n url: '/unionService/AliOSS/apk/oss/url',\n method: 'get'\n });\n}\n\n//获取省市\nfunction getCitys(id) {\n return __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0__utils_fetch__[\"a\" /* default */])({\n url: '/service-org/Region/getCitys?parentId=' + id,\n method: 'get'\n });\n}\n\n/***/ }),\n\n/***/ \"X3l8\":\n/***/ (function(module, exports, __webpack_require__) {\n\n/* eslint-disable node/no-deprecated-api */\nvar buffer = __webpack_require__(\"EuP9\")\nvar Buffer = buffer.Buffer\n\n// alternative to using Object.keys for old browsers\nfunction copyProps (src, dst) {\n for (var key in src) {\n dst[key] = src[key]\n }\n}\nif (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {\n module.exports = buffer\n} else {\n // Copy properties from require('buffer')\n copyProps(buffer, exports)\n exports.Buffer = SafeBuffer\n}\n\nfunction SafeBuffer (arg, encodingOrOffset, length) {\n return Buffer(arg, encodingOrOffset, length)\n}\n\n// Copy static methods from Buffer\ncopyProps(Buffer, SafeBuffer)\n\nSafeBuffer.from = function (arg, encodingOrOffset, length) {\n if (typeof arg === 'number') {\n throw new TypeError('Argument must not be a number')\n }\n return Buffer(arg, encodingOrOffset, length)\n}\n\nSafeBuffer.alloc = function (size, fill, encoding) {\n if (typeof size !== 'number') {\n throw new TypeError('Argument must be a number')\n }\n var buf = Buffer(size)\n if (fill !== undefined) {\n if (typeof encoding === 'string') {\n buf.fill(fill, encoding)\n } else {\n buf.fill(fill)\n }\n } else {\n buf.fill(0)\n }\n return buf\n}\n\nSafeBuffer.allocUnsafe = function (size) {\n if (typeof size !== 'number') {\n throw new TypeError('Argument must be a number')\n }\n return Buffer(size)\n}\n\nSafeBuffer.allocUnsafeSlow = function (size) {\n if (typeof size !== 'number') {\n throw new TypeError('Argument must be a number')\n }\n return buffer.SlowBuffer(size)\n}\n\n\n/***/ }),\n\n/***/ \"X4X3\":\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar Buffer = __webpack_require__(\"X3l8\").Buffer;\n\nvar isEncoding = Buffer.isEncoding || function (encoding) {\n encoding = '' + encoding;\n switch (encoding && encoding.toLowerCase()) {\n case 'hex':case 'utf8':case 'utf-8':case 'ascii':case 'binary':case 'base64':case 'ucs2':case 'ucs-2':case 'utf16le':case 'utf-16le':case 'raw':\n return true;\n default:\n return false;\n }\n};\n\nfunction _normalizeEncoding(enc) {\n if (!enc) return 'utf8';\n var retried;\n while (true) {\n switch (enc) {\n case 'utf8':\n case 'utf-8':\n return 'utf8';\n case 'ucs2':\n case 'ucs-2':\n case 'utf16le':\n case 'utf-16le':\n return 'utf16le';\n case 'latin1':\n case 'binary':\n return 'latin1';\n case 'base64':\n case 'ascii':\n case 'hex':\n return enc;\n default:\n if (retried) return; // undefined\n enc = ('' + enc).toLowerCase();\n retried = true;\n }\n }\n};\n\n// Do not cache `Buffer.isEncoding` when checking encoding names as some\n// modules monkey-patch it to support additional encodings\nfunction normalizeEncoding(enc) {\n var nenc = _normalizeEncoding(enc);\n if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc);\n return nenc || enc;\n}\n\n// StringDecoder provides an interface for efficiently splitting a series of\n// buffers into a series of JS strings without breaking apart multi-byte\n// characters.\nexports.StringDecoder = StringDecoder;\nfunction StringDecoder(encoding) {\n this.encoding = normalizeEncoding(encoding);\n var nb;\n switch (this.encoding) {\n case 'utf16le':\n this.text = utf16Text;\n this.end = utf16End;\n nb = 4;\n break;\n case 'utf8':\n this.fillLast = utf8FillLast;\n nb = 4;\n break;\n case 'base64':\n this.text = base64Text;\n this.end = base64End;\n nb = 3;\n break;\n default:\n this.write = simpleWrite;\n this.end = simpleEnd;\n return;\n }\n this.lastNeed = 0;\n this.lastTotal = 0;\n this.lastChar = Buffer.allocUnsafe(nb);\n}\n\nStringDecoder.prototype.write = function (buf) {\n if (buf.length === 0) return '';\n var r;\n var i;\n if (this.lastNeed) {\n r = this.fillLast(buf);\n if (r === undefined) return '';\n i = this.lastNeed;\n this.lastNeed = 0;\n } else {\n i = 0;\n }\n if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);\n return r || '';\n};\n\nStringDecoder.prototype.end = utf8End;\n\n// Returns only complete characters in a Buffer\nStringDecoder.prototype.text = utf8Text;\n\n// Attempts to complete a partial non-UTF-8 character using bytes from a Buffer\nStringDecoder.prototype.fillLast = function (buf) {\n if (this.lastNeed <= buf.length) {\n buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);\n return this.lastChar.toString(this.encoding, 0, this.lastTotal);\n }\n buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);\n this.lastNeed -= buf.length;\n};\n\n// Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a\n// continuation byte.\nfunction utf8CheckByte(byte) {\n if (byte <= 0x7F) return 0;else if (byte >> 5 === 0x06) return 2;else if (byte >> 4 === 0x0E) return 3;else if (byte >> 3 === 0x1E) return 4;\n return -1;\n}\n\n// Checks at most 3 bytes at the end of a Buffer in order to detect an\n// incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4)\n// needed to complete the UTF-8 character (if applicable) are returned.\nfunction utf8CheckIncomplete(self, buf, i) {\n var j = buf.length - 1;\n if (j < i) return 0;\n var nb = utf8CheckByte(buf[j]);\n if (nb >= 0) {\n if (nb > 0) self.lastNeed = nb - 1;\n return nb;\n }\n if (--j < i) return 0;\n nb = utf8CheckByte(buf[j]);\n if (nb >= 0) {\n if (nb > 0) self.lastNeed = nb - 2;\n return nb;\n }\n if (--j < i) return 0;\n nb = utf8CheckByte(buf[j]);\n if (nb >= 0) {\n if (nb > 0) {\n if (nb === 2) nb = 0;else self.lastNeed = nb - 3;\n }\n return nb;\n }\n return 0;\n}\n\n// Validates as many continuation bytes for a multi-byte UTF-8 character as\n// needed or are available. If we see a non-continuation byte where we expect\n// one, we \"replace\" the validated continuation bytes we've seen so far with\n// UTF-8 replacement characters ('\\ufffd'), to match v8's UTF-8 decoding\n// behavior. The continuation byte check is included three times in the case\n// where all of the continuation bytes for a character exist in the same buffer.\n// It is also done this way as a slight performance increase instead of using a\n// loop.\nfunction utf8CheckExtraBytes(self, buf, p) {\n if ((buf[0] & 0xC0) !== 0x80) {\n self.lastNeed = 0;\n return '\\ufffd'.repeat(p);\n }\n if (self.lastNeed > 1 && buf.length > 1) {\n if ((buf[1] & 0xC0) !== 0x80) {\n self.lastNeed = 1;\n return '\\ufffd'.repeat(p + 1);\n }\n if (self.lastNeed > 2 && buf.length > 2) {\n if ((buf[2] & 0xC0) !== 0x80) {\n self.lastNeed = 2;\n return '\\ufffd'.repeat(p + 2);\n }\n }\n }\n}\n\n// Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer.\nfunction utf8FillLast(buf) {\n var p = this.lastTotal - this.lastNeed;\n var r = utf8CheckExtraBytes(this, buf, p);\n if (r !== undefined) return r;\n if (this.lastNeed <= buf.length) {\n buf.copy(this.lastChar, p, 0, this.lastNeed);\n return this.lastChar.toString(this.encoding, 0, this.lastTotal);\n }\n buf.copy(this.lastChar, p, 0, buf.length);\n this.lastNeed -= buf.length;\n}\n\n// Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a\n// partial character, the character's bytes are buffered until the required\n// number of bytes are available.\nfunction utf8Text(buf, i) {\n var total = utf8CheckIncomplete(this, buf, i);\n if (!this.lastNeed) return buf.toString('utf8', i);\n this.lastTotal = total;\n var end = buf.length - (total - this.lastNeed);\n buf.copy(this.lastChar, 0, end);\n return buf.toString('utf8', i, end);\n}\n\n// For UTF-8, a replacement character for each buffered byte of a (partial)\n// character needs to be added to the output.\nfunction utf8End(buf) {\n var r = buf && buf.length ? this.write(buf) : '';\n if (this.lastNeed) return r + '\\ufffd'.repeat(this.lastTotal - this.lastNeed);\n return r;\n}\n\n// UTF-16LE typically needs two bytes per character, but even if we have an even\n// number of bytes available, we need to check if we end on a leading/high\n// surrogate. In that case, we need to wait for the next two bytes in order to\n// decode the last character properly.\nfunction utf16Text(buf, i) {\n if ((buf.length - i) % 2 === 0) {\n var r = buf.toString('utf16le', i);\n if (r) {\n var c = r.charCodeAt(r.length - 1);\n if (c >= 0xD800 && c <= 0xDBFF) {\n this.lastNeed = 2;\n this.lastTotal = 4;\n this.lastChar[0] = buf[buf.length - 2];\n this.lastChar[1] = buf[buf.length - 1];\n return r.slice(0, -1);\n }\n }\n return r;\n }\n this.lastNeed = 1;\n this.lastTotal = 2;\n this.lastChar[0] = buf[buf.length - 1];\n return buf.toString('utf16le', i, buf.length - 1);\n}\n\n// For UTF-16LE we do not explicitly append special replacement characters if we\n// end on a partial character, we simply let v8 handle that.\nfunction utf16End(buf) {\n var r = buf && buf.length ? this.write(buf) : '';\n if (this.lastNeed) {\n var end = this.lastTotal - this.lastNeed;\n return r + this.lastChar.toString('utf16le', 0, end);\n }\n return r;\n}\n\nfunction base64Text(buf, i) {\n var n = (buf.length - i) % 3;\n if (n === 0) return buf.toString('base64', i);\n this.lastNeed = 3 - n;\n this.lastTotal = 3;\n if (n === 1) {\n this.lastChar[0] = buf[buf.length - 1];\n } else {\n this.lastChar[0] = buf[buf.length - 2];\n this.lastChar[1] = buf[buf.length - 1];\n }\n return buf.toString('base64', i, buf.length - n);\n}\n\nfunction base64End(buf) {\n var r = buf && buf.length ? this.write(buf) : '';\n if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed);\n return r;\n}\n\n// Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex)\nfunction simpleWrite(buf) {\n return buf.toString(this.encoding);\n}\n\nfunction simpleEnd(buf) {\n return buf && buf.length ? this.write(buf) : '';\n}\n\n/***/ }),\n\n/***/ \"cSWu\":\n/***/ (function(module, exports, __webpack_require__) {\n\nexports = module.exports = __webpack_require__(\"Rt1F\");\nexports.Stream = exports;\nexports.Readable = exports;\nexports.Writable = __webpack_require__(\"7dSG\");\nexports.Duplex = __webpack_require__(\"DsFX\");\nexports.Transform = __webpack_require__(\"D1Va\");\nexports.PassThrough = __webpack_require__(\"f48b\");\n\n\n/***/ }),\n\n/***/ \"eCz2\":\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(Buffer) {\nvar inherits = __webpack_require__(\"LC74\")\nvar HashBase = __webpack_require__(\"wVeK\")\n\nvar ARRAY16 = new Array(16)\n\nfunction MD5 () {\n HashBase.call(this, 64)\n\n // state\n this._a = 0x67452301\n this._b = 0xefcdab89\n this._c = 0x98badcfe\n this._d = 0x10325476\n}\n\ninherits(MD5, HashBase)\n\nMD5.prototype._update = function () {\n var M = ARRAY16\n for (var i = 0; i < 16; ++i) M[i] = this._block.readInt32LE(i * 4)\n\n var a = this._a\n var b = this._b\n var c = this._c\n var d = this._d\n\n a = fnF(a, b, c, d, M[0], 0xd76aa478, 7)\n d = fnF(d, a, b, c, M[1], 0xe8c7b756, 12)\n c = fnF(c, d, a, b, M[2], 0x242070db, 17)\n b = fnF(b, c, d, a, M[3], 0xc1bdceee, 22)\n a = fnF(a, b, c, d, M[4], 0xf57c0faf, 7)\n d = fnF(d, a, b, c, M[5], 0x4787c62a, 12)\n c = fnF(c, d, a, b, M[6], 0xa8304613, 17)\n b = fnF(b, c, d, a, M[7], 0xfd469501, 22)\n a = fnF(a, b, c, d, M[8], 0x698098d8, 7)\n d = fnF(d, a, b, c, M[9], 0x8b44f7af, 12)\n c = fnF(c, d, a, b, M[10], 0xffff5bb1, 17)\n b = fnF(b, c, d, a, M[11], 0x895cd7be, 22)\n a = fnF(a, b, c, d, M[12], 0x6b901122, 7)\n d = fnF(d, a, b, c, M[13], 0xfd987193, 12)\n c = fnF(c, d, a, b, M[14], 0xa679438e, 17)\n b = fnF(b, c, d, a, M[15], 0x49b40821, 22)\n\n a = fnG(a, b, c, d, M[1], 0xf61e2562, 5)\n d = fnG(d, a, b, c, M[6], 0xc040b340, 9)\n c = fnG(c, d, a, b, M[11], 0x265e5a51, 14)\n b = fnG(b, c, d, a, M[0], 0xe9b6c7aa, 20)\n a = fnG(a, b, c, d, M[5], 0xd62f105d, 5)\n d = fnG(d, a, b, c, M[10], 0x02441453, 9)\n c = fnG(c, d, a, b, M[15], 0xd8a1e681, 14)\n b = fnG(b, c, d, a, M[4], 0xe7d3fbc8, 20)\n a = fnG(a, b, c, d, M[9], 0x21e1cde6, 5)\n d = fnG(d, a, b, c, M[14], 0xc33707d6, 9)\n c = fnG(c, d, a, b, M[3], 0xf4d50d87, 14)\n b = fnG(b, c, d, a, M[8], 0x455a14ed, 20)\n a = fnG(a, b, c, d, M[13], 0xa9e3e905, 5)\n d = fnG(d, a, b, c, M[2], 0xfcefa3f8, 9)\n c = fnG(c, d, a, b, M[7], 0x676f02d9, 14)\n b = fnG(b, c, d, a, M[12], 0x8d2a4c8a, 20)\n\n a = fnH(a, b, c, d, M[5], 0xfffa3942, 4)\n d = fnH(d, a, b, c, M[8], 0x8771f681, 11)\n c = fnH(c, d, a, b, M[11], 0x6d9d6122, 16)\n b = fnH(b, c, d, a, M[14], 0xfde5380c, 23)\n a = fnH(a, b, c, d, M[1], 0xa4beea44, 4)\n d = fnH(d, a, b, c, M[4], 0x4bdecfa9, 11)\n c = fnH(c, d, a, b, M[7], 0xf6bb4b60, 16)\n b = fnH(b, c, d, a, M[10], 0xbebfbc70, 23)\n a = fnH(a, b, c, d, M[13], 0x289b7ec6, 4)\n d = fnH(d, a, b, c, M[0], 0xeaa127fa, 11)\n c = fnH(c, d, a, b, M[3], 0xd4ef3085, 16)\n b = fnH(b, c, d, a, M[6], 0x04881d05, 23)\n a = fnH(a, b, c, d, M[9], 0xd9d4d039, 4)\n d = fnH(d, a, b, c, M[12], 0xe6db99e5, 11)\n c = fnH(c, d, a, b, M[15], 0x1fa27cf8, 16)\n b = fnH(b, c, d, a, M[2], 0xc4ac5665, 23)\n\n a = fnI(a, b, c, d, M[0], 0xf4292244, 6)\n d = fnI(d, a, b, c, M[7], 0x432aff97, 10)\n c = fnI(c, d, a, b, M[14], 0xab9423a7, 15)\n b = fnI(b, c, d, a, M[5], 0xfc93a039, 21)\n a = fnI(a, b, c, d, M[12], 0x655b59c3, 6)\n d = fnI(d, a, b, c, M[3], 0x8f0ccc92, 10)\n c = fnI(c, d, a, b, M[10], 0xffeff47d, 15)\n b = fnI(b, c, d, a, M[1], 0x85845dd1, 21)\n a = fnI(a, b, c, d, M[8], 0x6fa87e4f, 6)\n d = fnI(d, a, b, c, M[15], 0xfe2ce6e0, 10)\n c = fnI(c, d, a, b, M[6], 0xa3014314, 15)\n b = fnI(b, c, d, a, M[13], 0x4e0811a1, 21)\n a = fnI(a, b, c, d, M[4], 0xf7537e82, 6)\n d = fnI(d, a, b, c, M[11], 0xbd3af235, 10)\n c = fnI(c, d, a, b, M[2], 0x2ad7d2bb, 15)\n b = fnI(b, c, d, a, M[9], 0xeb86d391, 21)\n\n this._a = (this._a + a) | 0\n this._b = (this._b + b) | 0\n this._c = (this._c + c) | 0\n this._d = (this._d + d) | 0\n}\n\nMD5.prototype._digest = function () {\n // create padding and handle blocks\n this._block[this._blockOffset++] = 0x80\n if (this._blockOffset > 56) {\n this._block.fill(0, this._blockOffset, 64)\n this._update()\n this._blockOffset = 0\n }\n\n this._block.fill(0, this._blockOffset, 56)\n this._block.writeUInt32LE(this._length[0], 56)\n this._block.writeUInt32LE(this._length[1], 60)\n this._update()\n\n // produce result\n var buffer = new Buffer(16)\n buffer.writeInt32LE(this._a, 0)\n buffer.writeInt32LE(this._b, 4)\n buffer.writeInt32LE(this._c, 8)\n buffer.writeInt32LE(this._d, 12)\n return buffer\n}\n\nfunction rotl (x, n) {\n return (x << n) | (x >>> (32 - n))\n}\n\nfunction fnF (a, b, c, d, m, k, s) {\n return (rotl((a + ((b & c) | ((~b) & d)) + m + k) | 0, s) + b) | 0\n}\n\nfunction fnG (a, b, c, d, m, k, s) {\n return (rotl((a + ((b & d) | (c & (~d))) + m + k) | 0, s) + b) | 0\n}\n\nfunction fnH (a, b, c, d, m, k, s) {\n return (rotl((a + (b ^ c ^ d) + m + k) | 0, s) + b) | 0\n}\n\nfunction fnI (a, b, c, d, m, k, s) {\n return (rotl((a + ((c ^ (b | (~d)))) + m + k) | 0, s) + b) | 0\n}\n\nmodule.exports = MD5\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(\"EuP9\").Buffer))\n\n/***/ }),\n\n/***/ \"f48b\":\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a passthrough stream.\n// basically just the most minimal sort of Transform stream.\n// Every written chunk gets output as-is.\n\n\n\nmodule.exports = PassThrough;\n\nvar Transform = __webpack_require__(\"D1Va\");\n\n/*<replacement>*/\nvar util = __webpack_require__(\"jOgh\");\nutil.inherits = __webpack_require__(\"LC74\");\n/*</replacement>*/\n\nutil.inherits(PassThrough, Transform);\n\nfunction PassThrough(options) {\n if (!(this instanceof PassThrough)) return new PassThrough(options);\n\n Transform.call(this, options);\n}\n\nPassThrough.prototype._transform = function (chunk, encoding, cb) {\n cb(null, chunk);\n};\n\n/***/ }),\n\n/***/ \"fNc5\":\n/***/ (function(module, exports, __webpack_require__) {\n\nexports = module.exports = __webpack_require__(\"FZ+f\")(true);\n// imports\n\n\n// module\nexports.push([module.i, \".el-upload-list{width:50%}\", \"\", {\"version\":3,\"sources\":[\"D:/projects/gitLab/wxpos/posadmin/src/views/ota/version/add.vue\"],\"names\":[],\"mappings\":\"AACA,gBACI,SAAW,CACd\",\"file\":\"add.vue\",\"sourcesContent\":[\"\\n.el-upload-list{\\n width: 50%;\\n}\\n\"],\"sourceRoot\":\"\"}]);\n\n// exports\n\n\n/***/ }),\n\n/***/ \"iP15\":\n/***/ (function(module, exports, __webpack_require__) {\n\n/* WEBPACK VAR INJECTION */(function(global) {\n/**\n * Module exports.\n */\n\nmodule.exports = deprecate;\n\n/**\n * Mark that a method should not be used.\n * Returns a modified function which warns once by default.\n *\n * If `localStorage.noDeprecation = true` is set, then it is a no-op.\n *\n * If `localStorage.throwDeprecation = true` is set, then deprecated functions\n * will throw an Error when invoked.\n *\n * If `localStorage.traceDeprecation = true` is set, then deprecated functions\n * will invoke `console.trace()` instead of `console.error()`.\n *\n * @param {Function} fn - the function to deprecate\n * @param {String} msg - the string to print to the console when `fn` is invoked\n * @returns {Function} a new \"deprecated\" version of `fn`\n * @api public\n */\n\nfunction deprecate (fn, msg) {\n if (config('noDeprecation')) {\n return fn;\n }\n\n var warned = false;\n function deprecated() {\n if (!warned) {\n if (config('throwDeprecation')) {\n throw new Error(msg);\n } else if (config('traceDeprecation')) {\n console.trace(msg);\n } else {\n console.warn(msg);\n }\n warned = true;\n }\n return fn.apply(this, arguments);\n }\n\n return deprecated;\n}\n\n/**\n * Checks `localStorage` for boolean values for the given `name`.\n *\n * @param {String} name\n * @returns {Boolean}\n * @api private\n */\n\nfunction config (name) {\n // accessing global.localStorage can trigger a DOMException in sandboxed iframes\n try {\n if (!global.localStorage) return false;\n } catch (_) {\n return false;\n }\n var val = global.localStorage[name];\n if (null == val) return false;\n return String(val).toLowerCase() === 'true';\n}\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(\"DuR2\")))\n\n/***/ }),\n\n/***/ \"iVxu\":\n/***/ (function(module, exports, __webpack_require__) {\n\nmodule.exports = __webpack_require__(\"CBWy\");\n\n\n/***/ }),\n\n/***/ \"jOgh\":\n/***/ (function(module, exports, __webpack_require__) {\n\n/* WEBPACK VAR INJECTION */(function(Buffer) {// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// NOTE: These type checking functions intentionally don't use `instanceof`\n// because it is fragile and can be easily faked with `Object.create()`.\n\nfunction isArray(arg) {\n if (Array.isArray) {\n return Array.isArray(arg);\n }\n return objectToString(arg) === '[object Array]';\n}\nexports.isArray = isArray;\n\nfunction isBoolean(arg) {\n return typeof arg === 'boolean';\n}\nexports.isBoolean = isBoolean;\n\nfunction isNull(arg) {\n return arg === null;\n}\nexports.isNull = isNull;\n\nfunction isNullOrUndefined(arg) {\n return arg == null;\n}\nexports.isNullOrUndefined = isNullOrUndefined;\n\nfunction isNumber(arg) {\n return typeof arg === 'number';\n}\nexports.isNumber = isNumber;\n\nfunction isString(arg) {\n return typeof arg === 'string';\n}\nexports.isString = isString;\n\nfunction isSymbol(arg) {\n return typeof arg === 'symbol';\n}\nexports.isSymbol = isSymbol;\n\nfunction isUndefined(arg) {\n return arg === void 0;\n}\nexports.isUndefined = isUndefined;\n\nfunction isRegExp(re) {\n return objectToString(re) === '[object RegExp]';\n}\nexports.isRegExp = isRegExp;\n\nfunction isObject(arg) {\n return typeof arg === 'object' && arg !== null;\n}\nexports.isObject = isObject;\n\nfunction isDate(d) {\n return objectToString(d) === '[object Date]';\n}\nexports.isDate = isDate;\n\nfunction isError(e) {\n return (objectToString(e) === '[object Error]' || e instanceof Error);\n}\nexports.isError = isError;\n\nfunction isFunction(arg) {\n return typeof arg === 'function';\n}\nexports.isFunction = isFunction;\n\nfunction isPrimitive(arg) {\n return arg === null ||\n typeof arg === 'boolean' ||\n typeof arg === 'number' ||\n typeof arg === 'string' ||\n typeof arg === 'symbol' || // ES6 symbol\n typeof arg === 'undefined';\n}\nexports.isPrimitive = isPrimitive;\n\nexports.isBuffer = Buffer.isBuffer;\n\nfunction objectToString(o) {\n return Object.prototype.toString.call(o);\n}\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(\"EuP9\").Buffer))\n\n/***/ }),\n\n/***/ \"t7x4\":\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__api_comm__ = __webpack_require__(\"V8q2\");\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__api_ota_version__ = __webpack_require__(\"3eLu\");\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_md5_js__ = __webpack_require__(\"eCz2\");\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_md5_js___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_md5_js__);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_browser_md5_file__ = __webpack_require__(\"iVxu\");\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_browser_md5_file___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_browser_md5_file__);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_element_ui__ = __webpack_require__(\"zL8q\");\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_element_ui___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_element_ui__);\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n\n\n\n\n\n\n\n/* harmony default export */ __webpack_exports__[\"a\"] = ({\n created: function created() {\n var _this = this;\n\n //上传签名初始化\n __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0__api_comm__[\"a\" /* getOSSSignature */])(\"otadev\").then(function (response) {\n _this.updata.data.policy = response.result.policy;\n _this.updata.data.OSSAccessKeyId = response.result.accessid;\n _this.updata.data.success_action_status = '200';\n _this.updata.data.signature = response.result.signature;\n _this.updata.url = response.result.host;\n });\n __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0__api_comm__[\"d\" /* getPackageResoures */])().then(function (res) {\n _this.mediaUrl = res.result;\n });\n },\n data: function data() {\n return {\n fileList: [],\n loadingInstance: null,\n options: [{\n value: '0',\n label: '增量包'\n }, {\n value: '1',\n label: '全量包'\n }],\n ruleForm: {\n fileName: '',\n filePath: '',\n md5Code: '',\n fileSize: '',\n versionCode: '',\n manufacturer: '',\n deviceType: '',\n deviceModel: '',\n customer: '',\n fileType: '',\n releaseNote: ''\n },\n rules: {\n versionCode: [{ required: true, message: '请输入版本', trigger: 'blur' }],\n fileType: [{ required: true, message: '请上选择包类型', trigger: 'blur' }]\n },\n updata: {\n url: '',\n data: {}\n },\n selected: [],\n mediaUrl: ''\n };\n },\n\n methods: {\n handleRemove: function handleRemove(file, fileList) {\n this.ruleForm = {\n fileName: '',\n filePath: '',\n md5Code: '',\n fileSize: '',\n versionCode: '',\n manufacturer: '',\n deviceType: '',\n deviceModel: '',\n customer: '',\n fileType: '',\n releaseNote: ''\n };\n },\n submitForm: function submitForm(formName) {\n var _this2 = this;\n\n this.$refs[formName].validate(function (valid) {\n if (valid) {\n __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_1__api_ota_version__[\"d\" /* versionAdd */])(_this2.ruleForm).then(function (res) {\n var router = _this2.$router;\n _this2.$message({\n message: '操作成功',\n type: 'success',\n duration: 1000,\n onClose: function onClose() {\n router.push({ path: 'index' });\n }\n });\n });\n } else {\n return false;\n }\n });\n },\n resetForm: function resetForm(formName) {\n this.$refs[formName].resetFields();\n },\n handleAvatarSuccess: function handleAvatarSuccess(res, file) {\n console.log(file);\n this.ruleForm.fileName = file.name;\n this.ruleForm.filePath = this.mediaUrl;\n\n // this.ruleForm.md5Code = new MD5().update(file.name).digest('hex')\n this.ruleForm.fileSize = file.size;\n // this.loadingInstance.close()\n this.fileList = [];\n },\n beforeAvatarUpload: function beforeAvatarUpload(file) {\n\n var fileName = file.name;\n var versionCode = '';\n var packageType = this.findPackageType(fileName);\n if (packageType == \"zeng\") {\n //获取增量包版本号 ota-user-2.0.312-344.zip\n versionCode = fileName.split(\"-\")[2].split(\".\")[0] + \".\" + fileName.split(\"-\")[2].split(\".\")[1] + \".\" + fileName.split(\"-\")[3].split(\".\")[0];\n } else if (packageType == \"quan\") {\n //获取全量包版本号 rk3288-ota-user.root.2.0.344.zip\n versionCode = fileName.split(\".\")[2] + \".\" + fileName.split(\".\")[3] + \".\" + fileName.split(\".\")[4];\n } else {\n //PDA\n versionCode = \"1.0.\" + fileName.substring(0, fileName.lastIndexOf(\".\")).split(\"#\")[1];\n }\n if (versionCode.indexOf(\"undefined\") >= 0) {\n this.$message.error('包名称错误!');\n return false;\n }\n //上传文件命名\n this.updata.data.key = \"otadev/\" + file.name;\n this.ruleForm.versionCode = versionCode;\n var ruleForm = this.ruleForm;\n __WEBPACK_IMPORTED_MODULE_3_browser_md5_file___default()(file, function (err, md5) {\n ruleForm.md5Code = md5; // 97027eb624f85892c69c4bcec8ab0f11\n });\n // this.loadingInstance = Loading.service({\n // fullscreen: true,\n // text: '上传中...',\n // spinner: 'el-icon-loading',\n // background: 'rgba(0, 0, 0, 0.7)'\n // });\n\n return true;\n },\n\n //判断上传版本的文件是增量包还是全量包\n findPackageType: function findPackageType(packageName) {\n if (packageName.indexOf(\"#\") >= 0) {\n return \"pda\";\n }\n var packageNameArray = packageName.split(\".\");\n //获得除了.zip前一位截取的字符串是否包含\"-\",如果有就代表是增量包\n if (packageNameArray[packageNameArray.length - 2].indexOf(\"-\") >= 0) {\n return \"zeng\";\n } else {\n return \"quan\";\n }\n }\n }\n});\n\n/***/ }),\n\n/***/ \"vzCy\":\n/***/ (function(module, exports) {\n\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nfunction EventEmitter() {\n this._events = this._events || {};\n this._maxListeners = this._maxListeners || undefined;\n}\nmodule.exports = EventEmitter;\n\n// Backwards-compat with node 0.10.x\nEventEmitter.EventEmitter = EventEmitter;\n\nEventEmitter.prototype._events = undefined;\nEventEmitter.prototype._maxListeners = undefined;\n\n// By default EventEmitters will print a warning if more than 10 listeners are\n// added to it. This is a useful default which helps finding memory leaks.\nEventEmitter.defaultMaxListeners = 10;\n\n// Obviously not all Emitters should be limited to 10. This function allows\n// that to be increased. Set to zero for unlimited.\nEventEmitter.prototype.setMaxListeners = function(n) {\n if (!isNumber(n) || n < 0 || isNaN(n))\n throw TypeError('n must be a positive number');\n this._maxListeners = n;\n return this;\n};\n\nEventEmitter.prototype.emit = function(type) {\n var er, handler, len, args, i, listeners;\n\n if (!this._events)\n this._events = {};\n\n // If there is no 'error' event listener then throw.\n if (type === 'error') {\n if (!this._events.error ||\n (isObject(this._events.error) && !this._events.error.length)) {\n er = arguments[1];\n if (er instanceof Error) {\n throw er; // Unhandled 'error' event\n } else {\n // At least give some kind of context to the user\n var err = new Error('Uncaught, unspecified \"error\" event. (' + er + ')');\n err.context = er;\n throw err;\n }\n }\n }\n\n handler = this._events[type];\n\n if (isUndefined(handler))\n return false;\n\n if (isFunction(handler)) {\n switch (arguments.length) {\n // fast cases\n case 1:\n handler.call(this);\n break;\n case 2:\n handler.call(this, arguments[1]);\n break;\n case 3:\n handler.call(this, arguments[1], arguments[2]);\n break;\n // slower\n default:\n args = Array.prototype.slice.call(arguments, 1);\n handler.apply(this, args);\n }\n } else if (isObject(handler)) {\n args = Array.prototype.slice.call(arguments, 1);\n listeners = handler.slice();\n len = listeners.length;\n for (i = 0; i < len; i++)\n listeners[i].apply(this, args);\n }\n\n return true;\n};\n\nEventEmitter.prototype.addListener = function(type, listener) {\n var m;\n\n if (!isFunction(listener))\n throw TypeError('listener must be a function');\n\n if (!this._events)\n this._events = {};\n\n // To avoid recursion in the case that type === \"newListener\"! Before\n // adding it to the listeners, first emit \"newListener\".\n if (this._events.newListener)\n this.emit('newListener', type,\n isFunction(listener.listener) ?\n listener.listener : listener);\n\n if (!this._events[type])\n // Optimize the case of one listener. Don't need the extra array object.\n this._events[type] = listener;\n else if (isObject(this._events[type]))\n // If we've already got an array, just append.\n this._events[type].push(listener);\n else\n // Adding the second element, need to change to array.\n this._events[type] = [this._events[type], listener];\n\n // Check for listener leak\n if (isObject(this._events[type]) && !this._events[type].warned) {\n if (!isUndefined(this._maxListeners)) {\n m = this._maxListeners;\n } else {\n m = EventEmitter.defaultMaxListeners;\n }\n\n if (m && m > 0 && this._events[type].length > m) {\n this._events[type].warned = true;\n console.error('(node) warning: possible EventEmitter memory ' +\n 'leak detected. %d listeners added. ' +\n 'Use emitter.setMaxListeners() to increase limit.',\n this._events[type].length);\n if (typeof console.trace === 'function') {\n // not supported in IE 10\n console.trace();\n }\n }\n }\n\n return this;\n};\n\nEventEmitter.prototype.on = EventEmitter.prototype.addListener;\n\nEventEmitter.prototype.once = function(type, listener) {\n if (!isFunction(listener))\n throw TypeError('listener must be a function');\n\n var fired = false;\n\n function g() {\n this.removeListener(type, g);\n\n if (!fired) {\n fired = true;\n listener.apply(this, arguments);\n }\n }\n\n g.listener = listener;\n this.on(type, g);\n\n return this;\n};\n\n// emits a 'removeListener' event iff the listener was removed\nEventEmitter.prototype.removeListener = function(type, listener) {\n var list, position, length, i;\n\n if (!isFunction(listener))\n throw TypeError('listener must be a function');\n\n if (!this._events || !this._events[type])\n return this;\n\n list = this._events[type];\n length = list.length;\n position = -1;\n\n if (list === listener ||\n (isFunction(list.listener) && list.listener === listener)) {\n delete this._events[type];\n if (this._events.removeListener)\n this.emit('removeListener', type, listener);\n\n } else if (isObject(list)) {\n for (i = length; i-- > 0;) {\n if (list[i] === listener ||\n (list[i].listener && list[i].listener === listener)) {\n position = i;\n break;\n }\n }\n\n if (position < 0)\n return this;\n\n if (list.length === 1) {\n list.length = 0;\n delete this._events[type];\n } else {\n list.splice(position, 1);\n }\n\n if (this._events.removeListener)\n this.emit('removeListener', type, listener);\n }\n\n return this;\n};\n\nEventEmitter.prototype.removeAllListeners = function(type) {\n var key, listeners;\n\n if (!this._events)\n return this;\n\n // not listening for removeListener, no need to emit\n if (!this._events.removeListener) {\n if (arguments.length === 0)\n this._events = {};\n else if (this._events[type])\n delete this._events[type];\n return this;\n }\n\n // emit removeListener for all listeners on all events\n if (arguments.length === 0) {\n for (key in this._events) {\n if (key === 'removeListener') continue;\n this.removeAllListeners(key);\n }\n this.removeAllListeners('removeListener');\n this._events = {};\n return this;\n }\n\n listeners = this._events[type];\n\n if (isFunction(listeners)) {\n this.removeListener(type, listeners);\n } else if (listeners) {\n // LIFO order\n while (listeners.length)\n this.removeListener(type, listeners[listeners.length - 1]);\n }\n delete this._events[type];\n\n return this;\n};\n\nEventEmitter.prototype.listeners = function(type) {\n var ret;\n if (!this._events || !this._events[type])\n ret = [];\n else if (isFunction(this._events[type]))\n ret = [this._events[type]];\n else\n ret = this._events[type].slice();\n return ret;\n};\n\nEventEmitter.prototype.listenerCount = function(type) {\n if (this._events) {\n var evlistener = this._events[type];\n\n if (isFunction(evlistener))\n return 1;\n else if (evlistener)\n return evlistener.length;\n }\n return 0;\n};\n\nEventEmitter.listenerCount = function(emitter, type) {\n return emitter.listenerCount(type);\n};\n\nfunction isFunction(arg) {\n return typeof arg === 'function';\n}\n\nfunction isNumber(arg) {\n return typeof arg === 'number';\n}\n\nfunction isObject(arg) {\n return typeof arg === 'object' && arg !== null;\n}\n\nfunction isUndefined(arg) {\n return arg === void 0;\n}\n\n\n/***/ }),\n\n/***/ \"wVeK\":\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar Buffer = __webpack_require__(\"X3l8\").Buffer\nvar Transform = __webpack_require__(\"9DG0\").Transform\nvar inherits = __webpack_require__(\"LC74\")\n\nfunction throwIfNotStringOrBuffer (val, prefix) {\n if (!Buffer.isBuffer(val) && typeof val !== 'string') {\n throw new TypeError(prefix + ' must be a string or a buffer')\n }\n}\n\nfunction HashBase (blockSize) {\n Transform.call(this)\n\n this._block = Buffer.allocUnsafe(blockSize)\n this._blockSize = blockSize\n this._blockOffset = 0\n this._length = [0, 0, 0, 0]\n\n this._finalized = false\n}\n\ninherits(HashBase, Transform)\n\nHashBase.prototype._transform = function (chunk, encoding, callback) {\n var error = null\n try {\n this.update(chunk, encoding)\n } catch (err) {\n error = err\n }\n\n callback(error)\n}\n\nHashBase.prototype._flush = function (callback) {\n var error = null\n try {\n this.push(this.digest())\n } catch (err) {\n error = err\n }\n\n callback(error)\n}\n\nHashBase.prototype.update = function (data, encoding) {\n throwIfNotStringOrBuffer(data, 'Data')\n if (this._finalized) throw new Error('Digest already called')\n if (!Buffer.isBuffer(data)) data = Buffer.from(data, encoding)\n\n // consume data\n var block = this._block\n var offset = 0\n while (this._blockOffset + data.length - offset >= this._blockSize) {\n for (var i = this._blockOffset; i < this._blockSize;) block[i++] = data[offset++]\n this._update()\n this._blockOffset = 0\n }\n while (offset < data.length) block[this._blockOffset++] = data[offset++]\n\n // update length\n for (var j = 0, carry = data.length * 8; carry > 0; ++j) {\n this._length[j] += carry\n carry = (this._length[j] / 0x0100000000) | 0\n if (carry > 0) this._length[j] -= 0x0100000000 * carry\n }\n\n return this\n}\n\nHashBase.prototype._update = function () {\n throw new Error('_update is not implemented')\n}\n\nHashBase.prototype.digest = function (encoding) {\n if (this._finalized) throw new Error('Digest already called')\n this._finalized = true\n\n var digest = this._digest()\n if (encoding !== undefined) digest = digest.toString(encoding)\n\n // reset state\n this._block.fill(0)\n this._blockOffset = 0\n for (var i = 0; i < 4; ++i) this._length[i] = 0\n\n return digest\n}\n\nHashBase.prototype._digest = function () {\n throw new Error('_digest is not implemented')\n}\n\nmodule.exports = HashBase\n\n\n/***/ }),\n\n/***/ \"x0Ha\":\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n/*<replacement>*/\n\nvar processNextTick = __webpack_require__(\"ypnx\");\n/*</replacement>*/\n\n// undocumented cb() API, needed for core, not for public API\nfunction destroy(err, cb) {\n var _this = this;\n\n var readableDestroyed = this._readableState && this._readableState.destroyed;\n var writableDestroyed = this._writableState && this._writableState.destroyed;\n\n if (readableDestroyed || writableDestroyed) {\n if (cb) {\n cb(err);\n } else if (err && (!this._writableState || !this._writableState.errorEmitted)) {\n processNextTick(emitErrorNT, this, err);\n }\n return;\n }\n\n // we set destroyed to true before firing error callbacks in order\n // to make it re-entrance safe in case destroy() is called within callbacks\n\n if (this._readableState) {\n this._readableState.destroyed = true;\n }\n\n // if this is a duplex stream mark the writable part as destroyed as well\n if (this._writableState) {\n this._writableState.destroyed = true;\n }\n\n this._destroy(err || null, function (err) {\n if (!cb && err) {\n processNextTick(emitErrorNT, _this, err);\n if (_this._writableState) {\n _this._writableState.errorEmitted = true;\n }\n } else if (cb) {\n cb(err);\n }\n });\n}\n\nfunction undestroy() {\n if (this._readableState) {\n this._readableState.destroyed = false;\n this._readableState.reading = false;\n this._readableState.ended = false;\n this._readableState.endEmitted = false;\n }\n\n if (this._writableState) {\n this._writableState.destroyed = false;\n this._writableState.ended = false;\n this._writableState.ending = false;\n this._writableState.finished = false;\n this._writableState.errorEmitted = false;\n }\n}\n\nfunction emitErrorNT(self, err) {\n self.emit('error', err);\n}\n\nmodule.exports = {\n destroy: destroy,\n undestroy: undestroy\n};\n\n/***/ }),\n\n/***/ \"ypnx\":\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(process) {\n\nif (!process.version ||\n process.version.indexOf('v0.') === 0 ||\n process.version.indexOf('v1.') === 0 && process.version.indexOf('v1.8.') !== 0) {\n module.exports = nextTick;\n} else {\n module.exports = process.nextTick;\n}\n\nfunction nextTick(fn, arg1, arg2, arg3) {\n if (typeof fn !== 'function') {\n throw new TypeError('\"callback\" argument must be a function');\n }\n var len = arguments.length;\n var args, i;\n switch (len) {\n case 0:\n case 1:\n return process.nextTick(fn);\n case 2:\n return process.nextTick(function afterTickOne() {\n fn.call(null, arg1);\n });\n case 3:\n return process.nextTick(function afterTickTwo() {\n fn.call(null, arg1, arg2);\n });\n case 4:\n return process.nextTick(function afterTickThree() {\n fn.call(null, arg1, arg2, arg3);\n });\n default:\n args = new Array(len - 1);\n i = 0;\n while (i < args.length) {\n args[i++] = arguments[i];\n }\n return process.nextTick(function afterTick() {\n fn.apply(null, args);\n });\n }\n}\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(\"W2nU\")))\n\n/***/ }),\n\n/***/ \"yq/Z\":\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\nObject.defineProperty(__webpack_exports__, \"__esModule\", { value: true });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__babel_loader_node_modules_vue_loader_lib_selector_type_script_index_0_add_vue__ = __webpack_require__(\"t7x4\");\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__node_modules_vue_loader_lib_template_compiler_index_id_data_v_94cc7036_hasScoped_false_node_modules_vue_loader_lib_selector_type_template_index_0_add_vue__ = __webpack_require__(\"9bCr\");\nfunction injectStyle (ssrContext) {\n __webpack_require__(\"4lE3\")\n}\nvar normalizeComponent = __webpack_require__(\"VU/8\")\n/* script */\n\n/* template */\n\n/* styles */\nvar __vue_styles__ = injectStyle\n/* scopeId */\nvar __vue_scopeId__ = null\n/* moduleIdentifier (server only) */\nvar __vue_module_identifier__ = null\nvar Component = normalizeComponent(\n __WEBPACK_IMPORTED_MODULE_0__babel_loader_node_modules_vue_loader_lib_selector_type_script_index_0_add_vue__[\"a\" /* default */],\n __WEBPACK_IMPORTED_MODULE_1__node_modules_vue_loader_lib_template_compiler_index_id_data_v_94cc7036_hasScoped_false_node_modules_vue_loader_lib_selector_type_template_index_0_add_vue__[\"a\" /* default */],\n __vue_styles__,\n __vue_scopeId__,\n __vue_module_identifier__\n)\n\n/* harmony default export */ __webpack_exports__[\"default\"] = (Component.exports);\n\n\n/***/ })\n\n});\n\n\n// WEBPACK FOOTER //\n// static/js/2.45ccce1cdc165fb5bb8d.js","'use strict';\n\n/*<replacement>*/\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar Buffer = require('safe-buffer').Buffer;\n/*</replacement>*/\n\nfunction copyBuffer(src, target, offset) {\n src.copy(target, offset);\n}\n\nmodule.exports = function () {\n function BufferList() {\n _classCallCheck(this, BufferList);\n\n this.head = null;\n this.tail = null;\n this.length = 0;\n }\n\n BufferList.prototype.push = function push(v) {\n var entry = { data: v, next: null };\n if (this.length > 0) this.tail.next = entry;else this.head = entry;\n this.tail = entry;\n ++this.length;\n };\n\n BufferList.prototype.unshift = function unshift(v) {\n var entry = { data: v, next: this.head };\n if (this.length === 0) this.tail = entry;\n this.head = entry;\n ++this.length;\n };\n\n BufferList.prototype.shift = function shift() {\n if (this.length === 0) return;\n var ret = this.head.data;\n if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next;\n --this.length;\n return ret;\n };\n\n BufferList.prototype.clear = function clear() {\n this.head = this.tail = null;\n this.length = 0;\n };\n\n BufferList.prototype.join = function join(s) {\n if (this.length === 0) return '';\n var p = this.head;\n var ret = '' + p.data;\n while (p = p.next) {\n ret += s + p.data;\n }return ret;\n };\n\n BufferList.prototype.concat = function concat(n) {\n if (this.length === 0) return Buffer.alloc(0);\n if (this.length === 1) return this.head.data;\n var ret = Buffer.allocUnsafe(n >>> 0);\n var p = this.head;\n var i = 0;\n while (p) {\n copyBuffer(p.data, ret, i);\n i += p.data.length;\n p = p.next;\n }\n return ret;\n };\n\n return BufferList;\n}();\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/readable-stream/lib/internal/streams/BufferList.js\n// module id = +HRN\n// module chunks = 2","module.exports = require('./readable').PassThrough\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/readable-stream/passthrough.js\n// module id = /MLu\n// module chunks = 2","import fetch from '@/utils/fetch'\r\n\r\n//列表\r\nexport function versionList(params) {\r\n return fetch({\r\n url: '/service-ota/upgradePackages',\r\n method: 'post',\r\n data: params\r\n })\r\n}\r\n\r\n//添加\r\nexport function versionAdd(params) {\r\n return fetch({\r\n url: '/service-ota/upgradePackage',\r\n method: 'post',\r\n data: params\r\n })\r\n}\r\n\r\n//修改状态\r\nexport function versionUpdatestatus(params) {\r\n return fetch({\r\n url: '/service-ota/upgradePackage',\r\n method: 'delete',\r\n data: params,\r\n // params: params\r\n })\r\n}//删除版本\r\nexport function versionDel(id) {\r\n return fetch({\r\n url: '/service-ota/upgradePackage/'+id,\r\n method: 'delete',\r\n })\r\n}\n\n\n// WEBPACK FOOTER //\n// ./src/api/ota/version.js","module.exports = require('./readable').Transform\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/readable-stream/transform.js\n// module id = 4/4u\n// module chunks = 2","// style-loader: Adds some css to the DOM by adding a <style> tag\n\n// load the styles\nvar content = require(\"!!../../../../node_modules/css-loader/index.js?{\\\"minimize\\\":true,\\\"sourceMap\\\":true}!../../../../node_modules/vue-loader/lib/style-compiler/index.js?{\\\"vue\\\":true,\\\"id\\\":\\\"data-v-94cc7036\\\",\\\"scoped\\\":false,\\\"hasInlineConfig\\\":false}!../../../../node_modules/vue-loader/lib/selector.js?type=styles&index=0!./add.vue\");\nif(typeof content === 'string') content = [[module.id, content, '']];\nif(content.locals) module.exports = content.locals;\n// add the styles to the DOM\nvar update = require(\"!../../../../node_modules/vue-style-loader/lib/addStylesClient.js\")(\"aad91ca2\", content, true);\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/extract-text-webpack-plugin/loader.js?{\"omit\":1,\"remove\":true}!./~/vue-style-loader!./~/css-loader?{\"minimize\":true,\"sourceMap\":true}!./~/vue-loader/lib/style-compiler?{\"vue\":true,\"id\":\"data-v-94cc7036\",\"scoped\":false,\"hasInlineConfig\":false}!./~/vue-loader/lib/selector.js?type=styles&index=0!./src/views/ota/version/add.vue\n// module id = 4lE3\n// module chunks = 2","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// A bit simpler than readable streams.\n// Implement an async ._write(chunk, encoding, cb), and it'll handle all\n// the drain event emission and buffering.\n\n'use strict';\n\n/*<replacement>*/\n\nvar processNextTick = require('process-nextick-args');\n/*</replacement>*/\n\nmodule.exports = Writable;\n\n/* <replacement> */\nfunction WriteReq(chunk, encoding, cb) {\n this.chunk = chunk;\n this.encoding = encoding;\n this.callback = cb;\n this.next = null;\n}\n\n// It seems a linked list but it is not\n// there will be only 2 of these for each stream\nfunction CorkedRequest(state) {\n var _this = this;\n\n this.next = null;\n this.entry = null;\n this.finish = function () {\n onCorkedFinish(_this, state);\n };\n}\n/* </replacement> */\n\n/*<replacement>*/\nvar asyncWrite = !process.browser && ['v0.10', 'v0.9.'].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : processNextTick;\n/*</replacement>*/\n\n/*<replacement>*/\nvar Duplex;\n/*</replacement>*/\n\nWritable.WritableState = WritableState;\n\n/*<replacement>*/\nvar util = require('core-util-is');\nutil.inherits = require('inherits');\n/*</replacement>*/\n\n/*<replacement>*/\nvar internalUtil = {\n deprecate: require('util-deprecate')\n};\n/*</replacement>*/\n\n/*<replacement>*/\nvar Stream = require('./internal/streams/stream');\n/*</replacement>*/\n\n/*<replacement>*/\nvar Buffer = require('safe-buffer').Buffer;\nvar OurUint8Array = global.Uint8Array || function () {};\nfunction _uint8ArrayToBuffer(chunk) {\n return Buffer.from(chunk);\n}\nfunction _isUint8Array(obj) {\n return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n/*</replacement>*/\n\nvar destroyImpl = require('./internal/streams/destroy');\n\nutil.inherits(Writable, Stream);\n\nfunction nop() {}\n\nfunction WritableState(options, stream) {\n Duplex = Duplex || require('./_stream_duplex');\n\n options = options || {};\n\n // object stream flag to indicate whether or not this stream\n // contains buffers or objects.\n this.objectMode = !!options.objectMode;\n\n if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.writableObjectMode;\n\n // the point at which write() starts returning false\n // Note: 0 is a valid value, means that we always return false if\n // the entire buffer is not flushed immediately on write()\n var hwm = options.highWaterMark;\n var defaultHwm = this.objectMode ? 16 : 16 * 1024;\n this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm;\n\n // cast to ints.\n this.highWaterMark = Math.floor(this.highWaterMark);\n\n // if _final has been called\n this.finalCalled = false;\n\n // drain event flag.\n this.needDrain = false;\n // at the start of calling end()\n this.ending = false;\n // when end() has been called, and returned\n this.ended = false;\n // when 'finish' is emitted\n this.finished = false;\n\n // has it been destroyed\n this.destroyed = false;\n\n // should we decode strings into buffers before passing to _write?\n // this is here so that some node-core streams can optimize string\n // handling at a lower level.\n var noDecode = options.decodeStrings === false;\n this.decodeStrings = !noDecode;\n\n // Crypto is kind of old and crusty. Historically, its default string\n // encoding is 'binary' so we have to make this configurable.\n // Everything else in the universe uses 'utf8', though.\n this.defaultEncoding = options.defaultEncoding || 'utf8';\n\n // not an actual buffer we keep track of, but a measurement\n // of how much we're waiting to get pushed to some underlying\n // socket or file.\n this.length = 0;\n\n // a flag to see when we're in the middle of a write.\n this.writing = false;\n\n // when true all writes will be buffered until .uncork() call\n this.corked = 0;\n\n // a flag to be able to tell if the onwrite cb is called immediately,\n // or on a later tick. We set this to true at first, because any\n // actions that shouldn't happen until \"later\" should generally also\n // not happen before the first write call.\n this.sync = true;\n\n // a flag to know if we're processing previously buffered items, which\n // may call the _write() callback in the same tick, so that we don't\n // end up in an overlapped onwrite situation.\n this.bufferProcessing = false;\n\n // the callback that's passed to _write(chunk,cb)\n this.onwrite = function (er) {\n onwrite(stream, er);\n };\n\n // the callback that the user supplies to write(chunk,encoding,cb)\n this.writecb = null;\n\n // the amount that is being written when _write is called.\n this.writelen = 0;\n\n this.bufferedRequest = null;\n this.lastBufferedRequest = null;\n\n // number of pending user-supplied write callbacks\n // this must be 0 before 'finish' can be emitted\n this.pendingcb = 0;\n\n // emit prefinish if the only thing we're waiting for is _write cbs\n // This is relevant for synchronous Transform streams\n this.prefinished = false;\n\n // True if the error was already emitted and should not be thrown again\n this.errorEmitted = false;\n\n // count buffered requests\n this.bufferedRequestCount = 0;\n\n // allocate the first CorkedRequest, there is always\n // one allocated and free to use, and we maintain at most two\n this.corkedRequestsFree = new CorkedRequest(this);\n}\n\nWritableState.prototype.getBuffer = function getBuffer() {\n var current = this.bufferedRequest;\n var out = [];\n while (current) {\n out.push(current);\n current = current.next;\n }\n return out;\n};\n\n(function () {\n try {\n Object.defineProperty(WritableState.prototype, 'buffer', {\n get: internalUtil.deprecate(function () {\n return this.getBuffer();\n }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')\n });\n } catch (_) {}\n})();\n\n// Test _writableState for inheritance to account for Duplex streams,\n// whose prototype chain only points to Readable.\nvar realHasInstance;\nif (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {\n realHasInstance = Function.prototype[Symbol.hasInstance];\n Object.defineProperty(Writable, Symbol.hasInstance, {\n value: function (object) {\n if (realHasInstance.call(this, object)) return true;\n\n return object && object._writableState instanceof WritableState;\n }\n });\n} else {\n realHasInstance = function (object) {\n return object instanceof this;\n };\n}\n\nfunction Writable(options) {\n Duplex = Duplex || require('./_stream_duplex');\n\n // Writable ctor is applied to Duplexes, too.\n // `realHasInstance` is necessary because using plain `instanceof`\n // would return false, as no `_writableState` property is attached.\n\n // Trying to use the custom `instanceof` for Writable here will also break the\n // Node.js LazyTransform implementation, which has a non-trivial getter for\n // `_writableState` that would lead to infinite recursion.\n if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) {\n return new Writable(options);\n }\n\n this._writableState = new WritableState(options, this);\n\n // legacy.\n this.writable = true;\n\n if (options) {\n if (typeof options.write === 'function') this._write = options.write;\n\n if (typeof options.writev === 'function') this._writev = options.writev;\n\n if (typeof options.destroy === 'function') this._destroy = options.destroy;\n\n if (typeof options.final === 'function') this._final = options.final;\n }\n\n Stream.call(this);\n}\n\n// Otherwise people can pipe Writable streams, which is just wrong.\nWritable.prototype.pipe = function () {\n this.emit('error', new Error('Cannot pipe, not readable'));\n};\n\nfunction writeAfterEnd(stream, cb) {\n var er = new Error('write after end');\n // TODO: defer error events consistently everywhere, not just the cb\n stream.emit('error', er);\n processNextTick(cb, er);\n}\n\n// Checks that a user-supplied chunk is valid, especially for the particular\n// mode the stream is in. Currently this means that `null` is never accepted\n// and undefined/non-string values are only allowed in object mode.\nfunction validChunk(stream, state, chunk, cb) {\n var valid = true;\n var er = false;\n\n if (chunk === null) {\n er = new TypeError('May not write null values to stream');\n } else if (typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {\n er = new TypeError('Invalid non-string/buffer chunk');\n }\n if (er) {\n stream.emit('error', er);\n processNextTick(cb, er);\n valid = false;\n }\n return valid;\n}\n\nWritable.prototype.write = function (chunk, encoding, cb) {\n var state = this._writableState;\n var ret = false;\n var isBuf = _isUint8Array(chunk) && !state.objectMode;\n\n if (isBuf && !Buffer.isBuffer(chunk)) {\n chunk = _uint8ArrayToBuffer(chunk);\n }\n\n if (typeof encoding === 'function') {\n cb = encoding;\n encoding = null;\n }\n\n if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;\n\n if (typeof cb !== 'function') cb = nop;\n\n if (state.ended) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {\n state.pendingcb++;\n ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);\n }\n\n return ret;\n};\n\nWritable.prototype.cork = function () {\n var state = this._writableState;\n\n state.corked++;\n};\n\nWritable.prototype.uncork = function () {\n var state = this._writableState;\n\n if (state.corked) {\n state.corked--;\n\n if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);\n }\n};\n\nWritable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {\n // node::ParseEncoding() requires lower case.\n if (typeof encoding === 'string') encoding = encoding.toLowerCase();\n if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new TypeError('Unknown encoding: ' + encoding);\n this._writableState.defaultEncoding = encoding;\n return this;\n};\n\nfunction decodeChunk(state, chunk, encoding) {\n if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {\n chunk = Buffer.from(chunk, encoding);\n }\n return chunk;\n}\n\n// if we're already writing something, then just put this\n// in the queue, and wait our turn. Otherwise, call _write\n// If we return false, then we need a drain event, so set that flag.\nfunction writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {\n if (!isBuf) {\n var newChunk = decodeChunk(state, chunk, encoding);\n if (chunk !== newChunk) {\n isBuf = true;\n encoding = 'buffer';\n chunk = newChunk;\n }\n }\n var len = state.objectMode ? 1 : chunk.length;\n\n state.length += len;\n\n var ret = state.length < state.highWaterMark;\n // we must ensure that previous needDrain will not be reset to false.\n if (!ret) state.needDrain = true;\n\n if (state.writing || state.corked) {\n var last = state.lastBufferedRequest;\n state.lastBufferedRequest = {\n chunk: chunk,\n encoding: encoding,\n isBuf: isBuf,\n callback: cb,\n next: null\n };\n if (last) {\n last.next = state.lastBufferedRequest;\n } else {\n state.bufferedRequest = state.lastBufferedRequest;\n }\n state.bufferedRequestCount += 1;\n } else {\n doWrite(stream, state, false, len, chunk, encoding, cb);\n }\n\n return ret;\n}\n\nfunction doWrite(stream, state, writev, len, chunk, encoding, cb) {\n state.writelen = len;\n state.writecb = cb;\n state.writing = true;\n state.sync = true;\n if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);\n state.sync = false;\n}\n\nfunction onwriteError(stream, state, sync, er, cb) {\n --state.pendingcb;\n\n if (sync) {\n // defer the callback if we are being called synchronously\n // to avoid piling up things on the stack\n processNextTick(cb, er);\n // this can emit finish, and it will always happen\n // after error\n processNextTick(finishMaybe, stream, state);\n stream._writableState.errorEmitted = true;\n stream.emit('error', er);\n } else {\n // the caller expect this to happen before if\n // it is async\n cb(er);\n stream._writableState.errorEmitted = true;\n stream.emit('error', er);\n // this can emit finish, but finish must\n // always follow error\n finishMaybe(stream, state);\n }\n}\n\nfunction onwriteStateUpdate(state) {\n state.writing = false;\n state.writecb = null;\n state.length -= state.writelen;\n state.writelen = 0;\n}\n\nfunction onwrite(stream, er) {\n var state = stream._writableState;\n var sync = state.sync;\n var cb = state.writecb;\n\n onwriteStateUpdate(state);\n\n if (er) onwriteError(stream, state, sync, er, cb);else {\n // Check if we're actually ready to finish, but don't emit yet\n var finished = needFinish(state);\n\n if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {\n clearBuffer(stream, state);\n }\n\n if (sync) {\n /*<replacement>*/\n asyncWrite(afterWrite, stream, state, finished, cb);\n /*</replacement>*/\n } else {\n afterWrite(stream, state, finished, cb);\n }\n }\n}\n\nfunction afterWrite(stream, state, finished, cb) {\n if (!finished) onwriteDrain(stream, state);\n state.pendingcb--;\n cb();\n finishMaybe(stream, state);\n}\n\n// Must force callback to be called on nextTick, so that we don't\n// emit 'drain' before the write() consumer gets the 'false' return\n// value, and has a chance to attach a 'drain' listener.\nfunction onwriteDrain(stream, state) {\n if (state.length === 0 && state.needDrain) {\n state.needDrain = false;\n stream.emit('drain');\n }\n}\n\n// if there's something in the buffer waiting, then process it\nfunction clearBuffer(stream, state) {\n state.bufferProcessing = true;\n var entry = state.bufferedRequest;\n\n if (stream._writev && entry && entry.next) {\n // Fast case, write everything using _writev()\n var l = state.bufferedRequestCount;\n var buffer = new Array(l);\n var holder = state.corkedRequestsFree;\n holder.entry = entry;\n\n var count = 0;\n var allBuffers = true;\n while (entry) {\n buffer[count] = entry;\n if (!entry.isBuf) allBuffers = false;\n entry = entry.next;\n count += 1;\n }\n buffer.allBuffers = allBuffers;\n\n doWrite(stream, state, true, state.length, buffer, '', holder.finish);\n\n // doWrite is almost always async, defer these to save a bit of time\n // as the hot path ends with doWrite\n state.pendingcb++;\n state.lastBufferedRequest = null;\n if (holder.next) {\n state.corkedRequestsFree = holder.next;\n holder.next = null;\n } else {\n state.corkedRequestsFree = new CorkedRequest(state);\n }\n } else {\n // Slow case, write chunks one-by-one\n while (entry) {\n var chunk = entry.chunk;\n var encoding = entry.encoding;\n var cb = entry.callback;\n var len = state.objectMode ? 1 : chunk.length;\n\n doWrite(stream, state, false, len, chunk, encoding, cb);\n entry = entry.next;\n // if we didn't call the onwrite immediately, then\n // it means that we need to wait until it does.\n // also, that means that the chunk and cb are currently\n // being processed, so move the buffer counter past them.\n if (state.writing) {\n break;\n }\n }\n\n if (entry === null) state.lastBufferedRequest = null;\n }\n\n state.bufferedRequestCount = 0;\n state.bufferedRequest = entry;\n state.bufferProcessing = false;\n}\n\nWritable.prototype._write = function (chunk, encoding, cb) {\n cb(new Error('_write() is not implemented'));\n};\n\nWritable.prototype._writev = null;\n\nWritable.prototype.end = function (chunk, encoding, cb) {\n var state = this._writableState;\n\n if (typeof chunk === 'function') {\n cb = chunk;\n chunk = null;\n encoding = null;\n } else if (typeof encoding === 'function') {\n cb = encoding;\n encoding = null;\n }\n\n if (chunk !== null && chunk !== undefined) this.write(chunk, encoding);\n\n // .end() fully uncorks\n if (state.corked) {\n state.corked = 1;\n this.uncork();\n }\n\n // ignore unnecessary end() calls.\n if (!state.ending && !state.finished) endWritable(this, state, cb);\n};\n\nfunction needFinish(state) {\n return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;\n}\nfunction callFinal(stream, state) {\n stream._final(function (err) {\n state.pendingcb--;\n if (err) {\n stream.emit('error', err);\n }\n state.prefinished = true;\n stream.emit('prefinish');\n finishMaybe(stream, state);\n });\n}\nfunction prefinish(stream, state) {\n if (!state.prefinished && !state.finalCalled) {\n if (typeof stream._final === 'function') {\n state.pendingcb++;\n state.finalCalled = true;\n processNextTick(callFinal, stream, state);\n } else {\n state.prefinished = true;\n stream.emit('prefinish');\n }\n }\n}\n\nfunction finishMaybe(stream, state) {\n var need = needFinish(state);\n if (need) {\n prefinish(stream, state);\n if (state.pendingcb === 0) {\n state.finished = true;\n stream.emit('finish');\n }\n }\n return need;\n}\n\nfunction endWritable(stream, state, cb) {\n state.ending = true;\n finishMaybe(stream, state);\n if (cb) {\n if (state.finished) processNextTick(cb);else stream.once('finish', cb);\n }\n state.ended = true;\n stream.writable = false;\n}\n\nfunction onCorkedFinish(corkReq, state, err) {\n var entry = corkReq.entry;\n corkReq.entry = null;\n while (entry) {\n var cb = entry.callback;\n state.pendingcb--;\n cb(err);\n entry = entry.next;\n }\n if (state.corkedRequestsFree) {\n state.corkedRequestsFree.next = corkReq;\n } else {\n state.corkedRequestsFree = corkReq;\n }\n}\n\nObject.defineProperty(Writable.prototype, 'destroyed', {\n get: function () {\n if (this._writableState === undefined) {\n return false;\n }\n return this._writableState.destroyed;\n },\n set: function (value) {\n // we ignore the value if the stream\n // has not been initialized yet\n if (!this._writableState) {\n return;\n }\n\n // backward compatibility, the user is explicitly\n // managing destroyed\n this._writableState.destroyed = value;\n }\n});\n\nWritable.prototype.destroy = destroyImpl.destroy;\nWritable.prototype._undestroy = destroyImpl.undestroy;\nWritable.prototype._destroy = function (err, cb) {\n this.end();\n cb(err);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/readable-stream/lib/_stream_writable.js\n// module id = 7dSG\n// module chunks = 2","module.exports = require('./lib/_stream_writable.js');\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/readable-stream/writable-browser.js\n// module id = 87vf\n// module chunks = 2","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nmodule.exports = Stream;\n\nvar EE = require('events').EventEmitter;\nvar inherits = require('inherits');\n\ninherits(Stream, EE);\nStream.Readable = require('readable-stream/readable.js');\nStream.Writable = require('readable-stream/writable.js');\nStream.Duplex = require('readable-stream/duplex.js');\nStream.Transform = require('readable-stream/transform.js');\nStream.PassThrough = require('readable-stream/passthrough.js');\n\n// Backwards-compat with node 0.4.x\nStream.Stream = Stream;\n\n\n\n// old-style streams. Note that the pipe method (the only relevant\n// part of this class) is overridden in the Readable class.\n\nfunction Stream() {\n EE.call(this);\n}\n\nStream.prototype.pipe = function(dest, options) {\n var source = this;\n\n function ondata(chunk) {\n if (dest.writable) {\n if (false === dest.write(chunk) && source.pause) {\n source.pause();\n }\n }\n }\n\n source.on('data', ondata);\n\n function ondrain() {\n if (source.readable && source.resume) {\n source.resume();\n }\n }\n\n dest.on('drain', ondrain);\n\n // If the 'end' option is not supplied, dest.end() will be called when\n // source gets the 'end' or 'close' events. Only dest.end() once.\n if (!dest._isStdio && (!options || options.end !== false)) {\n source.on('end', onend);\n source.on('close', onclose);\n }\n\n var didOnEnd = false;\n function onend() {\n if (didOnEnd) return;\n didOnEnd = true;\n\n dest.end();\n }\n\n\n function onclose() {\n if (didOnEnd) return;\n didOnEnd = true;\n\n if (typeof dest.destroy === 'function') dest.destroy();\n }\n\n // don't leave dangling pipes when there are errors.\n function onerror(er) {\n cleanup();\n if (EE.listenerCount(this, 'error') === 0) {\n throw er; // Unhandled stream error in pipe.\n }\n }\n\n source.on('error', onerror);\n dest.on('error', onerror);\n\n // remove all the event listeners that were added.\n function cleanup() {\n source.removeListener('data', ondata);\n dest.removeListener('drain', ondrain);\n\n source.removeListener('end', onend);\n source.removeListener('close', onclose);\n\n source.removeListener('error', onerror);\n dest.removeListener('error', onerror);\n\n source.removeListener('end', cleanup);\n source.removeListener('close', cleanup);\n\n dest.removeListener('close', cleanup);\n }\n\n source.on('end', cleanup);\n source.on('close', cleanup);\n\n dest.on('close', cleanup);\n\n dest.emit('pipe', source);\n\n // Allow for unix-like usage: A.pipe(B).pipe(C)\n return dest;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/stream-browserify/index.js\n// module id = 9DG0\n// module chunks = 2","var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;\n return _c('div', {\n staticClass: \"app-container\"\n }, [_c('el-form', {\n ref: \"ruleForm\",\n staticClass: \"demo-ruleForm\",\n attrs: {\n \"model\": _vm.ruleForm,\n \"rules\": _vm.rules,\n \"label-width\": \"100px\"\n }\n }, [_c('el-form-item', {\n attrs: {\n \"label\": \"上传文件\",\n \"prop\": \"mediaUuid\"\n }\n }, [_c('el-tag', {\n attrs: {\n \"type\": \"danger\"\n }\n }, [_vm._v(\"请上传zip文件升级包,文件传输过程中请勿操作页面\")]), _vm._v(\" \"), _c('el-upload', {\n attrs: {\n \"action\": _vm.updata.url,\n \"show-file-list\": true,\n \"on-success\": _vm.handleAvatarSuccess,\n \"before-upload\": _vm.beforeAvatarUpload,\n \"data\": _vm.updata.data,\n \"fileList\": _vm.fileList,\n \"on-remove\": _vm.handleRemove\n }\n }, [_c('el-button', {\n attrs: {\n \"plain\": \"\",\n \"type\": \"primary\"\n }\n }, [_vm._v(\"点击上传\")])], 1)], 1), _vm._v(\" \"), _c('el-form-item', {\n attrs: {\n \"label\": \"版本\",\n \"prop\": \"versionCode\"\n }\n }, [_c('el-input', {\n staticStyle: {\n \"width\": \"50%\"\n },\n model: {\n value: (_vm.ruleForm.versionCode),\n callback: function($$v) {\n _vm.$set(_vm.ruleForm, \"versionCode\", $$v)\n },\n expression: \"ruleForm.versionCode\"\n }\n })], 1), _vm._v(\" \"), _c('el-form-item', {\n attrs: {\n \"label\": \"包类型\",\n \"prop\": \"fileType\"\n }\n }, [_c('el-select', {\n attrs: {\n \"placeholder\": \"请选择\"\n },\n model: {\n value: (_vm.ruleForm.fileType),\n callback: function($$v) {\n _vm.$set(_vm.ruleForm, \"fileType\", $$v)\n },\n expression: \"ruleForm.fileType\"\n }\n }, _vm._l((_vm.options), function(item) {\n return _c('el-option', {\n key: item.value,\n attrs: {\n \"label\": item.label,\n \"value\": item.value\n }\n })\n }))], 1), _vm._v(\" \"), _c('el-form-item', {\n attrs: {\n \"label\": \"文件名\",\n \"prop\": \"fileName\"\n }\n }, [_c('el-input', {\n staticStyle: {\n \"width\": \"50%\"\n },\n attrs: {\n \"disabled\": true\n },\n model: {\n value: (_vm.ruleForm.fileName),\n callback: function($$v) {\n _vm.$set(_vm.ruleForm, \"fileName\", $$v)\n },\n expression: \"ruleForm.fileName\"\n }\n })], 1), _vm._v(\" \"), _c('el-form-item', {\n attrs: {\n \"label\": \"路径\",\n \"prop\": \"filePath\"\n }\n }, [_c('el-input', {\n staticStyle: {\n \"width\": \"50%\"\n },\n attrs: {\n \"disabled\": true\n },\n model: {\n value: (_vm.ruleForm.filePath),\n callback: function($$v) {\n _vm.$set(_vm.ruleForm, \"filePath\", $$v)\n },\n expression: \"ruleForm.filePath\"\n }\n })], 1), _vm._v(\" \"), _c('el-form-item', {\n attrs: {\n \"label\": \"MD5\",\n \"prop\": \"md5Code\"\n }\n }, [_c('el-input', {\n staticStyle: {\n \"width\": \"50%\"\n },\n attrs: {\n \"disabled\": true\n },\n model: {\n value: (_vm.ruleForm.md5Code),\n callback: function($$v) {\n _vm.$set(_vm.ruleForm, \"md5Code\", $$v)\n },\n expression: \"ruleForm.md5Code\"\n }\n })], 1), _vm._v(\" \"), _c('el-form-item', {\n attrs: {\n \"label\": \"大小\",\n \"prop\": \"fileSize\"\n }\n }, [_c('el-input', {\n staticStyle: {\n \"width\": \"50%\"\n },\n attrs: {\n \"disabled\": true\n },\n model: {\n value: (_vm.ruleForm.fileSize),\n callback: function($$v) {\n _vm.$set(_vm.ruleForm, \"fileSize\", $$v)\n },\n expression: \"ruleForm.fileSize\"\n }\n })], 1), _vm._v(\" \"), _c('el-form-item', {\n attrs: {\n \"label\": \"厂商\",\n \"prop\": \"manufacturer\"\n }\n }, [_c('el-input', {\n staticStyle: {\n \"width\": \"50%\"\n },\n model: {\n value: (_vm.ruleForm.manufacturer),\n callback: function($$v) {\n _vm.$set(_vm.ruleForm, \"manufacturer\", $$v)\n },\n expression: \"ruleForm.manufacturer\"\n }\n })], 1), _vm._v(\" \"), _c('el-form-item', {\n attrs: {\n \"label\": \"设备\",\n \"prop\": \"deviceType\"\n }\n }, [_c('el-input', {\n staticStyle: {\n \"width\": \"50%\"\n },\n model: {\n value: (_vm.ruleForm.deviceType),\n callback: function($$v) {\n _vm.$set(_vm.ruleForm, \"deviceType\", $$v)\n },\n expression: \"ruleForm.deviceType\"\n }\n })], 1), _vm._v(\" \"), _c('el-form-item', {\n attrs: {\n \"label\": \"型号\",\n \"prop\": \"deviceModel\"\n }\n }, [_c('el-input', {\n staticStyle: {\n \"width\": \"50%\"\n },\n model: {\n value: (_vm.ruleForm.deviceModel),\n callback: function($$v) {\n _vm.$set(_vm.ruleForm, \"deviceModel\", $$v)\n },\n expression: \"ruleForm.deviceModel\"\n }\n })], 1), _vm._v(\" \"), _c('el-form-item', {\n attrs: {\n \"label\": \"客户\",\n \"prop\": \"customer\"\n }\n }, [_c('el-input', {\n staticStyle: {\n \"width\": \"50%\"\n },\n model: {\n value: (_vm.ruleForm.customer),\n callback: function($$v) {\n _vm.$set(_vm.ruleForm, \"customer\", $$v)\n },\n expression: \"ruleForm.customer\"\n }\n })], 1), _vm._v(\" \"), _c('el-form-item', {\n attrs: {\n \"label\": \"ReleaseNote\",\n \"prop\": \"releaseNote\"\n }\n }, [_c('el-input', {\n staticStyle: {\n \"width\": \"50%\"\n },\n attrs: {\n \"type\": \"textarea\"\n },\n model: {\n value: (_vm.ruleForm.releaseNote),\n callback: function($$v) {\n _vm.$set(_vm.ruleForm, \"releaseNote\", $$v)\n },\n expression: \"ruleForm.releaseNote\"\n }\n })], 1), _vm._v(\" \"), _c('el-form-item', [_c('el-button', {\n attrs: {\n \"type\": \"primary\"\n },\n on: {\n \"click\": function($event) {\n _vm.submitForm('ruleForm')\n }\n }\n }, [_vm._v(\"立即创建\")]), _vm._v(\" \"), _c('el-button', {\n on: {\n \"click\": function($event) {\n _vm.resetForm('ruleForm')\n }\n }\n }, [_vm._v(\"重置\")])], 1)], 1)], 1)\n}\nvar staticRenderFns = []\nvar esExports = { render: render, staticRenderFns: staticRenderFns }\nexport default esExports\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/vue-loader/lib/template-compiler?{\"id\":\"data-v-94cc7036\",\"hasScoped\":false}!./~/vue-loader/lib/selector.js?type=template&index=0!./src/views/ota/version/add.vue\n// module id = 9bCr\n// module chunks = 2","'use strict';\n\nvar SparkMD5 = require('spark-md5');\n\nmodule.exports = function (file, callback) {\n var blobSlice = File.prototype.slice || File.prototype.mozSlice || File.prototype.webkitSlice;\n var chunkSize = 2097152;\n var chunks = Math.ceil(file.size / chunkSize);\n var currentChunk = 0;\n var spark = new SparkMD5.ArrayBuffer();\n var reader = new FileReader();\n\n loadNext();\n\n reader.onloadend = function (e) {\n spark.append(e.target.result); // Append array buffer\n currentChunk++;\n\n if (currentChunk < chunks) {\n loadNext();\n } else {\n callback(null, spark.end());\n }\n };\n\n reader.onerror = function () {\n callback('oops, something went wrong.');\n };\n\n /////////////////////////\n function loadNext() {\n var start = currentChunk * chunkSize;\n var end = ((start + chunkSize) >= file.size) ? file.size : start + chunkSize;\n\n reader.readAsArrayBuffer(blobSlice.call(file, start, end));\n }\n\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/browser-md5-file/src/browser-md5-file.js\n// module id = CBWy\n// module chunks = 2","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a transform stream is a readable/writable stream where you do\n// something with the data. Sometimes it's called a \"filter\",\n// but that's not a great name for it, since that implies a thing where\n// some bits pass through, and others are simply ignored. (That would\n// be a valid example of a transform, of course.)\n//\n// While the output is causally related to the input, it's not a\n// necessarily symmetric or synchronous transformation. For example,\n// a zlib stream might take multiple plain-text writes(), and then\n// emit a single compressed chunk some time in the future.\n//\n// Here's how this works:\n//\n// The Transform stream has all the aspects of the readable and writable\n// stream classes. When you write(chunk), that calls _write(chunk,cb)\n// internally, and returns false if there's a lot of pending writes\n// buffered up. When you call read(), that calls _read(n) until\n// there's enough pending readable data buffered up.\n//\n// In a transform stream, the written data is placed in a buffer. When\n// _read(n) is called, it transforms the queued up data, calling the\n// buffered _write cb's as it consumes chunks. If consuming a single\n// written chunk would result in multiple output chunks, then the first\n// outputted bit calls the readcb, and subsequent chunks just go into\n// the read buffer, and will cause it to emit 'readable' if necessary.\n//\n// This way, back-pressure is actually determined by the reading side,\n// since _read has to be called to start processing a new chunk. However,\n// a pathological inflate type of transform can cause excessive buffering\n// here. For example, imagine a stream where every byte of input is\n// interpreted as an integer from 0-255, and then results in that many\n// bytes of output. Writing the 4 bytes {ff,ff,ff,ff} would result in\n// 1kb of data being output. In this case, you could write a very small\n// amount of input, and end up with a very large amount of output. In\n// such a pathological inflating mechanism, there'd be no way to tell\n// the system to stop doing the transform. A single 4MB write could\n// cause the system to run out of memory.\n//\n// However, even in such a pathological case, only a single written chunk\n// would be consumed, and then the rest would wait (un-transformed) until\n// the results of the previous transformed chunk were consumed.\n\n'use strict';\n\nmodule.exports = Transform;\n\nvar Duplex = require('./_stream_duplex');\n\n/*<replacement>*/\nvar util = require('core-util-is');\nutil.inherits = require('inherits');\n/*</replacement>*/\n\nutil.inherits(Transform, Duplex);\n\nfunction TransformState(stream) {\n this.afterTransform = function (er, data) {\n return afterTransform(stream, er, data);\n };\n\n this.needTransform = false;\n this.transforming = false;\n this.writecb = null;\n this.writechunk = null;\n this.writeencoding = null;\n}\n\nfunction afterTransform(stream, er, data) {\n var ts = stream._transformState;\n ts.transforming = false;\n\n var cb = ts.writecb;\n\n if (!cb) {\n return stream.emit('error', new Error('write callback called multiple times'));\n }\n\n ts.writechunk = null;\n ts.writecb = null;\n\n if (data !== null && data !== undefined) stream.push(data);\n\n cb(er);\n\n var rs = stream._readableState;\n rs.reading = false;\n if (rs.needReadable || rs.length < rs.highWaterMark) {\n stream._read(rs.highWaterMark);\n }\n}\n\nfunction Transform(options) {\n if (!(this instanceof Transform)) return new Transform(options);\n\n Duplex.call(this, options);\n\n this._transformState = new TransformState(this);\n\n var stream = this;\n\n // start out asking for a readable event once data is transformed.\n this._readableState.needReadable = true;\n\n // we have implemented the _read method, and done the other things\n // that Readable wants before the first _read call, so unset the\n // sync guard flag.\n this._readableState.sync = false;\n\n if (options) {\n if (typeof options.transform === 'function') this._transform = options.transform;\n\n if (typeof options.flush === 'function') this._flush = options.flush;\n }\n\n // When the writable side finishes, then flush out anything remaining.\n this.once('prefinish', function () {\n if (typeof this._flush === 'function') this._flush(function (er, data) {\n done(stream, er, data);\n });else done(stream);\n });\n}\n\nTransform.prototype.push = function (chunk, encoding) {\n this._transformState.needTransform = false;\n return Duplex.prototype.push.call(this, chunk, encoding);\n};\n\n// This is the part where you do stuff!\n// override this function in implementation classes.\n// 'chunk' is an input chunk.\n//\n// Call `push(newChunk)` to pass along transformed output\n// to the readable side. You may call 'push' zero or more times.\n//\n// Call `cb(err)` when you are done with this chunk. If you pass\n// an error, then that'll put the hurt on the whole operation. If you\n// never call cb(), then you'll never get another chunk.\nTransform.prototype._transform = function (chunk, encoding, cb) {\n throw new Error('_transform() is not implemented');\n};\n\nTransform.prototype._write = function (chunk, encoding, cb) {\n var ts = this._transformState;\n ts.writecb = cb;\n ts.writechunk = chunk;\n ts.writeencoding = encoding;\n if (!ts.transforming) {\n var rs = this._readableState;\n if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);\n }\n};\n\n// Doesn't matter what the args are here.\n// _transform does all the work.\n// That we got here means that the readable side wants more data.\nTransform.prototype._read = function (n) {\n var ts = this._transformState;\n\n if (ts.writechunk !== null && ts.writecb && !ts.transforming) {\n ts.transforming = true;\n this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);\n } else {\n // mark that we need a transform, so that any data that comes in\n // will get processed, now that we've asked for it.\n ts.needTransform = true;\n }\n};\n\nTransform.prototype._destroy = function (err, cb) {\n var _this = this;\n\n Duplex.prototype._destroy.call(this, err, function (err2) {\n cb(err2);\n _this.emit('close');\n });\n};\n\nfunction done(stream, er, data) {\n if (er) return stream.emit('error', er);\n\n if (data !== null && data !== undefined) stream.push(data);\n\n // if there's nothing in the write buffer, then that means\n // that nothing more will ever be provided\n var ws = stream._writableState;\n var ts = stream._transformState;\n\n if (ws.length) throw new Error('Calling transform done when ws.length != 0');\n\n if (ts.transforming) throw new Error('Calling transform done when still transforming');\n\n return stream.push(null);\n}\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/readable-stream/lib/_stream_transform.js\n// module id = D1Va\n// module chunks = 2","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a duplex stream is just a stream that is both readable and writable.\n// Since JS doesn't have multiple prototypal inheritance, this class\n// prototypally inherits from Readable, and then parasitically from\n// Writable.\n\n'use strict';\n\n/*<replacement>*/\n\nvar processNextTick = require('process-nextick-args');\n/*</replacement>*/\n\n/*<replacement>*/\nvar objectKeys = Object.keys || function (obj) {\n var keys = [];\n for (var key in obj) {\n keys.push(key);\n }return keys;\n};\n/*</replacement>*/\n\nmodule.exports = Duplex;\n\n/*<replacement>*/\nvar util = require('core-util-is');\nutil.inherits = require('inherits');\n/*</replacement>*/\n\nvar Readable = require('./_stream_readable');\nvar Writable = require('./_stream_writable');\n\nutil.inherits(Duplex, Readable);\n\nvar keys = objectKeys(Writable.prototype);\nfor (var v = 0; v < keys.length; v++) {\n var method = keys[v];\n if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];\n}\n\nfunction Duplex(options) {\n if (!(this instanceof Duplex)) return new Duplex(options);\n\n Readable.call(this, options);\n Writable.call(this, options);\n\n if (options && options.readable === false) this.readable = false;\n\n if (options && options.writable === false) this.writable = false;\n\n this.allowHalfOpen = true;\n if (options && options.allowHalfOpen === false) this.allowHalfOpen = false;\n\n this.once('end', onend);\n}\n\n// the no-half-open enforcer\nfunction onend() {\n // if we allow half-open state, or if the writable side ended,\n // then we're ok.\n if (this.allowHalfOpen || this._writableState.ended) return;\n\n // no more data can be written.\n // But allow more writes to happen in this tick.\n processNextTick(onEndNT, this);\n}\n\nfunction onEndNT(self) {\n self.end();\n}\n\nObject.defineProperty(Duplex.prototype, 'destroyed', {\n get: function () {\n if (this._readableState === undefined || this._writableState === undefined) {\n return false;\n }\n return this._readableState.destroyed && this._writableState.destroyed;\n },\n set: function (value) {\n // we ignore the value if the stream\n // has not been initialized yet\n if (this._readableState === undefined || this._writableState === undefined) {\n return;\n }\n\n // backward compatibility, the user is explicitly\n // managing destroyed\n this._readableState.destroyed = value;\n this._writableState.destroyed = value;\n }\n});\n\nDuplex.prototype._destroy = function (err, cb) {\n this.push(null);\n this.end();\n\n processNextTick(cb, err);\n};\n\nfunction forEach(xs, f) {\n for (var i = 0, l = xs.length; i < l; i++) {\n f(xs[i], i);\n }\n}\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/readable-stream/lib/_stream_duplex.js\n// module id = DsFX\n// module chunks = 2","(function (factory) {\n if (typeof exports === 'object') {\n // Node/CommonJS\n module.exports = factory();\n } else if (typeof define === 'function' && define.amd) {\n // AMD\n define(factory);\n } else {\n // Browser globals (with support for web workers)\n var glob;\n\n try {\n glob = window;\n } catch (e) {\n glob = self;\n }\n\n glob.SparkMD5 = factory();\n }\n}(function (undefined) {\n\n 'use strict';\n\n /*\n * Fastest md5 implementation around (JKM md5).\n * Credits: Joseph Myers\n *\n * @see http://www.myersdaily.org/joseph/javascript/md5-text.html\n * @see http://jsperf.com/md5-shootout/7\n */\n\n /* this function is much faster,\n so if possible we use it. Some IEs\n are the only ones I know of that\n need the idiotic second function,\n generated by an if clause. */\n var add32 = function (a, b) {\n return (a + b) & 0xFFFFFFFF;\n },\n hex_chr = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'];\n\n\n function cmn(q, a, b, x, s, t) {\n a = add32(add32(a, q), add32(x, t));\n return add32((a << s) | (a >>> (32 - s)), b);\n }\n\n function ff(a, b, c, d, x, s, t) {\n return cmn((b & c) | ((~b) & d), a, b, x, s, t);\n }\n\n function gg(a, b, c, d, x, s, t) {\n return cmn((b & d) | (c & (~d)), a, b, x, s, t);\n }\n\n function hh(a, b, c, d, x, s, t) {\n return cmn(b ^ c ^ d, a, b, x, s, t);\n }\n\n function ii(a, b, c, d, x, s, t) {\n return cmn(c ^ (b | (~d)), a, b, x, s, t);\n }\n\n function md5cycle(x, k) {\n var a = x[0],\n b = x[1],\n c = x[2],\n d = x[3];\n\n a = ff(a, b, c, d, k[0], 7, -680876936);\n d = ff(d, a, b, c, k[1], 12, -389564586);\n c = ff(c, d, a, b, k[2], 17, 606105819);\n b = ff(b, c, d, a, k[3], 22, -1044525330);\n a = ff(a, b, c, d, k[4], 7, -176418897);\n d = ff(d, a, b, c, k[5], 12, 1200080426);\n c = ff(c, d, a, b, k[6], 17, -1473231341);\n b = ff(b, c, d, a, k[7], 22, -45705983);\n a = ff(a, b, c, d, k[8], 7, 1770035416);\n d = ff(d, a, b, c, k[9], 12, -1958414417);\n c = ff(c, d, a, b, k[10], 17, -42063);\n b = ff(b, c, d, a, k[11], 22, -1990404162);\n a = ff(a, b, c, d, k[12], 7, 1804603682);\n d = ff(d, a, b, c, k[13], 12, -40341101);\n c = ff(c, d, a, b, k[14], 17, -1502002290);\n b = ff(b, c, d, a, k[15], 22, 1236535329);\n\n a = gg(a, b, c, d, k[1], 5, -165796510);\n d = gg(d, a, b, c, k[6], 9, -1069501632);\n c = gg(c, d, a, b, k[11], 14, 643717713);\n b = gg(b, c, d, a, k[0], 20, -373897302);\n a = gg(a, b, c, d, k[5], 5, -701558691);\n d = gg(d, a, b, c, k[10], 9, 38016083);\n c = gg(c, d, a, b, k[15], 14, -660478335);\n b = gg(b, c, d, a, k[4], 20, -405537848);\n a = gg(a, b, c, d, k[9], 5, 568446438);\n d = gg(d, a, b, c, k[14], 9, -1019803690);\n c = gg(c, d, a, b, k[3], 14, -187363961);\n b = gg(b, c, d, a, k[8], 20, 1163531501);\n a = gg(a, b, c, d, k[13], 5, -1444681467);\n d = gg(d, a, b, c, k[2], 9, -51403784);\n c = gg(c, d, a, b, k[7], 14, 1735328473);\n b = gg(b, c, d, a, k[12], 20, -1926607734);\n\n a = hh(a, b, c, d, k[5], 4, -378558);\n d = hh(d, a, b, c, k[8], 11, -2022574463);\n c = hh(c, d, a, b, k[11], 16, 1839030562);\n b = hh(b, c, d, a, k[14], 23, -35309556);\n a = hh(a, b, c, d, k[1], 4, -1530992060);\n d = hh(d, a, b, c, k[4], 11, 1272893353);\n c = hh(c, d, a, b, k[7], 16, -155497632);\n b = hh(b, c, d, a, k[10], 23, -1094730640);\n a = hh(a, b, c, d, k[13], 4, 681279174);\n d = hh(d, a, b, c, k[0], 11, -358537222);\n c = hh(c, d, a, b, k[3], 16, -722521979);\n b = hh(b, c, d, a, k[6], 23, 76029189);\n a = hh(a, b, c, d, k[9], 4, -640364487);\n d = hh(d, a, b, c, k[12], 11, -421815835);\n c = hh(c, d, a, b, k[15], 16, 530742520);\n b = hh(b, c, d, a, k[2], 23, -995338651);\n\n a = ii(a, b, c, d, k[0], 6, -198630844);\n d = ii(d, a, b, c, k[7], 10, 1126891415);\n c = ii(c, d, a, b, k[14], 15, -1416354905);\n b = ii(b, c, d, a, k[5], 21, -57434055);\n a = ii(a, b, c, d, k[12], 6, 1700485571);\n d = ii(d, a, b, c, k[3], 10, -1894986606);\n c = ii(c, d, a, b, k[10], 15, -1051523);\n b = ii(b, c, d, a, k[1], 21, -2054922799);\n a = ii(a, b, c, d, k[8], 6, 1873313359);\n d = ii(d, a, b, c, k[15], 10, -30611744);\n c = ii(c, d, a, b, k[6], 15, -1560198380);\n b = ii(b, c, d, a, k[13], 21, 1309151649);\n a = ii(a, b, c, d, k[4], 6, -145523070);\n d = ii(d, a, b, c, k[11], 10, -1120210379);\n c = ii(c, d, a, b, k[2], 15, 718787259);\n b = ii(b, c, d, a, k[9], 21, -343485551);\n\n x[0] = add32(a, x[0]);\n x[1] = add32(b, x[1]);\n x[2] = add32(c, x[2]);\n x[3] = add32(d, x[3]);\n }\n\n function md5blk(s) {\n var md5blks = [],\n i; /* Andy King said do it this way. */\n\n for (i = 0; i < 64; i += 4) {\n md5blks[i >> 2] = s.charCodeAt(i) + (s.charCodeAt(i + 1) << 8) + (s.charCodeAt(i + 2) << 16) + (s.charCodeAt(i + 3) << 24);\n }\n return md5blks;\n }\n\n function md5blk_array(a) {\n var md5blks = [],\n i; /* Andy King said do it this way. */\n\n for (i = 0; i < 64; i += 4) {\n md5blks[i >> 2] = a[i] + (a[i + 1] << 8) + (a[i + 2] << 16) + (a[i + 3] << 24);\n }\n return md5blks;\n }\n\n function md51(s) {\n var n = s.length,\n state = [1732584193, -271733879, -1732584194, 271733878],\n i,\n length,\n tail,\n tmp,\n lo,\n hi;\n\n for (i = 64; i <= n; i += 64) {\n md5cycle(state, md5blk(s.substring(i - 64, i)));\n }\n s = s.substring(i - 64);\n length = s.length;\n tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];\n for (i = 0; i < length; i += 1) {\n tail[i >> 2] |= s.charCodeAt(i) << ((i % 4) << 3);\n }\n tail[i >> 2] |= 0x80 << ((i % 4) << 3);\n if (i > 55) {\n md5cycle(state, tail);\n for (i = 0; i < 16; i += 1) {\n tail[i] = 0;\n }\n }\n\n // Beware that the final length might not fit in 32 bits so we take care of that\n tmp = n * 8;\n tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);\n lo = parseInt(tmp[2], 16);\n hi = parseInt(tmp[1], 16) || 0;\n\n tail[14] = lo;\n tail[15] = hi;\n\n md5cycle(state, tail);\n return state;\n }\n\n function md51_array(a) {\n var n = a.length,\n state = [1732584193, -271733879, -1732584194, 271733878],\n i,\n length,\n tail,\n tmp,\n lo,\n hi;\n\n for (i = 64; i <= n; i += 64) {\n md5cycle(state, md5blk_array(a.subarray(i - 64, i)));\n }\n\n // Not sure if it is a bug, however IE10 will always produce a sub array of length 1\n // containing the last element of the parent array if the sub array specified starts\n // beyond the length of the parent array - weird.\n // https://connect.microsoft.com/IE/feedback/details/771452/typed-array-subarray-issue\n a = (i - 64) < n ? a.subarray(i - 64) : new Uint8Array(0);\n\n length = a.length;\n tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];\n for (i = 0; i < length; i += 1) {\n tail[i >> 2] |= a[i] << ((i % 4) << 3);\n }\n\n tail[i >> 2] |= 0x80 << ((i % 4) << 3);\n if (i > 55) {\n md5cycle(state, tail);\n for (i = 0; i < 16; i += 1) {\n tail[i] = 0;\n }\n }\n\n // Beware that the final length might not fit in 32 bits so we take care of that\n tmp = n * 8;\n tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);\n lo = parseInt(tmp[2], 16);\n hi = parseInt(tmp[1], 16) || 0;\n\n tail[14] = lo;\n tail[15] = hi;\n\n md5cycle(state, tail);\n\n return state;\n }\n\n function rhex(n) {\n var s = '',\n j;\n for (j = 0; j < 4; j += 1) {\n s += hex_chr[(n >> (j * 8 + 4)) & 0x0F] + hex_chr[(n >> (j * 8)) & 0x0F];\n }\n return s;\n }\n\n function hex(x) {\n var i;\n for (i = 0; i < x.length; i += 1) {\n x[i] = rhex(x[i]);\n }\n return x.join('');\n }\n\n // In some cases the fast add32 function cannot be used..\n if (hex(md51('hello')) !== '5d41402abc4b2a76b9719d911017c592') {\n add32 = function (x, y) {\n var lsw = (x & 0xFFFF) + (y & 0xFFFF),\n msw = (x >> 16) + (y >> 16) + (lsw >> 16);\n return (msw << 16) | (lsw & 0xFFFF);\n };\n }\n\n // ---------------------------------------------------\n\n /**\n * ArrayBuffer slice polyfill.\n *\n * @see https://github.com/ttaubert/node-arraybuffer-slice\n */\n\n if (typeof ArrayBuffer !== 'undefined' && !ArrayBuffer.prototype.slice) {\n (function () {\n function clamp(val, length) {\n val = (val | 0) || 0;\n\n if (val < 0) {\n return Math.max(val + length, 0);\n }\n\n return Math.min(val, length);\n }\n\n ArrayBuffer.prototype.slice = function (from, to) {\n var length = this.byteLength,\n begin = clamp(from, length),\n end = length,\n num,\n target,\n targetArray,\n sourceArray;\n\n if (to !== undefined) {\n end = clamp(to, length);\n }\n\n if (begin > end) {\n return new ArrayBuffer(0);\n }\n\n num = end - begin;\n target = new ArrayBuffer(num);\n targetArray = new Uint8Array(target);\n\n sourceArray = new Uint8Array(this, begin, num);\n targetArray.set(sourceArray);\n\n return target;\n };\n })();\n }\n\n // ---------------------------------------------------\n\n /**\n * Helpers.\n */\n\n function toUtf8(str) {\n if (/[\\u0080-\\uFFFF]/.test(str)) {\n str = unescape(encodeURIComponent(str));\n }\n\n return str;\n }\n\n function utf8Str2ArrayBuffer(str, returnUInt8Array) {\n var length = str.length,\n buff = new ArrayBuffer(length),\n arr = new Uint8Array(buff),\n i;\n\n for (i = 0; i < length; i += 1) {\n arr[i] = str.charCodeAt(i);\n }\n\n return returnUInt8Array ? arr : buff;\n }\n\n function arrayBuffer2Utf8Str(buff) {\n return String.fromCharCode.apply(null, new Uint8Array(buff));\n }\n\n function concatenateArrayBuffers(first, second, returnUInt8Array) {\n var result = new Uint8Array(first.byteLength + second.byteLength);\n\n result.set(new Uint8Array(first));\n result.set(new Uint8Array(second), first.byteLength);\n\n return returnUInt8Array ? result : result.buffer;\n }\n\n function hexToBinaryString(hex) {\n var bytes = [],\n length = hex.length,\n x;\n\n for (x = 0; x < length - 1; x += 2) {\n bytes.push(parseInt(hex.substr(x, 2), 16));\n }\n\n return String.fromCharCode.apply(String, bytes);\n }\n\n // ---------------------------------------------------\n\n /**\n * SparkMD5 OOP implementation.\n *\n * Use this class to perform an incremental md5, otherwise use the\n * static methods instead.\n */\n\n function SparkMD5() {\n // call reset to init the instance\n this.reset();\n }\n\n /**\n * Appends a string.\n * A conversion will be applied if an utf8 string is detected.\n *\n * @param {String} str The string to be appended\n *\n * @return {SparkMD5} The instance itself\n */\n SparkMD5.prototype.append = function (str) {\n // Converts the string to utf8 bytes if necessary\n // Then append as binary\n this.appendBinary(toUtf8(str));\n\n return this;\n };\n\n /**\n * Appends a binary string.\n *\n * @param {String} contents The binary string to be appended\n *\n * @return {SparkMD5} The instance itself\n */\n SparkMD5.prototype.appendBinary = function (contents) {\n this._buff += contents;\n this._length += contents.length;\n\n var length = this._buff.length,\n i;\n\n for (i = 64; i <= length; i += 64) {\n md5cycle(this._hash, md5blk(this._buff.substring(i - 64, i)));\n }\n\n this._buff = this._buff.substring(i - 64);\n\n return this;\n };\n\n /**\n * Finishes the incremental computation, reseting the internal state and\n * returning the result.\n *\n * @param {Boolean} raw True to get the raw string, false to get the hex string\n *\n * @return {String} The result\n */\n SparkMD5.prototype.end = function (raw) {\n var buff = this._buff,\n length = buff.length,\n i,\n tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n ret;\n\n for (i = 0; i < length; i += 1) {\n tail[i >> 2] |= buff.charCodeAt(i) << ((i % 4) << 3);\n }\n\n this._finish(tail, length);\n ret = hex(this._hash);\n\n if (raw) {\n ret = hexToBinaryString(ret);\n }\n\n this.reset();\n\n return ret;\n };\n\n /**\n * Resets the internal state of the computation.\n *\n * @return {SparkMD5} The instance itself\n */\n SparkMD5.prototype.reset = function () {\n this._buff = '';\n this._length = 0;\n this._hash = [1732584193, -271733879, -1732584194, 271733878];\n\n return this;\n };\n\n /**\n * Gets the internal state of the computation.\n *\n * @return {Object} The state\n */\n SparkMD5.prototype.getState = function () {\n return {\n buff: this._buff,\n length: this._length,\n hash: this._hash\n };\n };\n\n /**\n * Gets the internal state of the computation.\n *\n * @param {Object} state The state\n *\n * @return {SparkMD5} The instance itself\n */\n SparkMD5.prototype.setState = function (state) {\n this._buff = state.buff;\n this._length = state.length;\n this._hash = state.hash;\n\n return this;\n };\n\n /**\n * Releases memory used by the incremental buffer and other additional\n * resources. If you plan to use the instance again, use reset instead.\n */\n SparkMD5.prototype.destroy = function () {\n delete this._hash;\n delete this._buff;\n delete this._length;\n };\n\n /**\n * Finish the final calculation based on the tail.\n *\n * @param {Array} tail The tail (will be modified)\n * @param {Number} length The length of the remaining buffer\n */\n SparkMD5.prototype._finish = function (tail, length) {\n var i = length,\n tmp,\n lo,\n hi;\n\n tail[i >> 2] |= 0x80 << ((i % 4) << 3);\n if (i > 55) {\n md5cycle(this._hash, tail);\n for (i = 0; i < 16; i += 1) {\n tail[i] = 0;\n }\n }\n\n // Do the final computation based on the tail and length\n // Beware that the final length may not fit in 32 bits so we take care of that\n tmp = this._length * 8;\n tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);\n lo = parseInt(tmp[2], 16);\n hi = parseInt(tmp[1], 16) || 0;\n\n tail[14] = lo;\n tail[15] = hi;\n md5cycle(this._hash, tail);\n };\n\n /**\n * Performs the md5 hash on a string.\n * A conversion will be applied if utf8 string is detected.\n *\n * @param {String} str The string\n * @param {Boolean} raw True to get the raw string, false to get the hex string\n *\n * @return {String} The result\n */\n SparkMD5.hash = function (str, raw) {\n // Converts the string to utf8 bytes if necessary\n // Then compute it using the binary function\n return SparkMD5.hashBinary(toUtf8(str), raw);\n };\n\n /**\n * Performs the md5 hash on a binary string.\n *\n * @param {String} content The binary string\n * @param {Boolean} raw True to get the raw string, false to get the hex string\n *\n * @return {String} The result\n */\n SparkMD5.hashBinary = function (content, raw) {\n var hash = md51(content),\n ret = hex(hash);\n\n return raw ? hexToBinaryString(ret) : ret;\n };\n\n // ---------------------------------------------------\n\n /**\n * SparkMD5 OOP implementation for array buffers.\n *\n * Use this class to perform an incremental md5 ONLY for array buffers.\n */\n SparkMD5.ArrayBuffer = function () {\n // call reset to init the instance\n this.reset();\n };\n\n /**\n * Appends an array buffer.\n *\n * @param {ArrayBuffer} arr The array to be appended\n *\n * @return {SparkMD5.ArrayBuffer} The instance itself\n */\n SparkMD5.ArrayBuffer.prototype.append = function (arr) {\n var buff = concatenateArrayBuffers(this._buff.buffer, arr, true),\n length = buff.length,\n i;\n\n this._length += arr.byteLength;\n\n for (i = 64; i <= length; i += 64) {\n md5cycle(this._hash, md5blk_array(buff.subarray(i - 64, i)));\n }\n\n this._buff = (i - 64) < length ? new Uint8Array(buff.buffer.slice(i - 64)) : new Uint8Array(0);\n\n return this;\n };\n\n /**\n * Finishes the incremental computation, reseting the internal state and\n * returning the result.\n *\n * @param {Boolean} raw True to get the raw string, false to get the hex string\n *\n * @return {String} The result\n */\n SparkMD5.ArrayBuffer.prototype.end = function (raw) {\n var buff = this._buff,\n length = buff.length,\n tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n i,\n ret;\n\n for (i = 0; i < length; i += 1) {\n tail[i >> 2] |= buff[i] << ((i % 4) << 3);\n }\n\n this._finish(tail, length);\n ret = hex(this._hash);\n\n if (raw) {\n ret = hexToBinaryString(ret);\n }\n\n this.reset();\n\n return ret;\n };\n\n /**\n * Resets the internal state of the computation.\n *\n * @return {SparkMD5.ArrayBuffer} The instance itself\n */\n SparkMD5.ArrayBuffer.prototype.reset = function () {\n this._buff = new Uint8Array(0);\n this._length = 0;\n this._hash = [1732584193, -271733879, -1732584194, 271733878];\n\n return this;\n };\n\n /**\n * Gets the internal state of the computation.\n *\n * @return {Object} The state\n */\n SparkMD5.ArrayBuffer.prototype.getState = function () {\n var state = SparkMD5.prototype.getState.call(this);\n\n // Convert buffer to a string\n state.buff = arrayBuffer2Utf8Str(state.buff);\n\n return state;\n };\n\n /**\n * Gets the internal state of the computation.\n *\n * @param {Object} state The state\n *\n * @return {SparkMD5.ArrayBuffer} The instance itself\n */\n SparkMD5.ArrayBuffer.prototype.setState = function (state) {\n // Convert string to buffer\n state.buff = utf8Str2ArrayBuffer(state.buff, true);\n\n return SparkMD5.prototype.setState.call(this, state);\n };\n\n SparkMD5.ArrayBuffer.prototype.destroy = SparkMD5.prototype.destroy;\n\n SparkMD5.ArrayBuffer.prototype._finish = SparkMD5.prototype._finish;\n\n /**\n * Performs the md5 hash on an array buffer.\n *\n * @param {ArrayBuffer} arr The array buffer\n * @param {Boolean} raw True to get the raw string, false to get the hex one\n *\n * @return {String} The result\n */\n SparkMD5.ArrayBuffer.hash = function (arr, raw) {\n var hash = md51_array(new Uint8Array(arr)),\n ret = hex(hash);\n\n return raw ? hexToBinaryString(ret) : ret;\n };\n\n return SparkMD5;\n}));\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/spark-md5/spark-md5.js\n// module id = JSQk\n// module chunks = 2","if (typeof Object.create === 'function') {\n // implementation from standard node.js 'util' module\n module.exports = function inherits(ctor, superCtor) {\n ctor.super_ = superCtor\n ctor.prototype = Object.create(superCtor.prototype, {\n constructor: {\n value: ctor,\n enumerable: false,\n writable: true,\n configurable: true\n }\n });\n };\n} else {\n // old school shim for old browsers\n module.exports = function inherits(ctor, superCtor) {\n ctor.super_ = superCtor\n var TempCtor = function () {}\n TempCtor.prototype = superCtor.prototype\n ctor.prototype = new TempCtor()\n ctor.prototype.constructor = ctor\n }\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/inherits/inherits_browser.js\n// module id = LC74\n// module chunks = 2","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\n/*<replacement>*/\n\nvar processNextTick = require('process-nextick-args');\n/*</replacement>*/\n\nmodule.exports = Readable;\n\n/*<replacement>*/\nvar isArray = require('isarray');\n/*</replacement>*/\n\n/*<replacement>*/\nvar Duplex;\n/*</replacement>*/\n\nReadable.ReadableState = ReadableState;\n\n/*<replacement>*/\nvar EE = require('events').EventEmitter;\n\nvar EElistenerCount = function (emitter, type) {\n return emitter.listeners(type).length;\n};\n/*</replacement>*/\n\n/*<replacement>*/\nvar Stream = require('./internal/streams/stream');\n/*</replacement>*/\n\n// TODO(bmeurer): Change this back to const once hole checks are\n// properly optimized away early in Ignition+TurboFan.\n/*<replacement>*/\nvar Buffer = require('safe-buffer').Buffer;\nvar OurUint8Array = global.Uint8Array || function () {};\nfunction _uint8ArrayToBuffer(chunk) {\n return Buffer.from(chunk);\n}\nfunction _isUint8Array(obj) {\n return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n/*</replacement>*/\n\n/*<replacement>*/\nvar util = require('core-util-is');\nutil.inherits = require('inherits');\n/*</replacement>*/\n\n/*<replacement>*/\nvar debugUtil = require('util');\nvar debug = void 0;\nif (debugUtil && debugUtil.debuglog) {\n debug = debugUtil.debuglog('stream');\n} else {\n debug = function () {};\n}\n/*</replacement>*/\n\nvar BufferList = require('./internal/streams/BufferList');\nvar destroyImpl = require('./internal/streams/destroy');\nvar StringDecoder;\n\nutil.inherits(Readable, Stream);\n\nvar kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];\n\nfunction prependListener(emitter, event, fn) {\n // Sadly this is not cacheable as some libraries bundle their own\n // event emitter implementation with them.\n if (typeof emitter.prependListener === 'function') {\n return emitter.prependListener(event, fn);\n } else {\n // This is a hack to make sure that our error handler is attached before any\n // userland ones. NEVER DO THIS. This is here only because this code needs\n // to continue to work with older versions of Node.js that do not include\n // the prependListener() method. The goal is to eventually remove this hack.\n if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]];\n }\n}\n\nfunction ReadableState(options, stream) {\n Duplex = Duplex || require('./_stream_duplex');\n\n options = options || {};\n\n // object stream flag. Used to make read(n) ignore n and to\n // make all the buffer merging and length checks go away\n this.objectMode = !!options.objectMode;\n\n if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.readableObjectMode;\n\n // the point at which it stops calling _read() to fill the buffer\n // Note: 0 is a valid value, means \"don't call _read preemptively ever\"\n var hwm = options.highWaterMark;\n var defaultHwm = this.objectMode ? 16 : 16 * 1024;\n this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm;\n\n // cast to ints.\n this.highWaterMark = Math.floor(this.highWaterMark);\n\n // A linked list is used to store data chunks instead of an array because the\n // linked list can remove elements from the beginning faster than\n // array.shift()\n this.buffer = new BufferList();\n this.length = 0;\n this.pipes = null;\n this.pipesCount = 0;\n this.flowing = null;\n this.ended = false;\n this.endEmitted = false;\n this.reading = false;\n\n // a flag to be able to tell if the event 'readable'/'data' is emitted\n // immediately, or on a later tick. We set this to true at first, because\n // any actions that shouldn't happen until \"later\" should generally also\n // not happen before the first read call.\n this.sync = true;\n\n // whenever we return null, then we set a flag to say\n // that we're awaiting a 'readable' event emission.\n this.needReadable = false;\n this.emittedReadable = false;\n this.readableListening = false;\n this.resumeScheduled = false;\n\n // has it been destroyed\n this.destroyed = false;\n\n // Crypto is kind of old and crusty. Historically, its default string\n // encoding is 'binary' so we have to make this configurable.\n // Everything else in the universe uses 'utf8', though.\n this.defaultEncoding = options.defaultEncoding || 'utf8';\n\n // the number of writers that are awaiting a drain event in .pipe()s\n this.awaitDrain = 0;\n\n // if true, a maybeReadMore has been scheduled\n this.readingMore = false;\n\n this.decoder = null;\n this.encoding = null;\n if (options.encoding) {\n if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;\n this.decoder = new StringDecoder(options.encoding);\n this.encoding = options.encoding;\n }\n}\n\nfunction Readable(options) {\n Duplex = Duplex || require('./_stream_duplex');\n\n if (!(this instanceof Readable)) return new Readable(options);\n\n this._readableState = new ReadableState(options, this);\n\n // legacy\n this.readable = true;\n\n if (options) {\n if (typeof options.read === 'function') this._read = options.read;\n\n if (typeof options.destroy === 'function') this._destroy = options.destroy;\n }\n\n Stream.call(this);\n}\n\nObject.defineProperty(Readable.prototype, 'destroyed', {\n get: function () {\n if (this._readableState === undefined) {\n return false;\n }\n return this._readableState.destroyed;\n },\n set: function (value) {\n // we ignore the value if the stream\n // has not been initialized yet\n if (!this._readableState) {\n return;\n }\n\n // backward compatibility, the user is explicitly\n // managing destroyed\n this._readableState.destroyed = value;\n }\n});\n\nReadable.prototype.destroy = destroyImpl.destroy;\nReadable.prototype._undestroy = destroyImpl.undestroy;\nReadable.prototype._destroy = function (err, cb) {\n this.push(null);\n cb(err);\n};\n\n// Manually shove something into the read() buffer.\n// This returns true if the highWaterMark has not been hit yet,\n// similar to how Writable.write() returns true if you should\n// write() some more.\nReadable.prototype.push = function (chunk, encoding) {\n var state = this._readableState;\n var skipChunkCheck;\n\n if (!state.objectMode) {\n if (typeof chunk === 'string') {\n encoding = encoding || state.defaultEncoding;\n if (encoding !== state.encoding) {\n chunk = Buffer.from(chunk, encoding);\n encoding = '';\n }\n skipChunkCheck = true;\n }\n } else {\n skipChunkCheck = true;\n }\n\n return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);\n};\n\n// Unshift should *always* be something directly out of read()\nReadable.prototype.unshift = function (chunk) {\n return readableAddChunk(this, chunk, null, true, false);\n};\n\nfunction readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {\n var state = stream._readableState;\n if (chunk === null) {\n state.reading = false;\n onEofChunk(stream, state);\n } else {\n var er;\n if (!skipChunkCheck) er = chunkInvalid(state, chunk);\n if (er) {\n stream.emit('error', er);\n } else if (state.objectMode || chunk && chunk.length > 0) {\n if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {\n chunk = _uint8ArrayToBuffer(chunk);\n }\n\n if (addToFront) {\n if (state.endEmitted) stream.emit('error', new Error('stream.unshift() after end event'));else addChunk(stream, state, chunk, true);\n } else if (state.ended) {\n stream.emit('error', new Error('stream.push() after EOF'));\n } else {\n state.reading = false;\n if (state.decoder && !encoding) {\n chunk = state.decoder.write(chunk);\n if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state);\n } else {\n addChunk(stream, state, chunk, false);\n }\n }\n } else if (!addToFront) {\n state.reading = false;\n }\n }\n\n return needMoreData(state);\n}\n\nfunction addChunk(stream, state, chunk, addToFront) {\n if (state.flowing && state.length === 0 && !state.sync) {\n stream.emit('data', chunk);\n stream.read(0);\n } else {\n // update the buffer info.\n state.length += state.objectMode ? 1 : chunk.length;\n if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);\n\n if (state.needReadable) emitReadable(stream);\n }\n maybeReadMore(stream, state);\n}\n\nfunction chunkInvalid(state, chunk) {\n var er;\n if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {\n er = new TypeError('Invalid non-string/buffer chunk');\n }\n return er;\n}\n\n// if it's past the high water mark, we can push in some more.\n// Also, if we have no data yet, we can stand some\n// more bytes. This is to work around cases where hwm=0,\n// such as the repl. Also, if the push() triggered a\n// readable event, and the user called read(largeNumber) such that\n// needReadable was set, then we ought to push more, so that another\n// 'readable' event will be triggered.\nfunction needMoreData(state) {\n return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0);\n}\n\nReadable.prototype.isPaused = function () {\n return this._readableState.flowing === false;\n};\n\n// backwards compatibility.\nReadable.prototype.setEncoding = function (enc) {\n if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;\n this._readableState.decoder = new StringDecoder(enc);\n this._readableState.encoding = enc;\n return this;\n};\n\n// Don't raise the hwm > 8MB\nvar MAX_HWM = 0x800000;\nfunction computeNewHighWaterMark(n) {\n if (n >= MAX_HWM) {\n n = MAX_HWM;\n } else {\n // Get the next highest power of 2 to prevent increasing hwm excessively in\n // tiny amounts\n n--;\n n |= n >>> 1;\n n |= n >>> 2;\n n |= n >>> 4;\n n |= n >>> 8;\n n |= n >>> 16;\n n++;\n }\n return n;\n}\n\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction howMuchToRead(n, state) {\n if (n <= 0 || state.length === 0 && state.ended) return 0;\n if (state.objectMode) return 1;\n if (n !== n) {\n // Only flow one buffer at a time\n if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;\n }\n // If we're asking for more than the current hwm, then raise the hwm.\n if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);\n if (n <= state.length) return n;\n // Don't have enough\n if (!state.ended) {\n state.needReadable = true;\n return 0;\n }\n return state.length;\n}\n\n// you can override either this method, or the async _read(n) below.\nReadable.prototype.read = function (n) {\n debug('read', n);\n n = parseInt(n, 10);\n var state = this._readableState;\n var nOrig = n;\n\n if (n !== 0) state.emittedReadable = false;\n\n // if we're doing read(0) to trigger a readable event, but we\n // already have a bunch of data in the buffer, then just trigger\n // the 'readable' event and move on.\n if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) {\n debug('read: emitReadable', state.length, state.ended);\n if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this);\n return null;\n }\n\n n = howMuchToRead(n, state);\n\n // if we've ended, and we're now clear, then finish it up.\n if (n === 0 && state.ended) {\n if (state.length === 0) endReadable(this);\n return null;\n }\n\n // All the actual chunk generation logic needs to be\n // *below* the call to _read. The reason is that in certain\n // synthetic stream cases, such as passthrough streams, _read\n // may be a completely synchronous operation which may change\n // the state of the read buffer, providing enough data when\n // before there was *not* enough.\n //\n // So, the steps are:\n // 1. Figure out what the state of things will be after we do\n // a read from the buffer.\n //\n // 2. If that resulting state will trigger a _read, then call _read.\n // Note that this may be asynchronous, or synchronous. Yes, it is\n // deeply ugly to write APIs this way, but that still doesn't mean\n // that the Readable class should behave improperly, as streams are\n // designed to be sync/async agnostic.\n // Take note if the _read call is sync or async (ie, if the read call\n // has returned yet), so that we know whether or not it's safe to emit\n // 'readable' etc.\n //\n // 3. Actually pull the requested chunks out of the buffer and return.\n\n // if we need a readable event, then we need to do some reading.\n var doRead = state.needReadable;\n debug('need readable', doRead);\n\n // if we currently have less than the highWaterMark, then also read some\n if (state.length === 0 || state.length - n < state.highWaterMark) {\n doRead = true;\n debug('length less than watermark', doRead);\n }\n\n // however, if we've ended, then there's no point, and if we're already\n // reading, then it's unnecessary.\n if (state.ended || state.reading) {\n doRead = false;\n debug('reading or ended', doRead);\n } else if (doRead) {\n debug('do read');\n state.reading = true;\n state.sync = true;\n // if the length is currently zero, then we *need* a readable event.\n if (state.length === 0) state.needReadable = true;\n // call internal read method\n this._read(state.highWaterMark);\n state.sync = false;\n // If _read pushed data synchronously, then `reading` will be false,\n // and we need to re-evaluate how much data we can return to the user.\n if (!state.reading) n = howMuchToRead(nOrig, state);\n }\n\n var ret;\n if (n > 0) ret = fromList(n, state);else ret = null;\n\n if (ret === null) {\n state.needReadable = true;\n n = 0;\n } else {\n state.length -= n;\n }\n\n if (state.length === 0) {\n // If we have nothing in the buffer, then we want to know\n // as soon as we *do* get something into the buffer.\n if (!state.ended) state.needReadable = true;\n\n // If we tried to read() past the EOF, then emit end on the next tick.\n if (nOrig !== n && state.ended) endReadable(this);\n }\n\n if (ret !== null) this.emit('data', ret);\n\n return ret;\n};\n\nfunction onEofChunk(stream, state) {\n if (state.ended) return;\n if (state.decoder) {\n var chunk = state.decoder.end();\n if (chunk && chunk.length) {\n state.buffer.push(chunk);\n state.length += state.objectMode ? 1 : chunk.length;\n }\n }\n state.ended = true;\n\n // emit 'readable' now to make sure it gets picked up.\n emitReadable(stream);\n}\n\n// Don't emit readable right away in sync mode, because this can trigger\n// another read() call => stack overflow. This way, it might trigger\n// a nextTick recursion warning, but that's not so bad.\nfunction emitReadable(stream) {\n var state = stream._readableState;\n state.needReadable = false;\n if (!state.emittedReadable) {\n debug('emitReadable', state.flowing);\n state.emittedReadable = true;\n if (state.sync) processNextTick(emitReadable_, stream);else emitReadable_(stream);\n }\n}\n\nfunction emitReadable_(stream) {\n debug('emit readable');\n stream.emit('readable');\n flow(stream);\n}\n\n// at this point, the user has presumably seen the 'readable' event,\n// and called read() to consume some data. that may have triggered\n// in turn another _read(n) call, in which case reading = true if\n// it's in progress.\n// However, if we're not ended, or reading, and the length < hwm,\n// then go ahead and try to read some more preemptively.\nfunction maybeReadMore(stream, state) {\n if (!state.readingMore) {\n state.readingMore = true;\n processNextTick(maybeReadMore_, stream, state);\n }\n}\n\nfunction maybeReadMore_(stream, state) {\n var len = state.length;\n while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) {\n debug('maybeReadMore read 0');\n stream.read(0);\n if (len === state.length)\n // didn't get any data, stop spinning.\n break;else len = state.length;\n }\n state.readingMore = false;\n}\n\n// abstract method. to be overridden in specific implementation classes.\n// call cb(er, data) where data is <= n in length.\n// for virtual (non-string, non-buffer) streams, \"length\" is somewhat\n// arbitrary, and perhaps not very meaningful.\nReadable.prototype._read = function (n) {\n this.emit('error', new Error('_read() is not implemented'));\n};\n\nReadable.prototype.pipe = function (dest, pipeOpts) {\n var src = this;\n var state = this._readableState;\n\n switch (state.pipesCount) {\n case 0:\n state.pipes = dest;\n break;\n case 1:\n state.pipes = [state.pipes, dest];\n break;\n default:\n state.pipes.push(dest);\n break;\n }\n state.pipesCount += 1;\n debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);\n\n var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;\n\n var endFn = doEnd ? onend : unpipe;\n if (state.endEmitted) processNextTick(endFn);else src.once('end', endFn);\n\n dest.on('unpipe', onunpipe);\n function onunpipe(readable, unpipeInfo) {\n debug('onunpipe');\n if (readable === src) {\n if (unpipeInfo && unpipeInfo.hasUnpiped === false) {\n unpipeInfo.hasUnpiped = true;\n cleanup();\n }\n }\n }\n\n function onend() {\n debug('onend');\n dest.end();\n }\n\n // when the dest drains, it reduces the awaitDrain counter\n // on the source. This would be more elegant with a .once()\n // handler in flow(), but adding and removing repeatedly is\n // too slow.\n var ondrain = pipeOnDrain(src);\n dest.on('drain', ondrain);\n\n var cleanedUp = false;\n function cleanup() {\n debug('cleanup');\n // cleanup event handlers once the pipe is broken\n dest.removeListener('close', onclose);\n dest.removeListener('finish', onfinish);\n dest.removeListener('drain', ondrain);\n dest.removeListener('error', onerror);\n dest.removeListener('unpipe', onunpipe);\n src.removeListener('end', onend);\n src.removeListener('end', unpipe);\n src.removeListener('data', ondata);\n\n cleanedUp = true;\n\n // if the reader is waiting for a drain event from this\n // specific writer, then it would cause it to never start\n // flowing again.\n // So, if this is awaiting a drain, then we just call it now.\n // If we don't know, then assume that we are waiting for one.\n if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();\n }\n\n // If the user pushes more data while we're writing to dest then we'll end up\n // in ondata again. However, we only want to increase awaitDrain once because\n // dest will only emit one 'drain' event for the multiple writes.\n // => Introduce a guard on increasing awaitDrain.\n var increasedAwaitDrain = false;\n src.on('data', ondata);\n function ondata(chunk) {\n debug('ondata');\n increasedAwaitDrain = false;\n var ret = dest.write(chunk);\n if (false === ret && !increasedAwaitDrain) {\n // If the user unpiped during `dest.write()`, it is possible\n // to get stuck in a permanently paused state if that write\n // also returned false.\n // => Check whether `dest` is still a piping destination.\n if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {\n debug('false write response, pause', src._readableState.awaitDrain);\n src._readableState.awaitDrain++;\n increasedAwaitDrain = true;\n }\n src.pause();\n }\n }\n\n // if the dest has an error, then stop piping into it.\n // however, don't suppress the throwing behavior for this.\n function onerror(er) {\n debug('onerror', er);\n unpipe();\n dest.removeListener('error', onerror);\n if (EElistenerCount(dest, 'error') === 0) dest.emit('error', er);\n }\n\n // Make sure our error handler is attached before userland ones.\n prependListener(dest, 'error', onerror);\n\n // Both close and finish should trigger unpipe, but only once.\n function onclose() {\n dest.removeListener('finish', onfinish);\n unpipe();\n }\n dest.once('close', onclose);\n function onfinish() {\n debug('onfinish');\n dest.removeListener('close', onclose);\n unpipe();\n }\n dest.once('finish', onfinish);\n\n function unpipe() {\n debug('unpipe');\n src.unpipe(dest);\n }\n\n // tell the dest that it's being piped to\n dest.emit('pipe', src);\n\n // start the flow if it hasn't been started already.\n if (!state.flowing) {\n debug('pipe resume');\n src.resume();\n }\n\n return dest;\n};\n\nfunction pipeOnDrain(src) {\n return function () {\n var state = src._readableState;\n debug('pipeOnDrain', state.awaitDrain);\n if (state.awaitDrain) state.awaitDrain--;\n if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {\n state.flowing = true;\n flow(src);\n }\n };\n}\n\nReadable.prototype.unpipe = function (dest) {\n var state = this._readableState;\n var unpipeInfo = { hasUnpiped: false };\n\n // if we're not piping anywhere, then do nothing.\n if (state.pipesCount === 0) return this;\n\n // just one destination. most common case.\n if (state.pipesCount === 1) {\n // passed in one, but it's not the right one.\n if (dest && dest !== state.pipes) return this;\n\n if (!dest) dest = state.pipes;\n\n // got a match.\n state.pipes = null;\n state.pipesCount = 0;\n state.flowing = false;\n if (dest) dest.emit('unpipe', this, unpipeInfo);\n return this;\n }\n\n // slow case. multiple pipe destinations.\n\n if (!dest) {\n // remove all.\n var dests = state.pipes;\n var len = state.pipesCount;\n state.pipes = null;\n state.pipesCount = 0;\n state.flowing = false;\n\n for (var i = 0; i < len; i++) {\n dests[i].emit('unpipe', this, unpipeInfo);\n }return this;\n }\n\n // try to find the right one.\n var index = indexOf(state.pipes, dest);\n if (index === -1) return this;\n\n state.pipes.splice(index, 1);\n state.pipesCount -= 1;\n if (state.pipesCount === 1) state.pipes = state.pipes[0];\n\n dest.emit('unpipe', this, unpipeInfo);\n\n return this;\n};\n\n// set up data events if they are asked for\n// Ensure readable listeners eventually get something\nReadable.prototype.on = function (ev, fn) {\n var res = Stream.prototype.on.call(this, ev, fn);\n\n if (ev === 'data') {\n // Start flowing on next tick if stream isn't explicitly paused\n if (this._readableState.flowing !== false) this.resume();\n } else if (ev === 'readable') {\n var state = this._readableState;\n if (!state.endEmitted && !state.readableListening) {\n state.readableListening = state.needReadable = true;\n state.emittedReadable = false;\n if (!state.reading) {\n processNextTick(nReadingNextTick, this);\n } else if (state.length) {\n emitReadable(this);\n }\n }\n }\n\n return res;\n};\nReadable.prototype.addListener = Readable.prototype.on;\n\nfunction nReadingNextTick(self) {\n debug('readable nexttick read 0');\n self.read(0);\n}\n\n// pause() and resume() are remnants of the legacy readable stream API\n// If the user uses them, then switch into old mode.\nReadable.prototype.resume = function () {\n var state = this._readableState;\n if (!state.flowing) {\n debug('resume');\n state.flowing = true;\n resume(this, state);\n }\n return this;\n};\n\nfunction resume(stream, state) {\n if (!state.resumeScheduled) {\n state.resumeScheduled = true;\n processNextTick(resume_, stream, state);\n }\n}\n\nfunction resume_(stream, state) {\n if (!state.reading) {\n debug('resume read 0');\n stream.read(0);\n }\n\n state.resumeScheduled = false;\n state.awaitDrain = 0;\n stream.emit('resume');\n flow(stream);\n if (state.flowing && !state.reading) stream.read(0);\n}\n\nReadable.prototype.pause = function () {\n debug('call pause flowing=%j', this._readableState.flowing);\n if (false !== this._readableState.flowing) {\n debug('pause');\n this._readableState.flowing = false;\n this.emit('pause');\n }\n return this;\n};\n\nfunction flow(stream) {\n var state = stream._readableState;\n debug('flow', state.flowing);\n while (state.flowing && stream.read() !== null) {}\n}\n\n// wrap an old-style stream as the async data source.\n// This is *not* part of the readable stream interface.\n// It is an ugly unfortunate mess of history.\nReadable.prototype.wrap = function (stream) {\n var state = this._readableState;\n var paused = false;\n\n var self = this;\n stream.on('end', function () {\n debug('wrapped end');\n if (state.decoder && !state.ended) {\n var chunk = state.decoder.end();\n if (chunk && chunk.length) self.push(chunk);\n }\n\n self.push(null);\n });\n\n stream.on('data', function (chunk) {\n debug('wrapped data');\n if (state.decoder) chunk = state.decoder.write(chunk);\n\n // don't skip over falsy values in objectMode\n if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;\n\n var ret = self.push(chunk);\n if (!ret) {\n paused = true;\n stream.pause();\n }\n });\n\n // proxy all the other methods.\n // important when wrapping filters and duplexes.\n for (var i in stream) {\n if (this[i] === undefined && typeof stream[i] === 'function') {\n this[i] = function (method) {\n return function () {\n return stream[method].apply(stream, arguments);\n };\n }(i);\n }\n }\n\n // proxy certain important events.\n for (var n = 0; n < kProxyEvents.length; n++) {\n stream.on(kProxyEvents[n], self.emit.bind(self, kProxyEvents[n]));\n }\n\n // when we try to consume some more bytes, simply unpause the\n // underlying stream.\n self._read = function (n) {\n debug('wrapped _read', n);\n if (paused) {\n paused = false;\n stream.resume();\n }\n };\n\n return self;\n};\n\n// exposed for testing purposes only.\nReadable._fromList = fromList;\n\n// Pluck off n bytes from an array of buffers.\n// Length is the combined lengths of all the buffers in the list.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction fromList(n, state) {\n // nothing buffered\n if (state.length === 0) return null;\n\n var ret;\n if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) {\n // read it all, truncate the list\n if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.head.data;else ret = state.buffer.concat(state.length);\n state.buffer.clear();\n } else {\n // read part of list\n ret = fromListPartial(n, state.buffer, state.decoder);\n }\n\n return ret;\n}\n\n// Extracts only enough buffered data to satisfy the amount requested.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction fromListPartial(n, list, hasStrings) {\n var ret;\n if (n < list.head.data.length) {\n // slice is the same for buffers and strings\n ret = list.head.data.slice(0, n);\n list.head.data = list.head.data.slice(n);\n } else if (n === list.head.data.length) {\n // first chunk is a perfect match\n ret = list.shift();\n } else {\n // result spans more than one buffer\n ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list);\n }\n return ret;\n}\n\n// Copies a specified amount of characters from the list of buffered data\n// chunks.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction copyFromBufferString(n, list) {\n var p = list.head;\n var c = 1;\n var ret = p.data;\n n -= ret.length;\n while (p = p.next) {\n var str = p.data;\n var nb = n > str.length ? str.length : n;\n if (nb === str.length) ret += str;else ret += str.slice(0, n);\n n -= nb;\n if (n === 0) {\n if (nb === str.length) {\n ++c;\n if (p.next) list.head = p.next;else list.head = list.tail = null;\n } else {\n list.head = p;\n p.data = str.slice(nb);\n }\n break;\n }\n ++c;\n }\n list.length -= c;\n return ret;\n}\n\n// Copies a specified amount of bytes from the list of buffered data chunks.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction copyFromBuffer(n, list) {\n var ret = Buffer.allocUnsafe(n);\n var p = list.head;\n var c = 1;\n p.data.copy(ret);\n n -= p.data.length;\n while (p = p.next) {\n var buf = p.data;\n var nb = n > buf.length ? buf.length : n;\n buf.copy(ret, ret.length - n, 0, nb);\n n -= nb;\n if (n === 0) {\n if (nb === buf.length) {\n ++c;\n if (p.next) list.head = p.next;else list.head = list.tail = null;\n } else {\n list.head = p;\n p.data = buf.slice(nb);\n }\n break;\n }\n ++c;\n }\n list.length -= c;\n return ret;\n}\n\nfunction endReadable(stream) {\n var state = stream._readableState;\n\n // If we get here before consuming all the bytes, then that is a\n // bug in node. Should never happen.\n if (state.length > 0) throw new Error('\"endReadable()\" called on non-empty stream');\n\n if (!state.endEmitted) {\n state.ended = true;\n processNextTick(endReadableNT, state, stream);\n }\n}\n\nfunction endReadableNT(state, stream) {\n // Check that we didn't get one last unshift.\n if (!state.endEmitted && state.length === 0) {\n state.endEmitted = true;\n stream.readable = false;\n stream.emit('end');\n }\n}\n\nfunction forEach(xs, f) {\n for (var i = 0, l = xs.length; i < l; i++) {\n f(xs[i], i);\n }\n}\n\nfunction indexOf(xs, x) {\n for (var i = 0, l = xs.length; i < l; i++) {\n if (xs[i] === x) return i;\n }\n return -1;\n}\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/readable-stream/lib/_stream_readable.js\n// module id = Rt1F\n// module chunks = 2","module.exports = require('./lib/_stream_duplex.js');\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/readable-stream/duplex-browser.js\n// module id = SDM6\n// module chunks = 2","module.exports = require('events').EventEmitter;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/readable-stream/lib/internal/streams/stream-browser.js\n// module id = UcPO\n// module chunks = 2","//全局通用 数据\r\nimport fetch from '@/utils/fetch'\r\n\r\n//获取上传授权\r\nexport function getOSSSignature(type) {\r\n return fetch({\r\n url: '/unionService/AliOSS/signature',\r\n method: 'post',\r\n params: {\r\n dir: type\r\n },\r\n withCredentials: false\r\n })\r\n}\r\n//获取资源下载OSS地址接口\r\nexport function getMediaResoures() {\r\n return fetch({\r\n url: '/unionService/AliOSS/mediaResource/oss/url',\r\n method: 'get',\r\n })\r\n}\r\n//获取更新包下载OSS地址接口\r\nexport function getPackageResoures() {\r\n return fetch({\r\n url: '/unionService/AliOSS/upgradePackage/oss/url',\r\n method: 'get',\r\n })\r\n}\r\n\r\n//获取配置下载OSS地址接口\r\nexport function getConfigResoures() {\r\n return fetch({\r\n url: '/unionService/AliOSS/deviceConfig/oss/url',\r\n method: 'get',\r\n })\r\n}\r\n//获取配置下载OSS地址接口\r\nexport function getLogoResoures() {\r\n return fetch({\r\n url: '/unionService/AliOSS/store/logo/oss/url',\r\n method: 'get',\r\n })\r\n}\r\n//获取支付二维码下载OSS地址接口\r\nexport function qrcodeResoures() {\r\n return fetch({\r\n url: '/unionService/AliOSS/trade/oss/url',\r\n method: 'get',\r\n })\r\n}\r\n//获取支付二维码下载OSS地址接口\r\nexport function getImgResoures() {\r\n return fetch({\r\n url: '/unionService/AliOSS/goods/oss/url',\r\n method: 'get',\r\n })\r\n}\r\n//获取apk下载OSS地址接口\r\nexport function getApkResoures() {\r\n return fetch({\r\n url: '/unionService/AliOSS/apk/oss/url',\r\n method: 'get',\r\n })\r\n}\r\n\r\n//获取省市\r\nexport function getCitys(id) {\r\n return fetch({\r\n url: '/service-org/Region/getCitys?parentId='+id,\r\n method: 'get',\r\n })\r\n}\r\n\n\n\n// WEBPACK FOOTER //\n// ./src/api/comm.js","/* eslint-disable node/no-deprecated-api */\nvar buffer = require('buffer')\nvar Buffer = buffer.Buffer\n\n// alternative to using Object.keys for old browsers\nfunction copyProps (src, dst) {\n for (var key in src) {\n dst[key] = src[key]\n }\n}\nif (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {\n module.exports = buffer\n} else {\n // Copy properties from require('buffer')\n copyProps(buffer, exports)\n exports.Buffer = SafeBuffer\n}\n\nfunction SafeBuffer (arg, encodingOrOffset, length) {\n return Buffer(arg, encodingOrOffset, length)\n}\n\n// Copy static methods from Buffer\ncopyProps(Buffer, SafeBuffer)\n\nSafeBuffer.from = function (arg, encodingOrOffset, length) {\n if (typeof arg === 'number') {\n throw new TypeError('Argument must not be a number')\n }\n return Buffer(arg, encodingOrOffset, length)\n}\n\nSafeBuffer.alloc = function (size, fill, encoding) {\n if (typeof size !== 'number') {\n throw new TypeError('Argument must be a number')\n }\n var buf = Buffer(size)\n if (fill !== undefined) {\n if (typeof encoding === 'string') {\n buf.fill(fill, encoding)\n } else {\n buf.fill(fill)\n }\n } else {\n buf.fill(0)\n }\n return buf\n}\n\nSafeBuffer.allocUnsafe = function (size) {\n if (typeof size !== 'number') {\n throw new TypeError('Argument must be a number')\n }\n return Buffer(size)\n}\n\nSafeBuffer.allocUnsafeSlow = function (size) {\n if (typeof size !== 'number') {\n throw new TypeError('Argument must be a number')\n }\n return buffer.SlowBuffer(size)\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/safe-buffer/index.js\n// module id = X3l8\n// module chunks = 2","'use strict';\n\nvar Buffer = require('safe-buffer').Buffer;\n\nvar isEncoding = Buffer.isEncoding || function (encoding) {\n encoding = '' + encoding;\n switch (encoding && encoding.toLowerCase()) {\n case 'hex':case 'utf8':case 'utf-8':case 'ascii':case 'binary':case 'base64':case 'ucs2':case 'ucs-2':case 'utf16le':case 'utf-16le':case 'raw':\n return true;\n default:\n return false;\n }\n};\n\nfunction _normalizeEncoding(enc) {\n if (!enc) return 'utf8';\n var retried;\n while (true) {\n switch (enc) {\n case 'utf8':\n case 'utf-8':\n return 'utf8';\n case 'ucs2':\n case 'ucs-2':\n case 'utf16le':\n case 'utf-16le':\n return 'utf16le';\n case 'latin1':\n case 'binary':\n return 'latin1';\n case 'base64':\n case 'ascii':\n case 'hex':\n return enc;\n default:\n if (retried) return; // undefined\n enc = ('' + enc).toLowerCase();\n retried = true;\n }\n }\n};\n\n// Do not cache `Buffer.isEncoding` when checking encoding names as some\n// modules monkey-patch it to support additional encodings\nfunction normalizeEncoding(enc) {\n var nenc = _normalizeEncoding(enc);\n if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc);\n return nenc || enc;\n}\n\n// StringDecoder provides an interface for efficiently splitting a series of\n// buffers into a series of JS strings without breaking apart multi-byte\n// characters.\nexports.StringDecoder = StringDecoder;\nfunction StringDecoder(encoding) {\n this.encoding = normalizeEncoding(encoding);\n var nb;\n switch (this.encoding) {\n case 'utf16le':\n this.text = utf16Text;\n this.end = utf16End;\n nb = 4;\n break;\n case 'utf8':\n this.fillLast = utf8FillLast;\n nb = 4;\n break;\n case 'base64':\n this.text = base64Text;\n this.end = base64End;\n nb = 3;\n break;\n default:\n this.write = simpleWrite;\n this.end = simpleEnd;\n return;\n }\n this.lastNeed = 0;\n this.lastTotal = 0;\n this.lastChar = Buffer.allocUnsafe(nb);\n}\n\nStringDecoder.prototype.write = function (buf) {\n if (buf.length === 0) return '';\n var r;\n var i;\n if (this.lastNeed) {\n r = this.fillLast(buf);\n if (r === undefined) return '';\n i = this.lastNeed;\n this.lastNeed = 0;\n } else {\n i = 0;\n }\n if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);\n return r || '';\n};\n\nStringDecoder.prototype.end = utf8End;\n\n// Returns only complete characters in a Buffer\nStringDecoder.prototype.text = utf8Text;\n\n// Attempts to complete a partial non-UTF-8 character using bytes from a Buffer\nStringDecoder.prototype.fillLast = function (buf) {\n if (this.lastNeed <= buf.length) {\n buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);\n return this.lastChar.toString(this.encoding, 0, this.lastTotal);\n }\n buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);\n this.lastNeed -= buf.length;\n};\n\n// Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a\n// continuation byte.\nfunction utf8CheckByte(byte) {\n if (byte <= 0x7F) return 0;else if (byte >> 5 === 0x06) return 2;else if (byte >> 4 === 0x0E) return 3;else if (byte >> 3 === 0x1E) return 4;\n return -1;\n}\n\n// Checks at most 3 bytes at the end of a Buffer in order to detect an\n// incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4)\n// needed to complete the UTF-8 character (if applicable) are returned.\nfunction utf8CheckIncomplete(self, buf, i) {\n var j = buf.length - 1;\n if (j < i) return 0;\n var nb = utf8CheckByte(buf[j]);\n if (nb >= 0) {\n if (nb > 0) self.lastNeed = nb - 1;\n return nb;\n }\n if (--j < i) return 0;\n nb = utf8CheckByte(buf[j]);\n if (nb >= 0) {\n if (nb > 0) self.lastNeed = nb - 2;\n return nb;\n }\n if (--j < i) return 0;\n nb = utf8CheckByte(buf[j]);\n if (nb >= 0) {\n if (nb > 0) {\n if (nb === 2) nb = 0;else self.lastNeed = nb - 3;\n }\n return nb;\n }\n return 0;\n}\n\n// Validates as many continuation bytes for a multi-byte UTF-8 character as\n// needed or are available. If we see a non-continuation byte where we expect\n// one, we \"replace\" the validated continuation bytes we've seen so far with\n// UTF-8 replacement characters ('\\ufffd'), to match v8's UTF-8 decoding\n// behavior. The continuation byte check is included three times in the case\n// where all of the continuation bytes for a character exist in the same buffer.\n// It is also done this way as a slight performance increase instead of using a\n// loop.\nfunction utf8CheckExtraBytes(self, buf, p) {\n if ((buf[0] & 0xC0) !== 0x80) {\n self.lastNeed = 0;\n return '\\ufffd'.repeat(p);\n }\n if (self.lastNeed > 1 && buf.length > 1) {\n if ((buf[1] & 0xC0) !== 0x80) {\n self.lastNeed = 1;\n return '\\ufffd'.repeat(p + 1);\n }\n if (self.lastNeed > 2 && buf.length > 2) {\n if ((buf[2] & 0xC0) !== 0x80) {\n self.lastNeed = 2;\n return '\\ufffd'.repeat(p + 2);\n }\n }\n }\n}\n\n// Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer.\nfunction utf8FillLast(buf) {\n var p = this.lastTotal - this.lastNeed;\n var r = utf8CheckExtraBytes(this, buf, p);\n if (r !== undefined) return r;\n if (this.lastNeed <= buf.length) {\n buf.copy(this.lastChar, p, 0, this.lastNeed);\n return this.lastChar.toString(this.encoding, 0, this.lastTotal);\n }\n buf.copy(this.lastChar, p, 0, buf.length);\n this.lastNeed -= buf.length;\n}\n\n// Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a\n// partial character, the character's bytes are buffered until the required\n// number of bytes are available.\nfunction utf8Text(buf, i) {\n var total = utf8CheckIncomplete(this, buf, i);\n if (!this.lastNeed) return buf.toString('utf8', i);\n this.lastTotal = total;\n var end = buf.length - (total - this.lastNeed);\n buf.copy(this.lastChar, 0, end);\n return buf.toString('utf8', i, end);\n}\n\n// For UTF-8, a replacement character for each buffered byte of a (partial)\n// character needs to be added to the output.\nfunction utf8End(buf) {\n var r = buf && buf.length ? this.write(buf) : '';\n if (this.lastNeed) return r + '\\ufffd'.repeat(this.lastTotal - this.lastNeed);\n return r;\n}\n\n// UTF-16LE typically needs two bytes per character, but even if we have an even\n// number of bytes available, we need to check if we end on a leading/high\n// surrogate. In that case, we need to wait for the next two bytes in order to\n// decode the last character properly.\nfunction utf16Text(buf, i) {\n if ((buf.length - i) % 2 === 0) {\n var r = buf.toString('utf16le', i);\n if (r) {\n var c = r.charCodeAt(r.length - 1);\n if (c >= 0xD800 && c <= 0xDBFF) {\n this.lastNeed = 2;\n this.lastTotal = 4;\n this.lastChar[0] = buf[buf.length - 2];\n this.lastChar[1] = buf[buf.length - 1];\n return r.slice(0, -1);\n }\n }\n return r;\n }\n this.lastNeed = 1;\n this.lastTotal = 2;\n this.lastChar[0] = buf[buf.length - 1];\n return buf.toString('utf16le', i, buf.length - 1);\n}\n\n// For UTF-16LE we do not explicitly append special replacement characters if we\n// end on a partial character, we simply let v8 handle that.\nfunction utf16End(buf) {\n var r = buf && buf.length ? this.write(buf) : '';\n if (this.lastNeed) {\n var end = this.lastTotal - this.lastNeed;\n return r + this.lastChar.toString('utf16le', 0, end);\n }\n return r;\n}\n\nfunction base64Text(buf, i) {\n var n = (buf.length - i) % 3;\n if (n === 0) return buf.toString('base64', i);\n this.lastNeed = 3 - n;\n this.lastTotal = 3;\n if (n === 1) {\n this.lastChar[0] = buf[buf.length - 1];\n } else {\n this.lastChar[0] = buf[buf.length - 2];\n this.lastChar[1] = buf[buf.length - 1];\n }\n return buf.toString('base64', i, buf.length - n);\n}\n\nfunction base64End(buf) {\n var r = buf && buf.length ? this.write(buf) : '';\n if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed);\n return r;\n}\n\n// Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex)\nfunction simpleWrite(buf) {\n return buf.toString(this.encoding);\n}\n\nfunction simpleEnd(buf) {\n return buf && buf.length ? this.write(buf) : '';\n}\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/string_decoder/lib/string_decoder.js\n// module id = X4X3\n// module chunks = 2","exports = module.exports = require('./lib/_stream_readable.js');\nexports.Stream = exports;\nexports.Readable = exports;\nexports.Writable = require('./lib/_stream_writable.js');\nexports.Duplex = require('./lib/_stream_duplex.js');\nexports.Transform = require('./lib/_stream_transform.js');\nexports.PassThrough = require('./lib/_stream_passthrough.js');\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/readable-stream/readable-browser.js\n// module id = cSWu\n// module chunks = 2","'use strict'\nvar inherits = require('inherits')\nvar HashBase = require('hash-base')\n\nvar ARRAY16 = new Array(16)\n\nfunction MD5 () {\n HashBase.call(this, 64)\n\n // state\n this._a = 0x67452301\n this._b = 0xefcdab89\n this._c = 0x98badcfe\n this._d = 0x10325476\n}\n\ninherits(MD5, HashBase)\n\nMD5.prototype._update = function () {\n var M = ARRAY16\n for (var i = 0; i < 16; ++i) M[i] = this._block.readInt32LE(i * 4)\n\n var a = this._a\n var b = this._b\n var c = this._c\n var d = this._d\n\n a = fnF(a, b, c, d, M[0], 0xd76aa478, 7)\n d = fnF(d, a, b, c, M[1], 0xe8c7b756, 12)\n c = fnF(c, d, a, b, M[2], 0x242070db, 17)\n b = fnF(b, c, d, a, M[3], 0xc1bdceee, 22)\n a = fnF(a, b, c, d, M[4], 0xf57c0faf, 7)\n d = fnF(d, a, b, c, M[5], 0x4787c62a, 12)\n c = fnF(c, d, a, b, M[6], 0xa8304613, 17)\n b = fnF(b, c, d, a, M[7], 0xfd469501, 22)\n a = fnF(a, b, c, d, M[8], 0x698098d8, 7)\n d = fnF(d, a, b, c, M[9], 0x8b44f7af, 12)\n c = fnF(c, d, a, b, M[10], 0xffff5bb1, 17)\n b = fnF(b, c, d, a, M[11], 0x895cd7be, 22)\n a = fnF(a, b, c, d, M[12], 0x6b901122, 7)\n d = fnF(d, a, b, c, M[13], 0xfd987193, 12)\n c = fnF(c, d, a, b, M[14], 0xa679438e, 17)\n b = fnF(b, c, d, a, M[15], 0x49b40821, 22)\n\n a = fnG(a, b, c, d, M[1], 0xf61e2562, 5)\n d = fnG(d, a, b, c, M[6], 0xc040b340, 9)\n c = fnG(c, d, a, b, M[11], 0x265e5a51, 14)\n b = fnG(b, c, d, a, M[0], 0xe9b6c7aa, 20)\n a = fnG(a, b, c, d, M[5], 0xd62f105d, 5)\n d = fnG(d, a, b, c, M[10], 0x02441453, 9)\n c = fnG(c, d, a, b, M[15], 0xd8a1e681, 14)\n b = fnG(b, c, d, a, M[4], 0xe7d3fbc8, 20)\n a = fnG(a, b, c, d, M[9], 0x21e1cde6, 5)\n d = fnG(d, a, b, c, M[14], 0xc33707d6, 9)\n c = fnG(c, d, a, b, M[3], 0xf4d50d87, 14)\n b = fnG(b, c, d, a, M[8], 0x455a14ed, 20)\n a = fnG(a, b, c, d, M[13], 0xa9e3e905, 5)\n d = fnG(d, a, b, c, M[2], 0xfcefa3f8, 9)\n c = fnG(c, d, a, b, M[7], 0x676f02d9, 14)\n b = fnG(b, c, d, a, M[12], 0x8d2a4c8a, 20)\n\n a = fnH(a, b, c, d, M[5], 0xfffa3942, 4)\n d = fnH(d, a, b, c, M[8], 0x8771f681, 11)\n c = fnH(c, d, a, b, M[11], 0x6d9d6122, 16)\n b = fnH(b, c, d, a, M[14], 0xfde5380c, 23)\n a = fnH(a, b, c, d, M[1], 0xa4beea44, 4)\n d = fnH(d, a, b, c, M[4], 0x4bdecfa9, 11)\n c = fnH(c, d, a, b, M[7], 0xf6bb4b60, 16)\n b = fnH(b, c, d, a, M[10], 0xbebfbc70, 23)\n a = fnH(a, b, c, d, M[13], 0x289b7ec6, 4)\n d = fnH(d, a, b, c, M[0], 0xeaa127fa, 11)\n c = fnH(c, d, a, b, M[3], 0xd4ef3085, 16)\n b = fnH(b, c, d, a, M[6], 0x04881d05, 23)\n a = fnH(a, b, c, d, M[9], 0xd9d4d039, 4)\n d = fnH(d, a, b, c, M[12], 0xe6db99e5, 11)\n c = fnH(c, d, a, b, M[15], 0x1fa27cf8, 16)\n b = fnH(b, c, d, a, M[2], 0xc4ac5665, 23)\n\n a = fnI(a, b, c, d, M[0], 0xf4292244, 6)\n d = fnI(d, a, b, c, M[7], 0x432aff97, 10)\n c = fnI(c, d, a, b, M[14], 0xab9423a7, 15)\n b = fnI(b, c, d, a, M[5], 0xfc93a039, 21)\n a = fnI(a, b, c, d, M[12], 0x655b59c3, 6)\n d = fnI(d, a, b, c, M[3], 0x8f0ccc92, 10)\n c = fnI(c, d, a, b, M[10], 0xffeff47d, 15)\n b = fnI(b, c, d, a, M[1], 0x85845dd1, 21)\n a = fnI(a, b, c, d, M[8], 0x6fa87e4f, 6)\n d = fnI(d, a, b, c, M[15], 0xfe2ce6e0, 10)\n c = fnI(c, d, a, b, M[6], 0xa3014314, 15)\n b = fnI(b, c, d, a, M[13], 0x4e0811a1, 21)\n a = fnI(a, b, c, d, M[4], 0xf7537e82, 6)\n d = fnI(d, a, b, c, M[11], 0xbd3af235, 10)\n c = fnI(c, d, a, b, M[2], 0x2ad7d2bb, 15)\n b = fnI(b, c, d, a, M[9], 0xeb86d391, 21)\n\n this._a = (this._a + a) | 0\n this._b = (this._b + b) | 0\n this._c = (this._c + c) | 0\n this._d = (this._d + d) | 0\n}\n\nMD5.prototype._digest = function () {\n // create padding and handle blocks\n this._block[this._blockOffset++] = 0x80\n if (this._blockOffset > 56) {\n this._block.fill(0, this._blockOffset, 64)\n this._update()\n this._blockOffset = 0\n }\n\n this._block.fill(0, this._blockOffset, 56)\n this._block.writeUInt32LE(this._length[0], 56)\n this._block.writeUInt32LE(this._length[1], 60)\n this._update()\n\n // produce result\n var buffer = new Buffer(16)\n buffer.writeInt32LE(this._a, 0)\n buffer.writeInt32LE(this._b, 4)\n buffer.writeInt32LE(this._c, 8)\n buffer.writeInt32LE(this._d, 12)\n return buffer\n}\n\nfunction rotl (x, n) {\n return (x << n) | (x >>> (32 - n))\n}\n\nfunction fnF (a, b, c, d, m, k, s) {\n return (rotl((a + ((b & c) | ((~b) & d)) + m + k) | 0, s) + b) | 0\n}\n\nfunction fnG (a, b, c, d, m, k, s) {\n return (rotl((a + ((b & d) | (c & (~d))) + m + k) | 0, s) + b) | 0\n}\n\nfunction fnH (a, b, c, d, m, k, s) {\n return (rotl((a + (b ^ c ^ d) + m + k) | 0, s) + b) | 0\n}\n\nfunction fnI (a, b, c, d, m, k, s) {\n return (rotl((a + ((c ^ (b | (~d)))) + m + k) | 0, s) + b) | 0\n}\n\nmodule.exports = MD5\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/md5.js/index.js\n// module id = eCz2\n// module chunks = 2","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a passthrough stream.\n// basically just the most minimal sort of Transform stream.\n// Every written chunk gets output as-is.\n\n'use strict';\n\nmodule.exports = PassThrough;\n\nvar Transform = require('./_stream_transform');\n\n/*<replacement>*/\nvar util = require('core-util-is');\nutil.inherits = require('inherits');\n/*</replacement>*/\n\nutil.inherits(PassThrough, Transform);\n\nfunction PassThrough(options) {\n if (!(this instanceof PassThrough)) return new PassThrough(options);\n\n Transform.call(this, options);\n}\n\nPassThrough.prototype._transform = function (chunk, encoding, cb) {\n cb(null, chunk);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/readable-stream/lib/_stream_passthrough.js\n// module id = f48b\n// module chunks = 2","exports = module.exports = require(\"../../../../node_modules/css-loader/lib/css-base.js\")(true);\n// imports\n\n\n// module\nexports.push([module.id, \".el-upload-list{width:50%}\", \"\", {\"version\":3,\"sources\":[\"D:/projects/gitLab/wxpos/posadmin/src/views/ota/version/add.vue\"],\"names\":[],\"mappings\":\"AACA,gBACI,SAAW,CACd\",\"file\":\"add.vue\",\"sourcesContent\":[\"\\n.el-upload-list{\\n width: 50%;\\n}\\n\"],\"sourceRoot\":\"\"}]);\n\n// exports\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/css-loader?{\"minimize\":true,\"sourceMap\":true}!./~/vue-loader/lib/style-compiler?{\"vue\":true,\"id\":\"data-v-94cc7036\",\"scoped\":false,\"hasInlineConfig\":false}!./~/vue-loader/lib/selector.js?type=styles&index=0!./src/views/ota/version/add.vue\n// module id = fNc5\n// module chunks = 2","\n/**\n * Module exports.\n */\n\nmodule.exports = deprecate;\n\n/**\n * Mark that a method should not be used.\n * Returns a modified function which warns once by default.\n *\n * If `localStorage.noDeprecation = true` is set, then it is a no-op.\n *\n * If `localStorage.throwDeprecation = true` is set, then deprecated functions\n * will throw an Error when invoked.\n *\n * If `localStorage.traceDeprecation = true` is set, then deprecated functions\n * will invoke `console.trace()` instead of `console.error()`.\n *\n * @param {Function} fn - the function to deprecate\n * @param {String} msg - the string to print to the console when `fn` is invoked\n * @returns {Function} a new \"deprecated\" version of `fn`\n * @api public\n */\n\nfunction deprecate (fn, msg) {\n if (config('noDeprecation')) {\n return fn;\n }\n\n var warned = false;\n function deprecated() {\n if (!warned) {\n if (config('throwDeprecation')) {\n throw new Error(msg);\n } else if (config('traceDeprecation')) {\n console.trace(msg);\n } else {\n console.warn(msg);\n }\n warned = true;\n }\n return fn.apply(this, arguments);\n }\n\n return deprecated;\n}\n\n/**\n * Checks `localStorage` for boolean values for the given `name`.\n *\n * @param {String} name\n * @returns {Boolean}\n * @api private\n */\n\nfunction config (name) {\n // accessing global.localStorage can trigger a DOMException in sandboxed iframes\n try {\n if (!global.localStorage) return false;\n } catch (_) {\n return false;\n }\n var val = global.localStorage[name];\n if (null == val) return false;\n return String(val).toLowerCase() === 'true';\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/util-deprecate/browser.js\n// module id = iP15\n// module chunks = 2","module.exports = require('./src/browser-md5-file');\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/browser-md5-file/index.js\n// module id = iVxu\n// module chunks = 2","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// NOTE: These type checking functions intentionally don't use `instanceof`\n// because it is fragile and can be easily faked with `Object.create()`.\n\nfunction isArray(arg) {\n if (Array.isArray) {\n return Array.isArray(arg);\n }\n return objectToString(arg) === '[object Array]';\n}\nexports.isArray = isArray;\n\nfunction isBoolean(arg) {\n return typeof arg === 'boolean';\n}\nexports.isBoolean = isBoolean;\n\nfunction isNull(arg) {\n return arg === null;\n}\nexports.isNull = isNull;\n\nfunction isNullOrUndefined(arg) {\n return arg == null;\n}\nexports.isNullOrUndefined = isNullOrUndefined;\n\nfunction isNumber(arg) {\n return typeof arg === 'number';\n}\nexports.isNumber = isNumber;\n\nfunction isString(arg) {\n return typeof arg === 'string';\n}\nexports.isString = isString;\n\nfunction isSymbol(arg) {\n return typeof arg === 'symbol';\n}\nexports.isSymbol = isSymbol;\n\nfunction isUndefined(arg) {\n return arg === void 0;\n}\nexports.isUndefined = isUndefined;\n\nfunction isRegExp(re) {\n return objectToString(re) === '[object RegExp]';\n}\nexports.isRegExp = isRegExp;\n\nfunction isObject(arg) {\n return typeof arg === 'object' && arg !== null;\n}\nexports.isObject = isObject;\n\nfunction isDate(d) {\n return objectToString(d) === '[object Date]';\n}\nexports.isDate = isDate;\n\nfunction isError(e) {\n return (objectToString(e) === '[object Error]' || e instanceof Error);\n}\nexports.isError = isError;\n\nfunction isFunction(arg) {\n return typeof arg === 'function';\n}\nexports.isFunction = isFunction;\n\nfunction isPrimitive(arg) {\n return arg === null ||\n typeof arg === 'boolean' ||\n typeof arg === 'number' ||\n typeof arg === 'string' ||\n typeof arg === 'symbol' || // ES6 symbol\n typeof arg === 'undefined';\n}\nexports.isPrimitive = isPrimitive;\n\nexports.isBuffer = Buffer.isBuffer;\n\nfunction objectToString(o) {\n return Object.prototype.toString.call(o);\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-util-is/lib/util.js\n// module id = jOgh\n// module chunks = 2","<template>\r\n <div class=\"app-container\">\r\n <el-form :model=\"ruleForm\" :rules=\"rules\" ref=\"ruleForm\" label-width=\"100px\" class=\"demo-ruleForm\">\r\n <el-form-item label=\"上传文件\" prop=\"mediaUuid\">\r\n <el-tag type=\"danger\">请上传zip文件升级包,文件传输过程中请勿操作页面</el-tag>\r\n <el-upload\r\n :action=\"updata.url\"\r\n :show-file-list=\"true\"\r\n :on-success=\"handleAvatarSuccess\"\r\n :before-upload=\"beforeAvatarUpload\"\r\n :data=\"updata.data\"\r\n :fileList=\"fileList\"\r\n :on-remove=\"handleRemove\"\r\n >\r\n <el-button plain type=\"primary\">点击上传</el-button>\r\n </el-upload>\r\n </el-form-item>\r\n <el-form-item label=\"版本\" prop=\"versionCode\">\r\n <el-input v-model=\"ruleForm.versionCode\" style=\"width: 50%\"></el-input>\r\n </el-form-item>\r\n <el-form-item label=\"包类型\" prop=\"fileType\">\r\n <el-select v-model=\"ruleForm.fileType\" placeholder=\"请选择\">\r\n <el-option\r\n v-for=\"item in options\"\r\n :key=\"item.value\"\r\n :label=\"item.label\"\r\n :value=\"item.value\">\r\n </el-option>\r\n </el-select>\r\n </el-form-item>\r\n <el-form-item label=\"文件名\" prop=\"fileName\">\r\n <el-input v-model=\"ruleForm.fileName\" style=\"width: 50%\" :disabled=\"true\"></el-input>\r\n </el-form-item>\r\n <el-form-item label=\"路径\" prop=\"filePath\">\r\n <el-input v-model=\"ruleForm.filePath\" style=\"width: 50%\" :disabled=\"true\"></el-input>\r\n </el-form-item>\r\n <el-form-item label=\"MD5\" prop=\"md5Code\">\r\n <el-input v-model=\"ruleForm.md5Code\" style=\"width: 50%\" :disabled=\"true\"></el-input>\r\n </el-form-item>\r\n <el-form-item label=\"大小\" prop=\"fileSize\">\r\n <el-input v-model=\"ruleForm.fileSize\" style=\"width: 50%\" :disabled=\"true\"></el-input>\r\n </el-form-item>\r\n <el-form-item label=\"厂商\" prop=\"manufacturer\">\r\n <el-input v-model=\"ruleForm.manufacturer\" style=\"width: 50%\"></el-input>\r\n </el-form-item>\r\n <el-form-item label=\"设备\" prop=\"deviceType\">\r\n <el-input v-model=\"ruleForm.deviceType\" style=\"width: 50%\"></el-input>\r\n </el-form-item>\r\n <el-form-item label=\"型号\" prop=\"deviceModel\">\r\n <el-input v-model=\"ruleForm.deviceModel\" style=\"width: 50%\"></el-input>\r\n </el-form-item>\r\n <el-form-item label=\"客户\" prop=\"customer\">\r\n <el-input v-model=\"ruleForm.customer\" style=\"width: 50%\"></el-input>\r\n </el-form-item>\r\n\r\n <el-form-item label=\"ReleaseNote\" prop=\"releaseNote\">\r\n <el-input type=\"textarea\" v-model=\"ruleForm.releaseNote\" style=\"width: 50%\"></el-input>\r\n </el-form-item>\r\n <el-form-item>\r\n <el-button type=\"primary\" @click=\"submitForm('ruleForm')\">立即创建</el-button>\r\n <el-button @click=\"resetForm('ruleForm')\">重置</el-button>\r\n </el-form-item>\r\n </el-form>\r\n </div>\r\n</template>\r\n\r\n<script>\r\n import {getOSSSignature, getPackageResoures} from '@/api/comm'\r\n import {versionAdd} from '@/api/ota/version'\r\n import MD5 from 'md5.js'\r\n import browserMD5File from 'browser-md5-file'\r\n import {Loading} from 'element-ui';\r\n\r\n export default {\r\n created() {\r\n //上传签名初始化\r\n getOSSSignature(\"otadev\").then(response => {\r\n this.updata.data.policy = response.result.policy\r\n this.updata.data.OSSAccessKeyId = response.result.accessid\r\n this.updata.data.success_action_status = '200'\r\n this.updata.data.signature = response.result.signature\r\n this.updata.url = response.result.host\r\n })\r\n getPackageResoures().then(res => {\r\n this.mediaUrl = res.result\r\n })\r\n },\r\n data() {\r\n return {\r\n fileList:[],\r\n loadingInstance: null,\r\n options: [\r\n {\r\n value: '0',\r\n label: '增量包',\r\n },\r\n {\r\n value: '1',\r\n label: '全量包',\r\n },\r\n ],\r\n ruleForm: {\r\n fileName: '',\r\n filePath: '',\r\n md5Code: '',\r\n fileSize: '',\r\n versionCode: '',\r\n manufacturer: '',\r\n deviceType: '',\r\n deviceModel: '',\r\n customer: '',\r\n fileType: '',\r\n releaseNote: ''\r\n },\r\n rules: {\r\n versionCode: [\r\n {required: true, message: '请输入版本', trigger: 'blur'},\r\n ],\r\n fileType: [\r\n {required: true, message: '请上选择包类型', trigger: 'blur'},\r\n ],\r\n },\r\n updata: {\r\n url: '',\r\n data: {}\r\n },\r\n selected: [],\r\n mediaUrl: '',\r\n };\r\n },\r\n methods: {\r\n handleRemove(file, fileList) {\r\n this.ruleForm={\r\n fileName: '',\r\n filePath: '',\r\n md5Code: '',\r\n fileSize: '',\r\n versionCode: '',\r\n manufacturer: '',\r\n deviceType: '',\r\n deviceModel: '',\r\n customer: '',\r\n fileType: '',\r\n releaseNote: ''\r\n }\r\n },\r\n submitForm(formName) {\r\n this.$refs[formName].validate((valid) => {\r\n if (valid) {\r\n versionAdd(this.ruleForm).then(res => {\r\n var router = this.$router;\r\n this.$message({\r\n message: '操作成功',\r\n type: 'success',\r\n duration: 1000,\r\n onClose: function () {\r\n router.push({path: 'index'})\r\n }\r\n });\r\n })\r\n\r\n } else {\r\n return false;\r\n }\r\n });\r\n },\r\n resetForm(formName) {\r\n this.$refs[formName].resetFields();\r\n },\r\n handleAvatarSuccess(res, file) {\r\n console.log(file)\r\n this.ruleForm.fileName = file.name\r\n this.ruleForm.filePath = this.mediaUrl\r\n\r\n// this.ruleForm.md5Code = new MD5().update(file.name).digest('hex')\r\n this.ruleForm.fileSize = file.size\r\n// this.loadingInstance.close()\r\n this.fileList=[]\r\n },\r\n beforeAvatarUpload(file) {\r\n\r\n var fileName = file.name;\r\n var versionCode = ''\r\n var packageType = this.findPackageType(fileName)\r\n if (packageType == \"zeng\") {\r\n //获取增量包版本号 ota-user-2.0.312-344.zip\r\n versionCode = fileName.split(\"-\")[2].split(\".\")[0] + \".\" + fileName.split(\"-\")[2].split(\".\")[1] + \".\" + fileName.split(\"-\")[3].split(\".\")[0]\r\n } else if (packageType == \"quan\") {\r\n //获取全量包版本号 rk3288-ota-user.root.2.0.344.zip\r\n versionCode = fileName.split(\".\")[2] + \".\" + fileName.split(\".\")[3] + \".\" + fileName.split(\".\")[4];\r\n } else {\r\n //PDA\r\n versionCode = \"1.0.\" + fileName.substring(0, fileName.lastIndexOf(\".\")).split(\"#\")[1];\r\n }\r\n if (versionCode.indexOf(\"undefined\") >= 0) {\r\n this.$message.error('包名称错误!');\r\n return false;\r\n }\r\n //上传文件命名\r\n this.updata.data.key = \"otadev/\" + file.name\r\n this.ruleForm.versionCode = versionCode\r\n var ruleForm =this.ruleForm\r\n browserMD5File(file, function (err, md5) {\r\n ruleForm.md5Code = md5; // 97027eb624f85892c69c4bcec8ab0f11\r\n\r\n });\r\n// this.loadingInstance = Loading.service({\r\n// fullscreen: true,\r\n// text: '上传中...',\r\n// spinner: 'el-icon-loading',\r\n// background: 'rgba(0, 0, 0, 0.7)'\r\n// });\r\n\r\n return true;\r\n },\r\n //判断上传版本的文件是增量包还是全量包\r\n findPackageType(packageName) {\r\n if (packageName.indexOf(\"#\") >= 0) {\r\n return \"pda\";\r\n }\r\n var packageNameArray = packageName.split(\".\");\r\n //获得除了.zip前一位截取的字符串是否包含\"-\",如果有就代表是增量包\r\n if (packageNameArray[packageNameArray.length - 2].indexOf(\"-\") >= 0) {\r\n return \"zeng\";\r\n } else {\r\n return \"quan\";\r\n }\r\n }\r\n\r\n }\r\n }\r\n</script>\r\n<style>\r\n .el-upload-list{\r\n width: 50%;\r\n }\r\n</style>\n\n\n// WEBPACK FOOTER //\n// src/views/ota/version/add.vue?2758f16c","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nfunction EventEmitter() {\n this._events = this._events || {};\n this._maxListeners = this._maxListeners || undefined;\n}\nmodule.exports = EventEmitter;\n\n// Backwards-compat with node 0.10.x\nEventEmitter.EventEmitter = EventEmitter;\n\nEventEmitter.prototype._events = undefined;\nEventEmitter.prototype._maxListeners = undefined;\n\n// By default EventEmitters will print a warning if more than 10 listeners are\n// added to it. This is a useful default which helps finding memory leaks.\nEventEmitter.defaultMaxListeners = 10;\n\n// Obviously not all Emitters should be limited to 10. This function allows\n// that to be increased. Set to zero for unlimited.\nEventEmitter.prototype.setMaxListeners = function(n) {\n if (!isNumber(n) || n < 0 || isNaN(n))\n throw TypeError('n must be a positive number');\n this._maxListeners = n;\n return this;\n};\n\nEventEmitter.prototype.emit = function(type) {\n var er, handler, len, args, i, listeners;\n\n if (!this._events)\n this._events = {};\n\n // If there is no 'error' event listener then throw.\n if (type === 'error') {\n if (!this._events.error ||\n (isObject(this._events.error) && !this._events.error.length)) {\n er = arguments[1];\n if (er instanceof Error) {\n throw er; // Unhandled 'error' event\n } else {\n // At least give some kind of context to the user\n var err = new Error('Uncaught, unspecified \"error\" event. (' + er + ')');\n err.context = er;\n throw err;\n }\n }\n }\n\n handler = this._events[type];\n\n if (isUndefined(handler))\n return false;\n\n if (isFunction(handler)) {\n switch (arguments.length) {\n // fast cases\n case 1:\n handler.call(this);\n break;\n case 2:\n handler.call(this, arguments[1]);\n break;\n case 3:\n handler.call(this, arguments[1], arguments[2]);\n break;\n // slower\n default:\n args = Array.prototype.slice.call(arguments, 1);\n handler.apply(this, args);\n }\n } else if (isObject(handler)) {\n args = Array.prototype.slice.call(arguments, 1);\n listeners = handler.slice();\n len = listeners.length;\n for (i = 0; i < len; i++)\n listeners[i].apply(this, args);\n }\n\n return true;\n};\n\nEventEmitter.prototype.addListener = function(type, listener) {\n var m;\n\n if (!isFunction(listener))\n throw TypeError('listener must be a function');\n\n if (!this._events)\n this._events = {};\n\n // To avoid recursion in the case that type === \"newListener\"! Before\n // adding it to the listeners, first emit \"newListener\".\n if (this._events.newListener)\n this.emit('newListener', type,\n isFunction(listener.listener) ?\n listener.listener : listener);\n\n if (!this._events[type])\n // Optimize the case of one listener. Don't need the extra array object.\n this._events[type] = listener;\n else if (isObject(this._events[type]))\n // If we've already got an array, just append.\n this._events[type].push(listener);\n else\n // Adding the second element, need to change to array.\n this._events[type] = [this._events[type], listener];\n\n // Check for listener leak\n if (isObject(this._events[type]) && !this._events[type].warned) {\n if (!isUndefined(this._maxListeners)) {\n m = this._maxListeners;\n } else {\n m = EventEmitter.defaultMaxListeners;\n }\n\n if (m && m > 0 && this._events[type].length > m) {\n this._events[type].warned = true;\n console.error('(node) warning: possible EventEmitter memory ' +\n 'leak detected. %d listeners added. ' +\n 'Use emitter.setMaxListeners() to increase limit.',\n this._events[type].length);\n if (typeof console.trace === 'function') {\n // not supported in IE 10\n console.trace();\n }\n }\n }\n\n return this;\n};\n\nEventEmitter.prototype.on = EventEmitter.prototype.addListener;\n\nEventEmitter.prototype.once = function(type, listener) {\n if (!isFunction(listener))\n throw TypeError('listener must be a function');\n\n var fired = false;\n\n function g() {\n this.removeListener(type, g);\n\n if (!fired) {\n fired = true;\n listener.apply(this, arguments);\n }\n }\n\n g.listener = listener;\n this.on(type, g);\n\n return this;\n};\n\n// emits a 'removeListener' event iff the listener was removed\nEventEmitter.prototype.removeListener = function(type, listener) {\n var list, position, length, i;\n\n if (!isFunction(listener))\n throw TypeError('listener must be a function');\n\n if (!this._events || !this._events[type])\n return this;\n\n list = this._events[type];\n length = list.length;\n position = -1;\n\n if (list === listener ||\n (isFunction(list.listener) && list.listener === listener)) {\n delete this._events[type];\n if (this._events.removeListener)\n this.emit('removeListener', type, listener);\n\n } else if (isObject(list)) {\n for (i = length; i-- > 0;) {\n if (list[i] === listener ||\n (list[i].listener && list[i].listener === listener)) {\n position = i;\n break;\n }\n }\n\n if (position < 0)\n return this;\n\n if (list.length === 1) {\n list.length = 0;\n delete this._events[type];\n } else {\n list.splice(position, 1);\n }\n\n if (this._events.removeListener)\n this.emit('removeListener', type, listener);\n }\n\n return this;\n};\n\nEventEmitter.prototype.removeAllListeners = function(type) {\n var key, listeners;\n\n if (!this._events)\n return this;\n\n // not listening for removeListener, no need to emit\n if (!this._events.removeListener) {\n if (arguments.length === 0)\n this._events = {};\n else if (this._events[type])\n delete this._events[type];\n return this;\n }\n\n // emit removeListener for all listeners on all events\n if (arguments.length === 0) {\n for (key in this._events) {\n if (key === 'removeListener') continue;\n this.removeAllListeners(key);\n }\n this.removeAllListeners('removeListener');\n this._events = {};\n return this;\n }\n\n listeners = this._events[type];\n\n if (isFunction(listeners)) {\n this.removeListener(type, listeners);\n } else if (listeners) {\n // LIFO order\n while (listeners.length)\n this.removeListener(type, listeners[listeners.length - 1]);\n }\n delete this._events[type];\n\n return this;\n};\n\nEventEmitter.prototype.listeners = function(type) {\n var ret;\n if (!this._events || !this._events[type])\n ret = [];\n else if (isFunction(this._events[type]))\n ret = [this._events[type]];\n else\n ret = this._events[type].slice();\n return ret;\n};\n\nEventEmitter.prototype.listenerCount = function(type) {\n if (this._events) {\n var evlistener = this._events[type];\n\n if (isFunction(evlistener))\n return 1;\n else if (evlistener)\n return evlistener.length;\n }\n return 0;\n};\n\nEventEmitter.listenerCount = function(emitter, type) {\n return emitter.listenerCount(type);\n};\n\nfunction isFunction(arg) {\n return typeof arg === 'function';\n}\n\nfunction isNumber(arg) {\n return typeof arg === 'number';\n}\n\nfunction isObject(arg) {\n return typeof arg === 'object' && arg !== null;\n}\n\nfunction isUndefined(arg) {\n return arg === void 0;\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/events/events.js\n// module id = vzCy\n// module chunks = 2","'use strict'\nvar Buffer = require('safe-buffer').Buffer\nvar Transform = require('stream').Transform\nvar inherits = require('inherits')\n\nfunction throwIfNotStringOrBuffer (val, prefix) {\n if (!Buffer.isBuffer(val) && typeof val !== 'string') {\n throw new TypeError(prefix + ' must be a string or a buffer')\n }\n}\n\nfunction HashBase (blockSize) {\n Transform.call(this)\n\n this._block = Buffer.allocUnsafe(blockSize)\n this._blockSize = blockSize\n this._blockOffset = 0\n this._length = [0, 0, 0, 0]\n\n this._finalized = false\n}\n\ninherits(HashBase, Transform)\n\nHashBase.prototype._transform = function (chunk, encoding, callback) {\n var error = null\n try {\n this.update(chunk, encoding)\n } catch (err) {\n error = err\n }\n\n callback(error)\n}\n\nHashBase.prototype._flush = function (callback) {\n var error = null\n try {\n this.push(this.digest())\n } catch (err) {\n error = err\n }\n\n callback(error)\n}\n\nHashBase.prototype.update = function (data, encoding) {\n throwIfNotStringOrBuffer(data, 'Data')\n if (this._finalized) throw new Error('Digest already called')\n if (!Buffer.isBuffer(data)) data = Buffer.from(data, encoding)\n\n // consume data\n var block = this._block\n var offset = 0\n while (this._blockOffset + data.length - offset >= this._blockSize) {\n for (var i = this._blockOffset; i < this._blockSize;) block[i++] = data[offset++]\n this._update()\n this._blockOffset = 0\n }\n while (offset < data.length) block[this._blockOffset++] = data[offset++]\n\n // update length\n for (var j = 0, carry = data.length * 8; carry > 0; ++j) {\n this._length[j] += carry\n carry = (this._length[j] / 0x0100000000) | 0\n if (carry > 0) this._length[j] -= 0x0100000000 * carry\n }\n\n return this\n}\n\nHashBase.prototype._update = function () {\n throw new Error('_update is not implemented')\n}\n\nHashBase.prototype.digest = function (encoding) {\n if (this._finalized) throw new Error('Digest already called')\n this._finalized = true\n\n var digest = this._digest()\n if (encoding !== undefined) digest = digest.toString(encoding)\n\n // reset state\n this._block.fill(0)\n this._blockOffset = 0\n for (var i = 0; i < 4; ++i) this._length[i] = 0\n\n return digest\n}\n\nHashBase.prototype._digest = function () {\n throw new Error('_digest is not implemented')\n}\n\nmodule.exports = HashBase\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/md5.js/~/hash-base/index.js\n// module id = wVeK\n// module chunks = 2","'use strict';\n\n/*<replacement>*/\n\nvar processNextTick = require('process-nextick-args');\n/*</replacement>*/\n\n// undocumented cb() API, needed for core, not for public API\nfunction destroy(err, cb) {\n var _this = this;\n\n var readableDestroyed = this._readableState && this._readableState.destroyed;\n var writableDestroyed = this._writableState && this._writableState.destroyed;\n\n if (readableDestroyed || writableDestroyed) {\n if (cb) {\n cb(err);\n } else if (err && (!this._writableState || !this._writableState.errorEmitted)) {\n processNextTick(emitErrorNT, this, err);\n }\n return;\n }\n\n // we set destroyed to true before firing error callbacks in order\n // to make it re-entrance safe in case destroy() is called within callbacks\n\n if (this._readableState) {\n this._readableState.destroyed = true;\n }\n\n // if this is a duplex stream mark the writable part as destroyed as well\n if (this._writableState) {\n this._writableState.destroyed = true;\n }\n\n this._destroy(err || null, function (err) {\n if (!cb && err) {\n processNextTick(emitErrorNT, _this, err);\n if (_this._writableState) {\n _this._writableState.errorEmitted = true;\n }\n } else if (cb) {\n cb(err);\n }\n });\n}\n\nfunction undestroy() {\n if (this._readableState) {\n this._readableState.destroyed = false;\n this._readableState.reading = false;\n this._readableState.ended = false;\n this._readableState.endEmitted = false;\n }\n\n if (this._writableState) {\n this._writableState.destroyed = false;\n this._writableState.ended = false;\n this._writableState.ending = false;\n this._writableState.finished = false;\n this._writableState.errorEmitted = false;\n }\n}\n\nfunction emitErrorNT(self, err) {\n self.emit('error', err);\n}\n\nmodule.exports = {\n destroy: destroy,\n undestroy: undestroy\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/readable-stream/lib/internal/streams/destroy.js\n// module id = x0Ha\n// module chunks = 2","'use strict';\n\nif (!process.version ||\n process.version.indexOf('v0.') === 0 ||\n process.version.indexOf('v1.') === 0 && process.version.indexOf('v1.8.') !== 0) {\n module.exports = nextTick;\n} else {\n module.exports = process.nextTick;\n}\n\nfunction nextTick(fn, arg1, arg2, arg3) {\n if (typeof fn !== 'function') {\n throw new TypeError('\"callback\" argument must be a function');\n }\n var len = arguments.length;\n var args, i;\n switch (len) {\n case 0:\n case 1:\n return process.nextTick(fn);\n case 2:\n return process.nextTick(function afterTickOne() {\n fn.call(null, arg1);\n });\n case 3:\n return process.nextTick(function afterTickTwo() {\n fn.call(null, arg1, arg2);\n });\n case 4:\n return process.nextTick(function afterTickThree() {\n fn.call(null, arg1, arg2, arg3);\n });\n default:\n args = new Array(len - 1);\n i = 0;\n while (i < args.length) {\n args[i++] = arguments[i];\n }\n return process.nextTick(function afterTick() {\n fn.apply(null, args);\n });\n }\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/process-nextick-args/index.js\n// module id = ypnx\n// module chunks = 2","function injectStyle (ssrContext) {\n require(\"!!../../../../node_modules/extract-text-webpack-plugin/loader.js?{\\\"omit\\\":1,\\\"remove\\\":true}!vue-style-loader!css-loader?{\\\"minimize\\\":true,\\\"sourceMap\\\":true}!../../../../node_modules/vue-loader/lib/style-compiler/index?{\\\"vue\\\":true,\\\"id\\\":\\\"data-v-94cc7036\\\",\\\"scoped\\\":false,\\\"hasInlineConfig\\\":false}!../../../../node_modules/vue-loader/lib/selector?type=styles&index=0!./add.vue\")\n}\nvar normalizeComponent = require(\"!../../../../node_modules/vue-loader/lib/component-normalizer\")\n/* script */\nimport __vue_script__ from \"!!babel-loader!../../../../node_modules/vue-loader/lib/selector?type=script&index=0!./add.vue\"\n/* template */\nimport __vue_template__ from \"!!../../../../node_modules/vue-loader/lib/template-compiler/index?{\\\"id\\\":\\\"data-v-94cc7036\\\",\\\"hasScoped\\\":false}!../../../../node_modules/vue-loader/lib/selector?type=template&index=0!./add.vue\"\n/* styles */\nvar __vue_styles__ = injectStyle\n/* scopeId */\nvar __vue_scopeId__ = null\n/* moduleIdentifier (server only) */\nvar __vue_module_identifier__ = null\nvar Component = normalizeComponent(\n __vue_script__,\n __vue_template__,\n __vue_styles__,\n __vue_scopeId__,\n __vue_module_identifier__\n)\n\nexport default Component.exports\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./src/views/ota/version/add.vue\n// module id = yq/Z\n// module chunks = 2"],"sourceRoot":""}
|