{"version":3,"sources":["webpack:///./node_modules/node-libs-browser/node_modules/buffer/index.js","webpack:///./src/assets/image/nicard-logo-part-3.png","webpack:///./node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js","webpack:///./src/assets/image/nicard-logo-part-1.png","webpack:///./node_modules/base64-js/index.js","webpack:///./src/assets/image/NoImage.jpg","webpack:///./src/assets/image/nicard-logo-part-2.png","webpack:///./src/components/LiveLogo.vue?ed64","webpack:///./node_modules/compressorjs/dist/compressor.js","webpack:///./node_modules/ieee754/index.js","webpack:///./node_modules/regenerator-runtime/runtime.js","webpack:///./src/components/LiveLogo.vue","webpack:///src/components/LiveLogo.vue","webpack:///./src/components/LiveLogo.vue?accc","webpack:///./src/components/LiveLogo.vue?1046","webpack:///./node_modules/isarray/index.js"],"names":["base64","ieee754","isArray","typedArraySupport","arr","Uint8Array","__proto__","prototype","foo","subarray","byteLength","e","kMaxLength","Buffer","TYPED_ARRAY_SUPPORT","createBuffer","that","length","RangeError","arg","encodingOrOffset","this","Error","allocUnsafe","from","value","TypeError","ArrayBuffer","fromArrayBuffer","fromString","fromObject","assertSize","size","alloc","fill","encoding","undefined","checked","i","string","isEncoding","actual","write","slice","fromArrayLike","array","byteOffset","obj","isBuffer","len","copy","buffer","isnan","type","data","toString","SlowBuffer","isView","loweredCase","utf8ToBytes","base64ToBytes","toLowerCase","slowToString","start","end","hexSlice","utf8Slice","asciiSlice","latin1Slice","base64Slice","utf16leSlice","swap","b","n","m","bidirectionalIndexOf","val","dir","isNaN","arrayIndexOf","indexOf","call","lastIndexOf","indexSize","arrLength","valLength","String","read","buf","readUInt16BE","foundIndex","found","j","hexWrite","offset","Number","remaining","strLen","parsed","parseInt","substr","utf8Write","blitBuffer","asciiWrite","asciiToBytes","latin1Write","base64Write","ucs2Write","utf16leToBytes","fromByteArray","Math","min","res","secondByte","thirdByte","fourthByte","tempCodePoint","firstByte","codePoint","bytesPerSequence","push","decodeCodePointsArray","exports","INSPECT_MAX_BYTES","global","poolSize","_augment","Symbol","species","Object","defineProperty","configurable","allocUnsafeSlow","_isBuffer","compare","a","x","y","concat","list","pos","swap16","swap32","swap64","arguments","apply","equals","inspect","str","max","match","join","target","thisStart","thisEnd","thisCopy","targetCopy","includes","isFinite","toJSON","Array","_arr","MAX_ARGUMENTS_LENGTH","codePoints","fromCharCode","ret","out","toHex","bytes","checkOffset","ext","checkInt","objectWriteUInt16","littleEndian","objectWriteUInt32","checkIEEE754","writeFloat","noAssert","writeDouble","newBuf","sliceLen","readUIntLE","mul","readUIntBE","readUInt8","readUInt16LE","readUInt32LE","readUInt32BE","readIntLE","pow","readIntBE","readInt8","readInt16LE","readInt16BE","readInt32LE","readInt32BE","readFloatLE","readFloatBE","readDoubleLE","readDoubleBE","writeUIntLE","maxBytes","writeUIntBE","writeUInt8","floor","writeUInt16LE","writeUInt16BE","writeUInt32LE","writeUInt32BE","writeIntLE","limit","sub","writeIntBE","writeInt8","writeInt16LE","writeInt16BE","writeInt32LE","writeInt32BE","writeFloatLE","writeFloatBE","writeDoubleLE","writeDoubleBE","targetStart","set","code","charCodeAt","INVALID_BASE64_RE","base64clean","stringtrim","replace","trim","units","Infinity","leadSurrogate","byteArray","c","hi","lo","toByteArray","src","dst","module","asyncGeneratorStep","t","r","o","u","done","Promise","resolve","then","_asyncToGenerator","_next","_throw","lookup","revLookup","Arr","getLens","b64","validLen","placeHoldersLen","lens","_byteLength","tmp","curByte","tripletToBase64","num","encodeChunk","uint8","output","extraBytes","parts","maxChunkLength","len2","factory","ownKeys","object","enumerableOnly","keys","getOwnPropertySymbols","symbols","filter","sym","getOwnPropertyDescriptor","enumerable","_objectSpread2","source","forEach","key","_defineProperty","getOwnPropertyDescriptors","defineProperties","_classCallCheck","instance","Constructor","_defineProperties","props","descriptor","writable","_toPropertyKey","_createClass","protoProps","staticProps","_extends","assign","bind","hasOwnProperty","_toPrimitive","input","hint","prim","toPrimitive","canvasToBlob","window","CanvasPrototype","HTMLCanvasElement","hasBlobConstructor","Blob","Boolean","hasArrayBufferViewSupport","BlobBuilder","WebKitBlobBuilder","MozBlobBuilder","MSBlobBuilder","dataURIPattern","dataURLtoBlob","atob","dataURI","matches","mediaType","isBase64","dataString","byteString","arrayBuffer","intArray","bb","decodeURIComponent","append","getBlob","toBlob","mozGetAsFile","callback","quality","self","setTimeout","toDataURL","msToBlob","isBlob","DEFAULTS","strict","checkOrientation","retainExif","maxWidth","maxHeight","minWidth","minHeight","width","height","resize","mimeType","convertTypes","convertSize","beforeDraw","drew","success","error","IS_BROWSER","document","WINDOW","isPositiveNumber","toArray","REGEXP_IMAGE_TYPE","isImageType","test","imageTypeToExtension","extension","getStringFromCharCode","dataView","getUint8","btoa","arrayBufferToDataURL","chunks","chunkSize","resetAndGetOrientation","orientation","DataView","app1Start","ifdStart","exifIDCode","tiffOffset","endianness","getUint16","firstIFDOffset","getUint32","_offset","_length","setUint16","parseOrientation","rotate","scaleX","scaleY","REGEXP_DECIMALS","normalizeDecimalNumber","times","round","getAdjustedSizes","_ref","aspectRatio","isValidWidth","isValidHeight","adjustedWidth","getExif","segments","next","segment","reduce","exifArray","current","insertExif","app0Length","newArrayBuffer","ArrayBuffer$1","FileReader","URL","webkitURL","REGEXP_EXTENSION","AnotherCompressor","Compressor","file","options","exif","image","Image","aborted","result","init","_this","isJPEGImage","reader","onload","url","createObjectURL","load","onabort","fail","onerror","onloadend","readAsArrayBuffer","readAsDataURL","_this2","draw","naturalWidth","naturalHeight","navigator","userAgent","crossOrigin","alt","name","_ref2","_this3","_ref2$rotate","_ref2$scaleX","_ref2$scaleY","canvas","createElement","context","getContext","is90DegreesRotated","abs","resizable","_ref3","_ref4","_ref5","_getAdjustedSizes","_getAdjustedSizes2","_getAdjustedSizes3","_getAdjustedSizes4","_getAdjustedSizes4$wi","_getAdjustedSizes4$he","destX","destY","destWidth","destHeight","params","srcX","srcY","srcWidth","srcHeight","_getAdjustedSizes5","contain","cover","_ref6","fillStyle","fillRect","save","translate","PI","scale","drawImage","restore","blob","catch","_ref7","_ref8","revokeObjectURL","date","Date","lastModified","getTime","lastModifiedDate","err","abort","complete","isLE","mLen","nBytes","eLen","eMax","eBias","nBits","d","s","NaN","rt","log","LN2","runtime","Op","hasOwn","desc","$Symbol","iteratorSymbol","iterator","asyncIteratorSymbol","asyncIterator","toStringTagSymbol","toStringTag","define","wrap","innerFn","outerFn","tryLocsList","protoGenerator","Generator","generator","create","Context","makeInvokeMethod","tryCatch","fn","GenStateSuspendedStart","GenStateSuspendedYield","GenStateExecuting","GenStateCompleted","ContinueSentinel","GeneratorFunction","GeneratorFunctionPrototype","IteratorPrototype","getProto","getPrototypeOf","NativeIteratorPrototype","values","Gp","defineIteratorMethods","method","_invoke","AsyncIterator","PromiseImpl","invoke","reject","record","__await","unwrapped","previousPromise","enqueue","callInvokeWithMethodAndArg","state","doneResult","delegate","delegateResult","maybeInvokeDelegate","sent","_sent","dispatchException","abrupt","methodName","info","resultName","nextLoc","pushTryEntry","locs","entry","tryLoc","catchLoc","finallyLoc","afterLoc","tryEntries","resetTryEntry","completion","reset","iterable","iteratorMethod","displayName","isGeneratorFunction","genFun","ctor","constructor","mark","setPrototypeOf","awrap","async","iter","reverse","pop","skipTempReset","prev","charAt","stop","rootEntry","rootRecord","rval","exception","handle","loc","caught","hasCatch","hasFinally","finallyEntry","finish","thrown","delegateYield","regeneratorRuntime","accidentalStrictMode","globalThis","Function","render","_vm","_c","_self","staticClass","class","tiny","no_bg","attrs","require","staticRenderFns","component"],"mappings":"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","file":"js/Club~748942c6.cf974b73.js","sourcesContent":["/*!\n * The buffer module from node.js, for the browser.\n *\n * @author Feross Aboukhadijeh \n * @license MIT\n */\n/* eslint-disable no-proto */\n\n'use strict'\n\nvar base64 = require('base64-js')\nvar ieee754 = require('ieee754')\nvar isArray = require('isarray')\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.INSPECT_MAX_BYTES = 50\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n * === true Use Uint8Array implementation (fastest)\n * === false Use Object implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * Due to various browser bugs, sometimes the Object implementation will be used even\n * when the browser supports typed arrays.\n *\n * Note:\n *\n * - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,\n * See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.\n *\n * - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.\n *\n * - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of\n * incorrect length in some situations.\n\n * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they\n * get the Object implementation, which is slower but behaves correctly.\n */\nBuffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined\n ? global.TYPED_ARRAY_SUPPORT\n : typedArraySupport()\n\n/*\n * Export kMaxLength after typed array support is determined.\n */\nexports.kMaxLength = kMaxLength()\n\nfunction typedArraySupport () {\n try {\n var arr = new Uint8Array(1)\n arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}\n return arr.foo() === 42 && // typed array instances can be augmented\n typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`\n arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`\n } catch (e) {\n return false\n }\n}\n\nfunction kMaxLength () {\n return Buffer.TYPED_ARRAY_SUPPORT\n ? 0x7fffffff\n : 0x3fffffff\n}\n\nfunction createBuffer (that, length) {\n if (kMaxLength() < length) {\n throw new RangeError('Invalid typed array length')\n }\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n // Return an augmented `Uint8Array` instance, for best performance\n that = new Uint8Array(length)\n that.__proto__ = Buffer.prototype\n } else {\n // Fallback: Return an object instance of the Buffer class\n if (that === null) {\n that = new Buffer(length)\n }\n that.length = length\n }\n\n return that\n}\n\n/**\n * The Buffer constructor returns instances of `Uint8Array` that have their\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n * returns a single octet.\n *\n * The `Uint8Array` prototype remains unmodified.\n */\n\nfunction Buffer (arg, encodingOrOffset, length) {\n if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {\n return new Buffer(arg, encodingOrOffset, length)\n }\n\n // Common case.\n if (typeof arg === 'number') {\n if (typeof encodingOrOffset === 'string') {\n throw new Error(\n 'If encoding is specified then the first argument must be a string'\n )\n }\n return allocUnsafe(this, arg)\n }\n return from(this, arg, encodingOrOffset, length)\n}\n\nBuffer.poolSize = 8192 // not used by this implementation\n\n// TODO: Legacy, not needed anymore. Remove in next major version.\nBuffer._augment = function (arr) {\n arr.__proto__ = Buffer.prototype\n return arr\n}\n\nfunction from (that, value, encodingOrOffset, length) {\n if (typeof value === 'number') {\n throw new TypeError('\"value\" argument must not be a number')\n }\n\n if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {\n return fromArrayBuffer(that, value, encodingOrOffset, length)\n }\n\n if (typeof value === 'string') {\n return fromString(that, value, encodingOrOffset)\n }\n\n return fromObject(that, value)\n}\n\n/**\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n * if value is a number.\n * Buffer.from(str[, encoding])\n * Buffer.from(array)\n * Buffer.from(buffer)\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\n **/\nBuffer.from = function (value, encodingOrOffset, length) {\n return from(null, value, encodingOrOffset, length)\n}\n\nif (Buffer.TYPED_ARRAY_SUPPORT) {\n Buffer.prototype.__proto__ = Uint8Array.prototype\n Buffer.__proto__ = Uint8Array\n if (typeof Symbol !== 'undefined' && Symbol.species &&\n Buffer[Symbol.species] === Buffer) {\n // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97\n Object.defineProperty(Buffer, Symbol.species, {\n value: null,\n configurable: true\n })\n }\n}\n\nfunction assertSize (size) {\n if (typeof size !== 'number') {\n throw new TypeError('\"size\" argument must be a number')\n } else if (size < 0) {\n throw new RangeError('\"size\" argument must not be negative')\n }\n}\n\nfunction alloc (that, size, fill, encoding) {\n assertSize(size)\n if (size <= 0) {\n return createBuffer(that, size)\n }\n if (fill !== undefined) {\n // Only pay attention to encoding if it's a string. This\n // prevents accidentally sending in a number that would\n // be interpretted as a start offset.\n return typeof encoding === 'string'\n ? createBuffer(that, size).fill(fill, encoding)\n : createBuffer(that, size).fill(fill)\n }\n return createBuffer(that, size)\n}\n\n/**\n * Creates a new filled Buffer instance.\n * alloc(size[, fill[, encoding]])\n **/\nBuffer.alloc = function (size, fill, encoding) {\n return alloc(null, size, fill, encoding)\n}\n\nfunction allocUnsafe (that, size) {\n assertSize(size)\n that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)\n if (!Buffer.TYPED_ARRAY_SUPPORT) {\n for (var i = 0; i < size; ++i) {\n that[i] = 0\n }\n }\n return that\n}\n\n/**\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n * */\nBuffer.allocUnsafe = function (size) {\n return allocUnsafe(null, size)\n}\n/**\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n */\nBuffer.allocUnsafeSlow = function (size) {\n return allocUnsafe(null, size)\n}\n\nfunction fromString (that, string, encoding) {\n if (typeof encoding !== 'string' || encoding === '') {\n encoding = 'utf8'\n }\n\n if (!Buffer.isEncoding(encoding)) {\n throw new TypeError('\"encoding\" must be a valid string encoding')\n }\n\n var length = byteLength(string, encoding) | 0\n that = createBuffer(that, length)\n\n var actual = that.write(string, encoding)\n\n if (actual !== length) {\n // Writing a hex string, for example, that contains invalid characters will\n // cause everything after the first invalid character to be ignored. (e.g.\n // 'abxxcd' will be treated as 'ab')\n that = that.slice(0, actual)\n }\n\n return that\n}\n\nfunction fromArrayLike (that, array) {\n var length = array.length < 0 ? 0 : checked(array.length) | 0\n that = createBuffer(that, length)\n for (var i = 0; i < length; i += 1) {\n that[i] = array[i] & 255\n }\n return that\n}\n\nfunction fromArrayBuffer (that, array, byteOffset, length) {\n array.byteLength // this throws if `array` is not a valid ArrayBuffer\n\n if (byteOffset < 0 || array.byteLength < byteOffset) {\n throw new RangeError('\\'offset\\' is out of bounds')\n }\n\n if (array.byteLength < byteOffset + (length || 0)) {\n throw new RangeError('\\'length\\' is out of bounds')\n }\n\n if (byteOffset === undefined && length === undefined) {\n array = new Uint8Array(array)\n } else if (length === undefined) {\n array = new Uint8Array(array, byteOffset)\n } else {\n array = new Uint8Array(array, byteOffset, length)\n }\n\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n // Return an augmented `Uint8Array` instance, for best performance\n that = array\n that.__proto__ = Buffer.prototype\n } else {\n // Fallback: Return an object instance of the Buffer class\n that = fromArrayLike(that, array)\n }\n return that\n}\n\nfunction fromObject (that, obj) {\n if (Buffer.isBuffer(obj)) {\n var len = checked(obj.length) | 0\n that = createBuffer(that, len)\n\n if (that.length === 0) {\n return that\n }\n\n obj.copy(that, 0, 0, len)\n return that\n }\n\n if (obj) {\n if ((typeof ArrayBuffer !== 'undefined' &&\n obj.buffer instanceof ArrayBuffer) || 'length' in obj) {\n if (typeof obj.length !== 'number' || isnan(obj.length)) {\n return createBuffer(that, 0)\n }\n return fromArrayLike(that, obj)\n }\n\n if (obj.type === 'Buffer' && isArray(obj.data)) {\n return fromArrayLike(that, obj.data)\n }\n }\n\n throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')\n}\n\nfunction checked (length) {\n // Note: cannot use `length < kMaxLength()` here because that fails when\n // length is NaN (which is otherwise coerced to zero.)\n if (length >= kMaxLength()) {\n throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n 'size: 0x' + kMaxLength().toString(16) + ' bytes')\n }\n return length | 0\n}\n\nfunction SlowBuffer (length) {\n if (+length != length) { // eslint-disable-line eqeqeq\n length = 0\n }\n return Buffer.alloc(+length)\n}\n\nBuffer.isBuffer = function isBuffer (b) {\n return !!(b != null && b._isBuffer)\n}\n\nBuffer.compare = function compare (a, b) {\n if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n throw new TypeError('Arguments must be Buffers')\n }\n\n if (a === b) return 0\n\n var x = a.length\n var y = b.length\n\n for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n if (a[i] !== b[i]) {\n x = a[i]\n y = b[i]\n break\n }\n }\n\n if (x < y) return -1\n if (y < x) return 1\n return 0\n}\n\nBuffer.isEncoding = function isEncoding (encoding) {\n switch (String(encoding).toLowerCase()) {\n case 'hex':\n case 'utf8':\n case 'utf-8':\n case 'ascii':\n case 'latin1':\n case 'binary':\n case 'base64':\n case 'ucs2':\n case 'ucs-2':\n case 'utf16le':\n case 'utf-16le':\n return true\n default:\n return false\n }\n}\n\nBuffer.concat = function concat (list, length) {\n if (!isArray(list)) {\n throw new TypeError('\"list\" argument must be an Array of Buffers')\n }\n\n if (list.length === 0) {\n return Buffer.alloc(0)\n }\n\n var i\n if (length === undefined) {\n length = 0\n for (i = 0; i < list.length; ++i) {\n length += list[i].length\n }\n }\n\n var buffer = Buffer.allocUnsafe(length)\n var pos = 0\n for (i = 0; i < list.length; ++i) {\n var buf = list[i]\n if (!Buffer.isBuffer(buf)) {\n throw new TypeError('\"list\" argument must be an Array of Buffers')\n }\n buf.copy(buffer, pos)\n pos += buf.length\n }\n return buffer\n}\n\nfunction byteLength (string, encoding) {\n if (Buffer.isBuffer(string)) {\n return string.length\n }\n if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&\n (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {\n return string.byteLength\n }\n if (typeof string !== 'string') {\n string = '' + string\n }\n\n var len = string.length\n if (len === 0) return 0\n\n // Use a for loop to avoid recursion\n var loweredCase = false\n for (;;) {\n switch (encoding) {\n case 'ascii':\n case 'latin1':\n case 'binary':\n return len\n case 'utf8':\n case 'utf-8':\n case undefined:\n return utf8ToBytes(string).length\n case 'ucs2':\n case 'ucs-2':\n case 'utf16le':\n case 'utf-16le':\n return len * 2\n case 'hex':\n return len >>> 1\n case 'base64':\n return base64ToBytes(string).length\n default:\n if (loweredCase) return utf8ToBytes(string).length // assume utf8\n encoding = ('' + encoding).toLowerCase()\n loweredCase = true\n }\n }\n}\nBuffer.byteLength = byteLength\n\nfunction slowToString (encoding, start, end) {\n var loweredCase = false\n\n // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n // property of a typed array.\n\n // This behaves neither like String nor Uint8Array in that we set start/end\n // to their upper/lower bounds if the value passed is out of range.\n // undefined is handled specially as per ECMA-262 6th Edition,\n // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\n if (start === undefined || start < 0) {\n start = 0\n }\n // Return early if start > this.length. Done here to prevent potential uint32\n // coercion fail below.\n if (start > this.length) {\n return ''\n }\n\n if (end === undefined || end > this.length) {\n end = this.length\n }\n\n if (end <= 0) {\n return ''\n }\n\n // Force coersion to uint32. This will also coerce falsey/NaN values to 0.\n end >>>= 0\n start >>>= 0\n\n if (end <= start) {\n return ''\n }\n\n if (!encoding) encoding = 'utf8'\n\n while (true) {\n switch (encoding) {\n case 'hex':\n return hexSlice(this, start, end)\n\n case 'utf8':\n case 'utf-8':\n return utf8Slice(this, start, end)\n\n case 'ascii':\n return asciiSlice(this, start, end)\n\n case 'latin1':\n case 'binary':\n return latin1Slice(this, start, end)\n\n case 'base64':\n return base64Slice(this, start, end)\n\n case 'ucs2':\n case 'ucs-2':\n case 'utf16le':\n case 'utf-16le':\n return utf16leSlice(this, start, end)\n\n default:\n if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n encoding = (encoding + '').toLowerCase()\n loweredCase = true\n }\n }\n}\n\n// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect\n// Buffer instances.\nBuffer.prototype._isBuffer = true\n\nfunction swap (b, n, m) {\n var i = b[n]\n b[n] = b[m]\n b[m] = i\n}\n\nBuffer.prototype.swap16 = function swap16 () {\n var len = this.length\n if (len % 2 !== 0) {\n throw new RangeError('Buffer size must be a multiple of 16-bits')\n }\n for (var i = 0; i < len; i += 2) {\n swap(this, i, i + 1)\n }\n return this\n}\n\nBuffer.prototype.swap32 = function swap32 () {\n var len = this.length\n if (len % 4 !== 0) {\n throw new RangeError('Buffer size must be a multiple of 32-bits')\n }\n for (var i = 0; i < len; i += 4) {\n swap(this, i, i + 3)\n swap(this, i + 1, i + 2)\n }\n return this\n}\n\nBuffer.prototype.swap64 = function swap64 () {\n var len = this.length\n if (len % 8 !== 0) {\n throw new RangeError('Buffer size must be a multiple of 64-bits')\n }\n for (var i = 0; i < len; i += 8) {\n swap(this, i, i + 7)\n swap(this, i + 1, i + 6)\n swap(this, i + 2, i + 5)\n swap(this, i + 3, i + 4)\n }\n return this\n}\n\nBuffer.prototype.toString = function toString () {\n var length = this.length | 0\n if (length === 0) return ''\n if (arguments.length === 0) return utf8Slice(this, 0, length)\n return slowToString.apply(this, arguments)\n}\n\nBuffer.prototype.equals = function equals (b) {\n if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n if (this === b) return true\n return Buffer.compare(this, b) === 0\n}\n\nBuffer.prototype.inspect = function inspect () {\n var str = ''\n var max = exports.INSPECT_MAX_BYTES\n if (this.length > 0) {\n str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')\n if (this.length > max) str += ' ... '\n }\n return ''\n}\n\nBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\n if (!Buffer.isBuffer(target)) {\n throw new TypeError('Argument must be a Buffer')\n }\n\n if (start === undefined) {\n start = 0\n }\n if (end === undefined) {\n end = target ? target.length : 0\n }\n if (thisStart === undefined) {\n thisStart = 0\n }\n if (thisEnd === undefined) {\n thisEnd = this.length\n }\n\n if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n throw new RangeError('out of range index')\n }\n\n if (thisStart >= thisEnd && start >= end) {\n return 0\n }\n if (thisStart >= thisEnd) {\n return -1\n }\n if (start >= end) {\n return 1\n }\n\n start >>>= 0\n end >>>= 0\n thisStart >>>= 0\n thisEnd >>>= 0\n\n if (this === target) return 0\n\n var x = thisEnd - thisStart\n var y = end - start\n var len = Math.min(x, y)\n\n var thisCopy = this.slice(thisStart, thisEnd)\n var targetCopy = target.slice(start, end)\n\n for (var i = 0; i < len; ++i) {\n if (thisCopy[i] !== targetCopy[i]) {\n x = thisCopy[i]\n y = targetCopy[i]\n break\n }\n }\n\n if (x < y) return -1\n if (y < x) return 1\n return 0\n}\n\n// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n//\n// Arguments:\n// - buffer - a Buffer to search\n// - val - a string, Buffer, or number\n// - byteOffset - an index into `buffer`; will be clamped to an int32\n// - encoding - an optional encoding, relevant is val is a string\n// - dir - true for indexOf, false for lastIndexOf\nfunction bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {\n // Empty buffer means no match\n if (buffer.length === 0) return -1\n\n // Normalize byteOffset\n if (typeof byteOffset === 'string') {\n encoding = byteOffset\n byteOffset = 0\n } else if (byteOffset > 0x7fffffff) {\n byteOffset = 0x7fffffff\n } else if (byteOffset < -0x80000000) {\n byteOffset = -0x80000000\n }\n byteOffset = +byteOffset // Coerce to Number.\n if (isNaN(byteOffset)) {\n // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n byteOffset = dir ? 0 : (buffer.length - 1)\n }\n\n // Normalize byteOffset: negative offsets start from the end of the buffer\n if (byteOffset < 0) byteOffset = buffer.length + byteOffset\n if (byteOffset >= buffer.length) {\n if (dir) return -1\n else byteOffset = buffer.length - 1\n } else if (byteOffset < 0) {\n if (dir) byteOffset = 0\n else return -1\n }\n\n // Normalize val\n if (typeof val === 'string') {\n val = Buffer.from(val, encoding)\n }\n\n // Finally, search either indexOf (if dir is true) or lastIndexOf\n if (Buffer.isBuffer(val)) {\n // Special case: looking for empty string/buffer always fails\n if (val.length === 0) {\n return -1\n }\n return arrayIndexOf(buffer, val, byteOffset, encoding, dir)\n } else if (typeof val === 'number') {\n val = val & 0xFF // Search for a byte value [0-255]\n if (Buffer.TYPED_ARRAY_SUPPORT &&\n typeof Uint8Array.prototype.indexOf === 'function') {\n if (dir) {\n return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)\n } else {\n return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)\n }\n }\n return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)\n }\n\n throw new TypeError('val must be string, number or Buffer')\n}\n\nfunction arrayIndexOf (arr, val, byteOffset, encoding, dir) {\n var indexSize = 1\n var arrLength = arr.length\n var valLength = val.length\n\n if (encoding !== undefined) {\n encoding = String(encoding).toLowerCase()\n if (encoding === 'ucs2' || encoding === 'ucs-2' ||\n encoding === 'utf16le' || encoding === 'utf-16le') {\n if (arr.length < 2 || val.length < 2) {\n return -1\n }\n indexSize = 2\n arrLength /= 2\n valLength /= 2\n byteOffset /= 2\n }\n }\n\n function read (buf, i) {\n if (indexSize === 1) {\n return buf[i]\n } else {\n return buf.readUInt16BE(i * indexSize)\n }\n }\n\n var i\n if (dir) {\n var foundIndex = -1\n for (i = byteOffset; i < arrLength; i++) {\n if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n if (foundIndex === -1) foundIndex = i\n if (i - foundIndex + 1 === valLength) return foundIndex * indexSize\n } else {\n if (foundIndex !== -1) i -= i - foundIndex\n foundIndex = -1\n }\n }\n } else {\n if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength\n for (i = byteOffset; i >= 0; i--) {\n var found = true\n for (var j = 0; j < valLength; j++) {\n if (read(arr, i + j) !== read(val, j)) {\n found = false\n break\n }\n }\n if (found) return i\n }\n }\n\n return -1\n}\n\nBuffer.prototype.includes = function includes (val, byteOffset, encoding) {\n return this.indexOf(val, byteOffset, encoding) !== -1\n}\n\nBuffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {\n return bidirectionalIndexOf(this, val, byteOffset, encoding, true)\n}\n\nBuffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {\n return bidirectionalIndexOf(this, val, byteOffset, encoding, false)\n}\n\nfunction hexWrite (buf, string, offset, length) {\n offset = Number(offset) || 0\n var remaining = buf.length - offset\n if (!length) {\n length = remaining\n } else {\n length = Number(length)\n if (length > remaining) {\n length = remaining\n }\n }\n\n // must be an even number of digits\n var strLen = string.length\n if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')\n\n if (length > strLen / 2) {\n length = strLen / 2\n }\n for (var i = 0; i < length; ++i) {\n var parsed = parseInt(string.substr(i * 2, 2), 16)\n if (isNaN(parsed)) return i\n buf[offset + i] = parsed\n }\n return i\n}\n\nfunction utf8Write (buf, string, offset, length) {\n return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nfunction asciiWrite (buf, string, offset, length) {\n return blitBuffer(asciiToBytes(string), buf, offset, length)\n}\n\nfunction latin1Write (buf, string, offset, length) {\n return asciiWrite(buf, string, offset, length)\n}\n\nfunction base64Write (buf, string, offset, length) {\n return blitBuffer(base64ToBytes(string), buf, offset, length)\n}\n\nfunction ucs2Write (buf, string, offset, length) {\n return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nBuffer.prototype.write = function write (string, offset, length, encoding) {\n // Buffer#write(string)\n if (offset === undefined) {\n encoding = 'utf8'\n length = this.length\n offset = 0\n // Buffer#write(string, encoding)\n } else if (length === undefined && typeof offset === 'string') {\n encoding = offset\n length = this.length\n offset = 0\n // Buffer#write(string, offset[, length][, encoding])\n } else if (isFinite(offset)) {\n offset = offset | 0\n if (isFinite(length)) {\n length = length | 0\n if (encoding === undefined) encoding = 'utf8'\n } else {\n encoding = length\n length = undefined\n }\n // legacy write(string, encoding, offset, length) - remove in v0.13\n } else {\n throw new Error(\n 'Buffer.write(string, encoding, offset[, length]) is no longer supported'\n )\n }\n\n var remaining = this.length - offset\n if (length === undefined || length > remaining) length = remaining\n\n if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n throw new RangeError('Attempt to write outside buffer bounds')\n }\n\n if (!encoding) encoding = 'utf8'\n\n var loweredCase = false\n for (;;) {\n switch (encoding) {\n case 'hex':\n return hexWrite(this, string, offset, length)\n\n case 'utf8':\n case 'utf-8':\n return utf8Write(this, string, offset, length)\n\n case 'ascii':\n return asciiWrite(this, string, offset, length)\n\n case 'latin1':\n case 'binary':\n return latin1Write(this, string, offset, length)\n\n case 'base64':\n // Warning: maxLength not taken into account in base64Write\n return base64Write(this, string, offset, length)\n\n case 'ucs2':\n case 'ucs-2':\n case 'utf16le':\n case 'utf-16le':\n return ucs2Write(this, string, offset, length)\n\n default:\n if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n encoding = ('' + encoding).toLowerCase()\n loweredCase = true\n }\n }\n}\n\nBuffer.prototype.toJSON = function toJSON () {\n return {\n type: 'Buffer',\n data: Array.prototype.slice.call(this._arr || this, 0)\n }\n}\n\nfunction base64Slice (buf, start, end) {\n if (start === 0 && end === buf.length) {\n return base64.fromByteArray(buf)\n } else {\n return base64.fromByteArray(buf.slice(start, end))\n }\n}\n\nfunction utf8Slice (buf, start, end) {\n end = Math.min(buf.length, end)\n var res = []\n\n var i = start\n while (i < end) {\n var firstByte = buf[i]\n var codePoint = null\n var bytesPerSequence = (firstByte > 0xEF) ? 4\n : (firstByte > 0xDF) ? 3\n : (firstByte > 0xBF) ? 2\n : 1\n\n if (i + bytesPerSequence <= end) {\n var secondByte, thirdByte, fourthByte, tempCodePoint\n\n switch (bytesPerSequence) {\n case 1:\n if (firstByte < 0x80) {\n codePoint = firstByte\n }\n break\n case 2:\n secondByte = buf[i + 1]\n if ((secondByte & 0xC0) === 0x80) {\n tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\n if (tempCodePoint > 0x7F) {\n codePoint = tempCodePoint\n }\n }\n break\n case 3:\n secondByte = buf[i + 1]\n thirdByte = buf[i + 2]\n if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\n if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n codePoint = tempCodePoint\n }\n }\n break\n case 4:\n secondByte = buf[i + 1]\n thirdByte = buf[i + 2]\n fourthByte = buf[i + 3]\n if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\n if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n codePoint = tempCodePoint\n }\n }\n }\n }\n\n if (codePoint === null) {\n // we did not generate a valid codePoint so insert a\n // replacement char (U+FFFD) and advance only 1 byte\n codePoint = 0xFFFD\n bytesPerSequence = 1\n } else if (codePoint > 0xFFFF) {\n // encode to utf16 (surrogate pair dance)\n codePoint -= 0x10000\n res.push(codePoint >>> 10 & 0x3FF | 0xD800)\n codePoint = 0xDC00 | codePoint & 0x3FF\n }\n\n res.push(codePoint)\n i += bytesPerSequence\n }\n\n return decodeCodePointsArray(res)\n}\n\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\nvar MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n var len = codePoints.length\n if (len <= MAX_ARGUMENTS_LENGTH) {\n return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\n }\n\n // Decode in chunks to avoid \"call stack size exceeded\".\n var res = ''\n var i = 0\n while (i < len) {\n res += String.fromCharCode.apply(\n String,\n codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n )\n }\n return res\n}\n\nfunction asciiSlice (buf, start, end) {\n var ret = ''\n end = Math.min(buf.length, end)\n\n for (var i = start; i < end; ++i) {\n ret += String.fromCharCode(buf[i] & 0x7F)\n }\n return ret\n}\n\nfunction latin1Slice (buf, start, end) {\n var ret = ''\n end = Math.min(buf.length, end)\n\n for (var i = start; i < end; ++i) {\n ret += String.fromCharCode(buf[i])\n }\n return ret\n}\n\nfunction hexSlice (buf, start, end) {\n var len = buf.length\n\n if (!start || start < 0) start = 0\n if (!end || end < 0 || end > len) end = len\n\n var out = ''\n for (var i = start; i < end; ++i) {\n out += toHex(buf[i])\n }\n return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n var bytes = buf.slice(start, end)\n var res = ''\n for (var i = 0; i < bytes.length; i += 2) {\n res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)\n }\n return res\n}\n\nBuffer.prototype.slice = function slice (start, end) {\n var len = this.length\n start = ~~start\n end = end === undefined ? len : ~~end\n\n if (start < 0) {\n start += len\n if (start < 0) start = 0\n } else if (start > len) {\n start = len\n }\n\n if (end < 0) {\n end += len\n if (end < 0) end = 0\n } else if (end > len) {\n end = len\n }\n\n if (end < start) end = start\n\n var newBuf\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n newBuf = this.subarray(start, end)\n newBuf.__proto__ = Buffer.prototype\n } else {\n var sliceLen = end - start\n newBuf = new Buffer(sliceLen, undefined)\n for (var i = 0; i < sliceLen; ++i) {\n newBuf[i] = this[i + start]\n }\n }\n\n return newBuf\n}\n\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\nfunction checkOffset (offset, ext, length) {\n if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n}\n\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n var val = this[offset]\n var mul = 1\n var i = 0\n while (++i < byteLength && (mul *= 0x100)) {\n val += this[offset + i] * mul\n }\n\n return val\n}\n\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) {\n checkOffset(offset, byteLength, this.length)\n }\n\n var val = this[offset + --byteLength]\n var mul = 1\n while (byteLength > 0 && (mul *= 0x100)) {\n val += this[offset + --byteLength] * mul\n }\n\n return val\n}\n\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 1, this.length)\n return this[offset]\n}\n\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 2, this.length)\n return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 2, this.length)\n return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n\n return ((this[offset]) |\n (this[offset + 1] << 8) |\n (this[offset + 2] << 16)) +\n (this[offset + 3] * 0x1000000)\n}\n\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n\n return (this[offset] * 0x1000000) +\n ((this[offset + 1] << 16) |\n (this[offset + 2] << 8) |\n this[offset + 3])\n}\n\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n var val = this[offset]\n var mul = 1\n var i = 0\n while (++i < byteLength && (mul *= 0x100)) {\n val += this[offset + i] * mul\n }\n mul *= 0x80\n\n if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n return val\n}\n\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n var i = byteLength\n var mul = 1\n var val = this[offset + --i]\n while (i > 0 && (mul *= 0x100)) {\n val += this[offset + --i] * mul\n }\n mul *= 0x80\n\n if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n return val\n}\n\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 1, this.length)\n if (!(this[offset] & 0x80)) return (this[offset])\n return ((0xff - this[offset] + 1) * -1)\n}\n\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 2, this.length)\n var val = this[offset] | (this[offset + 1] << 8)\n return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 2, this.length)\n var val = this[offset + 1] | (this[offset] << 8)\n return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n\n return (this[offset]) |\n (this[offset + 1] << 8) |\n (this[offset + 2] << 16) |\n (this[offset + 3] << 24)\n}\n\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n\n return (this[offset] << 24) |\n (this[offset + 1] << 16) |\n (this[offset + 2] << 8) |\n (this[offset + 3])\n}\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n return ieee754.read(this, offset, true, 23, 4)\n}\n\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n return ieee754.read(this, offset, false, 23, 4)\n}\n\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 8, this.length)\n return ieee754.read(this, offset, true, 52, 8)\n}\n\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 8, this.length)\n return ieee754.read(this, offset, false, 52, 8)\n}\n\nfunction checkInt (buf, value, offset, ext, max, min) {\n if (!Buffer.isBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance')\n if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds')\n if (offset + ext > buf.length) throw new RangeError('Index out of range')\n}\n\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n value = +value\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) {\n var maxBytes = Math.pow(2, 8 * byteLength) - 1\n checkInt(this, value, offset, byteLength, maxBytes, 0)\n }\n\n var mul = 1\n var i = 0\n this[offset] = value & 0xFF\n while (++i < byteLength && (mul *= 0x100)) {\n this[offset + i] = (value / mul) & 0xFF\n }\n\n return offset + byteLength\n}\n\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n value = +value\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) {\n var maxBytes = Math.pow(2, 8 * byteLength) - 1\n checkInt(this, value, offset, byteLength, maxBytes, 0)\n }\n\n var i = byteLength - 1\n var mul = 1\n this[offset + i] = value & 0xFF\n while (--i >= 0 && (mul *= 0x100)) {\n this[offset + i] = (value / mul) & 0xFF\n }\n\n return offset + byteLength\n}\n\nBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\n if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n this[offset] = (value & 0xff)\n return offset + 1\n}\n\nfunction objectWriteUInt16 (buf, value, offset, littleEndian) {\n if (value < 0) value = 0xffff + value + 1\n for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {\n buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>\n (littleEndian ? i : 1 - i) * 8\n }\n}\n\nBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value & 0xff)\n this[offset + 1] = (value >>> 8)\n } else {\n objectWriteUInt16(this, value, offset, true)\n }\n return offset + 2\n}\n\nBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value >>> 8)\n this[offset + 1] = (value & 0xff)\n } else {\n objectWriteUInt16(this, value, offset, false)\n }\n return offset + 2\n}\n\nfunction objectWriteUInt32 (buf, value, offset, littleEndian) {\n if (value < 0) value = 0xffffffff + value + 1\n for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {\n buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff\n }\n}\n\nBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset + 3] = (value >>> 24)\n this[offset + 2] = (value >>> 16)\n this[offset + 1] = (value >>> 8)\n this[offset] = (value & 0xff)\n } else {\n objectWriteUInt32(this, value, offset, true)\n }\n return offset + 4\n}\n\nBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value >>> 24)\n this[offset + 1] = (value >>> 16)\n this[offset + 2] = (value >>> 8)\n this[offset + 3] = (value & 0xff)\n } else {\n objectWriteUInt32(this, value, offset, false)\n }\n return offset + 4\n}\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) {\n var limit = Math.pow(2, 8 * byteLength - 1)\n\n checkInt(this, value, offset, byteLength, limit - 1, -limit)\n }\n\n var i = 0\n var mul = 1\n var sub = 0\n this[offset] = value & 0xFF\n while (++i < byteLength && (mul *= 0x100)) {\n if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n sub = 1\n }\n this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n }\n\n return offset + byteLength\n}\n\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) {\n var limit = Math.pow(2, 8 * byteLength - 1)\n\n checkInt(this, value, offset, byteLength, limit - 1, -limit)\n }\n\n var i = byteLength - 1\n var mul = 1\n var sub = 0\n this[offset + i] = value & 0xFF\n while (--i >= 0 && (mul *= 0x100)) {\n if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n sub = 1\n }\n this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n }\n\n return offset + byteLength\n}\n\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\n if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n if (value < 0) value = 0xff + value + 1\n this[offset] = (value & 0xff)\n return offset + 1\n}\n\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value & 0xff)\n this[offset + 1] = (value >>> 8)\n } else {\n objectWriteUInt16(this, value, offset, true)\n }\n return offset + 2\n}\n\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value >>> 8)\n this[offset + 1] = (value & 0xff)\n } else {\n objectWriteUInt16(this, value, offset, false)\n }\n return offset + 2\n}\n\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value & 0xff)\n this[offset + 1] = (value >>> 8)\n this[offset + 2] = (value >>> 16)\n this[offset + 3] = (value >>> 24)\n } else {\n objectWriteUInt32(this, value, offset, true)\n }\n return offset + 4\n}\n\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n if (value < 0) value = 0xffffffff + value + 1\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value >>> 24)\n this[offset + 1] = (value >>> 16)\n this[offset + 2] = (value >>> 8)\n this[offset + 3] = (value & 0xff)\n } else {\n objectWriteUInt32(this, value, offset, false)\n }\n return offset + 4\n}\n\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n if (offset + ext > buf.length) throw new RangeError('Index out of range')\n if (offset < 0) throw new RangeError('Index out of range')\n}\n\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n if (!noAssert) {\n checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\n }\n ieee754.write(buf, value, offset, littleEndian, 23, 4)\n return offset + 4\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n return writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n return writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n if (!noAssert) {\n checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\n }\n ieee754.write(buf, value, offset, littleEndian, 52, 8)\n return offset + 8\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n return writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n return writeDouble(this, value, offset, false, noAssert)\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n if (!start) start = 0\n if (!end && end !== 0) end = this.length\n if (targetStart >= target.length) targetStart = target.length\n if (!targetStart) targetStart = 0\n if (end > 0 && end < start) end = start\n\n // Copy 0 bytes; we're done\n if (end === start) return 0\n if (target.length === 0 || this.length === 0) return 0\n\n // Fatal error conditions\n if (targetStart < 0) {\n throw new RangeError('targetStart out of bounds')\n }\n if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')\n if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\n // Are we oob?\n if (end > this.length) end = this.length\n if (target.length - targetStart < end - start) {\n end = target.length - targetStart + start\n }\n\n var len = end - start\n var i\n\n if (this === target && start < targetStart && targetStart < end) {\n // descending copy from end\n for (i = len - 1; i >= 0; --i) {\n target[i + targetStart] = this[i + start]\n }\n } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {\n // ascending copy from start\n for (i = 0; i < len; ++i) {\n target[i + targetStart] = this[i + start]\n }\n } else {\n Uint8Array.prototype.set.call(\n target,\n this.subarray(start, start + len),\n targetStart\n )\n }\n\n return len\n}\n\n// Usage:\n// buffer.fill(number[, offset[, end]])\n// buffer.fill(buffer[, offset[, end]])\n// buffer.fill(string[, offset[, end]][, encoding])\nBuffer.prototype.fill = function fill (val, start, end, encoding) {\n // Handle string cases:\n if (typeof val === 'string') {\n if (typeof start === 'string') {\n encoding = start\n start = 0\n end = this.length\n } else if (typeof end === 'string') {\n encoding = end\n end = this.length\n }\n if (val.length === 1) {\n var code = val.charCodeAt(0)\n if (code < 256) {\n val = code\n }\n }\n if (encoding !== undefined && typeof encoding !== 'string') {\n throw new TypeError('encoding must be a string')\n }\n if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n throw new TypeError('Unknown encoding: ' + encoding)\n }\n } else if (typeof val === 'number') {\n val = val & 255\n }\n\n // Invalid ranges are not set to a default, so can range check early.\n if (start < 0 || this.length < start || this.length < end) {\n throw new RangeError('Out of range index')\n }\n\n if (end <= start) {\n return this\n }\n\n start = start >>> 0\n end = end === undefined ? this.length : end >>> 0\n\n if (!val) val = 0\n\n var i\n if (typeof val === 'number') {\n for (i = start; i < end; ++i) {\n this[i] = val\n }\n } else {\n var bytes = Buffer.isBuffer(val)\n ? val\n : utf8ToBytes(new Buffer(val, encoding).toString())\n var len = bytes.length\n for (i = 0; i < end - start; ++i) {\n this[i + start] = bytes[i % len]\n }\n }\n\n return this\n}\n\n// HELPER FUNCTIONS\n// ================\n\nvar INVALID_BASE64_RE = /[^+\\/0-9A-Za-z-_]/g\n\nfunction base64clean (str) {\n // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n str = stringtrim(str).replace(INVALID_BASE64_RE, '')\n // Node converts strings with length < 2 to ''\n if (str.length < 2) return ''\n // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n while (str.length % 4 !== 0) {\n str = str + '='\n }\n return str\n}\n\nfunction stringtrim (str) {\n if (str.trim) return str.trim()\n return str.replace(/^\\s+|\\s+$/g, '')\n}\n\nfunction toHex (n) {\n if (n < 16) return '0' + n.toString(16)\n return n.toString(16)\n}\n\nfunction utf8ToBytes (string, units) {\n units = units || Infinity\n var codePoint\n var length = string.length\n var leadSurrogate = null\n var bytes = []\n\n for (var i = 0; i < length; ++i) {\n codePoint = string.charCodeAt(i)\n\n // is surrogate component\n if (codePoint > 0xD7FF && codePoint < 0xE000) {\n // last char was a lead\n if (!leadSurrogate) {\n // no lead yet\n if (codePoint > 0xDBFF) {\n // unexpected trail\n if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n continue\n } else if (i + 1 === length) {\n // unpaired lead\n if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n continue\n }\n\n // valid lead\n leadSurrogate = codePoint\n\n continue\n }\n\n // 2 leads in a row\n if (codePoint < 0xDC00) {\n if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n leadSurrogate = codePoint\n continue\n }\n\n // valid surrogate pair\n codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000\n } else if (leadSurrogate) {\n // valid bmp char, but last char was a lead\n if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n }\n\n leadSurrogate = null\n\n // encode utf8\n if (codePoint < 0x80) {\n if ((units -= 1) < 0) break\n bytes.push(codePoint)\n } else if (codePoint < 0x800) {\n if ((units -= 2) < 0) break\n bytes.push(\n codePoint >> 0x6 | 0xC0,\n codePoint & 0x3F | 0x80\n )\n } else if (codePoint < 0x10000) {\n if ((units -= 3) < 0) break\n bytes.push(\n codePoint >> 0xC | 0xE0,\n codePoint >> 0x6 & 0x3F | 0x80,\n codePoint & 0x3F | 0x80\n )\n } else if (codePoint < 0x110000) {\n if ((units -= 4) < 0) break\n bytes.push(\n codePoint >> 0x12 | 0xF0,\n codePoint >> 0xC & 0x3F | 0x80,\n codePoint >> 0x6 & 0x3F | 0x80,\n codePoint & 0x3F | 0x80\n )\n } else {\n throw new Error('Invalid code point')\n }\n }\n\n return bytes\n}\n\nfunction asciiToBytes (str) {\n var byteArray = []\n for (var i = 0; i < str.length; ++i) {\n // Node's code seems to be doing this and not & 0x7F..\n byteArray.push(str.charCodeAt(i) & 0xFF)\n }\n return byteArray\n}\n\nfunction utf16leToBytes (str, units) {\n var c, hi, lo\n var byteArray = []\n for (var i = 0; i < str.length; ++i) {\n if ((units -= 2) < 0) break\n\n c = str.charCodeAt(i)\n hi = c >> 8\n lo = c % 256\n byteArray.push(lo)\n byteArray.push(hi)\n }\n\n return byteArray\n}\n\nfunction base64ToBytes (str) {\n return base64.toByteArray(base64clean(str))\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n for (var i = 0; i < length; ++i) {\n if ((i + offset >= dst.length) || (i >= src.length)) break\n dst[i + offset] = src[i]\n }\n return i\n}\n\nfunction isnan (val) {\n return val !== val // eslint-disable-line no-self-compare\n}\n","module.exports = __webpack_public_path__ + \"img/nicard-logo-part-3.4766458e.png\";","function asyncGeneratorStep(n, t, e, r, o, a, c) {\n try {\n var i = n[a](c),\n u = i.value;\n } catch (n) {\n return void e(n);\n }\n i.done ? t(u) : Promise.resolve(u).then(r, o);\n}\nfunction _asyncToGenerator(n) {\n return function () {\n var t = this,\n e = arguments;\n return new Promise(function (r, o) {\n var a = n.apply(t, e);\n function _next(n) {\n asyncGeneratorStep(a, r, o, _next, _throw, \"next\", n);\n }\n function _throw(n) {\n asyncGeneratorStep(a, r, o, _next, _throw, \"throw\", n);\n }\n _next(void 0);\n });\n };\n}\nexport { _asyncToGenerator as default };","module.exports = __webpack_public_path__ + \"img/nicard-logo-part-1.be98a343.png\";","'use strict'\n\nexports.byteLength = byteLength\nexports.toByteArray = toByteArray\nexports.fromByteArray = fromByteArray\n\nvar lookup = []\nvar revLookup = []\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array\n\nvar code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'\nfor (var i = 0, len = code.length; i < len; ++i) {\n lookup[i] = code[i]\n revLookup[code.charCodeAt(i)] = i\n}\n\n// Support decoding URL-safe base64 strings, as Node.js does.\n// See: https://en.wikipedia.org/wiki/Base64#URL_applications\nrevLookup['-'.charCodeAt(0)] = 62\nrevLookup['_'.charCodeAt(0)] = 63\n\nfunction getLens (b64) {\n var len = b64.length\n\n if (len % 4 > 0) {\n throw new Error('Invalid string. Length must be a multiple of 4')\n }\n\n // Trim off extra bytes after placeholder bytes are found\n // See: https://github.com/beatgammit/base64-js/issues/42\n var validLen = b64.indexOf('=')\n if (validLen === -1) validLen = len\n\n var placeHoldersLen = validLen === len\n ? 0\n : 4 - (validLen % 4)\n\n return [validLen, placeHoldersLen]\n}\n\n// base64 is 4/3 + up to two characters of the original data\nfunction byteLength (b64) {\n var lens = getLens(b64)\n var validLen = lens[0]\n var placeHoldersLen = lens[1]\n return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction _byteLength (b64, validLen, placeHoldersLen) {\n return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction toByteArray (b64) {\n var tmp\n var lens = getLens(b64)\n var validLen = lens[0]\n var placeHoldersLen = lens[1]\n\n var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))\n\n var curByte = 0\n\n // if there are placeholders, only get up to the last complete 4 chars\n var len = placeHoldersLen > 0\n ? validLen - 4\n : validLen\n\n var i\n for (i = 0; i < len; i += 4) {\n tmp =\n (revLookup[b64.charCodeAt(i)] << 18) |\n (revLookup[b64.charCodeAt(i + 1)] << 12) |\n (revLookup[b64.charCodeAt(i + 2)] << 6) |\n revLookup[b64.charCodeAt(i + 3)]\n arr[curByte++] = (tmp >> 16) & 0xFF\n arr[curByte++] = (tmp >> 8) & 0xFF\n arr[curByte++] = tmp & 0xFF\n }\n\n if (placeHoldersLen === 2) {\n tmp =\n (revLookup[b64.charCodeAt(i)] << 2) |\n (revLookup[b64.charCodeAt(i + 1)] >> 4)\n arr[curByte++] = tmp & 0xFF\n }\n\n if (placeHoldersLen === 1) {\n tmp =\n (revLookup[b64.charCodeAt(i)] << 10) |\n (revLookup[b64.charCodeAt(i + 1)] << 4) |\n (revLookup[b64.charCodeAt(i + 2)] >> 2)\n arr[curByte++] = (tmp >> 8) & 0xFF\n arr[curByte++] = tmp & 0xFF\n }\n\n return arr\n}\n\nfunction tripletToBase64 (num) {\n return lookup[num >> 18 & 0x3F] +\n lookup[num >> 12 & 0x3F] +\n lookup[num >> 6 & 0x3F] +\n lookup[num & 0x3F]\n}\n\nfunction encodeChunk (uint8, start, end) {\n var tmp\n var output = []\n for (var i = start; i < end; i += 3) {\n tmp =\n ((uint8[i] << 16) & 0xFF0000) +\n ((uint8[i + 1] << 8) & 0xFF00) +\n (uint8[i + 2] & 0xFF)\n output.push(tripletToBase64(tmp))\n }\n return output.join('')\n}\n\nfunction fromByteArray (uint8) {\n var tmp\n var len = uint8.length\n var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes\n var parts = []\n var maxChunkLength = 16383 // must be multiple of 3\n\n // go through the array every three bytes, we'll deal with trailing stuff later\n for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\n parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))\n }\n\n // pad the end with zeros, but make sure to not forget the extra bytes\n if (extraBytes === 1) {\n tmp = uint8[len - 1]\n parts.push(\n lookup[tmp >> 2] +\n lookup[(tmp << 4) & 0x3F] +\n '=='\n )\n } else if (extraBytes === 2) {\n tmp = (uint8[len - 2] << 8) + uint8[len - 1]\n parts.push(\n lookup[tmp >> 10] +\n lookup[(tmp >> 4) & 0x3F] +\n lookup[(tmp << 2) & 0x3F] +\n '='\n )\n }\n\n return parts.join('')\n}\n","module.exports = __webpack_public_path__ + \"img/NoImage.b9e45ee4.jpg\";","module.exports = __webpack_public_path__ + \"img/nicard-logo-part-2.929a7815.png\";","export * from \"-!../../node_modules/mini-css-extract-plugin/dist/loader.js??ref--6-oneOf-1-0!../../node_modules/css-loader/index.js??ref--6-oneOf-1-1!../../node_modules/vue-loader/lib/loaders/stylePostLoader.js!../../node_modules/postcss-loader/src/index.js??ref--6-oneOf-1-2!../../node_modules/cache-loader/dist/cjs.js??ref--0-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./LiveLogo.vue?vue&type=style&index=0&id=5b5f9f66&prod&scoped=true&lang=css\"","/*!\n * Compressor.js v1.2.1\n * https://fengyuanchen.github.io/compressorjs\n *\n * Copyright 2018-present Chen Fengyuan\n * Released under the MIT license\n *\n * Date: 2023-02-28T14:09:41.732Z\n */\n\n(function (global, factory) {\n typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :\n typeof define === 'function' && define.amd ? define(factory) :\n (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Compressor = factory());\n})(this, (function () { 'use strict';\n\n function ownKeys(object, enumerableOnly) {\n var keys = Object.keys(object);\n if (Object.getOwnPropertySymbols) {\n var symbols = Object.getOwnPropertySymbols(object);\n enumerableOnly && (symbols = symbols.filter(function (sym) {\n return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n })), keys.push.apply(keys, symbols);\n }\n return keys;\n }\n function _objectSpread2(target) {\n for (var i = 1; i < arguments.length; i++) {\n var source = null != arguments[i] ? arguments[i] : {};\n i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {\n _defineProperty(target, key, source[key]);\n }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {\n Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));\n });\n }\n return target;\n }\n function _classCallCheck(instance, Constructor) {\n if (!(instance instanceof Constructor)) {\n throw new TypeError(\"Cannot call a class as a function\");\n }\n }\n function _defineProperties(target, props) {\n for (var i = 0; i < props.length; i++) {\n var descriptor = props[i];\n descriptor.enumerable = descriptor.enumerable || false;\n descriptor.configurable = true;\n if (\"value\" in descriptor) descriptor.writable = true;\n Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);\n }\n }\n function _createClass(Constructor, protoProps, staticProps) {\n if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n if (staticProps) _defineProperties(Constructor, staticProps);\n Object.defineProperty(Constructor, \"prototype\", {\n writable: false\n });\n return Constructor;\n }\n function _defineProperty(obj, key, value) {\n key = _toPropertyKey(key);\n if (key in obj) {\n Object.defineProperty(obj, key, {\n value: value,\n enumerable: true,\n configurable: true,\n writable: true\n });\n } else {\n obj[key] = value;\n }\n return obj;\n }\n function _extends() {\n _extends = Object.assign ? Object.assign.bind() : function (target) {\n for (var i = 1; i < arguments.length; i++) {\n var source = arguments[i];\n for (var key in source) {\n if (Object.prototype.hasOwnProperty.call(source, key)) {\n target[key] = source[key];\n }\n }\n }\n return target;\n };\n return _extends.apply(this, arguments);\n }\n function _toPrimitive(input, hint) {\n if (typeof input !== \"object\" || input === null) return input;\n var prim = input[Symbol.toPrimitive];\n if (prim !== undefined) {\n var res = prim.call(input, hint || \"default\");\n if (typeof res !== \"object\") return res;\n throw new TypeError(\"@@toPrimitive must return a primitive value.\");\n }\n return (hint === \"string\" ? String : Number)(input);\n }\n function _toPropertyKey(arg) {\n var key = _toPrimitive(arg, \"string\");\n return typeof key === \"symbol\" ? key : String(key);\n }\n\n var canvasToBlob = {exports: {}};\n\n /*\n * JavaScript Canvas to Blob\n * https://github.com/blueimp/JavaScript-Canvas-to-Blob\n *\n * Copyright 2012, Sebastian Tschan\n * https://blueimp.net\n *\n * Licensed under the MIT license:\n * https://opensource.org/licenses/MIT\n *\n * Based on stackoverflow user Stoive's code snippet:\n * http://stackoverflow.com/q/4998908\n */\n (function (module) {\n if (typeof window === 'undefined') {\n return;\n }\n (function (window) {\n\n var CanvasPrototype = window.HTMLCanvasElement && window.HTMLCanvasElement.prototype;\n var hasBlobConstructor = window.Blob && function () {\n try {\n return Boolean(new Blob());\n } catch (e) {\n return false;\n }\n }();\n var hasArrayBufferViewSupport = hasBlobConstructor && window.Uint8Array && function () {\n try {\n return new Blob([new Uint8Array(100)]).size === 100;\n } catch (e) {\n return false;\n }\n }();\n var BlobBuilder = window.BlobBuilder || window.WebKitBlobBuilder || window.MozBlobBuilder || window.MSBlobBuilder;\n var dataURIPattern = /^data:((.*?)(;charset=.*?)?)(;base64)?,/;\n var dataURLtoBlob = (hasBlobConstructor || BlobBuilder) && window.atob && window.ArrayBuffer && window.Uint8Array && function (dataURI) {\n var matches, mediaType, isBase64, dataString, byteString, arrayBuffer, intArray, i, bb;\n // Parse the dataURI components as per RFC 2397\n matches = dataURI.match(dataURIPattern);\n if (!matches) {\n throw new Error('invalid data URI');\n }\n // Default to text/plain;charset=US-ASCII\n mediaType = matches[2] ? matches[1] : 'text/plain' + (matches[3] || ';charset=US-ASCII');\n isBase64 = !!matches[4];\n dataString = dataURI.slice(matches[0].length);\n if (isBase64) {\n // Convert base64 to raw binary data held in a string:\n byteString = atob(dataString);\n } else {\n // Convert base64/URLEncoded data component to raw binary:\n byteString = decodeURIComponent(dataString);\n }\n // Write the bytes of the string to an ArrayBuffer:\n arrayBuffer = new ArrayBuffer(byteString.length);\n intArray = new Uint8Array(arrayBuffer);\n for (i = 0; i < byteString.length; i += 1) {\n intArray[i] = byteString.charCodeAt(i);\n }\n // Write the ArrayBuffer (or ArrayBufferView) to a blob:\n if (hasBlobConstructor) {\n return new Blob([hasArrayBufferViewSupport ? intArray : arrayBuffer], {\n type: mediaType\n });\n }\n bb = new BlobBuilder();\n bb.append(arrayBuffer);\n return bb.getBlob(mediaType);\n };\n if (window.HTMLCanvasElement && !CanvasPrototype.toBlob) {\n if (CanvasPrototype.mozGetAsFile) {\n CanvasPrototype.toBlob = function (callback, type, quality) {\n var self = this;\n setTimeout(function () {\n if (quality && CanvasPrototype.toDataURL && dataURLtoBlob) {\n callback(dataURLtoBlob(self.toDataURL(type, quality)));\n } else {\n callback(self.mozGetAsFile('blob', type));\n }\n });\n };\n } else if (CanvasPrototype.toDataURL && dataURLtoBlob) {\n if (CanvasPrototype.msToBlob) {\n CanvasPrototype.toBlob = function (callback, type, quality) {\n var self = this;\n setTimeout(function () {\n if ((type && type !== 'image/png' || quality) && CanvasPrototype.toDataURL && dataURLtoBlob) {\n callback(dataURLtoBlob(self.toDataURL(type, quality)));\n } else {\n callback(self.msToBlob(type));\n }\n });\n };\n } else {\n CanvasPrototype.toBlob = function (callback, type, quality) {\n var self = this;\n setTimeout(function () {\n callback(dataURLtoBlob(self.toDataURL(type, quality)));\n });\n };\n }\n }\n }\n if (module.exports) {\n module.exports = dataURLtoBlob;\n } else {\n window.dataURLtoBlob = dataURLtoBlob;\n }\n })(window);\n })(canvasToBlob);\n var toBlob = canvasToBlob.exports;\n\n var isBlob = function isBlob(value) {\n if (typeof Blob === 'undefined') {\n return false;\n }\n return value instanceof Blob || Object.prototype.toString.call(value) === '[object Blob]';\n };\n\n var DEFAULTS = {\n /**\n * Indicates if output the original image instead of the compressed one\n * when the size of the compressed image is greater than the original one's\n * @type {boolean}\n */\n strict: true,\n /**\n * Indicates if read the image's Exif Orientation information,\n * and then rotate or flip the image automatically.\n * @type {boolean}\n */\n checkOrientation: true,\n /**\n * Indicates if retain the image's Exif information after compressed.\n * @type {boolean}\n */\n retainExif: false,\n /**\n * The max width of the output image.\n * @type {number}\n */\n maxWidth: Infinity,\n /**\n * The max height of the output image.\n * @type {number}\n */\n maxHeight: Infinity,\n /**\n * The min width of the output image.\n * @type {number}\n */\n minWidth: 0,\n /**\n * The min height of the output image.\n * @type {number}\n */\n minHeight: 0,\n /**\n * The width of the output image.\n * If not specified, the natural width of the source image will be used.\n * @type {number}\n */\n width: undefined,\n /**\n * The height of the output image.\n * If not specified, the natural height of the source image will be used.\n * @type {number}\n */\n height: undefined,\n /**\n * Sets how the size of the image should be resized to the container\n * specified by the `width` and `height` options.\n * @type {string}\n */\n resize: 'none',\n /**\n * The quality of the output image.\n * It must be a number between `0` and `1`,\n * and only available for `image/jpeg` and `image/webp` images.\n * Check out {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement/toBlob canvas.toBlob}.\n * @type {number}\n */\n quality: 0.8,\n /**\n * The mime type of the output image.\n * By default, the original mime type of the source image file will be used.\n * @type {string}\n */\n mimeType: 'auto',\n /**\n * Files whose file type is included in this list,\n * and whose file size exceeds the `convertSize` value will be converted to JPEGs.\n * @type {string｜Array}\n */\n convertTypes: ['image/png'],\n /**\n * PNG files over this size (5 MB by default) will be converted to JPEGs.\n * To disable this, just set the value to `Infinity`.\n * @type {number}\n */\n convertSize: 5000000,\n /**\n * The hook function to execute before draw the image into the canvas for compression.\n * @type {Function}\n * @param {CanvasRenderingContext2D} context - The 2d rendering context of the canvas.\n * @param {HTMLCanvasElement} canvas - The canvas for compression.\n * @example\n * function (context, canvas) {\n * context.fillStyle = '#fff';\n * }\n */\n beforeDraw: null,\n /**\n * The hook function to execute after drew the image into the canvas for compression.\n * @type {Function}\n * @param {CanvasRenderingContext2D} context - The 2d rendering context of the canvas.\n * @param {HTMLCanvasElement} canvas - The canvas for compression.\n * @example\n * function (context, canvas) {\n * context.filter = 'grayscale(100%)';\n * }\n */\n drew: null,\n /**\n * The hook function to execute when success to compress the image.\n * @type {Function}\n * @param {File} file - The compressed image File object.\n * @example\n * function (file) {\n * console.log(file);\n * }\n */\n success: null,\n /**\n * The hook function to execute when fail to compress the image.\n * @type {Function}\n * @param {Error} err - An Error object.\n * @example\n * function (err) {\n * console.log(err.message);\n * }\n */\n error: null\n };\n\n var IS_BROWSER = typeof window !== 'undefined' && typeof window.document !== 'undefined';\n var WINDOW = IS_BROWSER ? window : {};\n\n /**\n * Check if the given value is a positive number.\n * @param {*} value - The value to check.\n * @returns {boolean} Returns `true` if the given value is a positive number, else `false`.\n */\n var isPositiveNumber = function isPositiveNumber(value) {\n return value > 0 && value < Infinity;\n };\n var slice = Array.prototype.slice;\n\n /**\n * Convert array-like or iterable object to an array.\n * @param {*} value - The value to convert.\n * @returns {Array} Returns a new array.\n */\n function toArray(value) {\n return Array.from ? Array.from(value) : slice.call(value);\n }\n var REGEXP_IMAGE_TYPE = /^image\\/.+$/;\n\n /**\n * Check if the given value is a mime type of image.\n * @param {*} value - The value to check.\n * @returns {boolean} Returns `true` if the given is a mime type of image, else `false`.\n */\n function isImageType(value) {\n return REGEXP_IMAGE_TYPE.test(value);\n }\n\n /**\n * Convert image type to extension.\n * @param {string} value - The image type to convert.\n * @returns {boolean} Returns the image extension.\n */\n function imageTypeToExtension(value) {\n var extension = isImageType(value) ? value.substr(6) : '';\n if (extension === 'jpeg') {\n extension = 'jpg';\n }\n return \".\".concat(extension);\n }\n var fromCharCode = String.fromCharCode;\n\n /**\n * Get string from char code in data view.\n * @param {DataView} dataView - The data view for read.\n * @param {number} start - The start index.\n * @param {number} length - The read length.\n * @returns {string} The read result.\n */\n function getStringFromCharCode(dataView, start, length) {\n var str = '';\n var i;\n length += start;\n for (i = start; i < length; i += 1) {\n str += fromCharCode(dataView.getUint8(i));\n }\n return str;\n }\n var btoa = WINDOW.btoa;\n\n /**\n * Transform array buffer to Data URL.\n * @param {ArrayBuffer} arrayBuffer - The array buffer to transform.\n * @param {string} mimeType - The mime type of the Data URL.\n * @returns {string} The result Data URL.\n */\n function arrayBufferToDataURL(arrayBuffer, mimeType) {\n var chunks = [];\n var chunkSize = 8192;\n var uint8 = new Uint8Array(arrayBuffer);\n while (uint8.length > 0) {\n // XXX: Babel's `toConsumableArray` helper will throw error in IE or Safari 9\n // eslint-disable-next-line prefer-spread\n chunks.push(fromCharCode.apply(null, toArray(uint8.subarray(0, chunkSize))));\n uint8 = uint8.subarray(chunkSize);\n }\n return \"data:\".concat(mimeType, \";base64,\").concat(btoa(chunks.join('')));\n }\n\n /**\n * Get orientation value from given array buffer.\n * @param {ArrayBuffer} arrayBuffer - The array buffer to read.\n * @returns {number} The read orientation value.\n */\n function resetAndGetOrientation(arrayBuffer) {\n var dataView = new DataView(arrayBuffer);\n var orientation;\n\n // Ignores range error when the image does not have correct Exif information\n try {\n var littleEndian;\n var app1Start;\n var ifdStart;\n\n // Only handle JPEG image (start by 0xFFD8)\n if (dataView.getUint8(0) === 0xFF && dataView.getUint8(1) === 0xD8) {\n var length = dataView.byteLength;\n var offset = 2;\n while (offset + 1 < length) {\n if (dataView.getUint8(offset) === 0xFF && dataView.getUint8(offset + 1) === 0xE1) {\n app1Start = offset;\n break;\n }\n offset += 1;\n }\n }\n if (app1Start) {\n var exifIDCode = app1Start + 4;\n var tiffOffset = app1Start + 10;\n if (getStringFromCharCode(dataView, exifIDCode, 4) === 'Exif') {\n var endianness = dataView.getUint16(tiffOffset);\n littleEndian = endianness === 0x4949;\n if (littleEndian || endianness === 0x4D4D /* bigEndian */) {\n if (dataView.getUint16(tiffOffset + 2, littleEndian) === 0x002A) {\n var firstIFDOffset = dataView.getUint32(tiffOffset + 4, littleEndian);\n if (firstIFDOffset >= 0x00000008) {\n ifdStart = tiffOffset + firstIFDOffset;\n }\n }\n }\n }\n }\n if (ifdStart) {\n var _length = dataView.getUint16(ifdStart, littleEndian);\n var _offset;\n var i;\n for (i = 0; i < _length; i += 1) {\n _offset = ifdStart + i * 12 + 2;\n if (dataView.getUint16(_offset, littleEndian) === 0x0112 /* Orientation */) {\n // 8 is the offset of the current tag's value\n _offset += 8;\n\n // Get the original orientation value\n orientation = dataView.getUint16(_offset, littleEndian);\n\n // Override the orientation with its default value\n dataView.setUint16(_offset, 1, littleEndian);\n break;\n }\n }\n }\n } catch (e) {\n orientation = 1;\n }\n return orientation;\n }\n\n /**\n * Parse Exif Orientation value.\n * @param {number} orientation - The orientation to parse.\n * @returns {Object} The parsed result.\n */\n function parseOrientation(orientation) {\n var rotate = 0;\n var scaleX = 1;\n var scaleY = 1;\n switch (orientation) {\n // Flip horizontal\n case 2:\n scaleX = -1;\n break;\n\n // Rotate left 180°\n case 3:\n rotate = -180;\n break;\n\n // Flip vertical\n case 4:\n scaleY = -1;\n break;\n\n // Flip vertical and rotate right 90°\n case 5:\n rotate = 90;\n scaleY = -1;\n break;\n\n // Rotate right 90°\n case 6:\n rotate = 90;\n break;\n\n // Flip horizontal and rotate right 90°\n case 7:\n rotate = 90;\n scaleX = -1;\n break;\n\n // Rotate left 90°\n case 8:\n rotate = -90;\n break;\n }\n return {\n rotate: rotate,\n scaleX: scaleX,\n scaleY: scaleY\n };\n }\n var REGEXP_DECIMALS = /\\.\\d*(?:0|9){12}\\d*$/;\n\n /**\n * Normalize decimal number.\n * Check out {@link https://0.30000000000000004.com/}\n * @param {number} value - The value to normalize.\n * @param {number} [times=100000000000] - The times for normalizing.\n * @returns {number} Returns the normalized number.\n */\n function normalizeDecimalNumber(value) {\n var times = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 100000000000;\n return REGEXP_DECIMALS.test(value) ? Math.round(value * times) / times : value;\n }\n\n /**\n * Get the max sizes in a rectangle under the given aspect ratio.\n * @param {Object} data - The original sizes.\n * @param {string} [type='contain'] - The adjust type.\n * @returns {Object} The result sizes.\n */\n function getAdjustedSizes(_ref) {\n var aspectRatio = _ref.aspectRatio,\n height = _ref.height,\n width = _ref.width;\n var type = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'none';\n var isValidWidth = isPositiveNumber(width);\n var isValidHeight = isPositiveNumber(height);\n if (isValidWidth && isValidHeight) {\n var adjustedWidth = height * aspectRatio;\n if ((type === 'contain' || type === 'none') && adjustedWidth > width || type === 'cover' && adjustedWidth < width) {\n height = width / aspectRatio;\n } else {\n width = height * aspectRatio;\n }\n } else if (isValidWidth) {\n height = width / aspectRatio;\n } else if (isValidHeight) {\n width = height * aspectRatio;\n }\n return {\n width: width,\n height: height\n };\n }\n\n /**\n * Get Exif information from the given array buffer.\n * @param {ArrayBuffer} arrayBuffer - The array buffer to read.\n * @returns {Array} The read Exif information.\n */\n function getExif(arrayBuffer) {\n var array = toArray(new Uint8Array(arrayBuffer));\n var length = array.length;\n var segments = [];\n var start = 0;\n while (start + 3 < length) {\n var value = array[start];\n var next = array[start + 1];\n\n // SOS (Start of Scan)\n if (value === 0xFF && next === 0xDA) {\n break;\n }\n\n // SOI (Start of Image)\n if (value === 0xFF && next === 0xD8) {\n start += 2;\n } else {\n var offset = array[start + 2] * 256 + array[start + 3];\n var end = start + offset + 2;\n var segment = array.slice(start, end);\n segments.push(segment);\n start = end;\n }\n }\n return segments.reduce(function (exifArray, current) {\n if (current[0] === 0xFF && current[1] === 0xE1) {\n return exifArray.concat(current);\n }\n return exifArray;\n }, []);\n }\n\n /**\n * Insert Exif information into the given array buffer.\n * @param {ArrayBuffer} arrayBuffer - The array buffer to transform.\n * @param {Array} exifArray - The Exif information to insert.\n * @returns {ArrayBuffer} The transformed array buffer.\n */\n function insertExif(arrayBuffer, exifArray) {\n var array = toArray(new Uint8Array(arrayBuffer));\n if (array[2] !== 0xFF || array[3] !== 0xE0) {\n return arrayBuffer;\n }\n var app0Length = array[4] * 256 + array[5];\n var newArrayBuffer = [0xFF, 0xD8].concat(exifArray, array.slice(4 + app0Length));\n return new Uint8Array(newArrayBuffer);\n }\n\n var ArrayBuffer$1 = WINDOW.ArrayBuffer,\n FileReader = WINDOW.FileReader;\n var URL = WINDOW.URL || WINDOW.webkitURL;\n var REGEXP_EXTENSION = /\\.\\w+$/;\n var AnotherCompressor = WINDOW.Compressor;\n\n /**\n * Creates a new image compressor.\n * @class\n */\n var Compressor = /*#__PURE__*/function () {\n /**\n * The constructor of Compressor.\n * @param {File|Blob} file - The target image file for compressing.\n * @param {Object} [options] - The options for compressing.\n */\n function Compressor(file, options) {\n _classCallCheck(this, Compressor);\n this.file = file;\n this.exif = [];\n this.image = new Image();\n this.options = _objectSpread2(_objectSpread2({}, DEFAULTS), options);\n this.aborted = false;\n this.result = null;\n this.init();\n }\n _createClass(Compressor, [{\n key: \"init\",\n value: function init() {\n var _this = this;\n var file = this.file,\n options = this.options;\n if (!isBlob(file)) {\n this.fail(new Error('The first argument must be a File or Blob object.'));\n return;\n }\n var mimeType = file.type;\n if (!isImageType(mimeType)) {\n this.fail(new Error('The first argument must be an image File or Blob object.'));\n return;\n }\n if (!URL || !FileReader) {\n this.fail(new Error('The current browser does not support image compression.'));\n return;\n }\n if (!ArrayBuffer$1) {\n options.checkOrientation = false;\n options.retainExif = false;\n }\n var isJPEGImage = mimeType === 'image/jpeg';\n var checkOrientation = isJPEGImage && options.checkOrientation;\n var retainExif = isJPEGImage && options.retainExif;\n if (URL && !checkOrientation && !retainExif) {\n this.load({\n url: URL.createObjectURL(file)\n });\n } else {\n var reader = new FileReader();\n this.reader = reader;\n reader.onload = function (_ref) {\n var target = _ref.target;\n var result = target.result;\n var data = {};\n var orientation = 1;\n if (checkOrientation) {\n // Reset the orientation value to its default value 1\n // as some iOS browsers will render image with its orientation\n orientation = resetAndGetOrientation(result);\n if (orientation > 1) {\n _extends(data, parseOrientation(orientation));\n }\n }\n if (retainExif) {\n _this.exif = getExif(result);\n }\n if (checkOrientation || retainExif) {\n if (!URL\n\n // Generate a new URL with the default orientation value 1.\n || orientation > 1) {\n data.url = arrayBufferToDataURL(result, mimeType);\n } else {\n data.url = URL.createObjectURL(file);\n }\n } else {\n data.url = result;\n }\n _this.load(data);\n };\n reader.onabort = function () {\n _this.fail(new Error('Aborted to read the image with FileReader.'));\n };\n reader.onerror = function () {\n _this.fail(new Error('Failed to read the image with FileReader.'));\n };\n reader.onloadend = function () {\n _this.reader = null;\n };\n if (checkOrientation || retainExif) {\n reader.readAsArrayBuffer(file);\n } else {\n reader.readAsDataURL(file);\n }\n }\n }\n }, {\n key: \"load\",\n value: function load(data) {\n var _this2 = this;\n var file = this.file,\n image = this.image;\n image.onload = function () {\n _this2.draw(_objectSpread2(_objectSpread2({}, data), {}, {\n naturalWidth: image.naturalWidth,\n naturalHeight: image.naturalHeight\n }));\n };\n image.onabort = function () {\n _this2.fail(new Error('Aborted to load the image.'));\n };\n image.onerror = function () {\n _this2.fail(new Error('Failed to load the image.'));\n };\n\n // Match all browsers that use WebKit as the layout engine in iOS devices,\n // such as Safari for iOS, Chrome for iOS, and in-app browsers.\n if (WINDOW.navigator && /(?:iPad|iPhone|iPod).*?AppleWebKit/i.test(WINDOW.navigator.userAgent)) {\n // Fix the `The operation is insecure` error (#57)\n image.crossOrigin = 'anonymous';\n }\n image.alt = file.name;\n image.src = data.url;\n }\n }, {\n key: \"draw\",\n value: function draw(_ref2) {\n var _this3 = this;\n var naturalWidth = _ref2.naturalWidth,\n naturalHeight = _ref2.naturalHeight,\n _ref2$rotate = _ref2.rotate,\n rotate = _ref2$rotate === void 0 ? 0 : _ref2$rotate,\n _ref2$scaleX = _ref2.scaleX,\n scaleX = _ref2$scaleX === void 0 ? 1 : _ref2$scaleX,\n _ref2$scaleY = _ref2.scaleY,\n scaleY = _ref2$scaleY === void 0 ? 1 : _ref2$scaleY;\n var file = this.file,\n image = this.image,\n options = this.options;\n var canvas = document.createElement('canvas');\n var context = canvas.getContext('2d');\n var is90DegreesRotated = Math.abs(rotate) % 180 === 90;\n var resizable = (options.resize === 'contain' || options.resize === 'cover') && isPositiveNumber(options.width) && isPositiveNumber(options.height);\n var maxWidth = Math.max(options.maxWidth, 0) || Infinity;\n var maxHeight = Math.max(options.maxHeight, 0) || Infinity;\n var minWidth = Math.max(options.minWidth, 0) || 0;\n var minHeight = Math.max(options.minHeight, 0) || 0;\n var aspectRatio = naturalWidth / naturalHeight;\n var width = options.width,\n height = options.height;\n if (is90DegreesRotated) {\n var _ref3 = [maxHeight, maxWidth];\n maxWidth = _ref3[0];\n maxHeight = _ref3[1];\n var _ref4 = [minHeight, minWidth];\n minWidth = _ref4[0];\n minHeight = _ref4[1];\n var _ref5 = [height, width];\n width = _ref5[0];\n height = _ref5[1];\n }\n if (resizable) {\n aspectRatio = width / height;\n }\n var _getAdjustedSizes = getAdjustedSizes({\n aspectRatio: aspectRatio,\n width: maxWidth,\n height: maxHeight\n }, 'contain');\n maxWidth = _getAdjustedSizes.width;\n maxHeight = _getAdjustedSizes.height;\n var _getAdjustedSizes2 = getAdjustedSizes({\n aspectRatio: aspectRatio,\n width: minWidth,\n height: minHeight\n }, 'cover');\n minWidth = _getAdjustedSizes2.width;\n minHeight = _getAdjustedSizes2.height;\n if (resizable) {\n var _getAdjustedSizes3 = getAdjustedSizes({\n aspectRatio: aspectRatio,\n width: width,\n height: height\n }, options.resize);\n width = _getAdjustedSizes3.width;\n height = _getAdjustedSizes3.height;\n } else {\n var _getAdjustedSizes4 = getAdjustedSizes({\n aspectRatio: aspectRatio,\n width: width,\n height: height\n });\n var _getAdjustedSizes4$wi = _getAdjustedSizes4.width;\n width = _getAdjustedSizes4$wi === void 0 ? naturalWidth : _getAdjustedSizes4$wi;\n var _getAdjustedSizes4$he = _getAdjustedSizes4.height;\n height = _getAdjustedSizes4$he === void 0 ? naturalHeight : _getAdjustedSizes4$he;\n }\n width = Math.floor(normalizeDecimalNumber(Math.min(Math.max(width, minWidth), maxWidth)));\n height = Math.floor(normalizeDecimalNumber(Math.min(Math.max(height, minHeight), maxHeight)));\n var destX = -width / 2;\n var destY = -height / 2;\n var destWidth = width;\n var destHeight = height;\n var params = [];\n if (resizable) {\n var srcX = 0;\n var srcY = 0;\n var srcWidth = naturalWidth;\n var srcHeight = naturalHeight;\n var _getAdjustedSizes5 = getAdjustedSizes({\n aspectRatio: aspectRatio,\n width: naturalWidth,\n height: naturalHeight\n }, {\n contain: 'cover',\n cover: 'contain'\n }[options.resize]);\n srcWidth = _getAdjustedSizes5.width;\n srcHeight = _getAdjustedSizes5.height;\n srcX = (naturalWidth - srcWidth) / 2;\n srcY = (naturalHeight - srcHeight) / 2;\n params.push(srcX, srcY, srcWidth, srcHeight);\n }\n params.push(destX, destY, destWidth, destHeight);\n if (is90DegreesRotated) {\n var _ref6 = [height, width];\n width = _ref6[0];\n height = _ref6[1];\n }\n canvas.width = width;\n canvas.height = height;\n if (!isImageType(options.mimeType)) {\n options.mimeType = file.type;\n }\n var fillStyle = 'transparent';\n\n // Converts PNG files over the `convertSize` to JPEGs.\n if (file.size > options.convertSize && options.convertTypes.indexOf(options.mimeType) >= 0) {\n options.mimeType = 'image/jpeg';\n }\n var isJPEGImage = options.mimeType === 'image/jpeg';\n if (isJPEGImage) {\n fillStyle = '#fff';\n }\n\n // Override the default fill color (#000, black)\n context.fillStyle = fillStyle;\n context.fillRect(0, 0, width, height);\n if (options.beforeDraw) {\n options.beforeDraw.call(this, context, canvas);\n }\n if (this.aborted) {\n return;\n }\n context.save();\n context.translate(width / 2, height / 2);\n context.rotate(rotate * Math.PI / 180);\n context.scale(scaleX, scaleY);\n context.drawImage.apply(context, [image].concat(params));\n context.restore();\n if (options.drew) {\n options.drew.call(this, context, canvas);\n }\n if (this.aborted) {\n return;\n }\n var callback = function callback(blob) {\n if (!_this3.aborted) {\n var done = function done(result) {\n return _this3.done({\n naturalWidth: naturalWidth,\n naturalHeight: naturalHeight,\n result: result\n });\n };\n if (blob && isJPEGImage && options.retainExif && _this3.exif && _this3.exif.length > 0) {\n var next = function next(arrayBuffer) {\n return done(toBlob(arrayBufferToDataURL(insertExif(arrayBuffer, _this3.exif), options.mimeType)));\n };\n if (blob.arrayBuffer) {\n blob.arrayBuffer().then(next).catch(function () {\n _this3.fail(new Error('Failed to read the compressed image with Blob.arrayBuffer().'));\n });\n } else {\n var reader = new FileReader();\n _this3.reader = reader;\n reader.onload = function (_ref7) {\n var target = _ref7.target;\n next(target.result);\n };\n reader.onabort = function () {\n _this3.fail(new Error('Aborted to read the compressed image with FileReader.'));\n };\n reader.onerror = function () {\n _this3.fail(new Error('Failed to read the compressed image with FileReader.'));\n };\n reader.onloadend = function () {\n _this3.reader = null;\n };\n reader.readAsArrayBuffer(blob);\n }\n } else {\n done(blob);\n }\n }\n };\n if (canvas.toBlob) {\n canvas.toBlob(callback, options.mimeType, options.quality);\n } else {\n callback(toBlob(canvas.toDataURL(options.mimeType, options.quality)));\n }\n }\n }, {\n key: \"done\",\n value: function done(_ref8) {\n var naturalWidth = _ref8.naturalWidth,\n naturalHeight = _ref8.naturalHeight,\n result = _ref8.result;\n var file = this.file,\n image = this.image,\n options = this.options;\n if (URL && image.src.indexOf('blob:') === 0) {\n URL.revokeObjectURL(image.src);\n }\n if (result) {\n // Returns original file if the result is greater than it and without size related options\n if (options.strict && !options.retainExif && result.size > file.size && options.mimeType === file.type && !(options.width > naturalWidth || options.height > naturalHeight || options.minWidth > naturalWidth || options.minHeight > naturalHeight || options.maxWidth < naturalWidth || options.maxHeight < naturalHeight)) {\n result = file;\n } else {\n var date = new Date();\n result.lastModified = date.getTime();\n result.lastModifiedDate = date;\n result.name = file.name;\n\n // Convert the extension to match its type\n if (result.name && result.type !== file.type) {\n result.name = result.name.replace(REGEXP_EXTENSION, imageTypeToExtension(result.type));\n }\n }\n } else {\n // Returns original file if the result is null in some cases.\n result = file;\n }\n this.result = result;\n if (options.success) {\n options.success.call(this, result);\n }\n }\n }, {\n key: \"fail\",\n value: function fail(err) {\n var options = this.options;\n if (options.error) {\n options.error.call(this, err);\n } else {\n throw err;\n }\n }\n }, {\n key: \"abort\",\n value: function abort() {\n if (!this.aborted) {\n this.aborted = true;\n if (this.reader) {\n this.reader.abort();\n } else if (!this.image.complete) {\n this.image.onload = null;\n this.image.onabort();\n } else {\n this.fail(new Error('The compression process has been aborted.'));\n }\n }\n }\n\n /**\n * Get the no conflict compressor class.\n * @returns {Compressor} The compressor class.\n */\n }], [{\n key: \"noConflict\",\n value: function noConflict() {\n window.Compressor = AnotherCompressor;\n return Compressor;\n }\n\n /**\n * Change the default options.\n * @param {Object} options - The new default options.\n */\n }, {\n key: \"setDefaults\",\n value: function setDefaults(options) {\n _extends(DEFAULTS, options);\n }\n }]);\n return Compressor;\n }();\n\n return Compressor;\n\n}));\n","/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh */\nexports.read = function (buffer, offset, isLE, mLen, nBytes) {\n var e, m\n var eLen = (nBytes * 8) - mLen - 1\n var eMax = (1 << eLen) - 1\n var eBias = eMax >> 1\n var nBits = -7\n var i = isLE ? (nBytes - 1) : 0\n var d = isLE ? -1 : 1\n var s = buffer[offset + i]\n\n i += d\n\n e = s & ((1 << (-nBits)) - 1)\n s >>= (-nBits)\n nBits += eLen\n for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n m = e & ((1 << (-nBits)) - 1)\n e >>= (-nBits)\n nBits += mLen\n for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n if (e === 0) {\n e = 1 - eBias\n } else if (e === eMax) {\n return m ? NaN : ((s ? -1 : 1) * Infinity)\n } else {\n m = m + Math.pow(2, mLen)\n e = e - eBias\n }\n return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n}\n\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n var e, m, c\n var eLen = (nBytes * 8) - mLen - 1\n var eMax = (1 << eLen) - 1\n var eBias = eMax >> 1\n var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n var i = isLE ? 0 : (nBytes - 1)\n var d = isLE ? 1 : -1\n var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\n value = Math.abs(value)\n\n if (isNaN(value) || value === Infinity) {\n m = isNaN(value) ? 1 : 0\n e = eMax\n } else {\n e = Math.floor(Math.log(value) / Math.LN2)\n if (value * (c = Math.pow(2, -e)) < 1) {\n e--\n c *= 2\n }\n if (e + eBias >= 1) {\n value += rt / c\n } else {\n value += rt * Math.pow(2, 1 - eBias)\n }\n if (value * c >= 2) {\n e++\n c /= 2\n }\n\n if (e + eBias >= eMax) {\n m = 0\n e = eMax\n } else if (e + eBias >= 1) {\n m = ((value * c) - 1) * Math.pow(2, mLen)\n e = e + eBias\n } else {\n m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n e = 0\n }\n }\n\n for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n e = (e << mLen) | m\n eLen += mLen\n for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n buffer[offset + i - d] |= s * 128\n}\n","/**\n * Copyright (c) 2014-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nvar runtime = (function (exports) {\n \"use strict\";\n\n var Op = Object.prototype;\n var hasOwn = Op.hasOwnProperty;\n var defineProperty = Object.defineProperty || function (obj, key, desc) { obj[key] = desc.value; };\n var undefined; // More compressible than void 0.\n var $Symbol = typeof Symbol === \"function\" ? Symbol : {};\n var iteratorSymbol = $Symbol.iterator || \"@@iterator\";\n var asyncIteratorSymbol = $Symbol.asyncIterator || \"@@asyncIterator\";\n var toStringTagSymbol = $Symbol.toStringTag || \"@@toStringTag\";\n\n function define(obj, key, value) {\n Object.defineProperty(obj, key, {\n value: value,\n enumerable: true,\n configurable: true,\n writable: true\n });\n return obj[key];\n }\n try {\n // IE 8 has a broken Object.defineProperty that only works on DOM objects.\n define({}, \"\");\n } catch (err) {\n define = function(obj, key, value) {\n return obj[key] = value;\n };\n }\n\n function wrap(innerFn, outerFn, self, tryLocsList) {\n // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.\n var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;\n var generator = Object.create(protoGenerator.prototype);\n var context = new Context(tryLocsList || []);\n\n // The ._invoke method unifies the implementations of the .next,\n // .throw, and .return methods.\n defineProperty(generator, \"_invoke\", { value: makeInvokeMethod(innerFn, self, context) });\n\n return generator;\n }\n exports.wrap = wrap;\n\n // Try/catch helper to minimize deoptimizations. Returns a completion\n // record like context.tryEntries[i].completion. This interface could\n // have been (and was previously) designed to take a closure to be\n // invoked without arguments, but in all the cases we care about we\n // already have an existing method we want to call, so there's no need\n // to create a new function object. We can even get away with assuming\n // the method takes exactly one argument, since that happens to be true\n // in every case, so we don't have to touch the arguments object. The\n // only additional allocation required is the completion record, which\n // has a stable shape and so hopefully should be cheap to allocate.\n function tryCatch(fn, obj, arg) {\n try {\n return { type: \"normal\", arg: fn.call(obj, arg) };\n } catch (err) {\n return { type: \"throw\", arg: err };\n }\n }\n\n var GenStateSuspendedStart = \"suspendedStart\";\n var GenStateSuspendedYield = \"suspendedYield\";\n var GenStateExecuting = \"executing\";\n var GenStateCompleted = \"completed\";\n\n // Returning this object from the innerFn has the same effect as\n // breaking out of the dispatch switch statement.\n var ContinueSentinel = {};\n\n // Dummy constructor functions that we use as the .constructor and\n // .constructor.prototype properties for functions that return Generator\n // objects. For full spec compliance, you may wish to configure your\n // minifier not to mangle the names of these two functions.\n function Generator() {}\n function GeneratorFunction() {}\n function GeneratorFunctionPrototype() {}\n\n // This is a polyfill for %IteratorPrototype% for environments that\n // don't natively support it.\n var IteratorPrototype = {};\n define(IteratorPrototype, iteratorSymbol, function () {\n return this;\n });\n\n var getProto = Object.getPrototypeOf;\n var NativeIteratorPrototype = getProto && getProto(getProto(values([])));\n if (NativeIteratorPrototype &&\n NativeIteratorPrototype !== Op &&\n hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {\n // This environment has a native %IteratorPrototype%; use it instead\n // of the polyfill.\n IteratorPrototype = NativeIteratorPrototype;\n }\n\n var Gp = GeneratorFunctionPrototype.prototype =\n Generator.prototype = Object.create(IteratorPrototype);\n GeneratorFunction.prototype = GeneratorFunctionPrototype;\n defineProperty(Gp, \"constructor\", { value: GeneratorFunctionPrototype, configurable: true });\n defineProperty(\n GeneratorFunctionPrototype,\n \"constructor\",\n { value: GeneratorFunction, configurable: true }\n );\n GeneratorFunction.displayName = define(\n GeneratorFunctionPrototype,\n toStringTagSymbol,\n \"GeneratorFunction\"\n );\n\n // Helper for defining the .next, .throw, and .return methods of the\n // Iterator interface in terms of a single ._invoke method.\n function defineIteratorMethods(prototype) {\n [\"next\", \"throw\", \"return\"].forEach(function(method) {\n define(prototype, method, function(arg) {\n return this._invoke(method, arg);\n });\n });\n }\n\n exports.isGeneratorFunction = function(genFun) {\n var ctor = typeof genFun === \"function\" && genFun.constructor;\n return ctor\n ? ctor === GeneratorFunction ||\n // For the native GeneratorFunction constructor, the best we can\n // do is to check its .name property.\n (ctor.displayName || ctor.name) === \"GeneratorFunction\"\n : false;\n };\n\n exports.mark = function(genFun) {\n if (Object.setPrototypeOf) {\n Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);\n } else {\n genFun.__proto__ = GeneratorFunctionPrototype;\n define(genFun, toStringTagSymbol, \"GeneratorFunction\");\n }\n genFun.prototype = Object.create(Gp);\n return genFun;\n };\n\n // Within the body of any async function, `await x` is transformed to\n // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test\n // `hasOwn.call(value, \"__await\")` to determine if the yielded value is\n // meant to be awaited.\n exports.awrap = function(arg) {\n return { __await: arg };\n };\n\n function AsyncIterator(generator, PromiseImpl) {\n function invoke(method, arg, resolve, reject) {\n var record = tryCatch(generator[method], generator, arg);\n if (record.type === \"throw\") {\n reject(record.arg);\n } else {\n var result = record.arg;\n var value = result.value;\n if (value &&\n typeof value === \"object\" &&\n hasOwn.call(value, \"__await\")) {\n return PromiseImpl.resolve(value.__await).then(function(value) {\n invoke(\"next\", value, resolve, reject);\n }, function(err) {\n invoke(\"throw\", err, resolve, reject);\n });\n }\n\n return PromiseImpl.resolve(value).then(function(unwrapped) {\n // When a yielded Promise is resolved, its final value becomes\n // the .value of the Promise<{value,done}> result for the\n // current iteration.\n result.value = unwrapped;\n resolve(result);\n }, function(error) {\n // If a rejected Promise was yielded, throw the rejection back\n // into the async generator function so it can be handled there.\n return invoke(\"throw\", error, resolve, reject);\n });\n }\n }\n\n var previousPromise;\n\n function enqueue(method, arg) {\n function callInvokeWithMethodAndArg() {\n return new PromiseImpl(function(resolve, reject) {\n invoke(method, arg, resolve, reject);\n });\n }\n\n return previousPromise =\n // If enqueue has been called before, then we want to wait until\n // all previous Promises have been resolved before calling invoke,\n // so that results are always delivered in the correct order. If\n // enqueue has not been called before, then it is important to\n // call invoke immediately, without waiting on a callback to fire,\n // so that the async generator function has the opportunity to do\n // any necessary setup in a predictable way. This predictability\n // is why the Promise constructor synchronously invokes its\n // executor callback, and why async functions synchronously\n // execute code before the first await. Since we implement simple\n // async functions in terms of async generators, it is especially\n // important to get this right, even though it requires care.\n previousPromise ? previousPromise.then(\n callInvokeWithMethodAndArg,\n // Avoid propagating failures to Promises returned by later\n // invocations of the iterator.\n callInvokeWithMethodAndArg\n ) : callInvokeWithMethodAndArg();\n }\n\n // Define the unified helper method that is used to implement .next,\n // .throw, and .return (see defineIteratorMethods).\n defineProperty(this, \"_invoke\", { value: enqueue });\n }\n\n defineIteratorMethods(AsyncIterator.prototype);\n define(AsyncIterator.prototype, asyncIteratorSymbol, function () {\n return this;\n });\n exports.AsyncIterator = AsyncIterator;\n\n // Note that simple async functions are implemented on top of\n // AsyncIterator objects; they just return a Promise for the value of\n // the final result produced by the iterator.\n exports.async = function(innerFn, outerFn, self, tryLocsList, PromiseImpl) {\n if (PromiseImpl === void 0) PromiseImpl = Promise;\n\n var iter = new AsyncIterator(\n wrap(innerFn, outerFn, self, tryLocsList),\n PromiseImpl\n );\n\n return exports.isGeneratorFunction(outerFn)\n ? iter // If outerFn is a generator, return the full iterator.\n : iter.next().then(function(result) {\n return result.done ? result.value : iter.next();\n });\n };\n\n function makeInvokeMethod(innerFn, self, context) {\n var state = GenStateSuspendedStart;\n\n return function invoke(method, arg) {\n if (state === GenStateExecuting) {\n throw new Error(\"Generator is already running\");\n }\n\n if (state === GenStateCompleted) {\n if (method === \"throw\") {\n throw arg;\n }\n\n // Be forgiving, per 25.3.3.3.3 of the spec:\n // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume\n return doneResult();\n }\n\n context.method = method;\n context.arg = arg;\n\n while (true) {\n var delegate = context.delegate;\n if (delegate) {\n var delegateResult = maybeInvokeDelegate(delegate, context);\n if (delegateResult) {\n if (delegateResult === ContinueSentinel) continue;\n return delegateResult;\n }\n }\n\n if (context.method === \"next\") {\n // Setting context._sent for legacy support of Babel's\n // function.sent implementation.\n context.sent = context._sent = context.arg;\n\n } else if (context.method === \"throw\") {\n if (state === GenStateSuspendedStart) {\n state = GenStateCompleted;\n throw context.arg;\n }\n\n context.dispatchException(context.arg);\n\n } else if (context.method === \"return\") {\n context.abrupt(\"return\", context.arg);\n }\n\n state = GenStateExecuting;\n\n var record = tryCatch(innerFn, self, context);\n if (record.type === \"normal\") {\n // If an exception is thrown from innerFn, we leave state ===\n // GenStateExecuting and loop back for another invocation.\n state = context.done\n ? GenStateCompleted\n : GenStateSuspendedYield;\n\n if (record.arg === ContinueSentinel) {\n continue;\n }\n\n return {\n value: record.arg,\n done: context.done\n };\n\n } else if (record.type === \"throw\") {\n state = GenStateCompleted;\n // Dispatch the exception by looping back around to the\n // context.dispatchException(context.arg) call above.\n context.method = \"throw\";\n context.arg = record.arg;\n }\n }\n };\n }\n\n // Call delegate.iterator[context.method](context.arg) and handle the\n // result, either by returning a { value, done } result from the\n // delegate iterator, or by modifying context.method and context.arg,\n // setting context.delegate to null, and returning the ContinueSentinel.\n function maybeInvokeDelegate(delegate, context) {\n var methodName = context.method;\n var method = delegate.iterator[methodName];\n if (method === undefined) {\n // A .throw or .return when the delegate iterator has no .throw\n // method, or a missing .next mehtod, always terminate the\n // yield* loop.\n context.delegate = null;\n\n // Note: [\"return\"] must be used for ES3 parsing compatibility.\n if (methodName === \"throw\" && delegate.iterator[\"return\"]) {\n // If the delegate iterator has a return method, give it a\n // chance to clean up.\n context.method = \"return\";\n context.arg = undefined;\n maybeInvokeDelegate(delegate, context);\n\n if (context.method === \"throw\") {\n // If maybeInvokeDelegate(context) changed context.method from\n // \"return\" to \"throw\", let that override the TypeError below.\n return ContinueSentinel;\n }\n }\n if (methodName !== \"return\") {\n context.method = \"throw\";\n context.arg = new TypeError(\n \"The iterator does not provide a '\" + methodName + \"' method\");\n }\n\n return ContinueSentinel;\n }\n\n var record = tryCatch(method, delegate.iterator, context.arg);\n\n if (record.type === \"throw\") {\n context.method = \"throw\";\n context.arg = record.arg;\n context.delegate = null;\n return ContinueSentinel;\n }\n\n var info = record.arg;\n\n if (! info) {\n context.method = \"throw\";\n context.arg = new TypeError(\"iterator result is not an object\");\n context.delegate = null;\n return ContinueSentinel;\n }\n\n if (info.done) {\n // Assign the result of the finished delegate to the temporary\n // variable specified by delegate.resultName (see delegateYield).\n context[delegate.resultName] = info.value;\n\n // Resume execution at the desired location (see delegateYield).\n context.next = delegate.nextLoc;\n\n // If context.method was \"throw\" but the delegate handled the\n // exception, let the outer generator proceed normally. If\n // context.method was \"next\", forget context.arg since it has been\n // \"consumed\" by the delegate iterator. If context.method was\n // \"return\", allow the original .return call to continue in the\n // outer generator.\n if (context.method !== \"return\") {\n context.method = \"next\";\n context.arg = undefined;\n }\n\n } else {\n // Re-yield the result returned by the delegate method.\n return info;\n }\n\n // The delegate iterator is finished, so forget it and continue with\n // the outer generator.\n context.delegate = null;\n return ContinueSentinel;\n }\n\n // Define Generator.prototype.{next,throw,return} in terms of the\n // unified ._invoke helper method.\n defineIteratorMethods(Gp);\n\n define(Gp, toStringTagSymbol, \"Generator\");\n\n // A Generator should always return itself as the iterator object when the\n // @@iterator function is called on it. Some browsers' implementations of the\n // iterator prototype chain incorrectly implement this, causing the Generator\n // object to not be returned from this call. This ensures that doesn't happen.\n // See https://github.com/facebook/regenerator/issues/274 for more details.\n define(Gp, iteratorSymbol, function() {\n return this;\n });\n\n define(Gp, \"toString\", function() {\n return \"[object Generator]\";\n });\n\n function pushTryEntry(locs) {\n var entry = { tryLoc: locs[0] };\n\n if (1 in locs) {\n entry.catchLoc = locs[1];\n }\n\n if (2 in locs) {\n entry.finallyLoc = locs[2];\n entry.afterLoc = locs[3];\n }\n\n this.tryEntries.push(entry);\n }\n\n function resetTryEntry(entry) {\n var record = entry.completion || {};\n record.type = \"normal\";\n delete record.arg;\n entry.completion = record;\n }\n\n function Context(tryLocsList) {\n // The root entry object (effectively a try statement without a catch\n // or a finally block) gives us a place to store values thrown from\n // locations where there is no enclosing try statement.\n this.tryEntries = [{ tryLoc: \"root\" }];\n tryLocsList.forEach(pushTryEntry, this);\n this.reset(true);\n }\n\n exports.keys = function(val) {\n var object = Object(val);\n var keys = [];\n for (var key in object) {\n keys.push(key);\n }\n keys.reverse();\n\n // Rather than returning an object with a next method, we keep\n // things simple and return the next function itself.\n return function next() {\n while (keys.length) {\n var key = keys.pop();\n if (key in object) {\n next.value = key;\n next.done = false;\n return next;\n }\n }\n\n // To avoid creating an additional object, we just hang the .value\n // and .done properties off the next function object itself. This\n // also ensures that the minifier will not anonymize the function.\n next.done = true;\n return next;\n };\n };\n\n function values(iterable) {\n if (iterable) {\n var iteratorMethod = iterable[iteratorSymbol];\n if (iteratorMethod) {\n return iteratorMethod.call(iterable);\n }\n\n if (typeof iterable.next === \"function\") {\n return iterable;\n }\n\n if (!isNaN(iterable.length)) {\n var i = -1, next = function next() {\n while (++i < iterable.length) {\n if (hasOwn.call(iterable, i)) {\n next.value = iterable[i];\n next.done = false;\n return next;\n }\n }\n\n next.value = undefined;\n next.done = true;\n\n return next;\n };\n\n return next.next = next;\n }\n }\n\n // Return an iterator with no values.\n return { next: doneResult };\n }\n exports.values = values;\n\n function doneResult() {\n return { value: undefined, done: true };\n }\n\n Context.prototype = {\n constructor: Context,\n\n reset: function(skipTempReset) {\n this.prev = 0;\n this.next = 0;\n // Resetting context._sent for legacy support of Babel's\n // function.sent implementation.\n this.sent = this._sent = undefined;\n this.done = false;\n this.delegate = null;\n\n this.method = \"next\";\n this.arg = undefined;\n\n this.tryEntries.forEach(resetTryEntry);\n\n if (!skipTempReset) {\n for (var name in this) {\n // Not sure about the optimal order of these conditions:\n if (name.charAt(0) === \"t\" &&\n hasOwn.call(this, name) &&\n !isNaN(+name.slice(1))) {\n this[name] = undefined;\n }\n }\n }\n },\n\n stop: function() {\n this.done = true;\n\n var rootEntry = this.tryEntries[0];\n var rootRecord = rootEntry.completion;\n if (rootRecord.type === \"throw\") {\n throw rootRecord.arg;\n }\n\n return this.rval;\n },\n\n dispatchException: function(exception) {\n if (this.done) {\n throw exception;\n }\n\n var context = this;\n function handle(loc, caught) {\n record.type = \"throw\";\n record.arg = exception;\n context.next = loc;\n\n if (caught) {\n // If the dispatched exception was caught by a catch block,\n // then let that catch block handle the exception normally.\n context.method = \"next\";\n context.arg = undefined;\n }\n\n return !! caught;\n }\n\n for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n var entry = this.tryEntries[i];\n var record = entry.completion;\n\n if (entry.tryLoc === \"root\") {\n // Exception thrown outside of any try block that could handle\n // it, so set the completion value of the entire function to\n // throw the exception.\n return handle(\"end\");\n }\n\n if (entry.tryLoc <= this.prev) {\n var hasCatch = hasOwn.call(entry, \"catchLoc\");\n var hasFinally = hasOwn.call(entry, \"finallyLoc\");\n\n if (hasCatch && hasFinally) {\n if (this.prev < entry.catchLoc) {\n return handle(entry.catchLoc, true);\n } else if (this.prev < entry.finallyLoc) {\n return handle(entry.finallyLoc);\n }\n\n } else if (hasCatch) {\n if (this.prev < entry.catchLoc) {\n return handle(entry.catchLoc, true);\n }\n\n } else if (hasFinally) {\n if (this.prev < entry.finallyLoc) {\n return handle(entry.finallyLoc);\n }\n\n } else {\n throw new Error(\"try statement without catch or finally\");\n }\n }\n }\n },\n\n abrupt: function(type, arg) {\n for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n var entry = this.tryEntries[i];\n if (entry.tryLoc <= this.prev &&\n hasOwn.call(entry, \"finallyLoc\") &&\n this.prev < entry.finallyLoc) {\n var finallyEntry = entry;\n break;\n }\n }\n\n if (finallyEntry &&\n (type === \"break\" ||\n type === \"continue\") &&\n finallyEntry.tryLoc <= arg &&\n arg <= finallyEntry.finallyLoc) {\n // Ignore the finally entry if control is not jumping to a\n // location outside the try/catch block.\n finallyEntry = null;\n }\n\n var record = finallyEntry ? finallyEntry.completion : {};\n record.type = type;\n record.arg = arg;\n\n if (finallyEntry) {\n this.method = \"next\";\n this.next = finallyEntry.finallyLoc;\n return ContinueSentinel;\n }\n\n return this.complete(record);\n },\n\n complete: function(record, afterLoc) {\n if (record.type === \"throw\") {\n throw record.arg;\n }\n\n if (record.type === \"break\" ||\n record.type === \"continue\") {\n this.next = record.arg;\n } else if (record.type === \"return\") {\n this.rval = this.arg = record.arg;\n this.method = \"return\";\n this.next = \"end\";\n } else if (record.type === \"normal\" && afterLoc) {\n this.next = afterLoc;\n }\n\n return ContinueSentinel;\n },\n\n finish: function(finallyLoc) {\n for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n var entry = this.tryEntries[i];\n if (entry.finallyLoc === finallyLoc) {\n this.complete(entry.completion, entry.afterLoc);\n resetTryEntry(entry);\n return ContinueSentinel;\n }\n }\n },\n\n \"catch\": function(tryLoc) {\n for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n var entry = this.tryEntries[i];\n if (entry.tryLoc === tryLoc) {\n var record = entry.completion;\n if (record.type === \"throw\") {\n var thrown = record.arg;\n resetTryEntry(entry);\n }\n return thrown;\n }\n }\n\n // The context.catch method must only be called with a location\n // argument that corresponds to a known catch block.\n throw new Error(\"illegal catch attempt\");\n },\n\n delegateYield: function(iterable, resultName, nextLoc) {\n this.delegate = {\n iterator: values(iterable),\n resultName: resultName,\n nextLoc: nextLoc\n };\n\n if (this.method === \"next\") {\n // Deliberately forget the last sent value so that we don't\n // accidentally pass it on to the delegate.\n this.arg = undefined;\n }\n\n return ContinueSentinel;\n }\n };\n\n // Regardless of whether this script is executing as a CommonJS module\n // or not, return the runtime object so that we can declare the variable\n // regeneratorRuntime in the outer scope, which allows this module to be\n // injected easily by `bin/regenerator --include-runtime script.js`.\n return exports;\n\n}(\n // If this script is executing as a CommonJS module, use module.exports\n // as the regeneratorRuntime namespace. Otherwise create a new empty\n // object. Either way, the resulting object will be used to initialize\n // the regeneratorRuntime variable at the top of this file.\n typeof module === \"object\" ? module.exports : {}\n));\n\ntry {\n regeneratorRuntime = runtime;\n} catch (accidentalStrictMode) {\n // This module should not be running in strict mode, so the above\n // assignment should always work unless something is misconfigured. Just\n // in case runtime.js accidentally runs in strict mode, in modern engines\n // we can explicitly access globalThis. In older engines we can escape\n // strict mode using a global Function call. This could conceivably fail\n // if a Content Security Policy forbids using Function, but in that case\n // the proper solution is to fix the accidental strict mode problem. If\n // you've misconfigured your bundler to force strict mode and applied a\n // CSP to forbid Function, and you're not willing to fix either of those\n // problems, please detail your unique predicament in a GitHub issue.\n if (typeof globalThis === \"object\") {\n globalThis.regeneratorRuntime = runtime;\n } else {\n Function(\"r\", \"regeneratorRuntime = r\")(runtime);\n }\n}\n","var render = function render(){var _vm=this,_c=_vm._self._c;return _c('div',{staticClass:\"col-12 p-0 text-center\"},[_c('div',{staticClass:\"logo-live\",class:{ tiny: _vm.tiny, 'no-bg': _vm.no_bg }},[_c('img',{attrs:{\"data-part\":\"1\",\"src\":require(\"../assets/image/nicard-logo-part-1.png\")}}),_c('img',{attrs:{\"data-part\":\"2\",\"src\":require(\"../assets/image/nicard-logo-part-2.png\")}}),_c('img',{attrs:{\"data-part\":\"3\",\"src\":require(\"../assets/image/nicard-logo-part-3.png\")}})])])\n}\nvar staticRenderFns = []\n\nexport { render, staticRenderFns }","\r\n\r\n\r\n","import mod from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--12-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/cache-loader/dist/cjs.js??ref--0-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./LiveLogo.vue?vue&type=script&lang=js\"; export default mod; export * from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--12-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/cache-loader/dist/cjs.js??ref--0-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./LiveLogo.vue?vue&type=script&lang=js\"","import { render, staticRenderFns } from \"./LiveLogo.vue?vue&type=template&id=5b5f9f66&scoped=true\"\nimport script from \"./LiveLogo.vue?vue&type=script&lang=js\"\nexport * from \"./LiveLogo.vue?vue&type=script&lang=js\"\nimport style0 from \"./LiveLogo.vue?vue&type=style&index=0&id=5b5f9f66&prod&scoped=true&lang=css\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n \"5b5f9f66\",\n null\n \n)\n\nexport default component.exports","var toString = {}.toString;\n\nmodule.exports = Array.isArray || function (arr) {\n return toString.call(arr) == '[object Array]';\n};\n"],"sourceRoot":""}