diff --git a/src/components/kk-printer/empty-icon.png b/src/components/kk-printer/empty-icon.png
new file mode 100644
index 00000000..1f61685b
Binary files /dev/null and b/src/components/kk-printer/empty-icon.png differ
diff --git a/src/components/kk-printer/index.vue b/src/components/kk-printer/index.vue
new file mode 100644
index 00000000..3df817a2
--- /dev/null
+++ b/src/components/kk-printer/index.vue
@@ -0,0 +1,416 @@
+
+
+
+ {{isPrinting?printingText:defaultText}}
+
+
+
+
+
+ 根据SRRI过滤设备
+
+
+
+ 根据蓝牙名过滤
+
+
+
+
+ 搜索设备
+
+
+ 搜索中...
+
+
+ 停止搜索
+
+
+
+
+
+ ~ 无可搜索到的设备 ~
+
+
+
+
+ 设备名称:
+ {{item.name?item.name:'未命名'}}
+
+
+
+ 设备ID:
+ {{item.deviceId}}
+
+
+ advMac:
+ {{item.advMac}}
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/components/kk-printer/utils/barcode.js b/src/components/kk-printer/utils/barcode.js
new file mode 100644
index 00000000..0838c8ea
--- /dev/null
+++ b/src/components/kk-printer/utils/barcode.js
@@ -0,0 +1,402 @@
+var CHAR_TILDE = 126;
+var CODE_FNC1 = 102;
+
+var SET_STARTA = 103;
+var SET_STARTB = 104;
+var SET_STARTC = 105;
+var SET_SHIFT = 98;
+var SET_CODEA = 101;
+var SET_CODEB = 100;
+var SET_STOP = 106;
+
+
+var REPLACE_CODES = {
+ CHAR_TILDE: CODE_FNC1 //~ corresponds to FNC1 in GS1-128 standard
+}
+
+var CODESET = {
+ ANY: 1,
+ AB: 2,
+ A: 3,
+ B: 4,
+ C: 5
+};
+
+function getBytes(str) {
+ var bytes = [];
+ for (var i = 0; i < str.length; i++) {
+ bytes.push(str.charCodeAt(i));
+ }
+ return bytes;
+}
+
+exports.code128 = function (ctx, text, width, height) {
+
+ width = parseInt(width);
+
+ height = parseInt(height);
+
+ var codes = stringToCode128(text);
+
+ var g = new Graphics(ctx, width, height);
+
+ var barWeight = g.area.width / ((codes.length - 3) * 11 + 35);
+
+ var x = g.area.left;
+ var y = g.area.top;
+ for (var i = 0; i < codes.length; i++) {
+ var c = codes[i];
+ //two bars at a time: 1 black and 1 white
+ for (var bar = 0; bar < 8; bar += 2) {
+ var barW = PATTERNS[c][bar] * barWeight;
+ // var barH = height - y - this.border;
+ var barH = height - y;
+ var spcW = PATTERNS[c][bar + 1] * barWeight;
+
+ //no need to draw if 0 width
+ if (barW > 0) {
+ g.fillFgRect(x, y, barW, barH);
+ }
+
+ x += barW + spcW;
+ }
+ }
+
+ ctx.draw();
+}
+
+
+function stringToCode128(text) {
+
+ var barc = {
+ currcs: CODESET.C
+ };
+
+ var bytes = getBytes(text);
+ //decide starting codeset
+ var index = bytes[0] == CHAR_TILDE ? 1 : 0;
+
+ var csa1 = bytes.length > 0 ? codeSetAllowedFor(bytes[index++]) : CODESET.AB;
+ var csa2 = bytes.length > 0 ? codeSetAllowedFor(bytes[index++]) : CODESET.AB;
+ barc.currcs = getBestStartSet(csa1, csa2);
+ barc.currcs = perhapsCodeC(bytes, barc.currcs);
+
+ //if no codeset changes this will end up with bytes.length+3
+ //start, checksum and stop
+ var codes = new Array();
+
+ switch (barc.currcs) {
+ case CODESET.A:
+ codes.push(SET_STARTA);
+ break;
+ case CODESET.B:
+ codes.push(SET_STARTB);
+ break;
+ default:
+ codes.push(SET_STARTC);
+ break;
+ }
+
+
+ for (var i = 0; i < bytes.length; i++) {
+ var b1 = bytes[i]; //get the first of a pair
+ //should we translate/replace
+ if (b1 in REPLACE_CODES) {
+ codes.push(REPLACE_CODES[b1]);
+ i++ //jump to next
+ b1 = bytes[i];
+ }
+
+ //get the next in the pair if possible
+ var b2 = bytes.length > (i + 1) ? bytes[i + 1] : -1;
+
+ codes = codes.concat(codesForChar(b1, b2, barc.currcs));
+ //code C takes 2 chars each time
+ if (barc.currcs == CODESET.C) i++;
+ }
+
+ //calculate checksum according to Code 128 standards
+ var checksum = codes[0];
+ for (var weight = 1; weight < codes.length; weight++) {
+ checksum += (weight * codes[weight]);
+ }
+ codes.push(checksum % 103);
+
+ codes.push(SET_STOP);
+
+ //encoding should now be complete
+ return codes;
+
+ function getBestStartSet(csa1, csa2) {
+ //tries to figure out the best codeset
+ //to start with to get the most compact code
+ var vote = 0;
+ vote += csa1 == CODESET.A ? 1 : 0;
+ vote += csa1 == CODESET.B ? -1 : 0;
+ vote += csa2 == CODESET.A ? 1 : 0;
+ vote += csa2 == CODESET.B ? -1 : 0;
+ //tie goes to B due to my own predudices
+ return vote > 0 ? CODESET.A : CODESET.B;
+ }
+
+ function perhapsCodeC(bytes, codeset) {
+ for (var i = 0; i < bytes.length; i++) {
+ var b = bytes[i]
+ if ((b < 48 || b > 57) && b != CHAR_TILDE)
+ return codeset;
+ }
+ return CODESET.C;
+ }
+
+ //chr1 is current byte
+ //chr2 is the next byte to process. looks ahead.
+ function codesForChar(chr1, chr2, currcs) {
+ var result = [];
+ var shifter = -1;
+
+ if (charCompatible(chr1, currcs)) {
+ if (currcs == CODESET.C) {
+ if (chr2 == -1) {
+ shifter = SET_CODEB;
+ currcs = CODESET.B;
+ }
+ else if ((chr2 != -1) && !charCompatible(chr2, currcs)) {
+ //need to check ahead as well
+ if (charCompatible(chr2, CODESET.A)) {
+ shifter = SET_CODEA;
+ currcs = CODESET.A;
+ }
+ else {
+ shifter = SET_CODEB;
+ currcs = CODESET.B;
+ }
+ }
+ }
+ }
+ else {
+ //if there is a next char AND that next char is also not compatible
+ if ((chr2 != -1) && !charCompatible(chr2, currcs)) {
+ //need to switch code sets
+ switch (currcs) {
+ case CODESET.A:
+ shifter = SET_CODEB;
+ currcs = CODESET.B;
+ break;
+ case CODESET.B:
+ shifter = SET_CODEA;
+ currcs = CODESET.A;
+ break;
+ }
+ }
+ else {
+ //no need to shift code sets, a temporary SHIFT will suffice
+ shifter = SET_SHIFT;
+ }
+ }
+
+ //ok some type of shift is nessecary
+ if (shifter != -1) {
+ result.push(shifter);
+ result.push(codeValue(chr2));
+ }
+ else {
+ if (currcs == CODESET.C) {
+ //include next as well
+ result.push(codeValue(chr1, chr2));
+ }
+ else {
+ result.push(codeValue(chr1));
+ }
+ }
+ barc.currcs = currcs;
+
+ return result;
+ }
+}
+
+//reduce the ascii code to fit into the Code128 char table
+function codeValue(chr1, chr2) {
+ if (typeof chr2 == "undefined") {
+ return chr1 >= 32 ? chr1 - 32 : chr1 + 64;
+ }
+ else {
+ return parseInt(String.fromCharCode(chr1) + String.fromCharCode(chr2));
+ }
+}
+
+function charCompatible(chr, codeset) {
+ var csa = codeSetAllowedFor(chr);
+ if (csa == CODESET.ANY) return true;
+ //if we need to change from current
+ if (csa == CODESET.AB) return true;
+ if (csa == CODESET.A && codeset == CODESET.A) return true;
+ if (csa == CODESET.B && codeset == CODESET.B) return true;
+ return false;
+}
+
+function codeSetAllowedFor(chr) {
+ if (chr >= 48 && chr <= 57) {
+ //0-9
+ return CODESET.ANY;
+ }
+ else if (chr >= 32 && chr <= 95) {
+ //0-9 A-Z
+ return CODESET.AB;
+ }
+ else {
+ //if non printable
+ return chr < 32 ? CODESET.A : CODESET.B;
+ }
+}
+
+var Graphics = function(ctx, width, height) {
+
+ this.width = width;
+ this.height = height;
+ this.quiet = Math.round(this.width / 40);
+
+ this.border_size = 0;
+ this.padding_width = 0;
+
+ this.area = {
+ width : width - this.padding_width * 2 - this.quiet * 2,
+ height: height - this.border_size * 2,
+ top : this.border_size - 4,
+ left : this.padding_width + this.quiet
+ };
+
+ this.ctx = ctx;
+ this.fg = "#000000";
+ this.bg = "#ffffff";
+
+ // fill background
+ this.fillBgRect(0,0, width, height);
+
+ // fill center to create border
+ this.fillBgRect(0, this.border_size, width, height - this.border_size * 2);
+}
+
+//use native color
+Graphics.prototype._fillRect = function(x, y, width, height, color) {
+ this.ctx.setFillStyle(color)
+ this.ctx.fillRect(x, y, width, height)
+}
+
+Graphics.prototype.fillFgRect = function(x,y, width, height) {
+ this._fillRect(x, y, width, height, this.fg);
+}
+
+Graphics.prototype.fillBgRect = function(x,y, width, height) {
+ this._fillRect(x, y, width, height, this.bg);
+}
+
+var PATTERNS = [
+ [2, 1, 2, 2, 2, 2, 0, 0], // 0
+ [2, 2, 2, 1, 2, 2, 0, 0], // 1
+ [2, 2, 2, 2, 2, 1, 0, 0], // 2
+ [1, 2, 1, 2, 2, 3, 0, 0], // 3
+ [1, 2, 1, 3, 2, 2, 0, 0], // 4
+ [1, 3, 1, 2, 2, 2, 0, 0], // 5
+ [1, 2, 2, 2, 1, 3, 0, 0], // 6
+ [1, 2, 2, 3, 1, 2, 0, 0], // 7
+ [1, 3, 2, 2, 1, 2, 0, 0], // 8
+ [2, 2, 1, 2, 1, 3, 0, 0], // 9
+ [2, 2, 1, 3, 1, 2, 0, 0], // 10
+ [2, 3, 1, 2, 1, 2, 0, 0], // 11
+ [1, 1, 2, 2, 3, 2, 0, 0], // 12
+ [1, 2, 2, 1, 3, 2, 0, 0], // 13
+ [1, 2, 2, 2, 3, 1, 0, 0], // 14
+ [1, 1, 3, 2, 2, 2, 0, 0], // 15
+ [1, 2, 3, 1, 2, 2, 0, 0], // 16
+ [1, 2, 3, 2, 2, 1, 0, 0], // 17
+ [2, 2, 3, 2, 1, 1, 0, 0], // 18
+ [2, 2, 1, 1, 3, 2, 0, 0], // 19
+ [2, 2, 1, 2, 3, 1, 0, 0], // 20
+ [2, 1, 3, 2, 1, 2, 0, 0], // 21
+ [2, 2, 3, 1, 1, 2, 0, 0], // 22
+ [3, 1, 2, 1, 3, 1, 0, 0], // 23
+ [3, 1, 1, 2, 2, 2, 0, 0], // 24
+ [3, 2, 1, 1, 2, 2, 0, 0], // 25
+ [3, 2, 1, 2, 2, 1, 0, 0], // 26
+ [3, 1, 2, 2, 1, 2, 0, 0], // 27
+ [3, 2, 2, 1, 1, 2, 0, 0], // 28
+ [3, 2, 2, 2, 1, 1, 0, 0], // 29
+ [2, 1, 2, 1, 2, 3, 0, 0], // 30
+ [2, 1, 2, 3, 2, 1, 0, 0], // 31
+ [2, 3, 2, 1, 2, 1, 0, 0], // 32
+ [1, 1, 1, 3, 2, 3, 0, 0], // 33
+ [1, 3, 1, 1, 2, 3, 0, 0], // 34
+ [1, 3, 1, 3, 2, 1, 0, 0], // 35
+ [1, 1, 2, 3, 1, 3, 0, 0], // 36
+ [1, 3, 2, 1, 1, 3, 0, 0], // 37
+ [1, 3, 2, 3, 1, 1, 0, 0], // 38
+ [2, 1, 1, 3, 1, 3, 0, 0], // 39
+ [2, 3, 1, 1, 1, 3, 0, 0], // 40
+ [2, 3, 1, 3, 1, 1, 0, 0], // 41
+ [1, 1, 2, 1, 3, 3, 0, 0], // 42
+ [1, 1, 2, 3, 3, 1, 0, 0], // 43
+ [1, 3, 2, 1, 3, 1, 0, 0], // 44
+ [1, 1, 3, 1, 2, 3, 0, 0], // 45
+ [1, 1, 3, 3, 2, 1, 0, 0], // 46
+ [1, 3, 3, 1, 2, 1, 0, 0], // 47
+ [3, 1, 3, 1, 2, 1, 0, 0], // 48
+ [2, 1, 1, 3, 3, 1, 0, 0], // 49
+ [2, 3, 1, 1, 3, 1, 0, 0], // 50
+ [2, 1, 3, 1, 1, 3, 0, 0], // 51
+ [2, 1, 3, 3, 1, 1, 0, 0], // 52
+ [2, 1, 3, 1, 3, 1, 0, 0], // 53
+ [3, 1, 1, 1, 2, 3, 0, 0], // 54
+ [3, 1, 1, 3, 2, 1, 0, 0], // 55
+ [3, 3, 1, 1, 2, 1, 0, 0], // 56
+ [3, 1, 2, 1, 1, 3, 0, 0], // 57
+ [3, 1, 2, 3, 1, 1, 0, 0], // 58
+ [3, 3, 2, 1, 1, 1, 0, 0], // 59
+ [3, 1, 4, 1, 1, 1, 0, 0], // 60
+ [2, 2, 1, 4, 1, 1, 0, 0], // 61
+ [4, 3, 1, 1, 1, 1, 0, 0], // 62
+ [1, 1, 1, 2, 2, 4, 0, 0], // 63
+ [1, 1, 1, 4, 2, 2, 0, 0], // 64
+ [1, 2, 1, 1, 2, 4, 0, 0], // 65
+ [1, 2, 1, 4, 2, 1, 0, 0], // 66
+ [1, 4, 1, 1, 2, 2, 0, 0], // 67
+ [1, 4, 1, 2, 2, 1, 0, 0], // 68
+ [1, 1, 2, 2, 1, 4, 0, 0], // 69
+ [1, 1, 2, 4, 1, 2, 0, 0], // 70
+ [1, 2, 2, 1, 1, 4, 0, 0], // 71
+ [1, 2, 2, 4, 1, 1, 0, 0], // 72
+ [1, 4, 2, 1, 1, 2, 0, 0], // 73
+ [1, 4, 2, 2, 1, 1, 0, 0], // 74
+ [2, 4, 1, 2, 1, 1, 0, 0], // 75
+ [2, 2, 1, 1, 1, 4, 0, 0], // 76
+ [4, 1, 3, 1, 1, 1, 0, 0], // 77
+ [2, 4, 1, 1, 1, 2, 0, 0], // 78
+ [1, 3, 4, 1, 1, 1, 0, 0], // 79
+ [1, 1, 1, 2, 4, 2, 0, 0], // 80
+ [1, 2, 1, 1, 4, 2, 0, 0], // 81
+ [1, 2, 1, 2, 4, 1, 0, 0], // 82
+ [1, 1, 4, 2, 1, 2, 0, 0], // 83
+ [1, 2, 4, 1, 1, 2, 0, 0], // 84
+ [1, 2, 4, 2, 1, 1, 0, 0], // 85
+ [4, 1, 1, 2, 1, 2, 0, 0], // 86
+ [4, 2, 1, 1, 1, 2, 0, 0], // 87
+ [4, 2, 1, 2, 1, 1, 0, 0], // 88
+ [2, 1, 2, 1, 4, 1, 0, 0], // 89
+ [2, 1, 4, 1, 2, 1, 0, 0], // 90
+ [4, 1, 2, 1, 2, 1, 0, 0], // 91
+ [1, 1, 1, 1, 4, 3, 0, 0], // 92
+ [1, 1, 1, 3, 4, 1, 0, 0], // 93
+ [1, 3, 1, 1, 4, 1, 0, 0], // 94
+ [1, 1, 4, 1, 1, 3, 0, 0], // 95
+ [1, 1, 4, 3, 1, 1, 0, 0], // 96
+ [4, 1, 1, 1, 1, 3, 0, 0], // 97
+ [4, 1, 1, 3, 1, 1, 0, 0], // 98
+ [1, 1, 3, 1, 4, 1, 0, 0], // 99
+ [1, 1, 4, 1, 3, 1, 0, 0], // 100
+ [3, 1, 1, 1, 4, 1, 0, 0], // 101
+ [4, 1, 1, 1, 3, 1, 0, 0], // 102
+ [2, 1, 1, 4, 1, 2, 0, 0], // 103
+ [2, 1, 1, 2, 1, 4, 0, 0], // 104
+ [2, 1, 1, 2, 3, 2, 0, 0], // 105
+ [2, 3, 3, 1, 1, 1, 2, 0] // 106
+]
+
diff --git a/src/components/kk-printer/utils/bluetoolth.js b/src/components/kk-printer/utils/bluetoolth.js
new file mode 100644
index 00000000..764172d2
--- /dev/null
+++ b/src/components/kk-printer/utils/bluetoolth.js
@@ -0,0 +1,723 @@
+/**
+ * @export
+ * @param {string} name 微信api的名称 ,如 uniAsyncPromise("getSystemInfo",options)
+ * @param {object} options 除了success 和 fail 的其他参数
+ * @returns
+ */
+export function uniAsyncPromise(name, options) {
+ return new Promise((resolve, reject) => {
+ uni[name]({
+ ...(options || {}),
+ // ...options,
+ success: (res) => {
+ resolve(res);
+ },
+ fail: (err) => {
+ reject(err);
+ }
+ });
+ });
+}
+//微信小程序向蓝牙打印机发送数据进行打印的坑:
+//小程序api向蓝牙打印机发送数据打印,发送的任何内容都应该要转成二进制数据,而且蓝牙打印的文本编码是GBK的,发送中文需转成GBK编码再转成二进制数据发送
+//发送打印机指令也要转成二进制数据发送
+//蓝牙打印机一次接收的二级制数据有限制,不同的系统不同的蓝牙设备限制可能不同,微信建议一次20个字节,需做递归分包发送
+//发送完要打印的内容后,一定要发送一个打印的指令才能顺利打印 (有些指令就不需要)
+
+//一、初始化蓝牙、开始检索蓝牙设备
+// { allowDuplicatesKey: true, interval: 500}
+export function openBlue() {
+ return uniAsyncPromise('openBluetoothAdapter')
+}
+
+export function startBluetoothDevicesDiscovery(option) {
+ console.log('开始蓝牙扫描');
+ uniAsyncPromise('startBluetoothDevicesDiscovery', option).then((res) => {
+ console.log('正在搜寻蓝牙设备', res);
+ });
+}
+
+export function getConnectedBluetoothDevices(option) {
+ console.log('开始获取已连接设备');
+ return uniAsyncPromise('getConnectedBluetoothDevices', option)
+}
+//二、
+/**
+ *
+ *
+ * @export
+ * @param {function} getDevices uni.getBluetoothDevices的监听回调函数
+ */
+export function onfindBlueDevices(getDevices) {
+ //监听寻找到新设备的事件
+ uni.onBluetoothDeviceFound((devices)=>{
+ //获取在蓝牙模块生效期间所有已发现的蓝牙设备
+ uniAsyncPromise('getBluetoothDevices').then((res) => {
+ getDevices && getDevices(res.devices);
+ });
+ });
+}
+
+/**
+ * @export
+ * @param {function} stopBlueDevicesDiscovery 关闭蓝牙扫描
+ */
+export function stopBlueDevicesDiscovery() {
+ //监听寻找到新设备的事件
+ console.log('停止蓝牙扫描');
+ return uniAsyncPromise('stopBluetoothDevicesDiscovery').then((res) => {
+ console.log('停止搜寻蓝牙设备', res);
+ });
+}
+
+
+
+//三、连接蓝牙设备
+/**
+ * @export
+ * @param {function} createBLEConnection
+ * @param {number} deviceId 蓝牙设备id
+ */
+export function createBLEConnection(deviceId, sucess, fail) {
+ //连接蓝牙设备
+ console.log('连接蓝牙设备', deviceId);
+ uniAsyncPromise("createBLEConnection", {
+ deviceId
+ })
+ .then(res => {
+ //连接成功可选择停止搜索蓝牙
+ //stopBlueDevicesDiscovery();
+ console.log('连接成功');
+ sucess && sucess({
+ res: res,
+ });
+ })
+ .catch(res => {
+ console.log('连接设备异常' + res);
+ fail && fail({
+ res: res,
+ });
+ })
+ /*.finally(res=>{
+ console.log('连接成功');
+ sucess && sucess({
+ res: res,
+ });
+ });*/
+}
+
+export function closeBLEConnection(deviceId) {
+ console.log('断开蓝牙设备', deviceId);
+ uniAsyncPromise("closeBLEConnection", {
+ deviceId
+ })
+ .then(res => {
+ console.log('BLEDisconnect complete', res);
+ })
+ .catch(res => {
+ console.log('断开设备异常' + res);
+ })
+ /*.finally(res=>{
+ console.log('BLEDisconnect complete', res);
+ }); */
+}
+
+//四、连接成功后, 获取蓝牙设备的service服务
+// uniAsyncPromise("getBLEDeviceServices",{deviceId:""}).then(res=>{})
+export function getBLEDeviceServices(deviceId, success, fail) {
+ console.log('获取ServiceId', deviceId);
+ //加延迟避免取不到service
+ setTimeout(()=>{
+ uniAsyncPromise("getBLEDeviceServices", {
+ deviceId:deviceId
+ })
+ .then(res => {
+ console.log('服务', res);
+ success && success({
+ serviceId: res.services,
+ });
+ })
+ .catch((res) => {
+ //getBLEDeviceServices(deviceId, success, fail);
+ console.log('获取ServiceId异常' + res);
+ fail && fail({
+ res: res,
+ });
+ });
+ },1000)
+}
+
+//五、获取的service服务可能有多个,递归获取特征值(最后要用的是能读,能写,能监听的那个值的uuid作为特征值id)
+/**
+ *
+ *
+ * @export
+ * @param {number} deviceId 蓝牙设备id
+ * @param {array} services uniAsyncPromise("getBLEDeviceServices",{deviceId:""}).then(res=>{})获取的res.services
+ * @param {function} success 成功取得有用特征值uuid的回调函数
+ */
+export function getDeviceCharacteristics(deviceId, services, success, fail) {
+ //services = services.slice(0);
+ console.log('获取Characteristics', deviceId, services);
+ if (services.length) {
+ const serviceId = services.shift().uuid;
+ console.log('ServceID ', serviceId);
+ uniAsyncPromise('getBLEDeviceCharacteristics', {
+ deviceId,
+ serviceId,
+ })
+ .then((res) => {
+ console.log('getBLEDeviceCharacteristics', deviceId, serviceId, res);
+ let finished = false;
+ let write = false;
+ let notify = false;
+ let indicate = false;
+ var readId;
+ var writeId;
+ //有斑马品牌的一款打印机中res.characteristics的所有uuid都是相同的,找所有的properties存在(notify || indicate) && write这种情况就说明这个uuid是可用的(不确保所有的打印机都能用这种方式取得uuid,在主要测试得凯盛诺打印机res.characteristic只有一个uuid,所以也能用这个方式)
+ for (var i = 0; i < res.characteristics.length; i++) {
+ if (!notify) {
+ notify = res.characteristics[i].properties.notify;
+ if (notify) readId = res.characteristics[i].uuid;
+ }
+ if (!indicate) {
+ indicate = res.characteristics[i].properties.indicate;
+ if (indicate) readId = res.characteristics[i].uuid;
+ }
+ if (!write) {
+ write = res.characteristics[i].properties.write;
+ writeId = res.characteristics[i].uuid;
+ }
+ if ((notify || indicate) && write) {
+ /* 获取蓝牙特征值uuid */
+ success &&
+ success({
+ serviceId,
+ writeId: writeId,
+ readId: readId,
+ });
+ finished = true;
+ break;
+ }
+ }
+
+ if (!finished) {
+ getDeviceCharacteristics(deviceId, services, success, fail);
+ }
+ })
+ .catch((res) => {
+ getDeviceCharacteristics(deviceId, services, success, fail);
+ });
+ } else {
+ fail && fail();
+ }
+}
+
+//六、启动notify 蓝牙监听功能 然后使用 uni.onBLECharacteristicValueChange用来监听蓝牙设备传递数据
+/**
+ * @export
+ * @param {object} options
+ * {
+ deviceId,//蓝牙设备id
+ serviceId,//服务id
+ characteristicId,//可用特征值uuid
+ }
+ * @param {function} onChange 监听蓝牙设备传递数据回调函数
+ */
+export function onGetBLECharacteristicValueChange(options, onChange = function() {}) {
+ console.log('deviceId ', options.deviceId);
+ console.log('serviceId ', options.serviceId);
+ console.log('characteristicId ', options.characteristicId);
+ uniAsyncPromise('notifyBLECharacteristicValueChange', {
+ state: true,
+ ...options,
+ }).then((res) => {
+ console.log('onBLECharacteristicValueChange ');
+ uni.onBLECharacteristicValueChange(onChange);
+ });
+}
+
+//七、发送数据(递归分包发送)
+/**
+ * @export
+ * @param {object} options
+ * {
+ deviceId,
+ serviceId,
+ characteristicId,
+ value [ArrayBuffer],
+ lasterSuccess,
+ onceLength
+ }
+ */
+
+export function sendDataToDevice(options) {
+ let byteLength = options.value.byteLength;
+ //这里默认一次20个字节发送
+ const speed = options.onceLength; //20;
+ console.log("send data 20");
+ console.log(options);
+ if (byteLength > 0) {
+ uniAsyncPromise('writeBLECharacteristicValue', {
+ ...options,
+ value: options.value.slice(0, byteLength > speed ? speed : byteLength),
+ })
+ .then((res) => {
+ if (byteLength > speed) {
+ sendDataToDevice({
+ ...options,
+ value: options.value.slice(speed, byteLength),
+ });
+ } else {
+ options.lasterSuccess && options.lasterSuccess();
+ }
+ })
+ .catch((res) => {
+ console.log(res);
+ });
+ }
+}
+export function charToArrayBuffer(str) {
+ var out = new ArrayBuffer(str.length);
+ var uint8 = new Uint8Array(out);
+ var strs = str.split('');
+ for (var i = 0; i < strs.length; i++) {
+ uint8[i] = strs[i].charCodeAt();
+ }
+ return uint8;
+}
+export function charToArray(str) {
+ var arr = [];
+ var strs = str.split('');
+ for (var i = 0; i < strs.length; i++) {
+ arr[i] = strs[i].charCodeAt();
+ }
+ return arr;
+}
+//打印二维码
+/**
+ * @export
+ * @param {object} options
+ * {
+ deviceId,
+ serviceId,
+ characteristicId,
+ value,//ArrayBuffer:二维码的数据
+ }
+ */
+export function printQR(options) {
+ //打印二维码的十进制指令data:
+ let data = [29, 107, 97, 7, 4, options.value.byteLength, 0];
+ sendDataToDevice({
+ ...options,
+ value: new Uint8Array(data).buffer,
+ lasterSuccess: () => {
+ //指令发送成功后,发送二维码的数据
+ sendDataToDevice(options);
+ },
+ });
+}
+
+function grayPixle(pix) {
+ return pix[0] * 0.299 + pix[1] * 0.587 + pix[2] * 0.114;
+}
+
+export function overwriteImageData(data) {
+ let sendWidth = data.width,
+ sendHeight = data.height;
+ const threshold = data.threshold || 180;
+ let sendImageData = new ArrayBuffer((sendWidth * sendHeight) / 8);
+ sendImageData = new Uint8Array(sendImageData);
+ let pix = data.imageData;
+ const part = [];
+ let index = 0;
+ for (let i = 0; i < pix.length; i += 32) {
+ //横向每8个像素点组成一个字节(8位二进制数)。
+ for (let k = 0; k < 8; k++) {
+ const grayPixle1 = grayPixle(pix.slice(i + k * 4, i + k * 4 + (4 - 1)));
+ //阈值调整
+ if (grayPixle1 > threshold) {
+ //灰度值大于threshold位 白色 为第k位0不打印
+ part[k] = 0;
+ } else {
+ part[k] = 1;
+ }
+ }
+ let temp = 0;
+ for (let a = 0; a < part.length; a++) {
+ temp += part[a] * Math.pow(2, part.length - 1 - a);
+ }
+ //开始不明白以下算法什么意思,了解了字节才知道,一个字节是8位的二进制数,part这个数组存的0和1就是二进制的0和1,传输到打印的位图数据的一个字节是0-255之间的十进制数,以下是用权相加法转十进制数,理解了这个就用上面的for循环替代了
+ // const temp =
+ // part[0] * 128 +
+ // part[1] * 64 +
+ // part[2] * 32 +
+ // part[3] * 16 +
+ // part[4] * 8 +
+ // part[5] * 4 +
+ // part[6] * 2 +
+ // part[7] * 1;
+ sendImageData[index++] = temp;
+ }
+ return {
+ array: Array.from(sendImageData),
+ width: sendWidth / 8,
+ height: sendHeight,
+ };
+}
+/**
+ * printImage
+ * @param {object} opt
+ * {
+ deviceId,//蓝牙设备id
+ serviceId,//服务id
+ characteristicId,//可用特征值uuid
+ lasterSuccess , //最后完成的回调
+ }
+ */
+export function printImage(opt = {}, imageInfo = {}) {
+ let arr = imageInfo.array,
+ width = imageInfo.width;
+ const writeArray = [];
+ const xl = width % 256;
+ const xh = width / 256;
+ //分行发送图片数据,用的十进制指令
+ const command = [29, 118, 48, 0, xl, xh, 1, 0]; //1D 76 30 00 w h
+ const enter = [13, 10];
+ for (let i = 0; i < arr.length / width; i++) {
+ const subArr = arr.slice(i * width, i * width + width);
+ const tempArr = command.concat(subArr);
+ writeArray.push(new Uint8Array(tempArr));
+ }
+ writeArray.push(new Uint8Array(enter));
+ //console.log(writeArray);
+ const print = (options, writeArray) => {
+ if (writeArray.length) {
+ console.log("send");
+ sendDataToDevice({
+ ...options,
+ value: writeArray.shift().buffer,
+ lasterSuccess: () => {
+ if (writeArray.length) {
+ print(options, writeArray);
+ } else {
+ options.lasterSuccess && options.lasterSuccess();
+ }
+ },
+ });
+ }
+ };
+ console.log("start print");
+ print(opt, writeArray);
+}
+
+/* 16hex insert 0 */
+function Hex2Str(num) {
+ if (num.toString(16).length < 2) return "0" + num.toString(16);
+ else
+ return num.toString(16);
+}
+/*****CPCL指令接口****/
+
+/**
+ * 配置项如下
+ *
+ * width: 标签纸的宽度,单位像素點
+ * height: 标签纸的高度,单位像素點
+ * 8像素=1mm
+ * printNum: 打印张数,默认为1
+ * rotation:页面整体旋转 1-90度 2-180度 3-270度 其他-不旋转
+ */
+export function CreatCPCLPage(width, height, printNum, rotation = 0, offset = 0) {
+ var strCmd = '! ' + offset + ' 200 200 ' + height + ' ' + printNum + '\n';
+ strCmd += "PAGE-WIDTH " + width + '\n';
+ if (rotation == 1)
+ strCmd += "ZPROTATE90\n";
+ else if (rotation == 2)
+ strCmd += "ZPROTATE180\n";
+ else if (rotation == 3)
+ strCmd += "ZPROTATE270\n";
+ else
+ strCmd += "ZPROTATE0\n";
+ return strCmd;
+}
+
+/**
+ * 打印文字
+ * x: 文字方块左上角X座标,单位dot
+ * y: 文字方块左上角Y座标,单位dot
+ * fontName,fontSize: 字体,取值: 參考文檔
+ * rotation: 旋转 1-90度 2-180度 3-270度 其他-不旋转
+ * content: 文字内容
+ */
+export function addCPCLText(x, y, fontName, fontSize, rotation, content) {
+ //console.log(fontName,fontSize,rotation, content);
+ var strCmd = '';
+ if (rotation == 1) {
+ strCmd += 'T90 ';
+ }
+ if (rotation == 2) {
+ strCmd += 'T180 ';
+ }
+ if (rotation == 3) {
+ strCmd += 'T270 ';
+ } else {
+ strCmd += 'T ';
+ }
+ strCmd += fontName + ' ' + fontSize + ' ' + x + ' ' + y + ' ' + content + '\n';
+ return strCmd;
+};
+
+/**
+ * 打印一维码
+ *
+ * x: 文字方块左上角X座标,单位dot
+ * y: 文字方块左上角Y座标,单位dot
+ * codeType: 条码类型,取值为128、UPCA、UPCA2、UPCA5、UPCE、UPCE2、UPC5、EAN13、EAN13+2、EAN13+5、
+ * EAN8、EAN8+2、EAN8+5、39、39C、F39、F39C、93、CODABAR、CODABAR16、ITF、I2OF5
+ * h: 条码高度,单位dot
+ * rotation: 顺时针旋转角度,取值如下:
+ * - 0 不旋转
+ * - 1 顺时针旋转90度
+ *
+ * narrow: 窄条码比例因子(dot) 取值: 參考文檔
+ * wide: 宽条码比例因子(dot) 取值: 參考文檔
+ * content: 文字内容
+ *
+ */
+export function addCPCLBarCode(x, y, codeType, h, rotation, narrow, wide, content) {
+ var strCmd = '';
+ if (rotation == 0)
+ strCmd += 'B ';
+ else
+ strCmd += 'VB ';
+ strCmd += codeType + ' ' + narrow + ' ' + wide + ' ' + h + ' ' + x + ' ' + y + ' ' + content + '\n'
+ return strCmd;
+};
+
+/**
+ * 打印二维码
+ *
+ * x: 文字方块左上角X座标,单位dot
+ * y: 文字方块左上角Y座标,单位dot
+ * level: 错误纠正能力等级,取值为L(7%)、M(15%)、Q(25%)、H(30%)
+ * ver: 1-10 版本,根据内容调整以获取合适容量
+ * scale: 1-10 放大倍数
+ * content: 文字内容
+ *
+ */
+export function addCPCLQRCode(x, y, level, ver, scale, content) {
+ var strCmd = 'B QR ' + x + ' ' + y + ' M ' + ver + ' U ' + scale + '\n' + level + 'A,' + content + '\n';
+ strCmd += 'ENDQR\n';
+ return strCmd;
+};
+
+/**
+ * 放大指令
+ * scaleX: 横向放大倍数 1,2,3等整数
+ * scaleY: 纵向放大倍数 1,2,3等整数
+ */
+export function addCPCLSETMAG(scaleX, scaleY) {
+ var strCmd = 'SETMAG ' + scaleX + ' ' + scaleY + '\n';
+ return strCmd;
+};
+
+/**
+ * 对齐指令 0-左对齐 1-右对齐 2-居中
+ */
+export function addCPCLLocation(set) {
+ var strCmd = '';
+ if (set == 1) {
+ strCmd += 'RIGHT\n';
+ } else if (set == 2) {
+ strCmd += 'CENTER\n';
+ } else {
+ strCmd += 'LEFT\n';
+ }
+ return strCmd;
+};
+
+/**
+ * 反白线 x0,y0,x1,y1,width
+ */
+export function addCPCLInverseLine(x0, y0, x1, y1, width) {
+ var strCmd = 'IL ' + x0 + ' ' + y0 + ' ' + x1 + ' ' + y1 + ' ' + width + '\n';
+ return strCmd;
+};
+
+/**
+ * 画线 x0,y0,x1,y1,width
+ */
+export function addCPCLLine(x0, y0, x1, y1, width) {
+ var strCmd = 'L ' + x0 + ' ' + y0 + ' ' + x1 + ' ' + y1 + ' ' + width + '\n';
+ return strCmd;
+};
+
+/**
+ * 画框 x0,y0,x1,y1,width
+ */
+export function addCPCLBox(x0, y0, x1, y1, width) {
+ var strCmd = 'BOX ' + x0 + ' ' + y0 + ' ' + x1 + ' ' + y1 + ' ' + width + '\n';
+ return strCmd;
+};
+
+/**
+ * 字体加粗
+ */
+export function addCPCLSETBOLD(bold) {
+ var strCmd = 'SETBOLD ' + bold + '\n';
+ return strCmd;
+};
+
+/**
+ * 字体下划线
+ */
+export function addCPCLUNDERLINE(c) {
+ var strCmd = 'UNDERLINE ';
+ if (c) strCmd += 'ON\n';
+ else if (c) strCmd += 'OFF\n';
+ return strCmd;
+};
+
+/**
+ * 水印打印灰度等级 0-255
+ */
+export function addCPCLBACKGROUND(level) {
+ var strCmd = 'BACKGROUND ';
+ if (level > 255 || level < 0) level = 255;
+ strCmd += level + '\n';
+ return strCmd;
+};
+
+/**
+ * 打印水印文字
+ * x: 文字方块左上角X座标,单位dot
+ * y: 文字方块左上角Y座标,单位dot
+ * fontName,fontSize: 字体,取值: 參考文檔
+ * rotation: 旋转 1-90度 2-180度 3-270度 其他-不旋转
+ * content: 文字内容
+ */
+export function addCPCLBKVText(x, y, fontName, fontSize, rotation, content) {
+ //console.log(fontName,fontSize,rotation, content);
+ var strCmd = '';
+ if (rotation == 1) {
+ strCmd += 'BKT90 ';
+ }
+ if (rotation == 2) {
+ strCmd += 'BKT180 ';
+ }
+ if (rotation == 3) {
+ strCmd += 'BKT270 ';
+ } else {
+ strCmd += 'BKT ';
+ }
+ strCmd += fontName + ' ' + fontSize + ' ' + x + ' ' + y + ' ' + content + '\n';
+ return strCmd;
+};
+
+
+/**
+ * 标签缝隙定位指令
+ */
+export function addCPCLGAP() {
+ var strCmd = 'GAP-SENSE\nFORM\n';
+ return strCmd;
+};
+
+/**
+ * 标签右黑标检测指令
+ */
+export function addCPCLSENSE() {
+ var strCmd = 'BAR-SENSE\nFORM\n';
+ return strCmd;
+};
+
+/**
+ * 标签左黑标检测指令
+ */
+export function addCPCLSENSELEFT() {
+ var strCmd = 'BAR-SENSE LEFT\nFORM\n';
+ return strCmd;
+};
+
+/**
+ * 打印指令
+ */
+export function addCPCLPrint() {
+ var strCmd = 'PRINT\n';
+ return strCmd;
+};
+
+/**
+ * 图片打印指令
+ * x: 文字方块左上角X座标,单位dot
+ * y: 文字方块左上角Y座标,单位dot
+ * data{
+ threshold,//0/1提取的灰度级
+ width,//图像宽度
+ height,//图像高度
+ imageData , //图像数据
+ }
+ */
+export function addCPCLImageCmd(x, y, data) {
+ var strImgCmd = '';
+ const threshold = data.threshold || 180;
+ let myBitmapWidth = data.width,
+ myBitmapHeight = data.height;
+ let len = parseInt((myBitmapWidth + 7) / 8); //一行的数据长度
+ //console.log('len=',len);
+ //console.log('myBitmapWidth=',myBitmapWidth);
+ //console.log('myBitmapHeight=',myBitmapHeight);
+ let ndata = 0;
+ let i = 0;
+ let j = 0;
+ let sendImageData = new ArrayBuffer(len * myBitmapHeight);
+ sendImageData = new Uint8Array(sendImageData);
+ let pix = data.imageData;
+ console.log('pix=', pix);
+
+ for (i = 0; i < myBitmapHeight; i++) {
+ for (j = 0; j < len; j++) {
+ sendImageData[ndata + j] = 0;
+ }
+ for (j = 0; j < myBitmapWidth; j++) {
+ const grayPixle1 = grayPixle(pix.slice((i * myBitmapWidth + j) * 4, (i * myBitmapWidth + j) * 4 + 3));
+ if (grayPixle1 < threshold)
+ sendImageData[ndata + parseInt(j / 8)] |= (0x80 >> (j % 8));
+
+ }
+ ndata += len;
+ }
+ //console.log('sendImageData=',sendImageData);
+ //CPCL指令图片数据
+ strImgCmd += 'EG ' + len + ' ' + myBitmapHeight + ' ' + x + ' ' + y + ' ';
+ for (i = 0; i < sendImageData.length; i++) {
+ strImgCmd += Hex2Str(sendImageData[i]);
+ }
+ strImgCmd += '\n';
+ //console.log(strImgCmd);
+ return strImgCmd;
+}
+/**
+ * toast显示捕获的蓝牙异常
+ */
+export function catchToast(err) {
+ const errMsg = {
+ 10000: '未初始化蓝牙模块',
+ 10001: '蓝牙未打开',
+ 10002: '没有找到指定设备',
+ 10003: '连接失败',
+ 10004: '没有找到指定服务',
+ 10005: '没有找到指定特征值',
+ 10006: '当前连接已断开',
+ 10007: '当前特征值不支持此操作',
+ 10008: '系统上报异常',
+ 10009: '系统版本低于 4.3 不支持BLE'
+ };
+ let coode = err.errCode ? err.errCode.toString() : '';
+ let msg = errMsg[coode];
+ plus.nativeUI.toast(msg || coode, {
+ align: 'center',
+ verticalAlign: 'center'
+ });
+}
diff --git a/src/components/kk-printer/utils/index.js b/src/components/kk-printer/utils/index.js
new file mode 100644
index 00000000..78e43f40
--- /dev/null
+++ b/src/components/kk-printer/utils/index.js
@@ -0,0 +1,23 @@
+var barcode = require('./barcode');
+var qrcode = require('./qrcode');
+
+function convert_length(length) {
+ return Math.round(wx.getSystemInfoSync().windowWidth * length / 750);
+}
+
+function barc(id, code, width, height) {
+ barcode.code128(wx.createCanvasContext(id), code, convert_length(width), convert_length(height))
+}
+
+function qrc(id, code, width, height) {
+ qrcode.api.draw(code, {
+ ctx: wx.createCanvasContext(id),
+ width: convert_length(width),
+ height: convert_length(height)
+ })
+}
+
+module.exports = {
+ barcode: barc,
+ qrcode: qrc
+}
\ No newline at end of file
diff --git a/src/components/kk-printer/utils/mqtt.js b/src/components/kk-printer/utils/mqtt.js
new file mode 100644
index 00000000..79ceffb8
--- /dev/null
+++ b/src/components/kk-printer/utils/mqtt.js
@@ -0,0 +1,14633 @@
+(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.mqtt = f()}})(function(){var define,module,exports;return (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i to
+ *
+ * @param {String} topic - topic to publish to
+ * @param {String, Buffer} message - message to publish
+ * @param {Object} [opts] - publish options, includes:
+ * {Number} qos - qos level to publish on
+ * {Boolean} retain - whether or not to retain the message
+ * {Boolean} dup - whether or not mark a message as duplicate
+ * {Function} cbStorePut - function(){} called when message is put into `outgoingStore`
+ * @param {Function} [callback] - function(err){}
+ * called when publish succeeds or fails
+ * @returns {MqttClient} this - for chaining
+ * @api public
+ *
+ * @example client.publish('topic', 'message');
+ * @example
+ * client.publish('topic', 'message', {qos: 1, retain: true, dup: true});
+ * @example client.publish('topic', 'message', console.log);
+ */
+MqttClient.prototype.publish = function (topic, message, opts, callback) {
+ var packet
+ var options = this.options
+
+ // .publish(topic, payload, cb);
+ if (typeof opts === 'function') {
+ callback = opts
+ opts = null
+ }
+
+ // default opts
+ var defaultOpts = {qos: 0, retain: false, dup: false}
+ opts = xtend(defaultOpts, opts)
+
+ if (this._checkDisconnecting(callback)) {
+ return this
+ }
+
+ packet = {
+ cmd: 'publish',
+ topic: topic,
+ payload: message,
+ qos: opts.qos,
+ retain: opts.retain,
+ messageId: this._nextId(),
+ dup: opts.dup
+ }
+
+ if (options.protocolVersion === 5) {
+ packet.properties = opts.properties
+ if ((!options.properties && packet.properties && packet.properties.topicAlias) || ((opts.properties && options.properties) &&
+ ((opts.properties.topicAlias && options.properties.topicAliasMaximum && opts.properties.topicAlias > options.properties.topicAliasMaximum) ||
+ (!options.properties.topicAliasMaximum && opts.properties.topicAlias)))) {
+ /*
+ if we are don`t setup topic alias or
+ topic alias maximum less than topic alias or
+ server don`t give topic alias maximum,
+ we are removing topic alias from packet
+ */
+ delete packet.properties.topicAlias
+ }
+ }
+
+ switch (opts.qos) {
+ case 1:
+ case 2:
+ // Add to callbacks
+ this.outgoing[packet.messageId] = {
+ volatile: false,
+ cb: callback || nop
+ }
+ if (this._storeProcessing) {
+ this._packetIdsDuringStoreProcessing[packet.messageId] = false
+ this._storePacket(packet, undefined, opts.cbStorePut)
+ } else {
+ this._sendPacket(packet, undefined, opts.cbStorePut)
+ }
+ break
+ default:
+ if (this._storeProcessing) {
+ this._storePacket(packet, callback, opts.cbStorePut)
+ } else {
+ this._sendPacket(packet, callback, opts.cbStorePut)
+ }
+ break
+ }
+
+ return this
+}
+
+/**
+ * subscribe - subscribe to
+ *
+ * @param {String, Array, Object} topic - topic(s) to subscribe to, supports objects in the form {'topic': qos}
+ * @param {Object} [opts] - optional subscription options, includes:
+ * {Number} qos - subscribe qos level
+ * @param {Function} [callback] - function(err, granted){} where:
+ * {Error} err - subscription error (none at the moment!)
+ * {Array} granted - array of {topic: 't', qos: 0}
+ * @returns {MqttClient} this - for chaining
+ * @api public
+ * @example client.subscribe('topic');
+ * @example client.subscribe('topic', {qos: 1});
+ * @example client.subscribe({'topic': {qos: 0}, 'topic2': {qos: 1}}, console.log);
+ * @example client.subscribe('topic', console.log);
+ */
+MqttClient.prototype.subscribe = function () {
+ var packet
+ var args = new Array(arguments.length)
+ for (var i = 0; i < arguments.length; i++) {
+ args[i] = arguments[i]
+ }
+ var subs = []
+ var obj = args.shift()
+ var resubscribe = obj.resubscribe
+ var callback = args.pop() || nop
+ var opts = args.pop()
+ var invalidTopic
+ var that = this
+ var version = this.options.protocolVersion
+
+ delete obj.resubscribe
+
+ if (typeof obj === 'string') {
+ obj = [obj]
+ }
+
+ if (typeof callback !== 'function') {
+ opts = callback
+ callback = nop
+ }
+
+ invalidTopic = validations.validateTopics(obj)
+ if (invalidTopic !== null) {
+ setImmediate(callback, new Error('Invalid topic ' + invalidTopic))
+ return this
+ }
+
+ if (this._checkDisconnecting(callback)) {
+ return this
+ }
+
+ var defaultOpts = {
+ qos: 0
+ }
+ if (version === 5) {
+ defaultOpts.nl = false
+ defaultOpts.rap = false
+ defaultOpts.rh = 0
+ }
+ opts = xtend(defaultOpts, opts)
+
+ if (Array.isArray(obj)) {
+ obj.forEach(function (topic) {
+ if (!that._resubscribeTopics.hasOwnProperty(topic) ||
+ that._resubscribeTopics[topic].qos < opts.qos ||
+ resubscribe) {
+ var currentOpts = {
+ topic: topic,
+ qos: opts.qos
+ }
+ if (version === 5) {
+ currentOpts.nl = opts.nl
+ currentOpts.rap = opts.rap
+ currentOpts.rh = opts.rh
+ currentOpts.properties = opts.properties
+ }
+ subs.push(currentOpts)
+ }
+ })
+ } else {
+ Object
+ .keys(obj)
+ .forEach(function (k) {
+ if (!that._resubscribeTopics.hasOwnProperty(k) ||
+ that._resubscribeTopics[k].qos < obj[k].qos ||
+ resubscribe) {
+ var currentOpts = {
+ topic: k,
+ qos: obj[k].qos
+ }
+ if (version === 5) {
+ currentOpts.nl = obj[k].nl
+ currentOpts.rap = obj[k].rap
+ currentOpts.rh = obj[k].rh
+ currentOpts.properties = opts.properties
+ }
+ subs.push(currentOpts)
+ }
+ })
+ }
+
+ packet = {
+ cmd: 'subscribe',
+ subscriptions: subs,
+ qos: 1,
+ retain: false,
+ dup: false,
+ messageId: this._nextId()
+ }
+
+ if (opts.properties) {
+ packet.properties = opts.properties
+ }
+
+ if (!subs.length) {
+ callback(null, [])
+ return
+ }
+
+ // subscriptions to resubscribe to in case of disconnect
+ if (this.options.resubscribe) {
+ var topics = []
+ subs.forEach(function (sub) {
+ if (that.options.reconnectPeriod > 0) {
+ var topic = { qos: sub.qos }
+ if (version === 5) {
+ topic.nl = sub.nl || false
+ topic.rap = sub.rap || false
+ topic.rh = sub.rh || 0
+ topic.properties = sub.properties
+ }
+ that._resubscribeTopics[sub.topic] = topic
+ topics.push(sub.topic)
+ }
+ })
+ that.messageIdToTopic[packet.messageId] = topics
+ }
+
+ this.outgoing[packet.messageId] = {
+ volatile: true,
+ cb: function (err, packet) {
+ if (!err) {
+ var granted = packet.granted
+ for (var i = 0; i < granted.length; i += 1) {
+ subs[i].qos = granted[i]
+ }
+ }
+
+ callback(err, subs)
+ }
+ }
+
+ this._sendPacket(packet)
+
+ return this
+}
+
+/**
+ * unsubscribe - unsubscribe from topic(s)
+ *
+ * @param {String, Array} topic - topics to unsubscribe from
+ * @param {Object} [opts] - optional subscription options, includes:
+ * {Object} properties - properties of unsubscribe packet
+ * @param {Function} [callback] - callback fired on unsuback
+ * @returns {MqttClient} this - for chaining
+ * @api public
+ * @example client.unsubscribe('topic');
+ * @example client.unsubscribe('topic', console.log);
+ */
+MqttClient.prototype.unsubscribe = function () {
+ var packet = {
+ cmd: 'unsubscribe',
+ qos: 1,
+ messageId: this._nextId()
+ }
+ var that = this
+ var args = new Array(arguments.length)
+ for (var i = 0; i < arguments.length; i++) {
+ args[i] = arguments[i]
+ }
+ var topic = args.shift()
+ var callback = args.pop() || nop
+ var opts = args.pop()
+
+ if (typeof topic === 'string') {
+ topic = [topic]
+ }
+
+ if (typeof callback !== 'function') {
+ opts = callback
+ callback = nop
+ }
+
+ if (this._checkDisconnecting(callback)) {
+ return this
+ }
+
+ if (typeof topic === 'string') {
+ packet.unsubscriptions = [topic]
+ } else if (typeof topic === 'object' && topic.length) {
+ packet.unsubscriptions = topic
+ }
+
+ if (this.options.resubscribe) {
+ packet.unsubscriptions.forEach(function (topic) {
+ delete that._resubscribeTopics[topic]
+ })
+ }
+
+ if (typeof opts === 'object' && opts.properties) {
+ packet.properties = opts.properties
+ }
+
+ this.outgoing[packet.messageId] = {
+ volatile: true,
+ cb: callback
+ }
+
+ this._sendPacket(packet)
+
+ return this
+}
+
+/**
+ * end - close connection
+ *
+ * @returns {MqttClient} this - for chaining
+ * @param {Boolean} force - do not wait for all in-flight messages to be acked
+ * @param {Function} cb - called when the client has been closed
+ *
+ * @api public
+ */
+MqttClient.prototype.end = function () {
+ var that = this
+
+ var force = arguments[0]
+ var opts = arguments[1]
+ var cb = arguments[2]
+
+ if (force == null || typeof force !== 'boolean') {
+ cb = opts || nop
+ opts = force
+ force = false
+ if (typeof opts !== 'object') {
+ cb = opts
+ opts = null
+ if (typeof cb !== 'function') {
+ cb = nop
+ }
+ }
+ }
+
+ if (typeof opts !== 'object') {
+ cb = opts
+ opts = null
+ }
+
+ cb = cb || nop
+
+ function closeStores () {
+ that.disconnected = true
+ that.incomingStore.close(function () {
+ that.outgoingStore.close(function () {
+ if (cb) {
+ cb.apply(null, arguments)
+ }
+ that.emit('end')
+ })
+ })
+ if (that._deferredReconnect) {
+ that._deferredReconnect()
+ }
+ }
+
+ function finish () {
+ // defer closesStores of an I/O cycle,
+ // just to make sure things are
+ // ok for websockets
+ that._cleanUp(force, setImmediate.bind(null, closeStores), opts)
+ }
+
+ if (this.disconnecting) {
+ return this
+ }
+
+ this._clearReconnect()
+
+ this.disconnecting = true
+
+ if (!force && Object.keys(this.outgoing).length > 0) {
+ // wait 10ms, just to be sure we received all of it
+ this.once('outgoingEmpty', setTimeout.bind(null, finish, 10))
+ } else {
+ finish()
+ }
+
+ return this
+}
+
+/**
+ * removeOutgoingMessage - remove a message in outgoing store
+ * the outgoing callback will be called withe Error('Message removed') if the message is removed
+ *
+ * @param {Number} mid - messageId to remove message
+ * @returns {MqttClient} this - for chaining
+ * @api public
+ *
+ * @example client.removeOutgoingMessage(client.getLastMessageId());
+ */
+MqttClient.prototype.removeOutgoingMessage = function (mid) {
+ var cb = this.outgoing[mid] ? this.outgoing[mid].cb : null
+ delete this.outgoing[mid]
+ this.outgoingStore.del({messageId: mid}, function () {
+ cb(new Error('Message removed'))
+ })
+ return this
+}
+
+/**
+ * reconnect - connect again using the same options as connect()
+ *
+ * @param {Object} [opts] - optional reconnect options, includes:
+ * {Store} incomingStore - a store for the incoming packets
+ * {Store} outgoingStore - a store for the outgoing packets
+ * if opts is not given, current stores are used
+ * @returns {MqttClient} this - for chaining
+ *
+ * @api public
+ */
+MqttClient.prototype.reconnect = function (opts) {
+ var that = this
+ var f = function () {
+ if (opts) {
+ that.options.incomingStore = opts.incomingStore
+ that.options.outgoingStore = opts.outgoingStore
+ } else {
+ that.options.incomingStore = null
+ that.options.outgoingStore = null
+ }
+ that.incomingStore = that.options.incomingStore || new Store()
+ that.outgoingStore = that.options.outgoingStore || new Store()
+ that.disconnecting = false
+ that.disconnected = false
+ that._deferredReconnect = null
+ that._reconnect()
+ }
+
+ if (this.disconnecting && !this.disconnected) {
+ this._deferredReconnect = f
+ } else {
+ f()
+ }
+ return this
+}
+
+/**
+ * _reconnect - implement reconnection
+ * @api privateish
+ */
+MqttClient.prototype._reconnect = function () {
+ this.emit('reconnect')
+ this._setupStream()
+}
+
+/**
+ * _setupReconnect - setup reconnect timer
+ */
+MqttClient.prototype._setupReconnect = function () {
+ var that = this
+
+ if (!that.disconnecting && !that.reconnectTimer && (that.options.reconnectPeriod > 0)) {
+ if (!this.reconnecting) {
+ this.emit('offline')
+ this.reconnecting = true
+ }
+ that.reconnectTimer = setInterval(function () {
+ that._reconnect()
+ }, that.options.reconnectPeriod)
+ }
+}
+
+/**
+ * _clearReconnect - clear the reconnect timer
+ */
+MqttClient.prototype._clearReconnect = function () {
+ if (this.reconnectTimer) {
+ clearInterval(this.reconnectTimer)
+ this.reconnectTimer = null
+ }
+}
+
+/**
+ * _cleanUp - clean up on connection end
+ * @api private
+ */
+MqttClient.prototype._cleanUp = function (forced, done) {
+ var opts = arguments[2]
+ if (done) {
+ this.stream.on('close', done)
+ }
+
+ if (forced) {
+ if ((this.options.reconnectPeriod === 0) && this.options.clean) {
+ flush(this.outgoing)
+ }
+ this.stream.destroy()
+ } else {
+ var packet = xtend({ cmd: 'disconnect' }, opts)
+ this._sendPacket(
+ packet,
+ setImmediate.bind(
+ null,
+ this.stream.end.bind(this.stream)
+ )
+ )
+ }
+
+ if (!this.disconnecting) {
+ this._clearReconnect()
+ this._setupReconnect()
+ }
+
+ if (this.pingTimer !== null) {
+ this.pingTimer.clear()
+ this.pingTimer = null
+ }
+
+ if (done && !this.connected) {
+ this.stream.removeListener('close', done)
+ done()
+ }
+}
+
+/**
+ * _sendPacket - send or queue a packet
+ * @param {String} type - packet type (see `protocol`)
+ * @param {Object} packet - packet options
+ * @param {Function} cb - callback when the packet is sent
+ * @param {Function} cbStorePut - called when message is put into outgoingStore
+ * @api private
+ */
+MqttClient.prototype._sendPacket = function (packet, cb, cbStorePut) {
+ cbStorePut = cbStorePut || nop
+
+ if (!this.connected) {
+ this._storePacket(packet, cb, cbStorePut)
+ return
+ }
+
+ // When sending a packet, reschedule the ping timer
+ this._shiftPingInterval()
+
+ switch (packet.cmd) {
+ case 'publish':
+ break
+ case 'pubrel':
+ storeAndSend(this, packet, cb, cbStorePut)
+ return
+ default:
+ sendPacket(this, packet, cb)
+ return
+ }
+
+ switch (packet.qos) {
+ case 2:
+ case 1:
+ storeAndSend(this, packet, cb, cbStorePut)
+ break
+ /**
+ * no need of case here since it will be caught by default
+ * and jshint comply that before default it must be a break
+ * anyway it will result in -1 evaluation
+ */
+ case 0:
+ /* falls through */
+ default:
+ sendPacket(this, packet, cb)
+ break
+ }
+}
+
+/**
+ * _storePacket - queue a packet
+ * @param {String} type - packet type (see `protocol`)
+ * @param {Object} packet - packet options
+ * @param {Function} cb - callback when the packet is sent
+ * @param {Function} cbStorePut - called when message is put into outgoingStore
+ * @api private
+ */
+MqttClient.prototype._storePacket = function (packet, cb, cbStorePut) {
+ cbStorePut = cbStorePut || nop
+
+ if (((packet.qos || 0) === 0 && this.queueQoSZero) || packet.cmd !== 'publish') {
+ this.queue.push({ packet: packet, cb: cb })
+ } else if (packet.qos > 0) {
+ cb = this.outgoing[packet.messageId] ? this.outgoing[packet.messageId].cb : null
+ this.outgoingStore.put(packet, function (err) {
+ if (err) {
+ return cb && cb(err)
+ }
+ cbStorePut()
+ })
+ } else if (cb) {
+ cb(new Error('No connection to broker'))
+ }
+}
+
+/**
+ * _setupPingTimer - setup the ping timer
+ *
+ * @api private
+ */
+MqttClient.prototype._setupPingTimer = function () {
+ var that = this
+
+ if (!this.pingTimer && this.options.keepalive) {
+ this.pingResp = true
+ this.pingTimer = reInterval(function () {
+ that._checkPing()
+ }, this.options.keepalive * 1000)
+ }
+}
+
+/**
+ * _shiftPingInterval - reschedule the ping interval
+ *
+ * @api private
+ */
+MqttClient.prototype._shiftPingInterval = function () {
+ if (this.pingTimer && this.options.keepalive && this.options.reschedulePings) {
+ this.pingTimer.reschedule(this.options.keepalive * 1000)
+ }
+}
+/**
+ * _checkPing - check if a pingresp has come back, and ping the server again
+ *
+ * @api private
+ */
+MqttClient.prototype._checkPing = function () {
+ if (this.pingResp) {
+ this.pingResp = false
+ this._sendPacket({ cmd: 'pingreq' })
+ } else {
+ // do a forced cleanup since socket will be in bad shape
+ this._cleanUp(true)
+ }
+}
+
+/**
+ * _handlePingresp - handle a pingresp
+ *
+ * @api private
+ */
+MqttClient.prototype._handlePingresp = function () {
+ this.pingResp = true
+}
+
+/**
+ * _handleConnack
+ *
+ * @param {Object} packet
+ * @api private
+ */
+
+MqttClient.prototype._handleConnack = function (packet) {
+ var options = this.options
+ var version = options.protocolVersion
+ var rc = version === 5 ? packet.reasonCode : packet.returnCode
+
+ clearTimeout(this.connackTimer)
+
+ if (packet.properties) {
+ if (packet.properties.topicAliasMaximum) {
+ if (!options.properties) { options.properties = {} }
+ options.properties.topicAliasMaximum = packet.properties.topicAliasMaximum
+ }
+ if (packet.properties.serverKeepAlive && options.keepalive) {
+ options.keepalive = packet.properties.serverKeepAlive
+ this._shiftPingInterval()
+ }
+ if (packet.properties.maximumPacketSize) {
+ if (!options.properties) { options.properties = {} }
+ options.properties.maximumPacketSize = packet.properties.maximumPacketSize
+ }
+ }
+
+ if (rc === 0) {
+ this.reconnecting = false
+ this._onConnect(packet)
+ } else if (rc > 0) {
+ var err = new Error('Connection refused: ' + errors[rc])
+ err.code = rc
+ this.emit('error', err)
+ }
+}
+
+/**
+ * _handlePublish
+ *
+ * @param {Object} packet
+ * @api private
+ */
+/*
+those late 2 case should be rewrite to comply with coding style:
+
+case 1:
+case 0:
+ // do not wait sending a puback
+ // no callback passed
+ if (1 === qos) {
+ this._sendPacket({
+ cmd: 'puback',
+ messageId: mid
+ });
+ }
+ // emit the message event for both qos 1 and 0
+ this.emit('message', topic, message, packet);
+ this.handleMessage(packet, done);
+ break;
+default:
+ // do nothing but every switch mus have a default
+ // log or throw an error about unknown qos
+ break;
+
+for now i just suppressed the warnings
+*/
+MqttClient.prototype._handlePublish = function (packet, done) {
+ done = typeof done !== 'undefined' ? done : nop
+ var topic = packet.topic.toString()
+ var message = packet.payload
+ var qos = packet.qos
+ var mid = packet.messageId
+ var that = this
+ var options = this.options
+ var validReasonCodes = [0, 16, 128, 131, 135, 144, 145, 151, 153]
+
+ switch (qos) {
+ case 2: {
+ options.customHandleAcks(topic, message, packet, function (error, code) {
+ if (!(error instanceof Error)) {
+ code = error
+ error = null
+ }
+ if (error) { return that.emit('error', error) }
+ if (validReasonCodes.indexOf(code) === -1) { return that.emit('error', new Error('Wrong reason code for pubrec')) }
+ if (code) {
+ that._sendPacket({cmd: 'pubrec', messageId: mid, reasonCode: code}, done)
+ } else {
+ that.incomingStore.put(packet, function () {
+ that._sendPacket({cmd: 'pubrec', messageId: mid}, done)
+ })
+ }
+ })
+ break
+ }
+ case 1: {
+ // emit the message event
+ options.customHandleAcks(topic, message, packet, function (error, code) {
+ if (!(error instanceof Error)) {
+ code = error
+ error = null
+ }
+ if (error) { return that.emit('error', error) }
+ if (validReasonCodes.indexOf(code) === -1) { return that.emit('error', new Error('Wrong reason code for puback')) }
+ if (!code) { that.emit('message', topic, message, packet) }
+ that.handleMessage(packet, function (err) {
+ if (err) {
+ return done && done(err)
+ }
+ that._sendPacket({cmd: 'puback', messageId: mid, reasonCode: code}, done)
+ })
+ })
+ break
+ }
+ case 0:
+ // emit the message event
+ this.emit('message', topic, message, packet)
+ this.handleMessage(packet, done)
+ break
+ default:
+ // do nothing
+ // log or throw an error about unknown qos
+ break
+ }
+}
+
+/**
+ * Handle messages with backpressure support, one at a time.
+ * Override at will.
+ *
+ * @param Packet packet the packet
+ * @param Function callback call when finished
+ * @api public
+ */
+MqttClient.prototype.handleMessage = function (packet, callback) {
+ callback()
+}
+
+/**
+ * _handleAck
+ *
+ * @param {Object} packet
+ * @api private
+ */
+
+MqttClient.prototype._handleAck = function (packet) {
+ /* eslint no-fallthrough: "off" */
+ var mid = packet.messageId
+ var type = packet.cmd
+ var response = null
+ var cb = this.outgoing[mid] ? this.outgoing[mid].cb : null
+ var that = this
+ var err
+
+ if (!cb) {
+ // Server sent an ack in error, ignore it.
+ return
+ }
+
+ // Process
+ switch (type) {
+ case 'pubcomp':
+ // same thing as puback for QoS 2
+ case 'puback':
+ var pubackRC = packet.reasonCode
+ // Callback - we're done
+ if (pubackRC && pubackRC > 0 && pubackRC !== 16) {
+ err = new Error('Publish error: ' + errors[pubackRC])
+ err.code = pubackRC
+ cb(err, packet)
+ }
+ delete this.outgoing[mid]
+ this.outgoingStore.del(packet, cb)
+ break
+ case 'pubrec':
+ response = {
+ cmd: 'pubrel',
+ qos: 2,
+ messageId: mid
+ }
+ var pubrecRC = packet.reasonCode
+
+ if (pubrecRC && pubrecRC > 0 && pubrecRC !== 16) {
+ err = new Error('Publish error: ' + errors[pubrecRC])
+ err.code = pubrecRC
+ cb(err, packet)
+ } else {
+ this._sendPacket(response)
+ }
+ break
+ case 'suback':
+ delete this.outgoing[mid]
+ for (var grantedI = 0; grantedI < packet.granted.length; grantedI++) {
+ if ((packet.granted[grantedI] & 0x80) !== 0) {
+ // suback with Failure status
+ var topics = this.messageIdToTopic[mid]
+ if (topics) {
+ topics.forEach(function (topic) {
+ delete that._resubscribeTopics[topic]
+ })
+ }
+ }
+ }
+ cb(null, packet)
+ break
+ case 'unsuback':
+ delete this.outgoing[mid]
+ cb(null)
+ break
+ default:
+ that.emit('error', new Error('unrecognized packet type'))
+ }
+
+ if (this.disconnecting &&
+ Object.keys(this.outgoing).length === 0) {
+ this.emit('outgoingEmpty')
+ }
+}
+
+/**
+ * _handlePubrel
+ *
+ * @param {Object} packet
+ * @api private
+ */
+MqttClient.prototype._handlePubrel = function (packet, callback) {
+ callback = typeof callback !== 'undefined' ? callback : nop
+ var mid = packet.messageId
+ var that = this
+
+ var comp = {cmd: 'pubcomp', messageId: mid}
+
+ that.incomingStore.get(packet, function (err, pub) {
+ if (!err) {
+ that.emit('message', pub.topic, pub.payload, pub)
+ that.handleMessage(pub, function (err) {
+ if (err) {
+ return callback(err)
+ }
+ that.incomingStore.del(pub, nop)
+ that._sendPacket(comp, callback)
+ })
+ } else {
+ that._sendPacket(comp, callback)
+ }
+ })
+}
+
+/**
+ * _handleDisconnect
+ *
+ * @param {Object} packet
+ * @api private
+ */
+MqttClient.prototype._handleDisconnect = function (packet) {
+ this.emit('disconnect', packet)
+}
+
+/**
+ * _nextId
+ * @return unsigned int
+ */
+MqttClient.prototype._nextId = function () {
+ // id becomes current state of this.nextId and increments afterwards
+ var id = this.nextId++
+ // Ensure 16 bit unsigned int (max 65535, nextId got one higher)
+ if (this.nextId === 65536) {
+ this.nextId = 1
+ }
+ return id
+}
+
+/**
+ * getLastMessageId
+ * @return unsigned int
+ */
+MqttClient.prototype.getLastMessageId = function () {
+ return (this.nextId === 1) ? 65535 : (this.nextId - 1)
+}
+
+/**
+ * _resubscribe
+ * @api private
+ */
+MqttClient.prototype._resubscribe = function (connack) {
+ var _resubscribeTopicsKeys = Object.keys(this._resubscribeTopics)
+ if (!this._firstConnection &&
+ (this.options.clean || (this.options.protocolVersion === 5 && !connack.sessionPresent)) &&
+ _resubscribeTopicsKeys.length > 0) {
+ if (this.options.resubscribe) {
+ if (this.options.protocolVersion === 5) {
+ for (var topicI = 0; topicI < _resubscribeTopicsKeys.length; topicI++) {
+ var resubscribeTopic = {}
+ resubscribeTopic[_resubscribeTopicsKeys[topicI]] = this._resubscribeTopics[_resubscribeTopicsKeys[topicI]]
+ resubscribeTopic.resubscribe = true
+ this.subscribe(resubscribeTopic, {properties: resubscribeTopic[_resubscribeTopicsKeys[topicI]].properties})
+ }
+ } else {
+ this._resubscribeTopics.resubscribe = true
+ this.subscribe(this._resubscribeTopics)
+ }
+ } else {
+ this._resubscribeTopics = {}
+ }
+ }
+
+ this._firstConnection = false
+}
+
+/**
+ * _onConnect
+ *
+ * @api private
+ */
+MqttClient.prototype._onConnect = function (packet) {
+ if (this.disconnected) {
+ this.emit('connect', packet)
+ return
+ }
+
+ var that = this
+
+ this._setupPingTimer()
+ this._resubscribe(packet)
+
+ this.connected = true
+
+ function startStreamProcess () {
+ var outStore = that.outgoingStore.createStream()
+
+ function clearStoreProcessing () {
+ that._storeProcessing = false
+ that._packetIdsDuringStoreProcessing = {}
+ }
+
+ that.once('close', remove)
+ outStore.on('error', function (err) {
+ clearStoreProcessing()
+ that.removeListener('close', remove)
+ that.emit('error', err)
+ })
+
+ function remove () {
+ outStore.destroy()
+ outStore = null
+ clearStoreProcessing()
+ }
+
+ function storeDeliver () {
+ // edge case, we wrapped this twice
+ if (!outStore) {
+ return
+ }
+ that._storeProcessing = true
+
+ var packet = outStore.read(1)
+
+ var cb
+
+ if (!packet) {
+ // read when data is available in the future
+ outStore.once('readable', storeDeliver)
+ return
+ }
+
+ // Skip already processed store packets
+ if (that._packetIdsDuringStoreProcessing[packet.messageId]) {
+ storeDeliver()
+ return
+ }
+
+ // Avoid unnecessary stream read operations when disconnected
+ if (!that.disconnecting && !that.reconnectTimer) {
+ cb = that.outgoing[packet.messageId] ? that.outgoing[packet.messageId].cb : null
+ that.outgoing[packet.messageId] = {
+ volatile: false,
+ cb: function (err, status) {
+ // Ensure that the original callback passed in to publish gets invoked
+ if (cb) {
+ cb(err, status)
+ }
+
+ storeDeliver()
+ }
+ }
+ that._packetIdsDuringStoreProcessing[packet.messageId] = true
+ that._sendPacket(packet)
+ } else if (outStore.destroy) {
+ outStore.destroy()
+ }
+ }
+
+ outStore.on('end', function () {
+ var allProcessed = true
+ for (var id in that._packetIdsDuringStoreProcessing) {
+ if (!that._packetIdsDuringStoreProcessing[id]) {
+ allProcessed = false
+ break
+ }
+ }
+ if (allProcessed) {
+ clearStoreProcessing()
+ that.removeListener('close', remove)
+ that.emit('connect', packet)
+ } else {
+ startStreamProcess()
+ }
+ })
+ storeDeliver()
+ }
+ // start flowing
+ startStreamProcess()
+}
+
+module.exports = MqttClient
+
+}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"./store":7,"./validations":8,"_process":92,"events":13,"inherits":80,"mqtt-packet":84,"readable-stream":108,"reinterval":109,"xtend":121}],2:[function(require,module,exports){
+(function (Buffer){
+'use strict'
+
+var Transform = require('readable-stream').Transform
+var duplexify = require('duplexify')
+var base64 = require('base64-js')
+
+/* global FileReader */
+var my
+var proxy
+var stream
+var isInitialized = false
+
+function buildProxy () {
+ var proxy = new Transform()
+ proxy._write = function (chunk, encoding, next) {
+ my.sendSocketMessage({
+ data: chunk.buffer,
+ success: function () {
+ next()
+ },
+ fail: function () {
+ next(new Error())
+ }
+ })
+ }
+ proxy._flush = function socketEnd (done) {
+ my.closeSocket({
+ success: function () {
+ done()
+ }
+ })
+ }
+
+ return proxy
+}
+
+function setDefaultOpts (opts) {
+ if (!opts.hostname) {
+ opts.hostname = 'localhost'
+ }
+ if (!opts.path) {
+ opts.path = '/'
+ }
+
+ if (!opts.wsOptions) {
+ opts.wsOptions = {}
+ }
+}
+
+function buildUrl (opts, client) {
+ var protocol = opts.protocol === 'alis' ? 'wss' : 'ws'
+ var url = protocol + '://' + opts.hostname + opts.path
+ if (opts.port && opts.port !== 80 && opts.port !== 443) {
+ url = protocol + '://' + opts.hostname + ':' + opts.port + opts.path
+ }
+ if (typeof (opts.transformWsUrl) === 'function') {
+ url = opts.transformWsUrl(url, opts, client)
+ }
+ return url
+}
+
+function bindEventHandler () {
+ if (isInitialized) return
+
+ isInitialized = true
+
+ my.onSocketOpen(function () {
+ stream.setReadable(proxy)
+ stream.setWritable(proxy)
+ stream.emit('connect')
+ })
+
+ my.onSocketMessage(function (res) {
+ if (typeof res.data === 'string') {
+ var array = base64.toByteArray(res.data)
+ var buffer = Buffer.from(array)
+ proxy.push(buffer)
+ } else {
+ var reader = new FileReader()
+ reader.addEventListener('load', function () {
+ var data = reader.result
+
+ if (data instanceof ArrayBuffer) data = Buffer.from(data)
+ else data = Buffer.from(data, 'utf8')
+ proxy.push(data)
+ })
+ reader.readAsArrayBuffer(res.data)
+ }
+ })
+
+ my.onSocketClose(function () {
+ stream.end()
+ stream.destroy()
+ })
+
+ my.onSocketError(function (res) {
+ stream.destroy(res)
+ })
+}
+
+function buildStream (client, opts) {
+ opts.hostname = opts.hostname || opts.host
+
+ if (!opts.hostname) {
+ throw new Error('Could not determine host. Specify host manually.')
+ }
+
+ var websocketSubProtocol =
+ (opts.protocolId === 'MQIsdp') && (opts.protocolVersion === 3)
+ ? 'mqttv3.1'
+ : 'mqtt'
+
+ setDefaultOpts(opts)
+
+ var url = buildUrl(opts, client)
+ my = opts.my
+ my.connectSocket({
+ url: url,
+ protocols: websocketSubProtocol
+ })
+
+ proxy = buildProxy()
+ stream = duplexify.obj()
+
+ bindEventHandler()
+
+ return stream
+}
+
+module.exports = buildStream
+
+}).call(this,require("buffer").Buffer)
+},{"base64-js":10,"buffer":12,"duplexify":17,"readable-stream":108}],3:[function(require,module,exports){
+'use strict'
+var net = require('net')
+
+/*
+ variables port and host can be removed since
+ you have all required information in opts object
+*/
+function buildBuilder (client, opts) {
+ var port, host
+ opts.port = opts.port || 1883
+ opts.hostname = opts.hostname || opts.host || 'localhost'
+
+ port = opts.port
+ host = opts.hostname
+
+ return net.createConnection(port, host)
+}
+
+module.exports = buildBuilder
+
+},{"net":11}],4:[function(require,module,exports){
+'use strict'
+var tls = require('tls')
+
+function buildBuilder (mqttClient, opts) {
+ var connection
+ opts.port = opts.port || 8883
+ opts.host = opts.hostname || opts.host || 'localhost'
+
+ opts.rejectUnauthorized = opts.rejectUnauthorized !== false
+
+ delete opts.path
+
+ connection = tls.connect(opts)
+ /* eslint no-use-before-define: [2, "nofunc"] */
+ connection.on('secureConnect', function () {
+ if (opts.rejectUnauthorized && !connection.authorized) {
+ connection.emit('error', new Error('TLS not authorized'))
+ } else {
+ connection.removeListener('error', handleTLSerrors)
+ }
+ })
+
+ function handleTLSerrors (err) {
+ // How can I get verify this error is a tls error?
+ if (opts.rejectUnauthorized) {
+ mqttClient.emit('error', err)
+ }
+
+ // close this connection to match the behaviour of net
+ // otherwise all we get is an error from the connection
+ // and close event doesn't fire. This is a work around
+ // to enable the reconnect code to work the same as with
+ // net.createConnection
+ connection.end()
+ }
+
+ connection.on('error', handleTLSerrors)
+ return connection
+}
+
+module.exports = buildBuilder
+
+},{"tls":11}],5:[function(require,module,exports){
+(function (process){
+'use strict'
+
+var websocket = require('websocket-stream')
+var urlModule = require('url')
+var WSS_OPTIONS = [
+ 'rejectUnauthorized',
+ 'ca',
+ 'cert',
+ 'key',
+ 'pfx',
+ 'passphrase'
+]
+var IS_BROWSER = process.title === 'browser'
+
+function buildUrl (opts, client) {
+ var url = opts.protocol + '://' + opts.hostname + ':' + opts.port + opts.path
+ if (typeof (opts.transformWsUrl) === 'function') {
+ url = opts.transformWsUrl(url, opts, client)
+ }
+ return url
+}
+
+function setDefaultOpts (opts) {
+ if (!opts.hostname) {
+ opts.hostname = 'localhost'
+ }
+ if (!opts.port) {
+ if (opts.protocol === 'wss') {
+ opts.port = 443
+ } else {
+ opts.port = 80
+ }
+ }
+ if (!opts.path) {
+ opts.path = '/'
+ }
+
+ if (!opts.wsOptions) {
+ opts.wsOptions = {}
+ }
+ if (!IS_BROWSER && opts.protocol === 'wss') {
+ // Add cert/key/ca etc options
+ WSS_OPTIONS.forEach(function (prop) {
+ if (opts.hasOwnProperty(prop) && !opts.wsOptions.hasOwnProperty(prop)) {
+ opts.wsOptions[prop] = opts[prop]
+ }
+ })
+ }
+}
+
+function createWebSocket (client, opts) {
+ var websocketSubProtocol =
+ (opts.protocolId === 'MQIsdp') && (opts.protocolVersion === 3)
+ ? 'mqttv3.1'
+ : 'mqtt'
+
+ setDefaultOpts(opts)
+ var url = buildUrl(opts, client)
+ return websocket(url, [websocketSubProtocol], opts.wsOptions)
+}
+
+function buildBuilder (client, opts) {
+ return createWebSocket(client, opts)
+}
+
+function buildBuilderBrowser (client, opts) {
+ if (!opts.hostname) {
+ opts.hostname = opts.host
+ }
+
+ if (!opts.hostname) {
+ // Throwing an error in a Web Worker if no `hostname` is given, because we
+ // can not determine the `hostname` automatically. If connecting to
+ // localhost, please supply the `hostname` as an argument.
+ if (typeof (document) === 'undefined') {
+ throw new Error('Could not determine host. Specify host manually.')
+ }
+ var parsed = urlModule.parse(document.URL)
+ opts.hostname = parsed.hostname
+
+ if (!opts.port) {
+ opts.port = parsed.port
+ }
+ }
+ return createWebSocket(client, opts)
+}
+
+if (IS_BROWSER) {
+ module.exports = buildBuilderBrowser
+} else {
+ module.exports = buildBuilder
+}
+
+}).call(this,require('_process'))
+},{"_process":92,"url":113,"websocket-stream":118}],6:[function(require,module,exports){
+(function (process,Buffer){
+'use strict'
+
+var Transform = require('readable-stream').Transform
+var duplexify = require('duplexify')
+
+/* global wx */
+var socketTask
+var proxy
+var stream
+
+function buildProxy () {
+ var proxy = new Transform()
+ proxy._write = function (chunk, encoding, next) {
+ socketTask.send({
+ data: chunk.buffer,
+ success: function () {
+ next()
+ },
+ fail: function (errMsg) {
+ next(new Error(errMsg))
+ }
+ })
+ }
+ proxy._flush = function socketEnd (done) {
+ socketTask.close({
+ success: function () {
+ done()
+ }
+ })
+ }
+
+ return proxy
+}
+
+function setDefaultOpts (opts) {
+ if (!opts.hostname) {
+ opts.hostname = 'localhost'
+ }
+ if (!opts.path) {
+ opts.path = '/'
+ }
+
+ if (!opts.wsOptions) {
+ opts.wsOptions = {}
+ }
+}
+
+function buildUrl (opts, client) {
+ var protocol = opts.protocol === 'wxs' ? 'wss' : 'ws'
+ var url = protocol + '://' + opts.hostname + opts.path
+ if (opts.port && opts.port !== 80 && opts.port !== 443) {
+ url = protocol + '://' + opts.hostname + ':' + opts.port + opts.path
+ }
+ if (typeof (opts.transformWsUrl) === 'function') {
+ url = opts.transformWsUrl(url, opts, client)
+ }
+ return url
+}
+
+function bindEventHandler () {
+ socketTask.onOpen(function () {
+ stream.setReadable(proxy)
+ stream.setWritable(proxy)
+ stream.emit('connect')
+ })
+
+ socketTask.onMessage(function (res) {
+ var data = res.data
+
+ if (data instanceof ArrayBuffer) data = Buffer.from(data)
+ else data = Buffer.from(data, 'utf8')
+ proxy.push(data)
+ })
+
+ socketTask.onClose(function () {
+ stream.end()
+ stream.destroy()
+ })
+
+ socketTask.onError(function (res) {
+ stream.destroy(new Error(res.errMsg))
+ })
+}
+
+function buildStream (client, opts) {
+ opts.hostname = opts.hostname || opts.host
+
+ if (!opts.hostname) {
+ throw new Error('Could not determine host. Specify host manually.')
+ }
+
+ var websocketSubProtocol =
+ (opts.protocolId === 'MQIsdp') && (opts.protocolVersion === 3)
+ ? 'mqttv3.1'
+ : 'mqtt'
+
+ setDefaultOpts(opts)
+
+ var url = buildUrl(opts, client)
+ socketTask = wx.connectSocket({
+ url: url,
+ protocols: websocketSubProtocol
+ })
+
+ proxy = buildProxy()
+ stream = duplexify.obj()
+ stream._destroy = function (err, cb) {
+ socketTask.close({
+ success: function () {
+ cb && cb(err)
+ }
+ })
+ }
+
+ var destroyRef = stream.destroy
+ stream.destroy = function () {
+ stream.destroy = destroyRef
+
+ var self = this
+ process.nextTick(function () {
+ socketTask.close({
+ fail: function () {
+ self._destroy(new Error())
+ }
+ })
+ })
+ }.bind(stream)
+
+ bindEventHandler()
+
+ return stream
+}
+
+module.exports = buildStream
+
+}).call(this,require('_process'),require("buffer").Buffer)
+},{"_process":92,"buffer":12,"duplexify":17,"readable-stream":108}],7:[function(require,module,exports){
+(function (process){
+'use strict'
+
+/**
+ * Module dependencies
+ */
+var xtend = require('xtend')
+
+var Readable = require('readable-stream').Readable
+var streamsOpts = { objectMode: true }
+var defaultStoreOptions = {
+ clean: true
+}
+
+/**
+ * es6-map can preserve insertion order even if ES version is older.
+ *
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map#Description
+ * It should be noted that a Map which is a map of an object, especially
+ * a dictionary of dictionaries, will only map to the object's insertion
+ * order. In ES2015 this is ordered for objects but for older versions of
+ * ES, this may be random and not ordered.
+ *
+ */
+var Map = require('es6-map')
+
+/**
+ * In-memory implementation of the message store
+ * This can actually be saved into files.
+ *
+ * @param {Object} [options] - store options
+ */
+function Store (options) {
+ if (!(this instanceof Store)) {
+ return new Store(options)
+ }
+
+ this.options = options || {}
+
+ // Defaults
+ this.options = xtend(defaultStoreOptions, options)
+
+ this._inflights = new Map()
+}
+
+/**
+ * Adds a packet to the store, a packet is
+ * anything that has a messageId property.
+ *
+ */
+Store.prototype.put = function (packet, cb) {
+ this._inflights.set(packet.messageId, packet)
+
+ if (cb) {
+ cb()
+ }
+
+ return this
+}
+
+/**
+ * Creates a stream with all the packets in the store
+ *
+ */
+Store.prototype.createStream = function () {
+ var stream = new Readable(streamsOpts)
+ var destroyed = false
+ var values = []
+ var i = 0
+
+ this._inflights.forEach(function (value, key) {
+ values.push(value)
+ })
+
+ stream._read = function () {
+ if (!destroyed && i < values.length) {
+ this.push(values[i++])
+ } else {
+ this.push(null)
+ }
+ }
+
+ stream.destroy = function () {
+ if (destroyed) {
+ return
+ }
+
+ var self = this
+
+ destroyed = true
+
+ process.nextTick(function () {
+ self.emit('close')
+ })
+ }
+
+ return stream
+}
+
+/**
+ * deletes a packet from the store.
+ */
+Store.prototype.del = function (packet, cb) {
+ packet = this._inflights.get(packet.messageId)
+ if (packet) {
+ this._inflights.delete(packet.messageId)
+ cb(null, packet)
+ } else if (cb) {
+ cb(new Error('missing packet'))
+ }
+
+ return this
+}
+
+/**
+ * get a packet from the store.
+ */
+Store.prototype.get = function (packet, cb) {
+ packet = this._inflights.get(packet.messageId)
+ if (packet) {
+ cb(null, packet)
+ } else if (cb) {
+ cb(new Error('missing packet'))
+ }
+
+ return this
+}
+
+/**
+ * Close the store
+ */
+Store.prototype.close = function (cb) {
+ if (this.options.clean) {
+ this._inflights = null
+ }
+ if (cb) {
+ cb()
+ }
+}
+
+module.exports = Store
+
+}).call(this,require('_process'))
+},{"_process":92,"es6-map":67,"readable-stream":108,"xtend":121}],8:[function(require,module,exports){
+'use strict'
+
+/**
+ * Validate a topic to see if it's valid or not.
+ * A topic is valid if it follow below rules:
+ * - Rule #1: If any part of the topic is not `+` or `#`, then it must not contain `+` and '#'
+ * - Rule #2: Part `#` must be located at the end of the mailbox
+ *
+ * @param {String} topic - A topic
+ * @returns {Boolean} If the topic is valid, returns true. Otherwise, returns false.
+ */
+function validateTopic (topic) {
+ var parts = topic.split('/')
+
+ for (var i = 0; i < parts.length; i++) {
+ if (parts[i] === '+') {
+ continue
+ }
+
+ if (parts[i] === '#') {
+ // for Rule #2
+ return i === parts.length - 1
+ }
+
+ if (parts[i].indexOf('+') !== -1 || parts[i].indexOf('#') !== -1) {
+ return false
+ }
+ }
+
+ return true
+}
+
+/**
+ * Validate an array of topics to see if any of them is valid or not
+ * @param {Array} topics - Array of topics
+ * @returns {String} If the topics is valid, returns null. Otherwise, returns the invalid one
+ */
+function validateTopics (topics) {
+ if (topics.length === 0) {
+ return 'empty_topic_list'
+ }
+ for (var i = 0; i < topics.length; i++) {
+ if (!validateTopic(topics[i])) {
+ return topics[i]
+ }
+ }
+ return null
+}
+
+module.exports = {
+ validateTopics: validateTopics
+}
+
+},{}],9:[function(require,module,exports){
+(function (process){
+'use strict'
+
+var MqttClient = require('../client')
+var Store = require('../store')
+var url = require('url')
+var xtend = require('xtend')
+var protocols = {}
+
+if (process.title !== 'browser') {
+ protocols.mqtt = require('./tcp')
+ protocols.tcp = require('./tcp')
+ protocols.ssl = require('./tls')
+ protocols.tls = require('./tls')
+ protocols.mqtts = require('./tls')
+} else {
+ protocols.wx = require('./wx')
+ protocols.wxs = require('./wx')
+
+ protocols.ali = require('./ali')
+ protocols.alis = require('./ali')
+}
+
+protocols.ws = require('./ws')
+protocols.wss = require('./ws')
+
+/**
+ * Parse the auth attribute and merge username and password in the options object.
+ *
+ * @param {Object} [opts] option object
+ */
+function parseAuthOptions (opts) {
+ var matches
+ if (opts.auth) {
+ matches = opts.auth.match(/^(.+):(.+)$/)
+ if (matches) {
+ opts.username = matches[1]
+ opts.password = matches[2]
+ } else {
+ opts.username = opts.auth
+ }
+ }
+}
+
+/**
+ * connect - connect to an MQTT broker.
+ *
+ * @param {String} [brokerUrl] - url of the broker, optional
+ * @param {Object} opts - see MqttClient#constructor
+ */
+function connect (brokerUrl, opts) {
+ if ((typeof brokerUrl === 'object') && !opts) {
+ opts = brokerUrl
+ brokerUrl = null
+ }
+
+ opts = opts || {}
+
+ if (brokerUrl) {
+ var parsed = url.parse(brokerUrl, true)
+ if (parsed.port != null) {
+ parsed.port = Number(parsed.port)
+ }
+
+ opts = xtend(parsed, opts)
+
+ if (opts.protocol === null) {
+ throw new Error('Missing protocol')
+ }
+ opts.protocol = opts.protocol.replace(/:$/, '')
+ }
+
+ // merge in the auth options if supplied
+ parseAuthOptions(opts)
+
+ // support clientId passed in the query string of the url
+ if (opts.query && typeof opts.query.clientId === 'string') {
+ opts.clientId = opts.query.clientId
+ }
+
+ if (opts.cert && opts.key) {
+ if (opts.protocol) {
+ if (['mqtts', 'wss', 'wxs', 'alis'].indexOf(opts.protocol) === -1) {
+ switch (opts.protocol) {
+ case 'mqtt':
+ opts.protocol = 'mqtts'
+ break
+ case 'ws':
+ opts.protocol = 'wss'
+ break
+ case 'wx':
+ opts.protocol = 'wxs'
+ break
+ case 'ali':
+ opts.protocol = 'alis'
+ break
+ default:
+ throw new Error('Unknown protocol for secure connection: "' + opts.protocol + '"!')
+ }
+ }
+ } else {
+ // don't know what protocol he want to use, mqtts or wss
+ throw new Error('Missing secure protocol key')
+ }
+ }
+
+ if (!protocols[opts.protocol]) {
+ var isSecure = ['mqtts', 'wss'].indexOf(opts.protocol) !== -1
+ opts.protocol = [
+ 'mqtt',
+ 'mqtts',
+ 'ws',
+ 'wss',
+ 'wx',
+ 'wxs',
+ 'ali',
+ 'alis'
+ ].filter(function (key, index) {
+ if (isSecure && index % 2 === 0) {
+ // Skip insecure protocols when requesting a secure one.
+ return false
+ }
+ return (typeof protocols[key] === 'function')
+ })[0]
+ }
+
+ if (opts.clean === false && !opts.clientId) {
+ throw new Error('Missing clientId for unclean clients')
+ }
+
+ if (opts.protocol) {
+ opts.defaultProtocol = opts.protocol
+ }
+
+ function wrapper (client) {
+ if (opts.servers) {
+ if (!client._reconnectCount || client._reconnectCount === opts.servers.length) {
+ client._reconnectCount = 0
+ }
+
+ opts.host = opts.servers[client._reconnectCount].host
+ opts.port = opts.servers[client._reconnectCount].port
+ opts.protocol = (!opts.servers[client._reconnectCount].protocol ? opts.defaultProtocol : opts.servers[client._reconnectCount].protocol)
+ opts.hostname = opts.host
+
+ client._reconnectCount++
+ }
+
+ return protocols[opts.protocol](client, opts)
+ }
+
+ return new MqttClient(wrapper, opts)
+}
+
+module.exports = connect
+module.exports.connect = connect
+module.exports.MqttClient = MqttClient
+module.exports.Store = Store
+
+}).call(this,require('_process'))
+},{"../client":1,"../store":7,"./ali":2,"./tcp":3,"./tls":4,"./ws":5,"./wx":6,"_process":92,"url":113,"xtend":121}],10:[function(require,module,exports){
+'use strict'
+
+exports.byteLength = byteLength
+exports.toByteArray = toByteArray
+exports.fromByteArray = fromByteArray
+
+var lookup = []
+var revLookup = []
+var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array
+
+var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
+for (var i = 0, len = code.length; i < len; ++i) {
+ lookup[i] = code[i]
+ revLookup[code.charCodeAt(i)] = i
+}
+
+// Support decoding URL-safe base64 strings, as Node.js does.
+// See: https://en.wikipedia.org/wiki/Base64#URL_applications
+revLookup['-'.charCodeAt(0)] = 62
+revLookup['_'.charCodeAt(0)] = 63
+
+function getLens (b64) {
+ var len = b64.length
+
+ if (len % 4 > 0) {
+ throw new Error('Invalid string. Length must be a multiple of 4')
+ }
+
+ // Trim off extra bytes after placeholder bytes are found
+ // See: https://github.com/beatgammit/base64-js/issues/42
+ var validLen = b64.indexOf('=')
+ if (validLen === -1) validLen = len
+
+ var placeHoldersLen = validLen === len
+ ? 0
+ : 4 - (validLen % 4)
+
+ return [validLen, placeHoldersLen]
+}
+
+// base64 is 4/3 + up to two characters of the original data
+function byteLength (b64) {
+ var lens = getLens(b64)
+ var validLen = lens[0]
+ var placeHoldersLen = lens[1]
+ return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
+}
+
+function _byteLength (b64, validLen, placeHoldersLen) {
+ return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
+}
+
+function toByteArray (b64) {
+ var tmp
+ var lens = getLens(b64)
+ var validLen = lens[0]
+ var placeHoldersLen = lens[1]
+
+ var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))
+
+ var curByte = 0
+
+ // if there are placeholders, only get up to the last complete 4 chars
+ var len = placeHoldersLen > 0
+ ? validLen - 4
+ : validLen
+
+ for (var i = 0; i < len; i += 4) {
+ tmp =
+ (revLookup[b64.charCodeAt(i)] << 18) |
+ (revLookup[b64.charCodeAt(i + 1)] << 12) |
+ (revLookup[b64.charCodeAt(i + 2)] << 6) |
+ revLookup[b64.charCodeAt(i + 3)]
+ arr[curByte++] = (tmp >> 16) & 0xFF
+ arr[curByte++] = (tmp >> 8) & 0xFF
+ arr[curByte++] = tmp & 0xFF
+ }
+
+ if (placeHoldersLen === 2) {
+ tmp =
+ (revLookup[b64.charCodeAt(i)] << 2) |
+ (revLookup[b64.charCodeAt(i + 1)] >> 4)
+ arr[curByte++] = tmp & 0xFF
+ }
+
+ if (placeHoldersLen === 1) {
+ tmp =
+ (revLookup[b64.charCodeAt(i)] << 10) |
+ (revLookup[b64.charCodeAt(i + 1)] << 4) |
+ (revLookup[b64.charCodeAt(i + 2)] >> 2)
+ arr[curByte++] = (tmp >> 8) & 0xFF
+ arr[curByte++] = tmp & 0xFF
+ }
+
+ return arr
+}
+
+function tripletToBase64 (num) {
+ return lookup[num >> 18 & 0x3F] +
+ lookup[num >> 12 & 0x3F] +
+ lookup[num >> 6 & 0x3F] +
+ lookup[num & 0x3F]
+}
+
+function encodeChunk (uint8, start, end) {
+ var tmp
+ var output = []
+ for (var i = start; i < end; i += 3) {
+ tmp =
+ ((uint8[i] << 16) & 0xFF0000) +
+ ((uint8[i + 1] << 8) & 0xFF00) +
+ (uint8[i + 2] & 0xFF)
+ output.push(tripletToBase64(tmp))
+ }
+ return output.join('')
+}
+
+function fromByteArray (uint8) {
+ var tmp
+ var len = uint8.length
+ var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes
+ var parts = []
+ var maxChunkLength = 16383 // must be multiple of 3
+
+ // go through the array every three bytes, we'll deal with trailing stuff later
+ for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
+ parts.push(encodeChunk(
+ uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)
+ ))
+ }
+
+ // pad the end with zeros, but make sure to not forget the extra bytes
+ if (extraBytes === 1) {
+ tmp = uint8[len - 1]
+ parts.push(
+ lookup[tmp >> 2] +
+ lookup[(tmp << 4) & 0x3F] +
+ '=='
+ )
+ } else if (extraBytes === 2) {
+ tmp = (uint8[len - 2] << 8) + uint8[len - 1]
+ parts.push(
+ lookup[tmp >> 10] +
+ lookup[(tmp >> 4) & 0x3F] +
+ lookup[(tmp << 2) & 0x3F] +
+ '='
+ )
+ }
+
+ return parts.join('')
+}
+
+},{}],11:[function(require,module,exports){
+
+},{}],12:[function(require,module,exports){
+/*!
+ * The buffer module from node.js, for the browser.
+ *
+ * @author Feross Aboukhadijeh
+ * @license MIT
+ */
+/* eslint-disable no-proto */
+
+'use strict'
+
+var base64 = require('base64-js')
+var ieee754 = require('ieee754')
+
+exports.Buffer = Buffer
+exports.SlowBuffer = SlowBuffer
+exports.INSPECT_MAX_BYTES = 50
+
+var K_MAX_LENGTH = 0x7fffffff
+exports.kMaxLength = K_MAX_LENGTH
+
+/**
+ * If `Buffer.TYPED_ARRAY_SUPPORT`:
+ * === true Use Uint8Array implementation (fastest)
+ * === false Print warning and recommend using `buffer` v4.x which has an Object
+ * implementation (most compatible, even IE6)
+ *
+ * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
+ * Opera 11.6+, iOS 4.2+.
+ *
+ * We report that the browser does not support typed arrays if the are not subclassable
+ * using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array`
+ * (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support
+ * for __proto__ and has a buggy typed array implementation.
+ */
+Buffer.TYPED_ARRAY_SUPPORT = typedArraySupport()
+
+if (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== 'undefined' &&
+ typeof console.error === 'function') {
+ console.error(
+ 'This browser lacks typed array (Uint8Array) support which is required by ' +
+ '`buffer` v5.x. Use `buffer` v4.x if you require old browser support.'
+ )
+}
+
+function typedArraySupport () {
+ // Can typed array instances can be augmented?
+ try {
+ var arr = new Uint8Array(1)
+ arr.__proto__ = { __proto__: Uint8Array.prototype, foo: function () { return 42 } }
+ return arr.foo() === 42
+ } catch (e) {
+ return false
+ }
+}
+
+Object.defineProperty(Buffer.prototype, 'parent', {
+ enumerable: true,
+ get: function () {
+ if (!Buffer.isBuffer(this)) return undefined
+ return this.buffer
+ }
+})
+
+Object.defineProperty(Buffer.prototype, 'offset', {
+ enumerable: true,
+ get: function () {
+ if (!Buffer.isBuffer(this)) return undefined
+ return this.byteOffset
+ }
+})
+
+function createBuffer (length) {
+ if (length > K_MAX_LENGTH) {
+ throw new RangeError('The value "' + length + '" is invalid for option "size"')
+ }
+ // Return an augmented `Uint8Array` instance
+ var buf = new Uint8Array(length)
+ buf.__proto__ = Buffer.prototype
+ return buf
+}
+
+/**
+ * The Buffer constructor returns instances of `Uint8Array` that have their
+ * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
+ * `Uint8Array`, so the returned instances will have all the node `Buffer` methods
+ * and the `Uint8Array` methods. Square bracket notation works as expected -- it
+ * returns a single octet.
+ *
+ * The `Uint8Array` prototype remains unmodified.
+ */
+
+function Buffer (arg, encodingOrOffset, length) {
+ // Common case.
+ if (typeof arg === 'number') {
+ if (typeof encodingOrOffset === 'string') {
+ throw new TypeError(
+ 'The "string" argument must be of type string. Received type number'
+ )
+ }
+ return allocUnsafe(arg)
+ }
+ return from(arg, encodingOrOffset, length)
+}
+
+// Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97
+if (typeof Symbol !== 'undefined' && Symbol.species != null &&
+ Buffer[Symbol.species] === Buffer) {
+ Object.defineProperty(Buffer, Symbol.species, {
+ value: null,
+ configurable: true,
+ enumerable: false,
+ writable: false
+ })
+}
+
+Buffer.poolSize = 8192 // not used by this implementation
+
+function from (value, encodingOrOffset, length) {
+ if (typeof value === 'string') {
+ return fromString(value, encodingOrOffset)
+ }
+
+ if (ArrayBuffer.isView(value)) {
+ return fromArrayLike(value)
+ }
+
+ if (value == null) {
+ throw TypeError(
+ 'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +
+ 'or Array-like Object. Received type ' + (typeof value)
+ )
+ }
+
+ if (isInstance(value, ArrayBuffer) ||
+ (value && isInstance(value.buffer, ArrayBuffer))) {
+ return fromArrayBuffer(value, encodingOrOffset, length)
+ }
+
+ if (typeof value === 'number') {
+ throw new TypeError(
+ 'The "value" argument must not be of type number. Received type number'
+ )
+ }
+
+ var valueOf = value.valueOf && value.valueOf()
+ if (valueOf != null && valueOf !== value) {
+ return Buffer.from(valueOf, encodingOrOffset, length)
+ }
+
+ var b = fromObject(value)
+ if (b) return b
+
+ if (typeof Symbol !== 'undefined' && Symbol.toPrimitive != null &&
+ typeof value[Symbol.toPrimitive] === 'function') {
+ return Buffer.from(
+ value[Symbol.toPrimitive]('string'), encodingOrOffset, length
+ )
+ }
+
+ throw new TypeError(
+ 'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +
+ 'or Array-like Object. Received type ' + (typeof value)
+ )
+}
+
+/**
+ * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
+ * if value is a number.
+ * Buffer.from(str[, encoding])
+ * Buffer.from(array)
+ * Buffer.from(buffer)
+ * Buffer.from(arrayBuffer[, byteOffset[, length]])
+ **/
+Buffer.from = function (value, encodingOrOffset, length) {
+ return from(value, encodingOrOffset, length)
+}
+
+// Note: Change prototype *after* Buffer.from is defined to workaround Chrome bug:
+// https://github.com/feross/buffer/pull/148
+Buffer.prototype.__proto__ = Uint8Array.prototype
+Buffer.__proto__ = Uint8Array
+
+function assertSize (size) {
+ if (typeof size !== 'number') {
+ throw new TypeError('"size" argument must be of type number')
+ } else if (size < 0) {
+ throw new RangeError('The value "' + size + '" is invalid for option "size"')
+ }
+}
+
+function alloc (size, fill, encoding) {
+ assertSize(size)
+ if (size <= 0) {
+ return createBuffer(size)
+ }
+ if (fill !== undefined) {
+ // Only pay attention to encoding if it's a string. This
+ // prevents accidentally sending in a number that would
+ // be interpretted as a start offset.
+ return typeof encoding === 'string'
+ ? createBuffer(size).fill(fill, encoding)
+ : createBuffer(size).fill(fill)
+ }
+ return createBuffer(size)
+}
+
+/**
+ * Creates a new filled Buffer instance.
+ * alloc(size[, fill[, encoding]])
+ **/
+Buffer.alloc = function (size, fill, encoding) {
+ return alloc(size, fill, encoding)
+}
+
+function allocUnsafe (size) {
+ assertSize(size)
+ return createBuffer(size < 0 ? 0 : checked(size) | 0)
+}
+
+/**
+ * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
+ * */
+Buffer.allocUnsafe = function (size) {
+ return allocUnsafe(size)
+}
+/**
+ * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
+ */
+Buffer.allocUnsafeSlow = function (size) {
+ return allocUnsafe(size)
+}
+
+function fromString (string, encoding) {
+ if (typeof encoding !== 'string' || encoding === '') {
+ encoding = 'utf8'
+ }
+
+ if (!Buffer.isEncoding(encoding)) {
+ throw new TypeError('Unknown encoding: ' + encoding)
+ }
+
+ var length = byteLength(string, encoding) | 0
+ var buf = createBuffer(length)
+
+ var actual = buf.write(string, encoding)
+
+ if (actual !== length) {
+ // Writing a hex string, for example, that contains invalid characters will
+ // cause everything after the first invalid character to be ignored. (e.g.
+ // 'abxxcd' will be treated as 'ab')
+ buf = buf.slice(0, actual)
+ }
+
+ return buf
+}
+
+function fromArrayLike (array) {
+ var length = array.length < 0 ? 0 : checked(array.length) | 0
+ var buf = createBuffer(length)
+ for (var i = 0; i < length; i += 1) {
+ buf[i] = array[i] & 255
+ }
+ return buf
+}
+
+function fromArrayBuffer (array, byteOffset, length) {
+ if (byteOffset < 0 || array.byteLength < byteOffset) {
+ throw new RangeError('"offset" is outside of buffer bounds')
+ }
+
+ if (array.byteLength < byteOffset + (length || 0)) {
+ throw new RangeError('"length" is outside of buffer bounds')
+ }
+
+ var buf
+ if (byteOffset === undefined && length === undefined) {
+ buf = new Uint8Array(array)
+ } else if (length === undefined) {
+ buf = new Uint8Array(array, byteOffset)
+ } else {
+ buf = new Uint8Array(array, byteOffset, length)
+ }
+
+ // Return an augmented `Uint8Array` instance
+ buf.__proto__ = Buffer.prototype
+ return buf
+}
+
+function fromObject (obj) {
+ if (Buffer.isBuffer(obj)) {
+ var len = checked(obj.length) | 0
+ var buf = createBuffer(len)
+
+ if (buf.length === 0) {
+ return buf
+ }
+
+ obj.copy(buf, 0, 0, len)
+ return buf
+ }
+
+ if (obj.length !== undefined) {
+ if (typeof obj.length !== 'number' || numberIsNaN(obj.length)) {
+ return createBuffer(0)
+ }
+ return fromArrayLike(obj)
+ }
+
+ if (obj.type === 'Buffer' && Array.isArray(obj.data)) {
+ return fromArrayLike(obj.data)
+ }
+}
+
+function checked (length) {
+ // Note: cannot use `length < K_MAX_LENGTH` here because that fails when
+ // length is NaN (which is otherwise coerced to zero.)
+ if (length >= K_MAX_LENGTH) {
+ throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
+ 'size: 0x' + K_MAX_LENGTH.toString(16) + ' bytes')
+ }
+ return length | 0
+}
+
+function SlowBuffer (length) {
+ if (+length != length) { // eslint-disable-line eqeqeq
+ length = 0
+ }
+ return Buffer.alloc(+length)
+}
+
+Buffer.isBuffer = function isBuffer (b) {
+ return b != null && b._isBuffer === true &&
+ b !== Buffer.prototype // so Buffer.isBuffer(Buffer.prototype) will be false
+}
+
+Buffer.compare = function compare (a, b) {
+ if (isInstance(a, Uint8Array)) a = Buffer.from(a, a.offset, a.byteLength)
+ if (isInstance(b, Uint8Array)) b = Buffer.from(b, b.offset, b.byteLength)
+ if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
+ throw new TypeError(
+ 'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array'
+ )
+ }
+
+ if (a === b) return 0
+
+ var x = a.length
+ var y = b.length
+
+ for (var i = 0, len = Math.min(x, y); i < len; ++i) {
+ if (a[i] !== b[i]) {
+ x = a[i]
+ y = b[i]
+ break
+ }
+ }
+
+ if (x < y) return -1
+ if (y < x) return 1
+ return 0
+}
+
+Buffer.isEncoding = function isEncoding (encoding) {
+ switch (String(encoding).toLowerCase()) {
+ case 'hex':
+ case 'utf8':
+ case 'utf-8':
+ case 'ascii':
+ case 'latin1':
+ case 'binary':
+ case 'base64':
+ case 'ucs2':
+ case 'ucs-2':
+ case 'utf16le':
+ case 'utf-16le':
+ return true
+ default:
+ return false
+ }
+}
+
+Buffer.concat = function concat (list, length) {
+ if (!Array.isArray(list)) {
+ throw new TypeError('"list" argument must be an Array of Buffers')
+ }
+
+ if (list.length === 0) {
+ return Buffer.alloc(0)
+ }
+
+ var i
+ if (length === undefined) {
+ length = 0
+ for (i = 0; i < list.length; ++i) {
+ length += list[i].length
+ }
+ }
+
+ var buffer = Buffer.allocUnsafe(length)
+ var pos = 0
+ for (i = 0; i < list.length; ++i) {
+ var buf = list[i]
+ if (isInstance(buf, Uint8Array)) {
+ buf = Buffer.from(buf)
+ }
+ if (!Buffer.isBuffer(buf)) {
+ throw new TypeError('"list" argument must be an Array of Buffers')
+ }
+ buf.copy(buffer, pos)
+ pos += buf.length
+ }
+ return buffer
+}
+
+function byteLength (string, encoding) {
+ if (Buffer.isBuffer(string)) {
+ return string.length
+ }
+ if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {
+ return string.byteLength
+ }
+ if (typeof string !== 'string') {
+ throw new TypeError(
+ 'The "string" argument must be one of type string, Buffer, or ArrayBuffer. ' +
+ 'Received type ' + typeof string
+ )
+ }
+
+ var len = string.length
+ var mustMatch = (arguments.length > 2 && arguments[2] === true)
+ if (!mustMatch && len === 0) return 0
+
+ // Use a for loop to avoid recursion
+ var loweredCase = false
+ for (;;) {
+ switch (encoding) {
+ case 'ascii':
+ case 'latin1':
+ case 'binary':
+ return len
+ case 'utf8':
+ case 'utf-8':
+ return utf8ToBytes(string).length
+ case 'ucs2':
+ case 'ucs-2':
+ case 'utf16le':
+ case 'utf-16le':
+ return len * 2
+ case 'hex':
+ return len >>> 1
+ case 'base64':
+ return base64ToBytes(string).length
+ default:
+ if (loweredCase) {
+ return mustMatch ? -1 : utf8ToBytes(string).length // assume utf8
+ }
+ encoding = ('' + encoding).toLowerCase()
+ loweredCase = true
+ }
+ }
+}
+Buffer.byteLength = byteLength
+
+function slowToString (encoding, start, end) {
+ var loweredCase = false
+
+ // No need to verify that "this.length <= MAX_UINT32" since it's a read-only
+ // property of a typed array.
+
+ // This behaves neither like String nor Uint8Array in that we set start/end
+ // to their upper/lower bounds if the value passed is out of range.
+ // undefined is handled specially as per ECMA-262 6th Edition,
+ // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.
+ if (start === undefined || start < 0) {
+ start = 0
+ }
+ // Return early if start > this.length. Done here to prevent potential uint32
+ // coercion fail below.
+ if (start > this.length) {
+ return ''
+ }
+
+ if (end === undefined || end > this.length) {
+ end = this.length
+ }
+
+ if (end <= 0) {
+ return ''
+ }
+
+ // Force coersion to uint32. This will also coerce falsey/NaN values to 0.
+ end >>>= 0
+ start >>>= 0
+
+ if (end <= start) {
+ return ''
+ }
+
+ if (!encoding) encoding = 'utf8'
+
+ while (true) {
+ switch (encoding) {
+ case 'hex':
+ return hexSlice(this, start, end)
+
+ case 'utf8':
+ case 'utf-8':
+ return utf8Slice(this, start, end)
+
+ case 'ascii':
+ return asciiSlice(this, start, end)
+
+ case 'latin1':
+ case 'binary':
+ return latin1Slice(this, start, end)
+
+ case 'base64':
+ return base64Slice(this, start, end)
+
+ case 'ucs2':
+ case 'ucs-2':
+ case 'utf16le':
+ case 'utf-16le':
+ return utf16leSlice(this, start, end)
+
+ default:
+ if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
+ encoding = (encoding + '').toLowerCase()
+ loweredCase = true
+ }
+ }
+}
+
+// This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package)
+// to detect a Buffer instance. It's not possible to use `instanceof Buffer`
+// reliably in a browserify context because there could be multiple different
+// copies of the 'buffer' package in use. This method works even for Buffer
+// instances that were created from another copy of the `buffer` package.
+// See: https://github.com/feross/buffer/issues/154
+Buffer.prototype._isBuffer = true
+
+function swap (b, n, m) {
+ var i = b[n]
+ b[n] = b[m]
+ b[m] = i
+}
+
+Buffer.prototype.swap16 = function swap16 () {
+ var len = this.length
+ if (len % 2 !== 0) {
+ throw new RangeError('Buffer size must be a multiple of 16-bits')
+ }
+ for (var i = 0; i < len; i += 2) {
+ swap(this, i, i + 1)
+ }
+ return this
+}
+
+Buffer.prototype.swap32 = function swap32 () {
+ var len = this.length
+ if (len % 4 !== 0) {
+ throw new RangeError('Buffer size must be a multiple of 32-bits')
+ }
+ for (var i = 0; i < len; i += 4) {
+ swap(this, i, i + 3)
+ swap(this, i + 1, i + 2)
+ }
+ return this
+}
+
+Buffer.prototype.swap64 = function swap64 () {
+ var len = this.length
+ if (len % 8 !== 0) {
+ throw new RangeError('Buffer size must be a multiple of 64-bits')
+ }
+ for (var i = 0; i < len; i += 8) {
+ swap(this, i, i + 7)
+ swap(this, i + 1, i + 6)
+ swap(this, i + 2, i + 5)
+ swap(this, i + 3, i + 4)
+ }
+ return this
+}
+
+Buffer.prototype.toString = function toString () {
+ var length = this.length
+ if (length === 0) return ''
+ if (arguments.length === 0) return utf8Slice(this, 0, length)
+ return slowToString.apply(this, arguments)
+}
+
+Buffer.prototype.toLocaleString = Buffer.prototype.toString
+
+Buffer.prototype.equals = function equals (b) {
+ if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
+ if (this === b) return true
+ return Buffer.compare(this, b) === 0
+}
+
+Buffer.prototype.inspect = function inspect () {
+ var str = ''
+ var max = exports.INSPECT_MAX_BYTES
+ str = this.toString('hex', 0, max).replace(/(.{2})/g, '$1 ').trim()
+ if (this.length > max) str += ' ... '
+ return ''
+}
+
+Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {
+ if (isInstance(target, Uint8Array)) {
+ target = Buffer.from(target, target.offset, target.byteLength)
+ }
+ if (!Buffer.isBuffer(target)) {
+ throw new TypeError(
+ 'The "target" argument must be one of type Buffer or Uint8Array. ' +
+ 'Received type ' + (typeof target)
+ )
+ }
+
+ if (start === undefined) {
+ start = 0
+ }
+ if (end === undefined) {
+ end = target ? target.length : 0
+ }
+ if (thisStart === undefined) {
+ thisStart = 0
+ }
+ if (thisEnd === undefined) {
+ thisEnd = this.length
+ }
+
+ if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
+ throw new RangeError('out of range index')
+ }
+
+ if (thisStart >= thisEnd && start >= end) {
+ return 0
+ }
+ if (thisStart >= thisEnd) {
+ return -1
+ }
+ if (start >= end) {
+ return 1
+ }
+
+ start >>>= 0
+ end >>>= 0
+ thisStart >>>= 0
+ thisEnd >>>= 0
+
+ if (this === target) return 0
+
+ var x = thisEnd - thisStart
+ var y = end - start
+ var len = Math.min(x, y)
+
+ var thisCopy = this.slice(thisStart, thisEnd)
+ var targetCopy = target.slice(start, end)
+
+ for (var i = 0; i < len; ++i) {
+ if (thisCopy[i] !== targetCopy[i]) {
+ x = thisCopy[i]
+ y = targetCopy[i]
+ break
+ }
+ }
+
+ if (x < y) return -1
+ if (y < x) return 1
+ return 0
+}
+
+// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,
+// OR the last index of `val` in `buffer` at offset <= `byteOffset`.
+//
+// Arguments:
+// - buffer - a Buffer to search
+// - val - a string, Buffer, or number
+// - byteOffset - an index into `buffer`; will be clamped to an int32
+// - encoding - an optional encoding, relevant is val is a string
+// - dir - true for indexOf, false for lastIndexOf
+function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {
+ // Empty buffer means no match
+ if (buffer.length === 0) return -1
+
+ // Normalize byteOffset
+ if (typeof byteOffset === 'string') {
+ encoding = byteOffset
+ byteOffset = 0
+ } else if (byteOffset > 0x7fffffff) {
+ byteOffset = 0x7fffffff
+ } else if (byteOffset < -0x80000000) {
+ byteOffset = -0x80000000
+ }
+ byteOffset = +byteOffset // Coerce to Number.
+ if (numberIsNaN(byteOffset)) {
+ // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer
+ byteOffset = dir ? 0 : (buffer.length - 1)
+ }
+
+ // Normalize byteOffset: negative offsets start from the end of the buffer
+ if (byteOffset < 0) byteOffset = buffer.length + byteOffset
+ if (byteOffset >= buffer.length) {
+ if (dir) return -1
+ else byteOffset = buffer.length - 1
+ } else if (byteOffset < 0) {
+ if (dir) byteOffset = 0
+ else return -1
+ }
+
+ // Normalize val
+ if (typeof val === 'string') {
+ val = Buffer.from(val, encoding)
+ }
+
+ // Finally, search either indexOf (if dir is true) or lastIndexOf
+ if (Buffer.isBuffer(val)) {
+ // Special case: looking for empty string/buffer always fails
+ if (val.length === 0) {
+ return -1
+ }
+ return arrayIndexOf(buffer, val, byteOffset, encoding, dir)
+ } else if (typeof val === 'number') {
+ val = val & 0xFF // Search for a byte value [0-255]
+ if (typeof Uint8Array.prototype.indexOf === 'function') {
+ if (dir) {
+ return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)
+ } else {
+ return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)
+ }
+ }
+ return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)
+ }
+
+ throw new TypeError('val must be string, number or Buffer')
+}
+
+function arrayIndexOf (arr, val, byteOffset, encoding, dir) {
+ var indexSize = 1
+ var arrLength = arr.length
+ var valLength = val.length
+
+ if (encoding !== undefined) {
+ encoding = String(encoding).toLowerCase()
+ if (encoding === 'ucs2' || encoding === 'ucs-2' ||
+ encoding === 'utf16le' || encoding === 'utf-16le') {
+ if (arr.length < 2 || val.length < 2) {
+ return -1
+ }
+ indexSize = 2
+ arrLength /= 2
+ valLength /= 2
+ byteOffset /= 2
+ }
+ }
+
+ function read (buf, i) {
+ if (indexSize === 1) {
+ return buf[i]
+ } else {
+ return buf.readUInt16BE(i * indexSize)
+ }
+ }
+
+ var i
+ if (dir) {
+ var foundIndex = -1
+ for (i = byteOffset; i < arrLength; i++) {
+ if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
+ if (foundIndex === -1) foundIndex = i
+ if (i - foundIndex + 1 === valLength) return foundIndex * indexSize
+ } else {
+ if (foundIndex !== -1) i -= i - foundIndex
+ foundIndex = -1
+ }
+ }
+ } else {
+ if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength
+ for (i = byteOffset; i >= 0; i--) {
+ var found = true
+ for (var j = 0; j < valLength; j++) {
+ if (read(arr, i + j) !== read(val, j)) {
+ found = false
+ break
+ }
+ }
+ if (found) return i
+ }
+ }
+
+ return -1
+}
+
+Buffer.prototype.includes = function includes (val, byteOffset, encoding) {
+ return this.indexOf(val, byteOffset, encoding) !== -1
+}
+
+Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {
+ return bidirectionalIndexOf(this, val, byteOffset, encoding, true)
+}
+
+Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {
+ return bidirectionalIndexOf(this, val, byteOffset, encoding, false)
+}
+
+function hexWrite (buf, string, offset, length) {
+ offset = Number(offset) || 0
+ var remaining = buf.length - offset
+ if (!length) {
+ length = remaining
+ } else {
+ length = Number(length)
+ if (length > remaining) {
+ length = remaining
+ }
+ }
+
+ var strLen = string.length
+
+ if (length > strLen / 2) {
+ length = strLen / 2
+ }
+ for (var i = 0; i < length; ++i) {
+ var parsed = parseInt(string.substr(i * 2, 2), 16)
+ if (numberIsNaN(parsed)) return i
+ buf[offset + i] = parsed
+ }
+ return i
+}
+
+function utf8Write (buf, string, offset, length) {
+ return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)
+}
+
+function asciiWrite (buf, string, offset, length) {
+ return blitBuffer(asciiToBytes(string), buf, offset, length)
+}
+
+function latin1Write (buf, string, offset, length) {
+ return asciiWrite(buf, string, offset, length)
+}
+
+function base64Write (buf, string, offset, length) {
+ return blitBuffer(base64ToBytes(string), buf, offset, length)
+}
+
+function ucs2Write (buf, string, offset, length) {
+ return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)
+}
+
+Buffer.prototype.write = function write (string, offset, length, encoding) {
+ // Buffer#write(string)
+ if (offset === undefined) {
+ encoding = 'utf8'
+ length = this.length
+ offset = 0
+ // Buffer#write(string, encoding)
+ } else if (length === undefined && typeof offset === 'string') {
+ encoding = offset
+ length = this.length
+ offset = 0
+ // Buffer#write(string, offset[, length][, encoding])
+ } else if (isFinite(offset)) {
+ offset = offset >>> 0
+ if (isFinite(length)) {
+ length = length >>> 0
+ if (encoding === undefined) encoding = 'utf8'
+ } else {
+ encoding = length
+ length = undefined
+ }
+ } else {
+ throw new Error(
+ 'Buffer.write(string, encoding, offset[, length]) is no longer supported'
+ )
+ }
+
+ var remaining = this.length - offset
+ if (length === undefined || length > remaining) length = remaining
+
+ if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {
+ throw new RangeError('Attempt to write outside buffer bounds')
+ }
+
+ if (!encoding) encoding = 'utf8'
+
+ var loweredCase = false
+ for (;;) {
+ switch (encoding) {
+ case 'hex':
+ return hexWrite(this, string, offset, length)
+
+ case 'utf8':
+ case 'utf-8':
+ return utf8Write(this, string, offset, length)
+
+ case 'ascii':
+ return asciiWrite(this, string, offset, length)
+
+ case 'latin1':
+ case 'binary':
+ return latin1Write(this, string, offset, length)
+
+ case 'base64':
+ // Warning: maxLength not taken into account in base64Write
+ return base64Write(this, string, offset, length)
+
+ case 'ucs2':
+ case 'ucs-2':
+ case 'utf16le':
+ case 'utf-16le':
+ return ucs2Write(this, string, offset, length)
+
+ default:
+ if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
+ encoding = ('' + encoding).toLowerCase()
+ loweredCase = true
+ }
+ }
+}
+
+Buffer.prototype.toJSON = function toJSON () {
+ return {
+ type: 'Buffer',
+ data: Array.prototype.slice.call(this._arr || this, 0)
+ }
+}
+
+function base64Slice (buf, start, end) {
+ if (start === 0 && end === buf.length) {
+ return base64.fromByteArray(buf)
+ } else {
+ return base64.fromByteArray(buf.slice(start, end))
+ }
+}
+
+function utf8Slice (buf, start, end) {
+ end = Math.min(buf.length, end)
+ var res = []
+
+ var i = start
+ while (i < end) {
+ var firstByte = buf[i]
+ var codePoint = null
+ var bytesPerSequence = (firstByte > 0xEF) ? 4
+ : (firstByte > 0xDF) ? 3
+ : (firstByte > 0xBF) ? 2
+ : 1
+
+ if (i + bytesPerSequence <= end) {
+ var secondByte, thirdByte, fourthByte, tempCodePoint
+
+ switch (bytesPerSequence) {
+ case 1:
+ if (firstByte < 0x80) {
+ codePoint = firstByte
+ }
+ break
+ case 2:
+ secondByte = buf[i + 1]
+ if ((secondByte & 0xC0) === 0x80) {
+ tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)
+ if (tempCodePoint > 0x7F) {
+ codePoint = tempCodePoint
+ }
+ }
+ break
+ case 3:
+ secondByte = buf[i + 1]
+ thirdByte = buf[i + 2]
+ if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
+ tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)
+ if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
+ codePoint = tempCodePoint
+ }
+ }
+ break
+ case 4:
+ secondByte = buf[i + 1]
+ thirdByte = buf[i + 2]
+ fourthByte = buf[i + 3]
+ if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
+ tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)
+ if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
+ codePoint = tempCodePoint
+ }
+ }
+ }
+ }
+
+ if (codePoint === null) {
+ // we did not generate a valid codePoint so insert a
+ // replacement char (U+FFFD) and advance only 1 byte
+ codePoint = 0xFFFD
+ bytesPerSequence = 1
+ } else if (codePoint > 0xFFFF) {
+ // encode to utf16 (surrogate pair dance)
+ codePoint -= 0x10000
+ res.push(codePoint >>> 10 & 0x3FF | 0xD800)
+ codePoint = 0xDC00 | codePoint & 0x3FF
+ }
+
+ res.push(codePoint)
+ i += bytesPerSequence
+ }
+
+ return decodeCodePointsArray(res)
+}
+
+// Based on http://stackoverflow.com/a/22747272/680742, the browser with
+// the lowest limit is Chrome, with 0x10000 args.
+// We go 1 magnitude less, for safety
+var MAX_ARGUMENTS_LENGTH = 0x1000
+
+function decodeCodePointsArray (codePoints) {
+ var len = codePoints.length
+ if (len <= MAX_ARGUMENTS_LENGTH) {
+ return String.fromCharCode.apply(String, codePoints) // avoid extra slice()
+ }
+
+ // Decode in chunks to avoid "call stack size exceeded".
+ var res = ''
+ var i = 0
+ while (i < len) {
+ res += String.fromCharCode.apply(
+ String,
+ codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
+ )
+ }
+ return res
+}
+
+function asciiSlice (buf, start, end) {
+ var ret = ''
+ end = Math.min(buf.length, end)
+
+ for (var i = start; i < end; ++i) {
+ ret += String.fromCharCode(buf[i] & 0x7F)
+ }
+ return ret
+}
+
+function latin1Slice (buf, start, end) {
+ var ret = ''
+ end = Math.min(buf.length, end)
+
+ for (var i = start; i < end; ++i) {
+ ret += String.fromCharCode(buf[i])
+ }
+ return ret
+}
+
+function hexSlice (buf, start, end) {
+ var len = buf.length
+
+ if (!start || start < 0) start = 0
+ if (!end || end < 0 || end > len) end = len
+
+ var out = ''
+ for (var i = start; i < end; ++i) {
+ out += toHex(buf[i])
+ }
+ return out
+}
+
+function utf16leSlice (buf, start, end) {
+ var bytes = buf.slice(start, end)
+ var res = ''
+ for (var i = 0; i < bytes.length; i += 2) {
+ res += String.fromCharCode(bytes[i] + (bytes[i + 1] * 256))
+ }
+ return res
+}
+
+Buffer.prototype.slice = function slice (start, end) {
+ var len = this.length
+ start = ~~start
+ end = end === undefined ? len : ~~end
+
+ if (start < 0) {
+ start += len
+ if (start < 0) start = 0
+ } else if (start > len) {
+ start = len
+ }
+
+ if (end < 0) {
+ end += len
+ if (end < 0) end = 0
+ } else if (end > len) {
+ end = len
+ }
+
+ if (end < start) end = start
+
+ var newBuf = this.subarray(start, end)
+ // Return an augmented `Uint8Array` instance
+ newBuf.__proto__ = Buffer.prototype
+ return newBuf
+}
+
+/*
+ * Need to make sure that buffer isn't trying to write out of bounds.
+ */
+function checkOffset (offset, ext, length) {
+ if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')
+ if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')
+}
+
+Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {
+ offset = offset >>> 0
+ byteLength = byteLength >>> 0
+ if (!noAssert) checkOffset(offset, byteLength, this.length)
+
+ var val = this[offset]
+ var mul = 1
+ var i = 0
+ while (++i < byteLength && (mul *= 0x100)) {
+ val += this[offset + i] * mul
+ }
+
+ return val
+}
+
+Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {
+ offset = offset >>> 0
+ byteLength = byteLength >>> 0
+ if (!noAssert) {
+ checkOffset(offset, byteLength, this.length)
+ }
+
+ var val = this[offset + --byteLength]
+ var mul = 1
+ while (byteLength > 0 && (mul *= 0x100)) {
+ val += this[offset + --byteLength] * mul
+ }
+
+ return val
+}
+
+Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {
+ offset = offset >>> 0
+ if (!noAssert) checkOffset(offset, 1, this.length)
+ return this[offset]
+}
+
+Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {
+ offset = offset >>> 0
+ if (!noAssert) checkOffset(offset, 2, this.length)
+ return this[offset] | (this[offset + 1] << 8)
+}
+
+Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {
+ offset = offset >>> 0
+ if (!noAssert) checkOffset(offset, 2, this.length)
+ return (this[offset] << 8) | this[offset + 1]
+}
+
+Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {
+ offset = offset >>> 0
+ if (!noAssert) checkOffset(offset, 4, this.length)
+
+ return ((this[offset]) |
+ (this[offset + 1] << 8) |
+ (this[offset + 2] << 16)) +
+ (this[offset + 3] * 0x1000000)
+}
+
+Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {
+ offset = offset >>> 0
+ if (!noAssert) checkOffset(offset, 4, this.length)
+
+ return (this[offset] * 0x1000000) +
+ ((this[offset + 1] << 16) |
+ (this[offset + 2] << 8) |
+ this[offset + 3])
+}
+
+Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {
+ offset = offset >>> 0
+ byteLength = byteLength >>> 0
+ if (!noAssert) checkOffset(offset, byteLength, this.length)
+
+ var val = this[offset]
+ var mul = 1
+ var i = 0
+ while (++i < byteLength && (mul *= 0x100)) {
+ val += this[offset + i] * mul
+ }
+ mul *= 0x80
+
+ if (val >= mul) val -= Math.pow(2, 8 * byteLength)
+
+ return val
+}
+
+Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {
+ offset = offset >>> 0
+ byteLength = byteLength >>> 0
+ if (!noAssert) checkOffset(offset, byteLength, this.length)
+
+ var i = byteLength
+ var mul = 1
+ var val = this[offset + --i]
+ while (i > 0 && (mul *= 0x100)) {
+ val += this[offset + --i] * mul
+ }
+ mul *= 0x80
+
+ if (val >= mul) val -= Math.pow(2, 8 * byteLength)
+
+ return val
+}
+
+Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) {
+ offset = offset >>> 0
+ if (!noAssert) checkOffset(offset, 1, this.length)
+ if (!(this[offset] & 0x80)) return (this[offset])
+ return ((0xff - this[offset] + 1) * -1)
+}
+
+Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {
+ offset = offset >>> 0
+ if (!noAssert) checkOffset(offset, 2, this.length)
+ var val = this[offset] | (this[offset + 1] << 8)
+ return (val & 0x8000) ? val | 0xFFFF0000 : val
+}
+
+Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {
+ offset = offset >>> 0
+ if (!noAssert) checkOffset(offset, 2, this.length)
+ var val = this[offset + 1] | (this[offset] << 8)
+ return (val & 0x8000) ? val | 0xFFFF0000 : val
+}
+
+Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {
+ offset = offset >>> 0
+ if (!noAssert) checkOffset(offset, 4, this.length)
+
+ return (this[offset]) |
+ (this[offset + 1] << 8) |
+ (this[offset + 2] << 16) |
+ (this[offset + 3] << 24)
+}
+
+Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {
+ offset = offset >>> 0
+ if (!noAssert) checkOffset(offset, 4, this.length)
+
+ return (this[offset] << 24) |
+ (this[offset + 1] << 16) |
+ (this[offset + 2] << 8) |
+ (this[offset + 3])
+}
+
+Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {
+ offset = offset >>> 0
+ if (!noAssert) checkOffset(offset, 4, this.length)
+ return ieee754.read(this, offset, true, 23, 4)
+}
+
+Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {
+ offset = offset >>> 0
+ if (!noAssert) checkOffset(offset, 4, this.length)
+ return ieee754.read(this, offset, false, 23, 4)
+}
+
+Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {
+ offset = offset >>> 0
+ if (!noAssert) checkOffset(offset, 8, this.length)
+ return ieee754.read(this, offset, true, 52, 8)
+}
+
+Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {
+ offset = offset >>> 0
+ if (!noAssert) checkOffset(offset, 8, this.length)
+ return ieee754.read(this, offset, false, 52, 8)
+}
+
+function checkInt (buf, value, offset, ext, max, min) {
+ if (!Buffer.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance')
+ if (value > max || value < min) throw new RangeError('"value" argument is out of bounds')
+ if (offset + ext > buf.length) throw new RangeError('Index out of range')
+}
+
+Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {
+ value = +value
+ offset = offset >>> 0
+ byteLength = byteLength >>> 0
+ if (!noAssert) {
+ var maxBytes = Math.pow(2, 8 * byteLength) - 1
+ checkInt(this, value, offset, byteLength, maxBytes, 0)
+ }
+
+ var mul = 1
+ var i = 0
+ this[offset] = value & 0xFF
+ while (++i < byteLength && (mul *= 0x100)) {
+ this[offset + i] = (value / mul) & 0xFF
+ }
+
+ return offset + byteLength
+}
+
+Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {
+ value = +value
+ offset = offset >>> 0
+ byteLength = byteLength >>> 0
+ if (!noAssert) {
+ var maxBytes = Math.pow(2, 8 * byteLength) - 1
+ checkInt(this, value, offset, byteLength, maxBytes, 0)
+ }
+
+ var i = byteLength - 1
+ var mul = 1
+ this[offset + i] = value & 0xFF
+ while (--i >= 0 && (mul *= 0x100)) {
+ this[offset + i] = (value / mul) & 0xFF
+ }
+
+ return offset + byteLength
+}
+
+Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {
+ value = +value
+ offset = offset >>> 0
+ if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)
+ this[offset] = (value & 0xff)
+ return offset + 1
+}
+
+Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {
+ value = +value
+ offset = offset >>> 0
+ if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
+ this[offset] = (value & 0xff)
+ this[offset + 1] = (value >>> 8)
+ return offset + 2
+}
+
+Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {
+ value = +value
+ offset = offset >>> 0
+ if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
+ this[offset] = (value >>> 8)
+ this[offset + 1] = (value & 0xff)
+ return offset + 2
+}
+
+Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {
+ value = +value
+ offset = offset >>> 0
+ if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
+ this[offset + 3] = (value >>> 24)
+ this[offset + 2] = (value >>> 16)
+ this[offset + 1] = (value >>> 8)
+ this[offset] = (value & 0xff)
+ return offset + 4
+}
+
+Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {
+ value = +value
+ offset = offset >>> 0
+ if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
+ this[offset] = (value >>> 24)
+ this[offset + 1] = (value >>> 16)
+ this[offset + 2] = (value >>> 8)
+ this[offset + 3] = (value & 0xff)
+ return offset + 4
+}
+
+Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {
+ value = +value
+ offset = offset >>> 0
+ if (!noAssert) {
+ var limit = Math.pow(2, (8 * byteLength) - 1)
+
+ checkInt(this, value, offset, byteLength, limit - 1, -limit)
+ }
+
+ var i = 0
+ var mul = 1
+ var sub = 0
+ this[offset] = value & 0xFF
+ while (++i < byteLength && (mul *= 0x100)) {
+ if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
+ sub = 1
+ }
+ this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
+ }
+
+ return offset + byteLength
+}
+
+Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {
+ value = +value
+ offset = offset >>> 0
+ if (!noAssert) {
+ var limit = Math.pow(2, (8 * byteLength) - 1)
+
+ checkInt(this, value, offset, byteLength, limit - 1, -limit)
+ }
+
+ var i = byteLength - 1
+ var mul = 1
+ var sub = 0
+ this[offset + i] = value & 0xFF
+ while (--i >= 0 && (mul *= 0x100)) {
+ if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
+ sub = 1
+ }
+ this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
+ }
+
+ return offset + byteLength
+}
+
+Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {
+ value = +value
+ offset = offset >>> 0
+ if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)
+ if (value < 0) value = 0xff + value + 1
+ this[offset] = (value & 0xff)
+ return offset + 1
+}
+
+Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {
+ value = +value
+ offset = offset >>> 0
+ if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
+ this[offset] = (value & 0xff)
+ this[offset + 1] = (value >>> 8)
+ return offset + 2
+}
+
+Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {
+ value = +value
+ offset = offset >>> 0
+ if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
+ this[offset] = (value >>> 8)
+ this[offset + 1] = (value & 0xff)
+ return offset + 2
+}
+
+Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {
+ value = +value
+ offset = offset >>> 0
+ if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
+ this[offset] = (value & 0xff)
+ this[offset + 1] = (value >>> 8)
+ this[offset + 2] = (value >>> 16)
+ this[offset + 3] = (value >>> 24)
+ return offset + 4
+}
+
+Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {
+ value = +value
+ offset = offset >>> 0
+ if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
+ if (value < 0) value = 0xffffffff + value + 1
+ this[offset] = (value >>> 24)
+ this[offset + 1] = (value >>> 16)
+ this[offset + 2] = (value >>> 8)
+ this[offset + 3] = (value & 0xff)
+ return offset + 4
+}
+
+function checkIEEE754 (buf, value, offset, ext, max, min) {
+ if (offset + ext > buf.length) throw new RangeError('Index out of range')
+ if (offset < 0) throw new RangeError('Index out of range')
+}
+
+function writeFloat (buf, value, offset, littleEndian, noAssert) {
+ value = +value
+ offset = offset >>> 0
+ if (!noAssert) {
+ checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)
+ }
+ ieee754.write(buf, value, offset, littleEndian, 23, 4)
+ return offset + 4
+}
+
+Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {
+ return writeFloat(this, value, offset, true, noAssert)
+}
+
+Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {
+ return writeFloat(this, value, offset, false, noAssert)
+}
+
+function writeDouble (buf, value, offset, littleEndian, noAssert) {
+ value = +value
+ offset = offset >>> 0
+ if (!noAssert) {
+ checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)
+ }
+ ieee754.write(buf, value, offset, littleEndian, 52, 8)
+ return offset + 8
+}
+
+Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {
+ return writeDouble(this, value, offset, true, noAssert)
+}
+
+Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {
+ return writeDouble(this, value, offset, false, noAssert)
+}
+
+// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
+Buffer.prototype.copy = function copy (target, targetStart, start, end) {
+ if (!Buffer.isBuffer(target)) throw new TypeError('argument should be a Buffer')
+ if (!start) start = 0
+ if (!end && end !== 0) end = this.length
+ if (targetStart >= target.length) targetStart = target.length
+ if (!targetStart) targetStart = 0
+ if (end > 0 && end < start) end = start
+
+ // Copy 0 bytes; we're done
+ if (end === start) return 0
+ if (target.length === 0 || this.length === 0) return 0
+
+ // Fatal error conditions
+ if (targetStart < 0) {
+ throw new RangeError('targetStart out of bounds')
+ }
+ if (start < 0 || start >= this.length) throw new RangeError('Index out of range')
+ if (end < 0) throw new RangeError('sourceEnd out of bounds')
+
+ // Are we oob?
+ if (end > this.length) end = this.length
+ if (target.length - targetStart < end - start) {
+ end = target.length - targetStart + start
+ }
+
+ var len = end - start
+
+ if (this === target && typeof Uint8Array.prototype.copyWithin === 'function') {
+ // Use built-in when available, missing from IE11
+ this.copyWithin(targetStart, start, end)
+ } else if (this === target && start < targetStart && targetStart < end) {
+ // descending copy from end
+ for (var i = len - 1; i >= 0; --i) {
+ target[i + targetStart] = this[i + start]
+ }
+ } else {
+ Uint8Array.prototype.set.call(
+ target,
+ this.subarray(start, end),
+ targetStart
+ )
+ }
+
+ return len
+}
+
+// Usage:
+// buffer.fill(number[, offset[, end]])
+// buffer.fill(buffer[, offset[, end]])
+// buffer.fill(string[, offset[, end]][, encoding])
+Buffer.prototype.fill = function fill (val, start, end, encoding) {
+ // Handle string cases:
+ if (typeof val === 'string') {
+ if (typeof start === 'string') {
+ encoding = start
+ start = 0
+ end = this.length
+ } else if (typeof end === 'string') {
+ encoding = end
+ end = this.length
+ }
+ if (encoding !== undefined && typeof encoding !== 'string') {
+ throw new TypeError('encoding must be a string')
+ }
+ if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {
+ throw new TypeError('Unknown encoding: ' + encoding)
+ }
+ if (val.length === 1) {
+ var code = val.charCodeAt(0)
+ if ((encoding === 'utf8' && code < 128) ||
+ encoding === 'latin1') {
+ // Fast path: If `val` fits into a single byte, use that numeric value.
+ val = code
+ }
+ }
+ } else if (typeof val === 'number') {
+ val = val & 255
+ }
+
+ // Invalid ranges are not set to a default, so can range check early.
+ if (start < 0 || this.length < start || this.length < end) {
+ throw new RangeError('Out of range index')
+ }
+
+ if (end <= start) {
+ return this
+ }
+
+ start = start >>> 0
+ end = end === undefined ? this.length : end >>> 0
+
+ if (!val) val = 0
+
+ var i
+ if (typeof val === 'number') {
+ for (i = start; i < end; ++i) {
+ this[i] = val
+ }
+ } else {
+ var bytes = Buffer.isBuffer(val)
+ ? val
+ : Buffer.from(val, encoding)
+ var len = bytes.length
+ if (len === 0) {
+ throw new TypeError('The value "' + val +
+ '" is invalid for argument "value"')
+ }
+ for (i = 0; i < end - start; ++i) {
+ this[i + start] = bytes[i % len]
+ }
+ }
+
+ return this
+}
+
+// HELPER FUNCTIONS
+// ================
+
+var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g
+
+function base64clean (str) {
+ // Node takes equal signs as end of the Base64 encoding
+ str = str.split('=')[0]
+ // Node strips out invalid characters like \n and \t from the string, base64-js does not
+ str = str.trim().replace(INVALID_BASE64_RE, '')
+ // Node converts strings with length < 2 to ''
+ if (str.length < 2) return ''
+ // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
+ while (str.length % 4 !== 0) {
+ str = str + '='
+ }
+ return str
+}
+
+function toHex (n) {
+ if (n < 16) return '0' + n.toString(16)
+ return n.toString(16)
+}
+
+function utf8ToBytes (string, units) {
+ units = units || Infinity
+ var codePoint
+ var length = string.length
+ var leadSurrogate = null
+ var bytes = []
+
+ for (var i = 0; i < length; ++i) {
+ codePoint = string.charCodeAt(i)
+
+ // is surrogate component
+ if (codePoint > 0xD7FF && codePoint < 0xE000) {
+ // last char was a lead
+ if (!leadSurrogate) {
+ // no lead yet
+ if (codePoint > 0xDBFF) {
+ // unexpected trail
+ if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
+ continue
+ } else if (i + 1 === length) {
+ // unpaired lead
+ if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
+ continue
+ }
+
+ // valid lead
+ leadSurrogate = codePoint
+
+ continue
+ }
+
+ // 2 leads in a row
+ if (codePoint < 0xDC00) {
+ if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
+ leadSurrogate = codePoint
+ continue
+ }
+
+ // valid surrogate pair
+ codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000
+ } else if (leadSurrogate) {
+ // valid bmp char, but last char was a lead
+ if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
+ }
+
+ leadSurrogate = null
+
+ // encode utf8
+ if (codePoint < 0x80) {
+ if ((units -= 1) < 0) break
+ bytes.push(codePoint)
+ } else if (codePoint < 0x800) {
+ if ((units -= 2) < 0) break
+ bytes.push(
+ codePoint >> 0x6 | 0xC0,
+ codePoint & 0x3F | 0x80
+ )
+ } else if (codePoint < 0x10000) {
+ if ((units -= 3) < 0) break
+ bytes.push(
+ codePoint >> 0xC | 0xE0,
+ codePoint >> 0x6 & 0x3F | 0x80,
+ codePoint & 0x3F | 0x80
+ )
+ } else if (codePoint < 0x110000) {
+ if ((units -= 4) < 0) break
+ bytes.push(
+ codePoint >> 0x12 | 0xF0,
+ codePoint >> 0xC & 0x3F | 0x80,
+ codePoint >> 0x6 & 0x3F | 0x80,
+ codePoint & 0x3F | 0x80
+ )
+ } else {
+ throw new Error('Invalid code point')
+ }
+ }
+
+ return bytes
+}
+
+function asciiToBytes (str) {
+ var byteArray = []
+ for (var i = 0; i < str.length; ++i) {
+ // Node's code seems to be doing this and not & 0x7F..
+ byteArray.push(str.charCodeAt(i) & 0xFF)
+ }
+ return byteArray
+}
+
+function utf16leToBytes (str, units) {
+ var c, hi, lo
+ var byteArray = []
+ for (var i = 0; i < str.length; ++i) {
+ if ((units -= 2) < 0) break
+
+ c = str.charCodeAt(i)
+ hi = c >> 8
+ lo = c % 256
+ byteArray.push(lo)
+ byteArray.push(hi)
+ }
+
+ return byteArray
+}
+
+function base64ToBytes (str) {
+ return base64.toByteArray(base64clean(str))
+}
+
+function blitBuffer (src, dst, offset, length) {
+ for (var i = 0; i < length; ++i) {
+ if ((i + offset >= dst.length) || (i >= src.length)) break
+ dst[i + offset] = src[i]
+ }
+ return i
+}
+
+// ArrayBuffer or Uint8Array objects from other contexts (i.e. iframes) do not pass
+// the `instanceof` check but they should be treated as of that type.
+// See: https://github.com/feross/buffer/issues/166
+function isInstance (obj, type) {
+ return obj instanceof type ||
+ (obj != null && obj.constructor != null && obj.constructor.name != null &&
+ obj.constructor.name === type.name)
+}
+function numberIsNaN (obj) {
+ // For IE11 support
+ return obj !== obj // eslint-disable-line no-self-compare
+}
+
+},{"base64-js":10,"ieee754":79}],13:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+var objectCreate = Object.create || objectCreatePolyfill
+var objectKeys = Object.keys || objectKeysPolyfill
+var bind = Function.prototype.bind || functionBindPolyfill
+
+function EventEmitter() {
+ if (!this._events || !Object.prototype.hasOwnProperty.call(this, '_events')) {
+ this._events = objectCreate(null);
+ this._eventsCount = 0;
+ }
+
+ this._maxListeners = this._maxListeners || undefined;
+}
+module.exports = EventEmitter;
+
+// Backwards-compat with node 0.10.x
+EventEmitter.EventEmitter = EventEmitter;
+
+EventEmitter.prototype._events = undefined;
+EventEmitter.prototype._maxListeners = undefined;
+
+// By default EventEmitters will print a warning if more than 10 listeners are
+// added to it. This is a useful default which helps finding memory leaks.
+var defaultMaxListeners = 10;
+
+var hasDefineProperty;
+try {
+ var o = {};
+ if (Object.defineProperty) Object.defineProperty(o, 'x', { value: 0 });
+ hasDefineProperty = o.x === 0;
+} catch (err) { hasDefineProperty = false }
+if (hasDefineProperty) {
+ Object.defineProperty(EventEmitter, 'defaultMaxListeners', {
+ enumerable: true,
+ get: function() {
+ return defaultMaxListeners;
+ },
+ set: function(arg) {
+ // check whether the input is a positive number (whose value is zero or
+ // greater and not a NaN).
+ if (typeof arg !== 'number' || arg < 0 || arg !== arg)
+ throw new TypeError('"defaultMaxListeners" must be a positive number');
+ defaultMaxListeners = arg;
+ }
+ });
+} else {
+ EventEmitter.defaultMaxListeners = defaultMaxListeners;
+}
+
+// Obviously not all Emitters should be limited to 10. This function allows
+// that to be increased. Set to zero for unlimited.
+EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
+ if (typeof n !== 'number' || n < 0 || isNaN(n))
+ throw new TypeError('"n" argument must be a positive number');
+ this._maxListeners = n;
+ return this;
+};
+
+function $getMaxListeners(that) {
+ if (that._maxListeners === undefined)
+ return EventEmitter.defaultMaxListeners;
+ return that._maxListeners;
+}
+
+EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
+ return $getMaxListeners(this);
+};
+
+// These standalone emit* functions are used to optimize calling of event
+// handlers for fast cases because emit() itself often has a variable number of
+// arguments and can be deoptimized because of that. These functions always have
+// the same number of arguments and thus do not get deoptimized, so the code
+// inside them can execute faster.
+function emitNone(handler, isFn, self) {
+ if (isFn)
+ handler.call(self);
+ else {
+ var len = handler.length;
+ var listeners = arrayClone(handler, len);
+ for (var i = 0; i < len; ++i)
+ listeners[i].call(self);
+ }
+}
+function emitOne(handler, isFn, self, arg1) {
+ if (isFn)
+ handler.call(self, arg1);
+ else {
+ var len = handler.length;
+ var listeners = arrayClone(handler, len);
+ for (var i = 0; i < len; ++i)
+ listeners[i].call(self, arg1);
+ }
+}
+function emitTwo(handler, isFn, self, arg1, arg2) {
+ if (isFn)
+ handler.call(self, arg1, arg2);
+ else {
+ var len = handler.length;
+ var listeners = arrayClone(handler, len);
+ for (var i = 0; i < len; ++i)
+ listeners[i].call(self, arg1, arg2);
+ }
+}
+function emitThree(handler, isFn, self, arg1, arg2, arg3) {
+ if (isFn)
+ handler.call(self, arg1, arg2, arg3);
+ else {
+ var len = handler.length;
+ var listeners = arrayClone(handler, len);
+ for (var i = 0; i < len; ++i)
+ listeners[i].call(self, arg1, arg2, arg3);
+ }
+}
+
+function emitMany(handler, isFn, self, args) {
+ if (isFn)
+ handler.apply(self, args);
+ else {
+ var len = handler.length;
+ var listeners = arrayClone(handler, len);
+ for (var i = 0; i < len; ++i)
+ listeners[i].apply(self, args);
+ }
+}
+
+EventEmitter.prototype.emit = function emit(type) {
+ var er, handler, len, args, i, events;
+ var doError = (type === 'error');
+
+ events = this._events;
+ if (events)
+ doError = (doError && events.error == null);
+ else if (!doError)
+ return false;
+
+ // If there is no 'error' event listener then throw.
+ if (doError) {
+ if (arguments.length > 1)
+ er = arguments[1];
+ if (er instanceof Error) {
+ throw er; // Unhandled 'error' event
+ } else {
+ // At least give some kind of context to the user
+ var err = new Error('Unhandled "error" event. (' + er + ')');
+ err.context = er;
+ throw err;
+ }
+ return false;
+ }
+
+ handler = events[type];
+
+ if (!handler)
+ return false;
+
+ var isFn = typeof handler === 'function';
+ len = arguments.length;
+ switch (len) {
+ // fast cases
+ case 1:
+ emitNone(handler, isFn, this);
+ break;
+ case 2:
+ emitOne(handler, isFn, this, arguments[1]);
+ break;
+ case 3:
+ emitTwo(handler, isFn, this, arguments[1], arguments[2]);
+ break;
+ case 4:
+ emitThree(handler, isFn, this, arguments[1], arguments[2], arguments[3]);
+ break;
+ // slower
+ default:
+ args = new Array(len - 1);
+ for (i = 1; i < len; i++)
+ args[i - 1] = arguments[i];
+ emitMany(handler, isFn, this, args);
+ }
+
+ return true;
+};
+
+function _addListener(target, type, listener, prepend) {
+ var m;
+ var events;
+ var existing;
+
+ if (typeof listener !== 'function')
+ throw new TypeError('"listener" argument must be a function');
+
+ events = target._events;
+ if (!events) {
+ events = target._events = objectCreate(null);
+ target._eventsCount = 0;
+ } else {
+ // To avoid recursion in the case that type === "newListener"! Before
+ // adding it to the listeners, first emit "newListener".
+ if (events.newListener) {
+ target.emit('newListener', type,
+ listener.listener ? listener.listener : listener);
+
+ // Re-assign `events` because a newListener handler could have caused the
+ // this._events to be assigned to a new object
+ events = target._events;
+ }
+ existing = events[type];
+ }
+
+ if (!existing) {
+ // Optimize the case of one listener. Don't need the extra array object.
+ existing = events[type] = listener;
+ ++target._eventsCount;
+ } else {
+ if (typeof existing === 'function') {
+ // Adding the second element, need to change to array.
+ existing = events[type] =
+ prepend ? [listener, existing] : [existing, listener];
+ } else {
+ // If we've already got an array, just append.
+ if (prepend) {
+ existing.unshift(listener);
+ } else {
+ existing.push(listener);
+ }
+ }
+
+ // Check for listener leak
+ if (!existing.warned) {
+ m = $getMaxListeners(target);
+ if (m && m > 0 && existing.length > m) {
+ existing.warned = true;
+ var w = new Error('Possible EventEmitter memory leak detected. ' +
+ existing.length + ' "' + String(type) + '" listeners ' +
+ 'added. Use emitter.setMaxListeners() to ' +
+ 'increase limit.');
+ w.name = 'MaxListenersExceededWarning';
+ w.emitter = target;
+ w.type = type;
+ w.count = existing.length;
+ if (typeof console === 'object' && console.warn) {
+ console.warn('%s: %s', w.name, w.message);
+ }
+ }
+ }
+ }
+
+ return target;
+}
+
+EventEmitter.prototype.addListener = function addListener(type, listener) {
+ return _addListener(this, type, listener, false);
+};
+
+EventEmitter.prototype.on = EventEmitter.prototype.addListener;
+
+EventEmitter.prototype.prependListener =
+ function prependListener(type, listener) {
+ return _addListener(this, type, listener, true);
+ };
+
+function onceWrapper() {
+ if (!this.fired) {
+ this.target.removeListener(this.type, this.wrapFn);
+ this.fired = true;
+ switch (arguments.length) {
+ case 0:
+ return this.listener.call(this.target);
+ case 1:
+ return this.listener.call(this.target, arguments[0]);
+ case 2:
+ return this.listener.call(this.target, arguments[0], arguments[1]);
+ case 3:
+ return this.listener.call(this.target, arguments[0], arguments[1],
+ arguments[2]);
+ default:
+ var args = new Array(arguments.length);
+ for (var i = 0; i < args.length; ++i)
+ args[i] = arguments[i];
+ this.listener.apply(this.target, args);
+ }
+ }
+}
+
+function _onceWrap(target, type, listener) {
+ var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };
+ var wrapped = bind.call(onceWrapper, state);
+ wrapped.listener = listener;
+ state.wrapFn = wrapped;
+ return wrapped;
+}
+
+EventEmitter.prototype.once = function once(type, listener) {
+ if (typeof listener !== 'function')
+ throw new TypeError('"listener" argument must be a function');
+ this.on(type, _onceWrap(this, type, listener));
+ return this;
+};
+
+EventEmitter.prototype.prependOnceListener =
+ function prependOnceListener(type, listener) {
+ if (typeof listener !== 'function')
+ throw new TypeError('"listener" argument must be a function');
+ this.prependListener(type, _onceWrap(this, type, listener));
+ return this;
+ };
+
+// Emits a 'removeListener' event if and only if the listener was removed.
+EventEmitter.prototype.removeListener =
+ function removeListener(type, listener) {
+ var list, events, position, i, originalListener;
+
+ if (typeof listener !== 'function')
+ throw new TypeError('"listener" argument must be a function');
+
+ events = this._events;
+ if (!events)
+ return this;
+
+ list = events[type];
+ if (!list)
+ return this;
+
+ if (list === listener || list.listener === listener) {
+ if (--this._eventsCount === 0)
+ this._events = objectCreate(null);
+ else {
+ delete events[type];
+ if (events.removeListener)
+ this.emit('removeListener', type, list.listener || listener);
+ }
+ } else if (typeof list !== 'function') {
+ position = -1;
+
+ for (i = list.length - 1; i >= 0; i--) {
+ if (list[i] === listener || list[i].listener === listener) {
+ originalListener = list[i].listener;
+ position = i;
+ break;
+ }
+ }
+
+ if (position < 0)
+ return this;
+
+ if (position === 0)
+ list.shift();
+ else
+ spliceOne(list, position);
+
+ if (list.length === 1)
+ events[type] = list[0];
+
+ if (events.removeListener)
+ this.emit('removeListener', type, originalListener || listener);
+ }
+
+ return this;
+ };
+
+EventEmitter.prototype.removeAllListeners =
+ function removeAllListeners(type) {
+ var listeners, events, i;
+
+ events = this._events;
+ if (!events)
+ return this;
+
+ // not listening for removeListener, no need to emit
+ if (!events.removeListener) {
+ if (arguments.length === 0) {
+ this._events = objectCreate(null);
+ this._eventsCount = 0;
+ } else if (events[type]) {
+ if (--this._eventsCount === 0)
+ this._events = objectCreate(null);
+ else
+ delete events[type];
+ }
+ return this;
+ }
+
+ // emit removeListener for all listeners on all events
+ if (arguments.length === 0) {
+ var keys = objectKeys(events);
+ var key;
+ for (i = 0; i < keys.length; ++i) {
+ key = keys[i];
+ if (key === 'removeListener') continue;
+ this.removeAllListeners(key);
+ }
+ this.removeAllListeners('removeListener');
+ this._events = objectCreate(null);
+ this._eventsCount = 0;
+ return this;
+ }
+
+ listeners = events[type];
+
+ if (typeof listeners === 'function') {
+ this.removeListener(type, listeners);
+ } else if (listeners) {
+ // LIFO order
+ for (i = listeners.length - 1; i >= 0; i--) {
+ this.removeListener(type, listeners[i]);
+ }
+ }
+
+ return this;
+ };
+
+function _listeners(target, type, unwrap) {
+ var events = target._events;
+
+ if (!events)
+ return [];
+
+ var evlistener = events[type];
+ if (!evlistener)
+ return [];
+
+ if (typeof evlistener === 'function')
+ return unwrap ? [evlistener.listener || evlistener] : [evlistener];
+
+ return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
+}
+
+EventEmitter.prototype.listeners = function listeners(type) {
+ return _listeners(this, type, true);
+};
+
+EventEmitter.prototype.rawListeners = function rawListeners(type) {
+ return _listeners(this, type, false);
+};
+
+EventEmitter.listenerCount = function(emitter, type) {
+ if (typeof emitter.listenerCount === 'function') {
+ return emitter.listenerCount(type);
+ } else {
+ return listenerCount.call(emitter, type);
+ }
+};
+
+EventEmitter.prototype.listenerCount = listenerCount;
+function listenerCount(type) {
+ var events = this._events;
+
+ if (events) {
+ var evlistener = events[type];
+
+ if (typeof evlistener === 'function') {
+ return 1;
+ } else if (evlistener) {
+ return evlistener.length;
+ }
+ }
+
+ return 0;
+}
+
+EventEmitter.prototype.eventNames = function eventNames() {
+ return this._eventsCount > 0 ? Reflect.ownKeys(this._events) : [];
+};
+
+// About 1.5x faster than the two-arg version of Array#splice().
+function spliceOne(list, index) {
+ for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1)
+ list[i] = list[k];
+ list.pop();
+}
+
+function arrayClone(arr, n) {
+ var copy = new Array(n);
+ for (var i = 0; i < n; ++i)
+ copy[i] = arr[i];
+ return copy;
+}
+
+function unwrapListeners(arr) {
+ var ret = new Array(arr.length);
+ for (var i = 0; i < ret.length; ++i) {
+ ret[i] = arr[i].listener || arr[i];
+ }
+ return ret;
+}
+
+function objectCreatePolyfill(proto) {
+ var F = function() {};
+ F.prototype = proto;
+ return new F;
+}
+function objectKeysPolyfill(obj) {
+ var keys = [];
+ for (var k in obj) if (Object.prototype.hasOwnProperty.call(obj, k)) {
+ keys.push(k);
+ }
+ return k;
+}
+function functionBindPolyfill(context) {
+ var fn = this;
+ return function () {
+ return fn.apply(context, arguments);
+ };
+}
+
+},{}],14:[function(require,module,exports){
+(function (Buffer){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// NOTE: These type checking functions intentionally don't use `instanceof`
+// because it is fragile and can be easily faked with `Object.create()`.
+
+function isArray(arg) {
+ if (Array.isArray) {
+ return Array.isArray(arg);
+ }
+ return objectToString(arg) === '[object Array]';
+}
+exports.isArray = isArray;
+
+function isBoolean(arg) {
+ return typeof arg === 'boolean';
+}
+exports.isBoolean = isBoolean;
+
+function isNull(arg) {
+ return arg === null;
+}
+exports.isNull = isNull;
+
+function isNullOrUndefined(arg) {
+ return arg == null;
+}
+exports.isNullOrUndefined = isNullOrUndefined;
+
+function isNumber(arg) {
+ return typeof arg === 'number';
+}
+exports.isNumber = isNumber;
+
+function isString(arg) {
+ return typeof arg === 'string';
+}
+exports.isString = isString;
+
+function isSymbol(arg) {
+ return typeof arg === 'symbol';
+}
+exports.isSymbol = isSymbol;
+
+function isUndefined(arg) {
+ return arg === void 0;
+}
+exports.isUndefined = isUndefined;
+
+function isRegExp(re) {
+ return objectToString(re) === '[object RegExp]';
+}
+exports.isRegExp = isRegExp;
+
+function isObject(arg) {
+ return typeof arg === 'object' && arg !== null;
+}
+exports.isObject = isObject;
+
+function isDate(d) {
+ return objectToString(d) === '[object Date]';
+}
+exports.isDate = isDate;
+
+function isError(e) {
+ return (objectToString(e) === '[object Error]' || e instanceof Error);
+}
+exports.isError = isError;
+
+function isFunction(arg) {
+ return typeof arg === 'function';
+}
+exports.isFunction = isFunction;
+
+function isPrimitive(arg) {
+ return arg === null ||
+ typeof arg === 'boolean' ||
+ typeof arg === 'number' ||
+ typeof arg === 'string' ||
+ typeof arg === 'symbol' || // ES6 symbol
+ typeof arg === 'undefined';
+}
+exports.isPrimitive = isPrimitive;
+
+exports.isBuffer = Buffer.isBuffer;
+
+function objectToString(o) {
+ return Object.prototype.toString.call(o);
+}
+
+}).call(this,{"isBuffer":require("../../is-buffer/index.js")})
+},{"../../is-buffer/index.js":81}],15:[function(require,module,exports){
+'use strict';
+
+var copy = require('es5-ext/object/copy')
+ , normalizeOptions = require('es5-ext/object/normalize-options')
+ , ensureCallable = require('es5-ext/object/valid-callable')
+ , map = require('es5-ext/object/map')
+ , callable = require('es5-ext/object/valid-callable')
+ , validValue = require('es5-ext/object/valid-value')
+
+ , bind = Function.prototype.bind, defineProperty = Object.defineProperty
+ , hasOwnProperty = Object.prototype.hasOwnProperty
+ , define;
+
+define = function (name, desc, options) {
+ var value = validValue(desc) && callable(desc.value), dgs;
+ dgs = copy(desc);
+ delete dgs.writable;
+ delete dgs.value;
+ dgs.get = function () {
+ if (!options.overwriteDefinition && hasOwnProperty.call(this, name)) return value;
+ desc.value = bind.call(value, options.resolveContext ? options.resolveContext(this) : this);
+ defineProperty(this, name, desc);
+ return this[name];
+ };
+ return dgs;
+};
+
+module.exports = function (props/*, options*/) {
+ var options = normalizeOptions(arguments[1]);
+ if (options.resolveContext != null) ensureCallable(options.resolveContext);
+ return map(props, function (desc, name) { return define(name, desc, options); });
+};
+
+},{"es5-ext/object/copy":39,"es5-ext/object/map":48,"es5-ext/object/normalize-options":49,"es5-ext/object/valid-callable":54,"es5-ext/object/valid-value":55}],16:[function(require,module,exports){
+'use strict';
+
+var assign = require('es5-ext/object/assign')
+ , normalizeOpts = require('es5-ext/object/normalize-options')
+ , isCallable = require('es5-ext/object/is-callable')
+ , contains = require('es5-ext/string/#/contains')
+
+ , d;
+
+d = module.exports = function (dscr, value/*, options*/) {
+ var c, e, w, options, desc;
+ if ((arguments.length < 2) || (typeof dscr !== 'string')) {
+ options = value;
+ value = dscr;
+ dscr = null;
+ } else {
+ options = arguments[2];
+ }
+ if (dscr == null) {
+ c = w = true;
+ e = false;
+ } else {
+ c = contains.call(dscr, 'c');
+ e = contains.call(dscr, 'e');
+ w = contains.call(dscr, 'w');
+ }
+
+ desc = { value: value, configurable: c, enumerable: e, writable: w };
+ return !options ? desc : assign(normalizeOpts(options), desc);
+};
+
+d.gs = function (dscr, get, set/*, options*/) {
+ var c, e, options, desc;
+ if (typeof dscr !== 'string') {
+ options = set;
+ set = get;
+ get = dscr;
+ dscr = null;
+ } else {
+ options = arguments[3];
+ }
+ if (get == null) {
+ get = undefined;
+ } else if (!isCallable(get)) {
+ options = get;
+ get = set = undefined;
+ } else if (set == null) {
+ set = undefined;
+ } else if (!isCallable(set)) {
+ options = set;
+ set = undefined;
+ }
+ if (dscr == null) {
+ c = true;
+ e = false;
+ } else {
+ c = contains.call(dscr, 'c');
+ e = contains.call(dscr, 'e');
+ }
+
+ desc = { get: get, set: set, configurable: c, enumerable: e };
+ return !options ? desc : assign(normalizeOpts(options), desc);
+};
+
+},{"es5-ext/object/assign":36,"es5-ext/object/is-callable":42,"es5-ext/object/normalize-options":49,"es5-ext/string/#/contains":56}],17:[function(require,module,exports){
+(function (process,Buffer){
+var stream = require('readable-stream')
+var eos = require('end-of-stream')
+var inherits = require('inherits')
+var shift = require('stream-shift')
+
+var SIGNAL_FLUSH = (Buffer.from && Buffer.from !== Uint8Array.from)
+ ? Buffer.from([0])
+ : new Buffer([0])
+
+var onuncork = function(self, fn) {
+ if (self._corked) self.once('uncork', fn)
+ else fn()
+}
+
+var autoDestroy = function (self, err) {
+ if (self._autoDestroy) self.destroy(err)
+}
+
+var destroyer = function(self, end) {
+ return function(err) {
+ if (err) autoDestroy(self, err.message === 'premature close' ? null : err)
+ else if (end && !self._ended) self.end()
+ }
+}
+
+var end = function(ws, fn) {
+ if (!ws) return fn()
+ if (ws._writableState && ws._writableState.finished) return fn()
+ if (ws._writableState) return ws.end(fn)
+ ws.end()
+ fn()
+}
+
+var toStreams2 = function(rs) {
+ return new (stream.Readable)({objectMode:true, highWaterMark:16}).wrap(rs)
+}
+
+var Duplexify = function(writable, readable, opts) {
+ if (!(this instanceof Duplexify)) return new Duplexify(writable, readable, opts)
+ stream.Duplex.call(this, opts)
+
+ this._writable = null
+ this._readable = null
+ this._readable2 = null
+
+ this._autoDestroy = !opts || opts.autoDestroy !== false
+ this._forwardDestroy = !opts || opts.destroy !== false
+ this._forwardEnd = !opts || opts.end !== false
+ this._corked = 1 // start corked
+ this._ondrain = null
+ this._drained = false
+ this._forwarding = false
+ this._unwrite = null
+ this._unread = null
+ this._ended = false
+
+ this.destroyed = false
+
+ if (writable) this.setWritable(writable)
+ if (readable) this.setReadable(readable)
+}
+
+inherits(Duplexify, stream.Duplex)
+
+Duplexify.obj = function(writable, readable, opts) {
+ if (!opts) opts = {}
+ opts.objectMode = true
+ opts.highWaterMark = 16
+ return new Duplexify(writable, readable, opts)
+}
+
+Duplexify.prototype.cork = function() {
+ if (++this._corked === 1) this.emit('cork')
+}
+
+Duplexify.prototype.uncork = function() {
+ if (this._corked && --this._corked === 0) this.emit('uncork')
+}
+
+Duplexify.prototype.setWritable = function(writable) {
+ if (this._unwrite) this._unwrite()
+
+ if (this.destroyed) {
+ if (writable && writable.destroy) writable.destroy()
+ return
+ }
+
+ if (writable === null || writable === false) {
+ this.end()
+ return
+ }
+
+ var self = this
+ var unend = eos(writable, {writable:true, readable:false}, destroyer(this, this._forwardEnd))
+
+ var ondrain = function() {
+ var ondrain = self._ondrain
+ self._ondrain = null
+ if (ondrain) ondrain()
+ }
+
+ var clear = function() {
+ self._writable.removeListener('drain', ondrain)
+ unend()
+ }
+
+ if (this._unwrite) process.nextTick(ondrain) // force a drain on stream reset to avoid livelocks
+
+ this._writable = writable
+ this._writable.on('drain', ondrain)
+ this._unwrite = clear
+
+ this.uncork() // always uncork setWritable
+}
+
+Duplexify.prototype.setReadable = function(readable) {
+ if (this._unread) this._unread()
+
+ if (this.destroyed) {
+ if (readable && readable.destroy) readable.destroy()
+ return
+ }
+
+ if (readable === null || readable === false) {
+ this.push(null)
+ this.resume()
+ return
+ }
+
+ var self = this
+ var unend = eos(readable, {writable:false, readable:true}, destroyer(this))
+
+ var onreadable = function() {
+ self._forward()
+ }
+
+ var onend = function() {
+ self.push(null)
+ }
+
+ var clear = function() {
+ self._readable2.removeListener('readable', onreadable)
+ self._readable2.removeListener('end', onend)
+ unend()
+ }
+
+ this._drained = true
+ this._readable = readable
+ this._readable2 = readable._readableState ? readable : toStreams2(readable)
+ this._readable2.on('readable', onreadable)
+ this._readable2.on('end', onend)
+ this._unread = clear
+
+ this._forward()
+}
+
+Duplexify.prototype._read = function() {
+ this._drained = true
+ this._forward()
+}
+
+Duplexify.prototype._forward = function() {
+ if (this._forwarding || !this._readable2 || !this._drained) return
+ this._forwarding = true
+
+ var data
+
+ while (this._drained && (data = shift(this._readable2)) !== null) {
+ if (this.destroyed) continue
+ this._drained = this.push(data)
+ }
+
+ this._forwarding = false
+}
+
+Duplexify.prototype.destroy = function(err) {
+ if (this.destroyed) return
+ this.destroyed = true
+
+ var self = this
+ process.nextTick(function() {
+ self._destroy(err)
+ })
+}
+
+Duplexify.prototype._destroy = function(err) {
+ if (err) {
+ var ondrain = this._ondrain
+ this._ondrain = null
+ if (ondrain) ondrain(err)
+ else this.emit('error', err)
+ }
+
+ if (this._forwardDestroy) {
+ if (this._readable && this._readable.destroy) this._readable.destroy()
+ if (this._writable && this._writable.destroy) this._writable.destroy()
+ }
+
+ this.emit('close')
+}
+
+Duplexify.prototype._write = function(data, enc, cb) {
+ if (this.destroyed) return cb()
+ if (this._corked) return onuncork(this, this._write.bind(this, data, enc, cb))
+ if (data === SIGNAL_FLUSH) return this._finish(cb)
+ if (!this._writable) return cb()
+
+ if (this._writable.write(data) === false) this._ondrain = cb
+ else cb()
+}
+
+Duplexify.prototype._finish = function(cb) {
+ var self = this
+ this.emit('preend')
+ onuncork(this, function() {
+ end(self._forwardEnd && self._writable, function() {
+ // haxx to not emit prefinish twice
+ if (self._writableState.prefinished === false) self._writableState.prefinished = true
+ self.emit('prefinish')
+ onuncork(self, cb)
+ })
+ })
+}
+
+Duplexify.prototype.end = function(data, enc, cb) {
+ if (typeof data === 'function') return this.end(null, null, data)
+ if (typeof enc === 'function') return this.end(data, null, enc)
+ this._ended = true
+ if (data) this.write(data)
+ if (!this._writableState.ending) this.write(SIGNAL_FLUSH)
+ return stream.Writable.prototype.end.call(this, cb)
+}
+
+module.exports = Duplexify
+
+}).call(this,require('_process'),require("buffer").Buffer)
+},{"_process":92,"buffer":12,"end-of-stream":18,"inherits":80,"readable-stream":108,"stream-shift":111}],18:[function(require,module,exports){
+var once = require('once');
+
+var noop = function() {};
+
+var isRequest = function(stream) {
+ return stream.setHeader && typeof stream.abort === 'function';
+};
+
+var isChildProcess = function(stream) {
+ return stream.stdio && Array.isArray(stream.stdio) && stream.stdio.length === 3
+};
+
+var eos = function(stream, opts, callback) {
+ if (typeof opts === 'function') return eos(stream, null, opts);
+ if (!opts) opts = {};
+
+ callback = once(callback || noop);
+
+ var ws = stream._writableState;
+ var rs = stream._readableState;
+ var readable = opts.readable || (opts.readable !== false && stream.readable);
+ var writable = opts.writable || (opts.writable !== false && stream.writable);
+
+ var onlegacyfinish = function() {
+ if (!stream.writable) onfinish();
+ };
+
+ var onfinish = function() {
+ writable = false;
+ if (!readable) callback.call(stream);
+ };
+
+ var onend = function() {
+ readable = false;
+ if (!writable) callback.call(stream);
+ };
+
+ var onexit = function(exitCode) {
+ callback.call(stream, exitCode ? new Error('exited with error code: ' + exitCode) : null);
+ };
+
+ var onerror = function(err) {
+ callback.call(stream, err);
+ };
+
+ var onclose = function() {
+ if (readable && !(rs && rs.ended)) return callback.call(stream, new Error('premature close'));
+ if (writable && !(ws && ws.ended)) return callback.call(stream, new Error('premature close'));
+ };
+
+ var onrequest = function() {
+ stream.req.on('finish', onfinish);
+ };
+
+ if (isRequest(stream)) {
+ stream.on('complete', onfinish);
+ stream.on('abort', onclose);
+ if (stream.req) onrequest();
+ else stream.on('request', onrequest);
+ } else if (writable && !ws) { // legacy streams
+ stream.on('end', onlegacyfinish);
+ stream.on('close', onlegacyfinish);
+ }
+
+ if (isChildProcess(stream)) stream.on('exit', onexit);
+
+ stream.on('end', onend);
+ stream.on('finish', onfinish);
+ if (opts.error !== false) stream.on('error', onerror);
+ stream.on('close', onclose);
+
+ return function() {
+ stream.removeListener('complete', onfinish);
+ stream.removeListener('abort', onclose);
+ stream.removeListener('request', onrequest);
+ if (stream.req) stream.req.removeListener('finish', onfinish);
+ stream.removeListener('end', onlegacyfinish);
+ stream.removeListener('close', onlegacyfinish);
+ stream.removeListener('finish', onfinish);
+ stream.removeListener('exit', onexit);
+ stream.removeListener('end', onend);
+ stream.removeListener('error', onerror);
+ stream.removeListener('close', onclose);
+ };
+};
+
+module.exports = eos;
+
+},{"once":90}],19:[function(require,module,exports){
+// Inspired by Google Closure:
+// http://closure-library.googlecode.com/svn/docs/
+// closure_goog_array_array.js.html#goog.array.clear
+
+"use strict";
+
+var value = require("../../object/valid-value");
+
+module.exports = function () {
+ value(this).length = 0;
+ return this;
+};
+
+},{"../../object/valid-value":55}],20:[function(require,module,exports){
+"use strict";
+
+var numberIsNaN = require("../../number/is-nan")
+ , toPosInt = require("../../number/to-pos-integer")
+ , value = require("../../object/valid-value")
+ , indexOf = Array.prototype.indexOf
+ , objHasOwnProperty = Object.prototype.hasOwnProperty
+ , abs = Math.abs
+ , floor = Math.floor;
+
+module.exports = function (searchElement /*, fromIndex*/) {
+ var i, length, fromIndex, val;
+ if (!numberIsNaN(searchElement)) return indexOf.apply(this, arguments);
+
+ length = toPosInt(value(this).length);
+ fromIndex = arguments[1];
+ if (isNaN(fromIndex)) fromIndex = 0;
+ else if (fromIndex >= 0) fromIndex = floor(fromIndex);
+ else fromIndex = toPosInt(this.length) - floor(abs(fromIndex));
+
+ for (i = fromIndex; i < length; ++i) {
+ if (objHasOwnProperty.call(this, i)) {
+ val = this[i];
+ if (numberIsNaN(val)) return i; // Jslint: ignore
+ }
+ }
+ return -1;
+};
+
+},{"../../number/is-nan":30,"../../number/to-pos-integer":34,"../../object/valid-value":55}],21:[function(require,module,exports){
+"use strict";
+
+module.exports = require("./is-implemented")()
+ ? Array.from
+ : require("./shim");
+
+},{"./is-implemented":22,"./shim":23}],22:[function(require,module,exports){
+"use strict";
+
+module.exports = function () {
+ var from = Array.from, arr, result;
+ if (typeof from !== "function") return false;
+ arr = ["raz", "dwa"];
+ result = from(arr);
+ return Boolean(result && (result !== arr) && (result[1] === "dwa"));
+};
+
+},{}],23:[function(require,module,exports){
+"use strict";
+
+var iteratorSymbol = require("es6-symbol").iterator
+ , isArguments = require("../../function/is-arguments")
+ , isFunction = require("../../function/is-function")
+ , toPosInt = require("../../number/to-pos-integer")
+ , callable = require("../../object/valid-callable")
+ , validValue = require("../../object/valid-value")
+ , isValue = require("../../object/is-value")
+ , isString = require("../../string/is-string")
+ , isArray = Array.isArray
+ , call = Function.prototype.call
+ , desc = { configurable: true, enumerable: true, writable: true, value: null }
+ , defineProperty = Object.defineProperty;
+
+// eslint-disable-next-line complexity
+module.exports = function (arrayLike /*, mapFn, thisArg*/) {
+ var mapFn = arguments[1]
+ , thisArg = arguments[2]
+ , Context
+ , i
+ , j
+ , arr
+ , length
+ , code
+ , iterator
+ , result
+ , getIterator
+ , value;
+
+ arrayLike = Object(validValue(arrayLike));
+
+ if (isValue(mapFn)) callable(mapFn);
+ if (!this || this === Array || !isFunction(this)) {
+ // Result: Plain array
+ if (!mapFn) {
+ if (isArguments(arrayLike)) {
+ // Source: Arguments
+ length = arrayLike.length;
+ if (length !== 1) return Array.apply(null, arrayLike);
+ arr = new Array(1);
+ arr[0] = arrayLike[0];
+ return arr;
+ }
+ if (isArray(arrayLike)) {
+ // Source: Array
+ arr = new Array(length = arrayLike.length);
+ for (i = 0; i < length; ++i) arr[i] = arrayLike[i];
+ return arr;
+ }
+ }
+ arr = [];
+ } else {
+ // Result: Non plain array
+ Context = this;
+ }
+
+ if (!isArray(arrayLike)) {
+ if ((getIterator = arrayLike[iteratorSymbol]) !== undefined) {
+ // Source: Iterator
+ iterator = callable(getIterator).call(arrayLike);
+ if (Context) arr = new Context();
+ result = iterator.next();
+ i = 0;
+ while (!result.done) {
+ value = mapFn ? call.call(mapFn, thisArg, result.value, i) : result.value;
+ if (Context) {
+ desc.value = value;
+ defineProperty(arr, i, desc);
+ } else {
+ arr[i] = value;
+ }
+ result = iterator.next();
+ ++i;
+ }
+ length = i;
+ } else if (isString(arrayLike)) {
+ // Source: String
+ length = arrayLike.length;
+ if (Context) arr = new Context();
+ for (i = 0, j = 0; i < length; ++i) {
+ value = arrayLike[i];
+ if (i + 1 < length) {
+ code = value.charCodeAt(0);
+ // eslint-disable-next-line max-depth
+ if (code >= 0xd800 && code <= 0xdbff) value += arrayLike[++i];
+ }
+ value = mapFn ? call.call(mapFn, thisArg, value, j) : value;
+ if (Context) {
+ desc.value = value;
+ defineProperty(arr, j, desc);
+ } else {
+ arr[j] = value;
+ }
+ ++j;
+ }
+ length = j;
+ }
+ }
+ if (length === undefined) {
+ // Source: array or array-like
+ length = toPosInt(arrayLike.length);
+ if (Context) arr = new Context(length);
+ for (i = 0; i < length; ++i) {
+ value = mapFn ? call.call(mapFn, thisArg, arrayLike[i], i) : arrayLike[i];
+ if (Context) {
+ desc.value = value;
+ defineProperty(arr, i, desc);
+ } else {
+ arr[i] = value;
+ }
+ }
+ }
+ if (Context) {
+ desc.value = null;
+ arr.length = length;
+ }
+ return arr;
+};
+
+},{"../../function/is-arguments":24,"../../function/is-function":25,"../../number/to-pos-integer":34,"../../object/is-value":44,"../../object/valid-callable":54,"../../object/valid-value":55,"../../string/is-string":59,"es6-symbol":73}],24:[function(require,module,exports){
+"use strict";
+
+var objToString = Object.prototype.toString
+ , id = objToString.call(
+ (function () {
+ return arguments;
+ })()
+);
+
+module.exports = function (value) {
+ return objToString.call(value) === id;
+};
+
+},{}],25:[function(require,module,exports){
+"use strict";
+
+var objToString = Object.prototype.toString, id = objToString.call(require("./noop"));
+
+module.exports = function (value) {
+ return typeof value === "function" && objToString.call(value) === id;
+};
+
+},{"./noop":26}],26:[function(require,module,exports){
+"use strict";
+
+// eslint-disable-next-line no-empty-function
+module.exports = function () {};
+
+},{}],27:[function(require,module,exports){
+"use strict";
+
+module.exports = require("./is-implemented")()
+ ? Math.sign
+ : require("./shim");
+
+},{"./is-implemented":28,"./shim":29}],28:[function(require,module,exports){
+"use strict";
+
+module.exports = function () {
+ var sign = Math.sign;
+ if (typeof sign !== "function") return false;
+ return (sign(10) === 1) && (sign(-20) === -1);
+};
+
+},{}],29:[function(require,module,exports){
+"use strict";
+
+module.exports = function (value) {
+ value = Number(value);
+ if (isNaN(value) || (value === 0)) return value;
+ return value > 0 ? 1 : -1;
+};
+
+},{}],30:[function(require,module,exports){
+"use strict";
+
+module.exports = require("./is-implemented")()
+ ? Number.isNaN
+ : require("./shim");
+
+},{"./is-implemented":31,"./shim":32}],31:[function(require,module,exports){
+"use strict";
+
+module.exports = function () {
+ var numberIsNaN = Number.isNaN;
+ if (typeof numberIsNaN !== "function") return false;
+ return !numberIsNaN({}) && numberIsNaN(NaN) && !numberIsNaN(34);
+};
+
+},{}],32:[function(require,module,exports){
+"use strict";
+
+module.exports = function (value) {
+ // eslint-disable-next-line no-self-compare
+ return value !== value;
+};
+
+},{}],33:[function(require,module,exports){
+"use strict";
+
+var sign = require("../math/sign")
+
+ , abs = Math.abs, floor = Math.floor;
+
+module.exports = function (value) {
+ if (isNaN(value)) return 0;
+ value = Number(value);
+ if ((value === 0) || !isFinite(value)) return value;
+ return sign(value) * floor(abs(value));
+};
+
+},{"../math/sign":27}],34:[function(require,module,exports){
+"use strict";
+
+var toInteger = require("./to-integer")
+
+ , max = Math.max;
+
+module.exports = function (value) {
+ return max(0, toInteger(value));
+};
+
+},{"./to-integer":33}],35:[function(require,module,exports){
+// Internal method, used by iteration functions.
+// Calls a function for each key-value pair found in object
+// Optionally takes compareFn to iterate object in specific order
+
+"use strict";
+
+var callable = require("./valid-callable")
+ , value = require("./valid-value")
+ , bind = Function.prototype.bind
+ , call = Function.prototype.call
+ , keys = Object.keys
+ , objPropertyIsEnumerable = Object.prototype.propertyIsEnumerable;
+
+module.exports = function (method, defVal) {
+ return function (obj, cb /*, thisArg, compareFn*/) {
+ var list, thisArg = arguments[2], compareFn = arguments[3];
+ obj = Object(value(obj));
+ callable(cb);
+
+ list = keys(obj);
+ if (compareFn) {
+ list.sort(typeof compareFn === "function" ? bind.call(compareFn, obj) : undefined);
+ }
+ if (typeof method !== "function") method = list[method];
+ return call.call(method, list, function (key, index) {
+ if (!objPropertyIsEnumerable.call(obj, key)) return defVal;
+ return call.call(cb, thisArg, obj[key], key, obj, index);
+ });
+ };
+};
+
+},{"./valid-callable":54,"./valid-value":55}],36:[function(require,module,exports){
+"use strict";
+
+module.exports = require("./is-implemented")()
+ ? Object.assign
+ : require("./shim");
+
+},{"./is-implemented":37,"./shim":38}],37:[function(require,module,exports){
+"use strict";
+
+module.exports = function () {
+ var assign = Object.assign, obj;
+ if (typeof assign !== "function") return false;
+ obj = { foo: "raz" };
+ assign(obj, { bar: "dwa" }, { trzy: "trzy" });
+ return (obj.foo + obj.bar + obj.trzy) === "razdwatrzy";
+};
+
+},{}],38:[function(require,module,exports){
+"use strict";
+
+var keys = require("../keys")
+ , value = require("../valid-value")
+ , max = Math.max;
+
+module.exports = function (dest, src /*, …srcn*/) {
+ var error, i, length = max(arguments.length, 2), assign;
+ dest = Object(value(dest));
+ assign = function (key) {
+ try {
+ dest[key] = src[key];
+ } catch (e) {
+ if (!error) error = e;
+ }
+ };
+ for (i = 1; i < length; ++i) {
+ src = arguments[i];
+ keys(src).forEach(assign);
+ }
+ if (error !== undefined) throw error;
+ return dest;
+};
+
+},{"../keys":45,"../valid-value":55}],39:[function(require,module,exports){
+"use strict";
+
+var aFrom = require("../array/from")
+ , assign = require("./assign")
+ , value = require("./valid-value");
+
+module.exports = function (obj/*, propertyNames, options*/) {
+ var copy = Object(value(obj)), propertyNames = arguments[1], options = Object(arguments[2]);
+ if (copy !== obj && !propertyNames) return copy;
+ var result = {};
+ if (propertyNames) {
+ aFrom(propertyNames, function (propertyName) {
+ if (options.ensure || propertyName in obj) result[propertyName] = obj[propertyName];
+ });
+ } else {
+ assign(result, obj);
+ }
+ return result;
+};
+
+},{"../array/from":21,"./assign":36,"./valid-value":55}],40:[function(require,module,exports){
+// Workaround for http://code.google.com/p/v8/issues/detail?id=2804
+
+"use strict";
+
+var create = Object.create, shim;
+
+if (!require("./set-prototype-of/is-implemented")()) {
+ shim = require("./set-prototype-of/shim");
+}
+
+module.exports = (function () {
+ var nullObject, polyProps, desc;
+ if (!shim) return create;
+ if (shim.level !== 1) return create;
+
+ nullObject = {};
+ polyProps = {};
+ desc = {
+ configurable: false,
+ enumerable: false,
+ writable: true,
+ value: undefined
+ };
+ Object.getOwnPropertyNames(Object.prototype).forEach(function (name) {
+ if (name === "__proto__") {
+ polyProps[name] = {
+ configurable: true,
+ enumerable: false,
+ writable: true,
+ value: undefined
+ };
+ return;
+ }
+ polyProps[name] = desc;
+ });
+ Object.defineProperties(nullObject, polyProps);
+
+ Object.defineProperty(shim, "nullPolyfill", {
+ configurable: false,
+ enumerable: false,
+ writable: false,
+ value: nullObject
+ });
+
+ return function (prototype, props) {
+ return create(prototype === null ? nullObject : prototype, props);
+ };
+}());
+
+},{"./set-prototype-of/is-implemented":52,"./set-prototype-of/shim":53}],41:[function(require,module,exports){
+"use strict";
+
+module.exports = require("./_iterate")("forEach");
+
+},{"./_iterate":35}],42:[function(require,module,exports){
+// Deprecated
+
+"use strict";
+
+module.exports = function (obj) {
+ return typeof obj === "function";
+};
+
+},{}],43:[function(require,module,exports){
+"use strict";
+
+var isValue = require("./is-value");
+
+var map = { function: true, object: true };
+
+module.exports = function (value) {
+ return (isValue(value) && map[typeof value]) || false;
+};
+
+},{"./is-value":44}],44:[function(require,module,exports){
+"use strict";
+
+var _undefined = require("../function/noop")(); // Support ES3 engines
+
+module.exports = function (val) {
+ return (val !== _undefined) && (val !== null);
+};
+
+},{"../function/noop":26}],45:[function(require,module,exports){
+"use strict";
+
+module.exports = require("./is-implemented")() ? Object.keys : require("./shim");
+
+},{"./is-implemented":46,"./shim":47}],46:[function(require,module,exports){
+"use strict";
+
+module.exports = function () {
+ try {
+ Object.keys("primitive");
+ return true;
+ } catch (e) {
+ return false;
+ }
+};
+
+},{}],47:[function(require,module,exports){
+"use strict";
+
+var isValue = require("../is-value");
+
+var keys = Object.keys;
+
+module.exports = function (object) { return keys(isValue(object) ? Object(object) : object); };
+
+},{"../is-value":44}],48:[function(require,module,exports){
+"use strict";
+
+var callable = require("./valid-callable")
+ , forEach = require("./for-each")
+ , call = Function.prototype.call;
+
+module.exports = function (obj, cb /*, thisArg*/) {
+ var result = {}, thisArg = arguments[2];
+ callable(cb);
+ forEach(obj, function (value, key, targetObj, index) {
+ result[key] = call.call(cb, thisArg, value, key, targetObj, index);
+ });
+ return result;
+};
+
+},{"./for-each":41,"./valid-callable":54}],49:[function(require,module,exports){
+"use strict";
+
+var isValue = require("./is-value");
+
+var forEach = Array.prototype.forEach, create = Object.create;
+
+var process = function (src, obj) {
+ var key;
+ for (key in src) obj[key] = src[key];
+};
+
+// eslint-disable-next-line no-unused-vars
+module.exports = function (opts1 /*, …options*/) {
+ var result = create(null);
+ forEach.call(arguments, function (options) {
+ if (!isValue(options)) return;
+ process(Object(options), result);
+ });
+ return result;
+};
+
+},{"./is-value":44}],50:[function(require,module,exports){
+"use strict";
+
+var forEach = Array.prototype.forEach, create = Object.create;
+
+// eslint-disable-next-line no-unused-vars
+module.exports = function (arg /*, …args*/) {
+ var set = create(null);
+ forEach.call(arguments, function (name) {
+ set[name] = true;
+ });
+ return set;
+};
+
+},{}],51:[function(require,module,exports){
+"use strict";
+
+module.exports = require("./is-implemented")()
+ ? Object.setPrototypeOf
+ : require("./shim");
+
+},{"./is-implemented":52,"./shim":53}],52:[function(require,module,exports){
+"use strict";
+
+var create = Object.create, getPrototypeOf = Object.getPrototypeOf, plainObject = {};
+
+module.exports = function (/* CustomCreate*/) {
+ var setPrototypeOf = Object.setPrototypeOf, customCreate = arguments[0] || create;
+ if (typeof setPrototypeOf !== "function") return false;
+ return getPrototypeOf(setPrototypeOf(customCreate(null), plainObject)) === plainObject;
+};
+
+},{}],53:[function(require,module,exports){
+/* eslint no-proto: "off" */
+
+// Big thanks to @WebReflection for sorting this out
+// https://gist.github.com/WebReflection/5593554
+
+"use strict";
+
+var isObject = require("../is-object")
+ , value = require("../valid-value")
+ , objIsPrototypeOf = Object.prototype.isPrototypeOf
+ , defineProperty = Object.defineProperty
+ , nullDesc = {
+ configurable: true,
+ enumerable: false,
+ writable: true,
+ value: undefined
+}
+ , validate;
+
+validate = function (obj, prototype) {
+ value(obj);
+ if (prototype === null || isObject(prototype)) return obj;
+ throw new TypeError("Prototype must be null or an object");
+};
+
+module.exports = (function (status) {
+ var fn, set;
+ if (!status) return null;
+ if (status.level === 2) {
+ if (status.set) {
+ set = status.set;
+ fn = function (obj, prototype) {
+ set.call(validate(obj, prototype), prototype);
+ return obj;
+ };
+ } else {
+ fn = function (obj, prototype) {
+ validate(obj, prototype).__proto__ = prototype;
+ return obj;
+ };
+ }
+ } else {
+ fn = function self(obj, prototype) {
+ var isNullBase;
+ validate(obj, prototype);
+ isNullBase = objIsPrototypeOf.call(self.nullPolyfill, obj);
+ if (isNullBase) delete self.nullPolyfill.__proto__;
+ if (prototype === null) prototype = self.nullPolyfill;
+ obj.__proto__ = prototype;
+ if (isNullBase) defineProperty(self.nullPolyfill, "__proto__", nullDesc);
+ return obj;
+ };
+ }
+ return Object.defineProperty(fn, "level", {
+ configurable: false,
+ enumerable: false,
+ writable: false,
+ value: status.level
+ });
+}(
+ (function () {
+ var tmpObj1 = Object.create(null)
+ , tmpObj2 = {}
+ , set
+ , desc = Object.getOwnPropertyDescriptor(Object.prototype, "__proto__");
+
+ if (desc) {
+ try {
+ set = desc.set; // Opera crashes at this point
+ set.call(tmpObj1, tmpObj2);
+ } catch (ignore) {}
+ if (Object.getPrototypeOf(tmpObj1) === tmpObj2) return { set: set, level: 2 };
+ }
+
+ tmpObj1.__proto__ = tmpObj2;
+ if (Object.getPrototypeOf(tmpObj1) === tmpObj2) return { level: 2 };
+
+ tmpObj1 = {};
+ tmpObj1.__proto__ = tmpObj2;
+ if (Object.getPrototypeOf(tmpObj1) === tmpObj2) return { level: 1 };
+
+ return false;
+ })()
+));
+
+require("../create");
+
+},{"../create":40,"../is-object":43,"../valid-value":55}],54:[function(require,module,exports){
+"use strict";
+
+module.exports = function (fn) {
+ if (typeof fn !== "function") throw new TypeError(fn + " is not a function");
+ return fn;
+};
+
+},{}],55:[function(require,module,exports){
+"use strict";
+
+var isValue = require("./is-value");
+
+module.exports = function (value) {
+ if (!isValue(value)) throw new TypeError("Cannot use null or undefined");
+ return value;
+};
+
+},{"./is-value":44}],56:[function(require,module,exports){
+"use strict";
+
+module.exports = require("./is-implemented")()
+ ? String.prototype.contains
+ : require("./shim");
+
+},{"./is-implemented":57,"./shim":58}],57:[function(require,module,exports){
+"use strict";
+
+var str = "razdwatrzy";
+
+module.exports = function () {
+ if (typeof str.contains !== "function") return false;
+ return (str.contains("dwa") === true) && (str.contains("foo") === false);
+};
+
+},{}],58:[function(require,module,exports){
+"use strict";
+
+var indexOf = String.prototype.indexOf;
+
+module.exports = function (searchString/*, position*/) {
+ return indexOf.call(this, searchString, arguments[1]) > -1;
+};
+
+},{}],59:[function(require,module,exports){
+"use strict";
+
+var objToString = Object.prototype.toString, id = objToString.call("");
+
+module.exports = function (value) {
+ return (
+ typeof value === "string" ||
+ (value &&
+ typeof value === "object" &&
+ (value instanceof String || objToString.call(value) === id)) ||
+ false
+ );
+};
+
+},{}],60:[function(require,module,exports){
+"use strict";
+
+var setPrototypeOf = require("es5-ext/object/set-prototype-of")
+ , contains = require("es5-ext/string/#/contains")
+ , d = require("d")
+ , Symbol = require("es6-symbol")
+ , Iterator = require("./");
+
+var defineProperty = Object.defineProperty, ArrayIterator;
+
+ArrayIterator = module.exports = function (arr, kind) {
+ if (!(this instanceof ArrayIterator)) throw new TypeError("Constructor requires 'new'");
+ Iterator.call(this, arr);
+ if (!kind) kind = "value";
+ else if (contains.call(kind, "key+value")) kind = "key+value";
+ else if (contains.call(kind, "key")) kind = "key";
+ else kind = "value";
+ defineProperty(this, "__kind__", d("", kind));
+};
+if (setPrototypeOf) setPrototypeOf(ArrayIterator, Iterator);
+
+// Internal %ArrayIteratorPrototype% doesn't expose its constructor
+delete ArrayIterator.prototype.constructor;
+
+ArrayIterator.prototype = Object.create(Iterator.prototype, {
+ _resolve: d(function (i) {
+ if (this.__kind__ === "value") return this.__list__[i];
+ if (this.__kind__ === "key+value") return [i, this.__list__[i]];
+ return i;
+ })
+});
+defineProperty(ArrayIterator.prototype, Symbol.toStringTag, d("c", "Array Iterator"));
+
+},{"./":63,"d":16,"es5-ext/object/set-prototype-of":51,"es5-ext/string/#/contains":56,"es6-symbol":73}],61:[function(require,module,exports){
+"use strict";
+
+var isArguments = require("es5-ext/function/is-arguments")
+ , callable = require("es5-ext/object/valid-callable")
+ , isString = require("es5-ext/string/is-string")
+ , get = require("./get");
+
+var isArray = Array.isArray, call = Function.prototype.call, some = Array.prototype.some;
+
+module.exports = function (iterable, cb /*, thisArg*/) {
+ var mode, thisArg = arguments[2], result, doBreak, broken, i, length, char, code;
+ if (isArray(iterable) || isArguments(iterable)) mode = "array";
+ else if (isString(iterable)) mode = "string";
+ else iterable = get(iterable);
+
+ callable(cb);
+ doBreak = function () {
+ broken = true;
+ };
+ if (mode === "array") {
+ some.call(iterable, function (value) {
+ call.call(cb, thisArg, value, doBreak);
+ return broken;
+ });
+ return;
+ }
+ if (mode === "string") {
+ length = iterable.length;
+ for (i = 0; i < length; ++i) {
+ char = iterable[i];
+ if (i + 1 < length) {
+ code = char.charCodeAt(0);
+ if (code >= 0xd800 && code <= 0xdbff) char += iterable[++i];
+ }
+ call.call(cb, thisArg, char, doBreak);
+ if (broken) break;
+ }
+ return;
+ }
+ result = iterable.next();
+
+ while (!result.done) {
+ call.call(cb, thisArg, result.value, doBreak);
+ if (broken) return;
+ result = iterable.next();
+ }
+};
+
+},{"./get":62,"es5-ext/function/is-arguments":24,"es5-ext/object/valid-callable":54,"es5-ext/string/is-string":59}],62:[function(require,module,exports){
+"use strict";
+
+var isArguments = require("es5-ext/function/is-arguments")
+ , isString = require("es5-ext/string/is-string")
+ , ArrayIterator = require("./array")
+ , StringIterator = require("./string")
+ , iterable = require("./valid-iterable")
+ , iteratorSymbol = require("es6-symbol").iterator;
+
+module.exports = function (obj) {
+ if (typeof iterable(obj)[iteratorSymbol] === "function") return obj[iteratorSymbol]();
+ if (isArguments(obj)) return new ArrayIterator(obj);
+ if (isString(obj)) return new StringIterator(obj);
+ return new ArrayIterator(obj);
+};
+
+},{"./array":60,"./string":65,"./valid-iterable":66,"es5-ext/function/is-arguments":24,"es5-ext/string/is-string":59,"es6-symbol":73}],63:[function(require,module,exports){
+"use strict";
+
+var clear = require("es5-ext/array/#/clear")
+ , assign = require("es5-ext/object/assign")
+ , callable = require("es5-ext/object/valid-callable")
+ , value = require("es5-ext/object/valid-value")
+ , d = require("d")
+ , autoBind = require("d/auto-bind")
+ , Symbol = require("es6-symbol");
+
+var defineProperty = Object.defineProperty, defineProperties = Object.defineProperties, Iterator;
+
+module.exports = Iterator = function (list, context) {
+ if (!(this instanceof Iterator)) throw new TypeError("Constructor requires 'new'");
+ defineProperties(this, {
+ __list__: d("w", value(list)),
+ __context__: d("w", context),
+ __nextIndex__: d("w", 0)
+ });
+ if (!context) return;
+ callable(context.on);
+ context.on("_add", this._onAdd);
+ context.on("_delete", this._onDelete);
+ context.on("_clear", this._onClear);
+};
+
+// Internal %IteratorPrototype% doesn't expose its constructor
+delete Iterator.prototype.constructor;
+
+defineProperties(
+ Iterator.prototype,
+ assign(
+ {
+ _next: d(function () {
+ var i;
+ if (!this.__list__) return undefined;
+ if (this.__redo__) {
+ i = this.__redo__.shift();
+ if (i !== undefined) return i;
+ }
+ if (this.__nextIndex__ < this.__list__.length) return this.__nextIndex__++;
+ this._unBind();
+ return undefined;
+ }),
+ next: d(function () {
+ return this._createResult(this._next());
+ }),
+ _createResult: d(function (i) {
+ if (i === undefined) return { done: true, value: undefined };
+ return { done: false, value: this._resolve(i) };
+ }),
+ _resolve: d(function (i) {
+ return this.__list__[i];
+ }),
+ _unBind: d(function () {
+ this.__list__ = null;
+ delete this.__redo__;
+ if (!this.__context__) return;
+ this.__context__.off("_add", this._onAdd);
+ this.__context__.off("_delete", this._onDelete);
+ this.__context__.off("_clear", this._onClear);
+ this.__context__ = null;
+ }),
+ toString: d(function () {
+ return "[object " + (this[Symbol.toStringTag] || "Object") + "]";
+ })
+ },
+ autoBind({
+ _onAdd: d(function (index) {
+ if (index >= this.__nextIndex__) return;
+ ++this.__nextIndex__;
+ if (!this.__redo__) {
+ defineProperty(this, "__redo__", d("c", [index]));
+ return;
+ }
+ this.__redo__.forEach(function (redo, i) {
+ if (redo >= index) this.__redo__[i] = ++redo;
+ }, this);
+ this.__redo__.push(index);
+ }),
+ _onDelete: d(function (index) {
+ var i;
+ if (index >= this.__nextIndex__) return;
+ --this.__nextIndex__;
+ if (!this.__redo__) return;
+ i = this.__redo__.indexOf(index);
+ if (i !== -1) this.__redo__.splice(i, 1);
+ this.__redo__.forEach(function (redo, j) {
+ if (redo > index) this.__redo__[j] = --redo;
+ }, this);
+ }),
+ _onClear: d(function () {
+ if (this.__redo__) clear.call(this.__redo__);
+ this.__nextIndex__ = 0;
+ })
+ })
+ )
+);
+
+defineProperty(
+ Iterator.prototype,
+ Symbol.iterator,
+ d(function () {
+ return this;
+ })
+);
+
+},{"d":16,"d/auto-bind":15,"es5-ext/array/#/clear":19,"es5-ext/object/assign":36,"es5-ext/object/valid-callable":54,"es5-ext/object/valid-value":55,"es6-symbol":73}],64:[function(require,module,exports){
+"use strict";
+
+var isArguments = require("es5-ext/function/is-arguments")
+ , isValue = require("es5-ext/object/is-value")
+ , isString = require("es5-ext/string/is-string");
+
+var iteratorSymbol = require("es6-symbol").iterator
+ , isArray = Array.isArray;
+
+module.exports = function (value) {
+ if (!isValue(value)) return false;
+ if (isArray(value)) return true;
+ if (isString(value)) return true;
+ if (isArguments(value)) return true;
+ return typeof value[iteratorSymbol] === "function";
+};
+
+},{"es5-ext/function/is-arguments":24,"es5-ext/object/is-value":44,"es5-ext/string/is-string":59,"es6-symbol":73}],65:[function(require,module,exports){
+// Thanks @mathiasbynens
+// http://mathiasbynens.be/notes/javascript-unicode#iterating-over-symbols
+
+"use strict";
+
+var setPrototypeOf = require("es5-ext/object/set-prototype-of")
+ , d = require("d")
+ , Symbol = require("es6-symbol")
+ , Iterator = require("./");
+
+var defineProperty = Object.defineProperty, StringIterator;
+
+StringIterator = module.exports = function (str) {
+ if (!(this instanceof StringIterator)) throw new TypeError("Constructor requires 'new'");
+ str = String(str);
+ Iterator.call(this, str);
+ defineProperty(this, "__length__", d("", str.length));
+};
+if (setPrototypeOf) setPrototypeOf(StringIterator, Iterator);
+
+// Internal %ArrayIteratorPrototype% doesn't expose its constructor
+delete StringIterator.prototype.constructor;
+
+StringIterator.prototype = Object.create(Iterator.prototype, {
+ _next: d(function () {
+ if (!this.__list__) return undefined;
+ if (this.__nextIndex__ < this.__length__) return this.__nextIndex__++;
+ this._unBind();
+ return undefined;
+ }),
+ _resolve: d(function (i) {
+ var char = this.__list__[i], code;
+ if (this.__nextIndex__ === this.__length__) return char;
+ code = char.charCodeAt(0);
+ if (code >= 0xd800 && code <= 0xdbff) return char + this.__list__[this.__nextIndex__++];
+ return char;
+ })
+});
+defineProperty(StringIterator.prototype, Symbol.toStringTag, d("c", "String Iterator"));
+
+},{"./":63,"d":16,"es5-ext/object/set-prototype-of":51,"es6-symbol":73}],66:[function(require,module,exports){
+"use strict";
+
+var isIterable = require("./is-iterable");
+
+module.exports = function (value) {
+ if (!isIterable(value)) throw new TypeError(value + " is not iterable");
+ return value;
+};
+
+},{"./is-iterable":64}],67:[function(require,module,exports){
+'use strict';
+
+module.exports = require('./is-implemented')() ? Map : require('./polyfill');
+
+},{"./is-implemented":68,"./polyfill":72}],68:[function(require,module,exports){
+'use strict';
+
+module.exports = function () {
+ var map, iterator, result;
+ if (typeof Map !== 'function') return false;
+ try {
+ // WebKit doesn't support arguments and crashes
+ map = new Map([['raz', 'one'], ['dwa', 'two'], ['trzy', 'three']]);
+ } catch (e) {
+ return false;
+ }
+ if (String(map) !== '[object Map]') return false;
+ if (map.size !== 3) return false;
+ if (typeof map.clear !== 'function') return false;
+ if (typeof map.delete !== 'function') return false;
+ if (typeof map.entries !== 'function') return false;
+ if (typeof map.forEach !== 'function') return false;
+ if (typeof map.get !== 'function') return false;
+ if (typeof map.has !== 'function') return false;
+ if (typeof map.keys !== 'function') return false;
+ if (typeof map.set !== 'function') return false;
+ if (typeof map.values !== 'function') return false;
+
+ iterator = map.entries();
+ result = iterator.next();
+ if (result.done !== false) return false;
+ if (!result.value) return false;
+ if (result.value[0] !== 'raz') return false;
+ if (result.value[1] !== 'one') return false;
+
+ return true;
+};
+
+},{}],69:[function(require,module,exports){
+// Exports true if environment provides native `Map` implementation,
+// whatever that is.
+
+'use strict';
+
+module.exports = (function () {
+ if (typeof Map === 'undefined') return false;
+ return (Object.prototype.toString.call(new Map()) === '[object Map]');
+}());
+
+},{}],70:[function(require,module,exports){
+'use strict';
+
+module.exports = require('es5-ext/object/primitive-set')('key',
+ 'value', 'key+value');
+
+},{"es5-ext/object/primitive-set":50}],71:[function(require,module,exports){
+'use strict';
+
+var setPrototypeOf = require('es5-ext/object/set-prototype-of')
+ , d = require('d')
+ , Iterator = require('es6-iterator')
+ , toStringTagSymbol = require('es6-symbol').toStringTag
+ , kinds = require('./iterator-kinds')
+
+ , defineProperties = Object.defineProperties
+ , unBind = Iterator.prototype._unBind
+ , MapIterator;
+
+MapIterator = module.exports = function (map, kind) {
+ if (!(this instanceof MapIterator)) return new MapIterator(map, kind);
+ Iterator.call(this, map.__mapKeysData__, map);
+ if (!kind || !kinds[kind]) kind = 'key+value';
+ defineProperties(this, {
+ __kind__: d('', kind),
+ __values__: d('w', map.__mapValuesData__)
+ });
+};
+if (setPrototypeOf) setPrototypeOf(MapIterator, Iterator);
+
+MapIterator.prototype = Object.create(Iterator.prototype, {
+ constructor: d(MapIterator),
+ _resolve: d(function (i) {
+ if (this.__kind__ === 'value') return this.__values__[i];
+ if (this.__kind__ === 'key') return this.__list__[i];
+ return [this.__list__[i], this.__values__[i]];
+ }),
+ _unBind: d(function () {
+ this.__values__ = null;
+ unBind.call(this);
+ }),
+ toString: d(function () { return '[object Map Iterator]'; })
+});
+Object.defineProperty(MapIterator.prototype, toStringTagSymbol,
+ d('c', 'Map Iterator'));
+
+},{"./iterator-kinds":70,"d":16,"es5-ext/object/set-prototype-of":51,"es6-iterator":63,"es6-symbol":73}],72:[function(require,module,exports){
+'use strict';
+
+var clear = require('es5-ext/array/#/clear')
+ , eIndexOf = require('es5-ext/array/#/e-index-of')
+ , setPrototypeOf = require('es5-ext/object/set-prototype-of')
+ , callable = require('es5-ext/object/valid-callable')
+ , validValue = require('es5-ext/object/valid-value')
+ , d = require('d')
+ , ee = require('event-emitter')
+ , Symbol = require('es6-symbol')
+ , iterator = require('es6-iterator/valid-iterable')
+ , forOf = require('es6-iterator/for-of')
+ , Iterator = require('./lib/iterator')
+ , isNative = require('./is-native-implemented')
+
+ , call = Function.prototype.call
+ , defineProperties = Object.defineProperties, getPrototypeOf = Object.getPrototypeOf
+ , MapPoly;
+
+module.exports = MapPoly = function (/*iterable*/) {
+ var iterable = arguments[0], keys, values, self;
+ if (!(this instanceof MapPoly)) throw new TypeError('Constructor requires \'new\'');
+ if (isNative && setPrototypeOf && (Map !== MapPoly)) {
+ self = setPrototypeOf(new Map(), getPrototypeOf(this));
+ } else {
+ self = this;
+ }
+ if (iterable != null) iterator(iterable);
+ defineProperties(self, {
+ __mapKeysData__: d('c', keys = []),
+ __mapValuesData__: d('c', values = [])
+ });
+ if (!iterable) return self;
+ forOf(iterable, function (value) {
+ var key = validValue(value)[0];
+ value = value[1];
+ if (eIndexOf.call(keys, key) !== -1) return;
+ keys.push(key);
+ values.push(value);
+ }, self);
+ return self;
+};
+
+if (isNative) {
+ if (setPrototypeOf) setPrototypeOf(MapPoly, Map);
+ MapPoly.prototype = Object.create(Map.prototype, {
+ constructor: d(MapPoly)
+ });
+}
+
+ee(defineProperties(MapPoly.prototype, {
+ clear: d(function () {
+ if (!this.__mapKeysData__.length) return;
+ clear.call(this.__mapKeysData__);
+ clear.call(this.__mapValuesData__);
+ this.emit('_clear');
+ }),
+ delete: d(function (key) {
+ var index = eIndexOf.call(this.__mapKeysData__, key);
+ if (index === -1) return false;
+ this.__mapKeysData__.splice(index, 1);
+ this.__mapValuesData__.splice(index, 1);
+ this.emit('_delete', index, key);
+ return true;
+ }),
+ entries: d(function () { return new Iterator(this, 'key+value'); }),
+ forEach: d(function (cb/*, thisArg*/) {
+ var thisArg = arguments[1], iterator, result;
+ callable(cb);
+ iterator = this.entries();
+ result = iterator._next();
+ while (result !== undefined) {
+ call.call(cb, thisArg, this.__mapValuesData__[result],
+ this.__mapKeysData__[result], this);
+ result = iterator._next();
+ }
+ }),
+ get: d(function (key) {
+ var index = eIndexOf.call(this.__mapKeysData__, key);
+ if (index === -1) return;
+ return this.__mapValuesData__[index];
+ }),
+ has: d(function (key) {
+ return (eIndexOf.call(this.__mapKeysData__, key) !== -1);
+ }),
+ keys: d(function () { return new Iterator(this, 'key'); }),
+ set: d(function (key, value) {
+ var index = eIndexOf.call(this.__mapKeysData__, key), emit;
+ if (index === -1) {
+ index = this.__mapKeysData__.push(key) - 1;
+ emit = true;
+ }
+ this.__mapValuesData__[index] = value;
+ if (emit) this.emit('_add', index, key);
+ return this;
+ }),
+ size: d.gs(function () { return this.__mapKeysData__.length; }),
+ values: d(function () { return new Iterator(this, 'value'); }),
+ toString: d(function () { return '[object Map]'; })
+}));
+Object.defineProperty(MapPoly.prototype, Symbol.iterator, d(function () {
+ return this.entries();
+}));
+Object.defineProperty(MapPoly.prototype, Symbol.toStringTag, d('c', 'Map'));
+
+},{"./is-native-implemented":69,"./lib/iterator":71,"d":16,"es5-ext/array/#/clear":19,"es5-ext/array/#/e-index-of":20,"es5-ext/object/set-prototype-of":51,"es5-ext/object/valid-callable":54,"es5-ext/object/valid-value":55,"es6-iterator/for-of":61,"es6-iterator/valid-iterable":66,"es6-symbol":73,"event-emitter":78}],73:[function(require,module,exports){
+'use strict';
+
+module.exports = require('./is-implemented')() ? Symbol : require('./polyfill');
+
+},{"./is-implemented":74,"./polyfill":76}],74:[function(require,module,exports){
+'use strict';
+
+var validTypes = { object: true, symbol: true };
+
+module.exports = function () {
+ var symbol;
+ if (typeof Symbol !== 'function') return false;
+ symbol = Symbol('test symbol');
+ try { String(symbol); } catch (e) { return false; }
+
+ // Return 'true' also for polyfills
+ if (!validTypes[typeof Symbol.iterator]) return false;
+ if (!validTypes[typeof Symbol.toPrimitive]) return false;
+ if (!validTypes[typeof Symbol.toStringTag]) return false;
+
+ return true;
+};
+
+},{}],75:[function(require,module,exports){
+'use strict';
+
+module.exports = function (x) {
+ if (!x) return false;
+ if (typeof x === 'symbol') return true;
+ if (!x.constructor) return false;
+ if (x.constructor.name !== 'Symbol') return false;
+ return (x[x.constructor.toStringTag] === 'Symbol');
+};
+
+},{}],76:[function(require,module,exports){
+// ES2015 Symbol polyfill for environments that do not (or partially) support it
+
+'use strict';
+
+var d = require('d')
+ , validateSymbol = require('./validate-symbol')
+
+ , create = Object.create, defineProperties = Object.defineProperties
+ , defineProperty = Object.defineProperty, objPrototype = Object.prototype
+ , NativeSymbol, SymbolPolyfill, HiddenSymbol, globalSymbols = create(null)
+ , isNativeSafe;
+
+if (typeof Symbol === 'function') {
+ NativeSymbol = Symbol;
+ try {
+ String(NativeSymbol());
+ isNativeSafe = true;
+ } catch (ignore) {}
+}
+
+var generateName = (function () {
+ var created = create(null);
+ return function (desc) {
+ var postfix = 0, name, ie11BugWorkaround;
+ while (created[desc + (postfix || '')]) ++postfix;
+ desc += (postfix || '');
+ created[desc] = true;
+ name = '@@' + desc;
+ defineProperty(objPrototype, name, d.gs(null, function (value) {
+ // For IE11 issue see:
+ // https://connect.microsoft.com/IE/feedbackdetail/view/1928508/
+ // ie11-broken-getters-on-dom-objects
+ // https://github.com/medikoo/es6-symbol/issues/12
+ if (ie11BugWorkaround) return;
+ ie11BugWorkaround = true;
+ defineProperty(this, name, d(value));
+ ie11BugWorkaround = false;
+ }));
+ return name;
+ };
+}());
+
+// Internal constructor (not one exposed) for creating Symbol instances.
+// This one is used to ensure that `someSymbol instanceof Symbol` always return false
+HiddenSymbol = function Symbol(description) {
+ if (this instanceof HiddenSymbol) throw new TypeError('Symbol is not a constructor');
+ return SymbolPolyfill(description);
+};
+
+// Exposed `Symbol` constructor
+// (returns instances of HiddenSymbol)
+module.exports = SymbolPolyfill = function Symbol(description) {
+ var symbol;
+ if (this instanceof Symbol) throw new TypeError('Symbol is not a constructor');
+ if (isNativeSafe) return NativeSymbol(description);
+ symbol = create(HiddenSymbol.prototype);
+ description = (description === undefined ? '' : String(description));
+ return defineProperties(symbol, {
+ __description__: d('', description),
+ __name__: d('', generateName(description))
+ });
+};
+defineProperties(SymbolPolyfill, {
+ for: d(function (key) {
+ if (globalSymbols[key]) return globalSymbols[key];
+ return (globalSymbols[key] = SymbolPolyfill(String(key)));
+ }),
+ keyFor: d(function (s) {
+ var key;
+ validateSymbol(s);
+ for (key in globalSymbols) if (globalSymbols[key] === s) return key;
+ }),
+
+ // To ensure proper interoperability with other native functions (e.g. Array.from)
+ // fallback to eventual native implementation of given symbol
+ hasInstance: d('', (NativeSymbol && NativeSymbol.hasInstance) || SymbolPolyfill('hasInstance')),
+ isConcatSpreadable: d('', (NativeSymbol && NativeSymbol.isConcatSpreadable) ||
+ SymbolPolyfill('isConcatSpreadable')),
+ iterator: d('', (NativeSymbol && NativeSymbol.iterator) || SymbolPolyfill('iterator')),
+ match: d('', (NativeSymbol && NativeSymbol.match) || SymbolPolyfill('match')),
+ replace: d('', (NativeSymbol && NativeSymbol.replace) || SymbolPolyfill('replace')),
+ search: d('', (NativeSymbol && NativeSymbol.search) || SymbolPolyfill('search')),
+ species: d('', (NativeSymbol && NativeSymbol.species) || SymbolPolyfill('species')),
+ split: d('', (NativeSymbol && NativeSymbol.split) || SymbolPolyfill('split')),
+ toPrimitive: d('', (NativeSymbol && NativeSymbol.toPrimitive) || SymbolPolyfill('toPrimitive')),
+ toStringTag: d('', (NativeSymbol && NativeSymbol.toStringTag) || SymbolPolyfill('toStringTag')),
+ unscopables: d('', (NativeSymbol && NativeSymbol.unscopables) || SymbolPolyfill('unscopables'))
+});
+
+// Internal tweaks for real symbol producer
+defineProperties(HiddenSymbol.prototype, {
+ constructor: d(SymbolPolyfill),
+ toString: d('', function () { return this.__name__; })
+});
+
+// Proper implementation of methods exposed on Symbol.prototype
+// They won't be accessible on produced symbol instances as they derive from HiddenSymbol.prototype
+defineProperties(SymbolPolyfill.prototype, {
+ toString: d(function () { return 'Symbol (' + validateSymbol(this).__description__ + ')'; }),
+ valueOf: d(function () { return validateSymbol(this); })
+});
+defineProperty(SymbolPolyfill.prototype, SymbolPolyfill.toPrimitive, d('', function () {
+ var symbol = validateSymbol(this);
+ if (typeof symbol === 'symbol') return symbol;
+ return symbol.toString();
+}));
+defineProperty(SymbolPolyfill.prototype, SymbolPolyfill.toStringTag, d('c', 'Symbol'));
+
+// Proper implementaton of toPrimitive and toStringTag for returned symbol instances
+defineProperty(HiddenSymbol.prototype, SymbolPolyfill.toStringTag,
+ d('c', SymbolPolyfill.prototype[SymbolPolyfill.toStringTag]));
+
+// Note: It's important to define `toPrimitive` as last one, as some implementations
+// implement `toPrimitive` natively without implementing `toStringTag` (or other specified symbols)
+// And that may invoke error in definition flow:
+// See: https://github.com/medikoo/es6-symbol/issues/13#issuecomment-164146149
+defineProperty(HiddenSymbol.prototype, SymbolPolyfill.toPrimitive,
+ d('c', SymbolPolyfill.prototype[SymbolPolyfill.toPrimitive]));
+
+},{"./validate-symbol":77,"d":16}],77:[function(require,module,exports){
+'use strict';
+
+var isSymbol = require('./is-symbol');
+
+module.exports = function (value) {
+ if (!isSymbol(value)) throw new TypeError(value + " is not a symbol");
+ return value;
+};
+
+},{"./is-symbol":75}],78:[function(require,module,exports){
+'use strict';
+
+var d = require('d')
+ , callable = require('es5-ext/object/valid-callable')
+
+ , apply = Function.prototype.apply, call = Function.prototype.call
+ , create = Object.create, defineProperty = Object.defineProperty
+ , defineProperties = Object.defineProperties
+ , hasOwnProperty = Object.prototype.hasOwnProperty
+ , descriptor = { configurable: true, enumerable: false, writable: true }
+
+ , on, once, off, emit, methods, descriptors, base;
+
+on = function (type, listener) {
+ var data;
+
+ callable(listener);
+
+ if (!hasOwnProperty.call(this, '__ee__')) {
+ data = descriptor.value = create(null);
+ defineProperty(this, '__ee__', descriptor);
+ descriptor.value = null;
+ } else {
+ data = this.__ee__;
+ }
+ if (!data[type]) data[type] = listener;
+ else if (typeof data[type] === 'object') data[type].push(listener);
+ else data[type] = [data[type], listener];
+
+ return this;
+};
+
+once = function (type, listener) {
+ var once, self;
+
+ callable(listener);
+ self = this;
+ on.call(this, type, once = function () {
+ off.call(self, type, once);
+ apply.call(listener, this, arguments);
+ });
+
+ once.__eeOnceListener__ = listener;
+ return this;
+};
+
+off = function (type, listener) {
+ var data, listeners, candidate, i;
+
+ callable(listener);
+
+ if (!hasOwnProperty.call(this, '__ee__')) return this;
+ data = this.__ee__;
+ if (!data[type]) return this;
+ listeners = data[type];
+
+ if (typeof listeners === 'object') {
+ for (i = 0; (candidate = listeners[i]); ++i) {
+ if ((candidate === listener) ||
+ (candidate.__eeOnceListener__ === listener)) {
+ if (listeners.length === 2) data[type] = listeners[i ? 0 : 1];
+ else listeners.splice(i, 1);
+ }
+ }
+ } else {
+ if ((listeners === listener) ||
+ (listeners.__eeOnceListener__ === listener)) {
+ delete data[type];
+ }
+ }
+
+ return this;
+};
+
+emit = function (type) {
+ var i, l, listener, listeners, args;
+
+ if (!hasOwnProperty.call(this, '__ee__')) return;
+ listeners = this.__ee__[type];
+ if (!listeners) return;
+
+ if (typeof listeners === 'object') {
+ l = arguments.length;
+ args = new Array(l - 1);
+ for (i = 1; i < l; ++i) args[i - 1] = arguments[i];
+
+ listeners = listeners.slice();
+ for (i = 0; (listener = listeners[i]); ++i) {
+ apply.call(listener, this, args);
+ }
+ } else {
+ switch (arguments.length) {
+ case 1:
+ call.call(listeners, this);
+ break;
+ case 2:
+ call.call(listeners, this, arguments[1]);
+ break;
+ case 3:
+ call.call(listeners, this, arguments[1], arguments[2]);
+ break;
+ default:
+ l = arguments.length;
+ args = new Array(l - 1);
+ for (i = 1; i < l; ++i) {
+ args[i - 1] = arguments[i];
+ }
+ apply.call(listeners, this, args);
+ }
+ }
+};
+
+methods = {
+ on: on,
+ once: once,
+ off: off,
+ emit: emit
+};
+
+descriptors = {
+ on: d(on),
+ once: d(once),
+ off: d(off),
+ emit: d(emit)
+};
+
+base = defineProperties({}, descriptors);
+
+module.exports = exports = function (o) {
+ return (o == null) ? create(base) : defineProperties(Object(o), descriptors);
+};
+exports.methods = methods;
+
+},{"d":16,"es5-ext/object/valid-callable":54}],79:[function(require,module,exports){
+exports.read = function (buffer, offset, isLE, mLen, nBytes) {
+ var e, m
+ var eLen = (nBytes * 8) - mLen - 1
+ var eMax = (1 << eLen) - 1
+ var eBias = eMax >> 1
+ var nBits = -7
+ var i = isLE ? (nBytes - 1) : 0
+ var d = isLE ? -1 : 1
+ var s = buffer[offset + i]
+
+ i += d
+
+ e = s & ((1 << (-nBits)) - 1)
+ s >>= (-nBits)
+ nBits += eLen
+ for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}
+
+ m = e & ((1 << (-nBits)) - 1)
+ e >>= (-nBits)
+ nBits += mLen
+ for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}
+
+ if (e === 0) {
+ e = 1 - eBias
+ } else if (e === eMax) {
+ return m ? NaN : ((s ? -1 : 1) * Infinity)
+ } else {
+ m = m + Math.pow(2, mLen)
+ e = e - eBias
+ }
+ return (s ? -1 : 1) * m * Math.pow(2, e - mLen)
+}
+
+exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
+ var e, m, c
+ var eLen = (nBytes * 8) - mLen - 1
+ var eMax = (1 << eLen) - 1
+ var eBias = eMax >> 1
+ var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)
+ var i = isLE ? 0 : (nBytes - 1)
+ var d = isLE ? 1 : -1
+ var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0
+
+ value = Math.abs(value)
+
+ if (isNaN(value) || value === Infinity) {
+ m = isNaN(value) ? 1 : 0
+ e = eMax
+ } else {
+ e = Math.floor(Math.log(value) / Math.LN2)
+ if (value * (c = Math.pow(2, -e)) < 1) {
+ e--
+ c *= 2
+ }
+ if (e + eBias >= 1) {
+ value += rt / c
+ } else {
+ value += rt * Math.pow(2, 1 - eBias)
+ }
+ if (value * c >= 2) {
+ e++
+ c /= 2
+ }
+
+ if (e + eBias >= eMax) {
+ m = 0
+ e = eMax
+ } else if (e + eBias >= 1) {
+ m = ((value * c) - 1) * Math.pow(2, mLen)
+ e = e + eBias
+ } else {
+ m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)
+ e = 0
+ }
+ }
+
+ for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}
+
+ e = (e << mLen) | m
+ eLen += mLen
+ for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}
+
+ buffer[offset + i - d] |= s * 128
+}
+
+},{}],80:[function(require,module,exports){
+if (typeof Object.create === 'function') {
+ // implementation from standard node.js 'util' module
+ module.exports = function inherits(ctor, superCtor) {
+ ctor.super_ = superCtor
+ ctor.prototype = Object.create(superCtor.prototype, {
+ constructor: {
+ value: ctor,
+ enumerable: false,
+ writable: true,
+ configurable: true
+ }
+ });
+ };
+} else {
+ // old school shim for old browsers
+ module.exports = function inherits(ctor, superCtor) {
+ ctor.super_ = superCtor
+ var TempCtor = function () {}
+ TempCtor.prototype = superCtor.prototype
+ ctor.prototype = new TempCtor()
+ ctor.prototype.constructor = ctor
+ }
+}
+
+},{}],81:[function(require,module,exports){
+/*!
+ * Determine if an object is a Buffer
+ *
+ * @author Feross Aboukhadijeh
+ * @license MIT
+ */
+
+// The _isBuffer check is for Safari 5-7 support, because it's missing
+// Object.prototype.constructor. Remove this eventually
+module.exports = function (obj) {
+ return obj != null && (isBuffer(obj) || isSlowBuffer(obj) || !!obj._isBuffer)
+}
+
+function isBuffer (obj) {
+ return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)
+}
+
+// For Node v0.10 support. Remove this eventually.
+function isSlowBuffer (obj) {
+ return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isBuffer(obj.slice(0, 0))
+}
+
+},{}],82:[function(require,module,exports){
+'use strict'
+
+var Buffer = require('safe-buffer').Buffer
+
+/* Protocol - protocol constants */
+var protocol = module.exports
+
+/* Command code => mnemonic */
+protocol.types = {
+ 0: 'reserved',
+ 1: 'connect',
+ 2: 'connack',
+ 3: 'publish',
+ 4: 'puback',
+ 5: 'pubrec',
+ 6: 'pubrel',
+ 7: 'pubcomp',
+ 8: 'subscribe',
+ 9: 'suback',
+ 10: 'unsubscribe',
+ 11: 'unsuback',
+ 12: 'pingreq',
+ 13: 'pingresp',
+ 14: 'disconnect',
+ 15: 'auth'
+}
+
+/* Mnemonic => Command code */
+protocol.codes = {}
+for (var k in protocol.types) {
+ var v = protocol.types[k]
+ protocol.codes[v] = k
+}
+
+/* Header */
+protocol.CMD_SHIFT = 4
+protocol.CMD_MASK = 0xF0
+protocol.DUP_MASK = 0x08
+protocol.QOS_MASK = 0x03
+protocol.QOS_SHIFT = 1
+protocol.RETAIN_MASK = 0x01
+
+/* Length */
+protocol.LENGTH_MASK = 0x7F
+protocol.LENGTH_FIN_MASK = 0x80
+
+/* Connack */
+protocol.SESSIONPRESENT_MASK = 0x01
+protocol.SESSIONPRESENT_HEADER = Buffer.from([protocol.SESSIONPRESENT_MASK])
+protocol.CONNACK_HEADER = Buffer.from([protocol.codes['connack'] << protocol.CMD_SHIFT])
+
+/* Connect */
+protocol.USERNAME_MASK = 0x80
+protocol.PASSWORD_MASK = 0x40
+protocol.WILL_RETAIN_MASK = 0x20
+protocol.WILL_QOS_MASK = 0x18
+protocol.WILL_QOS_SHIFT = 3
+protocol.WILL_FLAG_MASK = 0x04
+protocol.CLEAN_SESSION_MASK = 0x02
+protocol.CONNECT_HEADER = Buffer.from([protocol.codes['connect'] << protocol.CMD_SHIFT])
+
+/* Properties */
+protocol.properties = {
+ sessionExpiryInterval: 17,
+ willDelayInterval: 24,
+ receiveMaximum: 33,
+ maximumPacketSize: 39,
+ topicAliasMaximum: 34,
+ requestResponseInformation: 25,
+ requestProblemInformation: 23,
+ userProperties: 38,
+ authenticationMethod: 21,
+ authenticationData: 22,
+ payloadFormatIndicator: 1,
+ messageExpiryInterval: 2,
+ contentType: 3,
+ responseTopic: 8,
+ correlationData: 9,
+ maximumQoS: 36,
+ retainAvailable: 37,
+ assignedClientIdentifier: 18,
+ reasonString: 31,
+ wildcardSubscriptionAvailable: 40,
+ subscriptionIdentifiersAvailable: 41,
+ sharedSubscriptionAvailable: 42,
+ serverKeepAlive: 19,
+ responseInformation: 26,
+ serverReference: 28,
+ topicAlias: 35,
+ subscriptionIdentifier: 11
+}
+protocol.propertiesCodes = {}
+for (var prop in protocol.properties) {
+ var id = protocol.properties[prop]
+ protocol.propertiesCodes[id] = prop
+}
+protocol.propertiesTypes = {
+ sessionExpiryInterval: 'int32',
+ willDelayInterval: 'int32',
+ receiveMaximum: 'int16',
+ maximumPacketSize: 'int32',
+ topicAliasMaximum: 'int16',
+ requestResponseInformation: 'byte',
+ requestProblemInformation: 'byte',
+ userProperties: 'pair',
+ authenticationMethod: 'string',
+ authenticationData: 'binary',
+ payloadFormatIndicator: 'byte',
+ messageExpiryInterval: 'int32',
+ contentType: 'string',
+ responseTopic: 'string',
+ correlationData: 'binary',
+ maximumQoS: 'int8',
+ retainAvailable: 'byte',
+ assignedClientIdentifier: 'string',
+ reasonString: 'string',
+ wildcardSubscriptionAvailable: 'byte',
+ subscriptionIdentifiersAvailable: 'byte',
+ sharedSubscriptionAvailable: 'byte',
+ serverKeepAlive: 'int32',
+ responseInformation: 'string',
+ serverReference: 'string',
+ topicAlias: 'int16',
+ subscriptionIdentifier: 'var'
+}
+
+function genHeader (type) {
+ return [0, 1, 2].map(function (qos) {
+ return [0, 1].map(function (dup) {
+ return [0, 1].map(function (retain) {
+ var buf = new Buffer(1)
+ buf.writeUInt8(
+ protocol.codes[type] << protocol.CMD_SHIFT |
+ (dup ? protocol.DUP_MASK : 0) |
+ qos << protocol.QOS_SHIFT | retain, 0, true)
+ return buf
+ })
+ })
+ })
+}
+
+/* Publish */
+protocol.PUBLISH_HEADER = genHeader('publish')
+
+/* Subscribe */
+protocol.SUBSCRIBE_HEADER = genHeader('subscribe')
+protocol.SUBSCRIBE_OPTIONS_QOS_MASK = 0x03
+protocol.SUBSCRIBE_OPTIONS_NL_MASK = 0x01
+protocol.SUBSCRIBE_OPTIONS_NL_SHIFT = 2
+protocol.SUBSCRIBE_OPTIONS_RAP_MASK = 0x01
+protocol.SUBSCRIBE_OPTIONS_RAP_SHIFT = 3
+protocol.SUBSCRIBE_OPTIONS_RH_MASK = 0x03
+protocol.SUBSCRIBE_OPTIONS_RH_SHIFT = 4
+protocol.SUBSCRIBE_OPTIONS_RH = [0x00, 0x10, 0x20]
+protocol.SUBSCRIBE_OPTIONS_NL = 0x04
+protocol.SUBSCRIBE_OPTIONS_RAP = 0x08
+protocol.SUBSCRIBE_OPTIONS_QOS = [0x00, 0x01, 0x02]
+
+/* Unsubscribe */
+protocol.UNSUBSCRIBE_HEADER = genHeader('unsubscribe')
+
+/* Confirmations */
+protocol.ACKS = {
+ unsuback: genHeader('unsuback'),
+ puback: genHeader('puback'),
+ pubcomp: genHeader('pubcomp'),
+ pubrel: genHeader('pubrel'),
+ pubrec: genHeader('pubrec')
+}
+
+protocol.SUBACK_HEADER = Buffer.from([protocol.codes['suback'] << protocol.CMD_SHIFT])
+
+/* Protocol versions */
+protocol.VERSION3 = Buffer.from([3])
+protocol.VERSION4 = Buffer.from([4])
+protocol.VERSION5 = Buffer.from([5])
+
+/* QoS */
+protocol.QOS = [0, 1, 2].map(function (qos) {
+ return Buffer.from([qos])
+})
+
+/* Empty packets */
+protocol.EMPTY = {
+ pingreq: Buffer.from([protocol.codes['pingreq'] << 4, 0]),
+ pingresp: Buffer.from([protocol.codes['pingresp'] << 4, 0]),
+ disconnect: Buffer.from([protocol.codes['disconnect'] << 4, 0])
+}
+
+},{"safe-buffer":110}],83:[function(require,module,exports){
+'use strict'
+
+var Buffer = require('safe-buffer').Buffer
+var writeToStream = require('./writeToStream')
+var EE = require('events').EventEmitter
+var inherits = require('inherits')
+
+function generate (packet, opts) {
+ var stream = new Accumulator()
+ writeToStream(packet, stream, opts)
+ return stream.concat()
+}
+
+function Accumulator () {
+ this._array = new Array(20)
+ this._i = 0
+}
+
+inherits(Accumulator, EE)
+
+Accumulator.prototype.write = function (chunk) {
+ this._array[this._i++] = chunk
+ return true
+}
+
+Accumulator.prototype.concat = function () {
+ var length = 0
+ var lengths = new Array(this._array.length)
+ var list = this._array
+ var pos = 0
+ var i
+ var result
+
+ for (i = 0; i < list.length && list[i] !== undefined; i++) {
+ if (typeof list[i] !== 'string') lengths[i] = list[i].length
+ else lengths[i] = Buffer.byteLength(list[i])
+
+ length += lengths[i]
+ }
+
+ result = Buffer.allocUnsafe(length)
+
+ for (i = 0; i < list.length && list[i] !== undefined; i++) {
+ if (typeof list[i] !== 'string') {
+ list[i].copy(result, pos)
+ pos += lengths[i]
+ } else {
+ result.write(list[i], pos)
+ pos += lengths[i]
+ }
+ }
+
+ return result
+}
+
+module.exports = generate
+
+},{"./writeToStream":89,"events":13,"inherits":80,"safe-buffer":110}],84:[function(require,module,exports){
+'use strict'
+
+exports.parser = require('./parser')
+exports.generate = require('./generate')
+exports.writeToStream = require('./writeToStream')
+
+},{"./generate":83,"./parser":88,"./writeToStream":89}],85:[function(require,module,exports){
+var DuplexStream = require('readable-stream/duplex')
+ , util = require('util')
+ , Buffer = require('safe-buffer').Buffer
+
+
+function BufferList (callback) {
+ if (!(this instanceof BufferList))
+ return new BufferList(callback)
+
+ this._bufs = []
+ this.length = 0
+
+ if (typeof callback == 'function') {
+ this._callback = callback
+
+ var piper = function piper (err) {
+ if (this._callback) {
+ this._callback(err)
+ this._callback = null
+ }
+ }.bind(this)
+
+ this.on('pipe', function onPipe (src) {
+ src.on('error', piper)
+ })
+ this.on('unpipe', function onUnpipe (src) {
+ src.removeListener('error', piper)
+ })
+ } else {
+ this.append(callback)
+ }
+
+ DuplexStream.call(this)
+}
+
+
+util.inherits(BufferList, DuplexStream)
+
+
+BufferList.prototype._offset = function _offset (offset) {
+ var tot = 0, i = 0, _t
+ if (offset === 0) return [ 0, 0 ]
+ for (; i < this._bufs.length; i++) {
+ _t = tot + this._bufs[i].length
+ if (offset < _t || i == this._bufs.length - 1)
+ return [ i, offset - tot ]
+ tot = _t
+ }
+}
+
+
+BufferList.prototype.append = function append (buf) {
+ var i = 0
+
+ if (Buffer.isBuffer(buf)) {
+ this._appendBuffer(buf);
+ } else if (Array.isArray(buf)) {
+ for (; i < buf.length; i++)
+ this.append(buf[i])
+ } else if (buf instanceof BufferList) {
+ // unwrap argument into individual BufferLists
+ for (; i < buf._bufs.length; i++)
+ this.append(buf._bufs[i])
+ } else if (buf != null) {
+ // coerce number arguments to strings, since Buffer(number) does
+ // uninitialized memory allocation
+ if (typeof buf == 'number')
+ buf = buf.toString()
+
+ this._appendBuffer(Buffer.from(buf));
+ }
+
+ return this
+}
+
+
+BufferList.prototype._appendBuffer = function appendBuffer (buf) {
+ this._bufs.push(buf)
+ this.length += buf.length
+}
+
+
+BufferList.prototype._write = function _write (buf, encoding, callback) {
+ this._appendBuffer(buf)
+
+ if (typeof callback == 'function')
+ callback()
+}
+
+
+BufferList.prototype._read = function _read (size) {
+ if (!this.length)
+ return this.push(null)
+
+ size = Math.min(size, this.length)
+ this.push(this.slice(0, size))
+ this.consume(size)
+}
+
+
+BufferList.prototype.end = function end (chunk) {
+ DuplexStream.prototype.end.call(this, chunk)
+
+ if (this._callback) {
+ this._callback(null, this.slice())
+ this._callback = null
+ }
+}
+
+
+BufferList.prototype.get = function get (index) {
+ return this.slice(index, index + 1)[0]
+}
+
+
+BufferList.prototype.slice = function slice (start, end) {
+ if (typeof start == 'number' && start < 0)
+ start += this.length
+ if (typeof end == 'number' && end < 0)
+ end += this.length
+ return this.copy(null, 0, start, end)
+}
+
+
+BufferList.prototype.copy = function copy (dst, dstStart, srcStart, srcEnd) {
+ if (typeof srcStart != 'number' || srcStart < 0)
+ srcStart = 0
+ if (typeof srcEnd != 'number' || srcEnd > this.length)
+ srcEnd = this.length
+ if (srcStart >= this.length)
+ return dst || Buffer.alloc(0)
+ if (srcEnd <= 0)
+ return dst || Buffer.alloc(0)
+
+ var copy = !!dst
+ , off = this._offset(srcStart)
+ , len = srcEnd - srcStart
+ , bytes = len
+ , bufoff = (copy && dstStart) || 0
+ , start = off[1]
+ , l
+ , i
+
+ // copy/slice everything
+ if (srcStart === 0 && srcEnd == this.length) {
+ if (!copy) { // slice, but full concat if multiple buffers
+ return this._bufs.length === 1
+ ? this._bufs[0]
+ : Buffer.concat(this._bufs, this.length)
+ }
+
+ // copy, need to copy individual buffers
+ for (i = 0; i < this._bufs.length; i++) {
+ this._bufs[i].copy(dst, bufoff)
+ bufoff += this._bufs[i].length
+ }
+
+ return dst
+ }
+
+ // easy, cheap case where it's a subset of one of the buffers
+ if (bytes <= this._bufs[off[0]].length - start) {
+ return copy
+ ? this._bufs[off[0]].copy(dst, dstStart, start, start + bytes)
+ : this._bufs[off[0]].slice(start, start + bytes)
+ }
+
+ if (!copy) // a slice, we need something to copy in to
+ dst = Buffer.allocUnsafe(len)
+
+ for (i = off[0]; i < this._bufs.length; i++) {
+ l = this._bufs[i].length - start
+
+ if (bytes > l) {
+ this._bufs[i].copy(dst, bufoff, start)
+ } else {
+ this._bufs[i].copy(dst, bufoff, start, start + bytes)
+ break
+ }
+
+ bufoff += l
+ bytes -= l
+
+ if (start)
+ start = 0
+ }
+
+ return dst
+}
+
+BufferList.prototype.shallowSlice = function shallowSlice (start, end) {
+ start = start || 0
+ end = end || this.length
+
+ if (start < 0)
+ start += this.length
+ if (end < 0)
+ end += this.length
+
+ var startOffset = this._offset(start)
+ , endOffset = this._offset(end)
+ , buffers = this._bufs.slice(startOffset[0], endOffset[0] + 1)
+
+ if (endOffset[1] == 0)
+ buffers.pop()
+ else
+ buffers[buffers.length-1] = buffers[buffers.length-1].slice(0, endOffset[1])
+
+ if (startOffset[1] != 0)
+ buffers[0] = buffers[0].slice(startOffset[1])
+
+ return new BufferList(buffers)
+}
+
+BufferList.prototype.toString = function toString (encoding, start, end) {
+ return this.slice(start, end).toString(encoding)
+}
+
+BufferList.prototype.consume = function consume (bytes) {
+ while (this._bufs.length) {
+ if (bytes >= this._bufs[0].length) {
+ bytes -= this._bufs[0].length
+ this.length -= this._bufs[0].length
+ this._bufs.shift()
+ } else {
+ this._bufs[0] = this._bufs[0].slice(bytes)
+ this.length -= bytes
+ break
+ }
+ }
+ return this
+}
+
+
+BufferList.prototype.duplicate = function duplicate () {
+ var i = 0
+ , copy = new BufferList()
+
+ for (; i < this._bufs.length; i++)
+ copy.append(this._bufs[i])
+
+ return copy
+}
+
+
+BufferList.prototype.destroy = function destroy () {
+ this._bufs.length = 0
+ this.length = 0
+ this.push(null)
+}
+
+
+;(function () {
+ var methods = {
+ 'readDoubleBE' : 8
+ , 'readDoubleLE' : 8
+ , 'readFloatBE' : 4
+ , 'readFloatLE' : 4
+ , 'readInt32BE' : 4
+ , 'readInt32LE' : 4
+ , 'readUInt32BE' : 4
+ , 'readUInt32LE' : 4
+ , 'readInt16BE' : 2
+ , 'readInt16LE' : 2
+ , 'readUInt16BE' : 2
+ , 'readUInt16LE' : 2
+ , 'readInt8' : 1
+ , 'readUInt8' : 1
+ }
+
+ for (var m in methods) {
+ (function (m) {
+ BufferList.prototype[m] = function (offset) {
+ return this.slice(offset, offset + methods[m])[m](0)
+ }
+ }(m))
+ }
+}())
+
+
+module.exports = BufferList
+
+},{"readable-stream/duplex":97,"safe-buffer":110,"util":117}],86:[function(require,module,exports){
+'use strict'
+
+var Buffer = require('safe-buffer').Buffer
+var max = 65536
+var cache = {}
+
+function generateBuffer (i) {
+ var buffer = Buffer.allocUnsafe(2)
+ buffer.writeUInt8(i >> 8, 0)
+ buffer.writeUInt8(i & 0x00FF, 0 + 1)
+
+ return buffer
+}
+
+function generateCache () {
+ for (var i = 0; i < max; i++) {
+ cache[i] = generateBuffer(i)
+ }
+}
+
+/**
+ * calcVariableByteIntLength - calculate the variable byte integer
+ * length field
+ *
+ * @api private
+ */
+function calcVariableByteIntLength (length) {
+ if (length >= 0 && length < 128) return 1
+ else if (length >= 128 && length < 16384) return 2
+ else if (length >= 16384 && length < 2097152) return 3
+ else if (length >= 2097152 && length < 268435456) return 4
+ else return 0
+}
+
+function genBufVariableByteInt (num) {
+ var digit = 0
+ var pos = 0
+ var length = calcVariableByteIntLength(num)
+ var buffer = Buffer.allocUnsafe(length)
+
+ do {
+ digit = num % 128 | 0
+ num = num / 128 | 0
+ if (num > 0) digit = digit | 0x80
+
+ buffer.writeUInt8(digit, pos++)
+ } while (num > 0)
+
+ return {
+ data: buffer,
+ length: length
+ }
+}
+
+function generate4ByteBuffer (num) {
+ var buffer = Buffer.allocUnsafe(4)
+ buffer.writeUInt32BE(num, 0)
+ return buffer
+}
+
+module.exports = {
+ cache: cache,
+ generateCache: generateCache,
+ generateNumber: generateBuffer,
+ genBufVariableByteInt: genBufVariableByteInt,
+ generate4ByteBuffer: generate4ByteBuffer
+}
+
+},{"safe-buffer":110}],87:[function(require,module,exports){
+
+function Packet () {
+ this.cmd = null
+ this.retain = false
+ this.qos = 0
+ this.dup = false
+ this.length = -1
+ this.topic = null
+ this.payload = null
+}
+
+module.exports = Packet
+
+},{}],88:[function(require,module,exports){
+'use strict'
+
+var bl = require('bl')
+var inherits = require('inherits')
+var EE = require('events').EventEmitter
+var Packet = require('./packet')
+var constants = require('./constants')
+
+function Parser (opt) {
+ if (!(this instanceof Parser)) return new Parser(opt)
+
+ this.settings = opt || {}
+
+ this._states = [
+ '_parseHeader',
+ '_parseLength',
+ '_parsePayload',
+ '_newPacket'
+ ]
+
+ this._resetState()
+}
+
+inherits(Parser, EE)
+
+Parser.prototype._resetState = function () {
+ this.packet = new Packet()
+ this.error = null
+ this._list = bl()
+ this._stateCounter = 0
+}
+
+Parser.prototype.parse = function (buf) {
+ if (this.error) this._resetState()
+
+ this._list.append(buf)
+
+ while ((this.packet.length !== -1 || this._list.length > 0) &&
+ this[this._states[this._stateCounter]]() &&
+ !this.error) {
+ this._stateCounter++
+
+ if (this._stateCounter >= this._states.length) this._stateCounter = 0
+ }
+
+ return this._list.length
+}
+
+Parser.prototype._parseHeader = function () {
+ // There is at least one byte in the buffer
+ var zero = this._list.readUInt8(0)
+ this.packet.cmd = constants.types[zero >> constants.CMD_SHIFT]
+ this.packet.retain = (zero & constants.RETAIN_MASK) !== 0
+ this.packet.qos = (zero >> constants.QOS_SHIFT) & constants.QOS_MASK
+ this.packet.dup = (zero & constants.DUP_MASK) !== 0
+
+ this._list.consume(1)
+
+ return true
+}
+
+Parser.prototype._parseLength = function () {
+ // There is at least one byte in the list
+ var result = this._parseVarByteNum(true)
+
+ if (result) {
+ this.packet.length = result.value
+ this._list.consume(result.bytes)
+ }
+
+ return !!result
+}
+
+Parser.prototype._parsePayload = function () {
+ var result = false
+
+ // Do we have a payload? Do we have enough data to complete the payload?
+ // PINGs have no payload
+ if (this.packet.length === 0 || this._list.length >= this.packet.length) {
+ this._pos = 0
+
+ switch (this.packet.cmd) {
+ case 'connect':
+ this._parseConnect()
+ break
+ case 'connack':
+ this._parseConnack()
+ break
+ case 'publish':
+ this._parsePublish()
+ break
+ case 'puback':
+ case 'pubrec':
+ case 'pubrel':
+ case 'pubcomp':
+ this._parseConfirmation()
+ break
+ case 'subscribe':
+ this._parseSubscribe()
+ break
+ case 'suback':
+ this._parseSuback()
+ break
+ case 'unsubscribe':
+ this._parseUnsubscribe()
+ break
+ case 'unsuback':
+ this._parseUnsuback()
+ break
+ case 'pingreq':
+ case 'pingresp':
+ // These are empty, nothing to do
+ break
+ case 'disconnect':
+ this._parseDisconnect()
+ break
+ case 'auth':
+ this._parseAuth()
+ break
+ default:
+ this._emitError(new Error('Not supported'))
+ }
+
+ result = true
+ }
+
+ return result
+}
+
+Parser.prototype._parseConnect = function () {
+ var protocolId // Protocol ID
+ var clientId // Client ID
+ var topic // Will topic
+ var payload // Will payload
+ var password // Password
+ var username // Username
+ var flags = {}
+ var packet = this.packet
+
+ // Parse protocolId
+ protocolId = this._parseString()
+
+ if (protocolId === null) return this._emitError(new Error('Cannot parse protocolId'))
+ if (protocolId !== 'MQTT' && protocolId !== 'MQIsdp') {
+ return this._emitError(new Error('Invalid protocolId'))
+ }
+
+ packet.protocolId = protocolId
+
+ // Parse constants version number
+ if (this._pos >= this._list.length) return this._emitError(new Error('Packet too short'))
+
+ packet.protocolVersion = this._list.readUInt8(this._pos)
+
+ if (packet.protocolVersion !== 3 && packet.protocolVersion !== 4 && packet.protocolVersion !== 5) {
+ return this._emitError(new Error('Invalid protocol version'))
+ }
+
+ this._pos++
+
+ if (this._pos >= this._list.length) {
+ return this._emitError(new Error('Packet too short'))
+ }
+
+ // Parse connect flags
+ flags.username = (this._list.readUInt8(this._pos) & constants.USERNAME_MASK)
+ flags.password = (this._list.readUInt8(this._pos) & constants.PASSWORD_MASK)
+ flags.will = (this._list.readUInt8(this._pos) & constants.WILL_FLAG_MASK)
+
+ if (flags.will) {
+ packet.will = {}
+ packet.will.retain = (this._list.readUInt8(this._pos) & constants.WILL_RETAIN_MASK) !== 0
+ packet.will.qos = (this._list.readUInt8(this._pos) &
+ constants.WILL_QOS_MASK) >> constants.WILL_QOS_SHIFT
+ }
+
+ packet.clean = (this._list.readUInt8(this._pos) & constants.CLEAN_SESSION_MASK) !== 0
+ this._pos++
+
+ // Parse keepalive
+ packet.keepalive = this._parseNum()
+ if (packet.keepalive === -1) return this._emitError(new Error('Packet too short'))
+
+ // parse properties
+ if (packet.protocolVersion === 5) {
+ var properties = this._parseProperties()
+ if (Object.getOwnPropertyNames(properties).length) {
+ packet.properties = properties
+ }
+ }
+ // Parse clientId
+ clientId = this._parseString()
+ if (clientId === null) return this._emitError(new Error('Packet too short'))
+ packet.clientId = clientId
+
+ if (flags.will) {
+ if (packet.protocolVersion === 5) {
+ var willProperties = this._parseProperties()
+ if (Object.getOwnPropertyNames(willProperties).length) {
+ packet.will.properties = willProperties
+ }
+ }
+ // Parse will topic
+ topic = this._parseString()
+ if (topic === null) return this._emitError(new Error('Cannot parse will topic'))
+ packet.will.topic = topic
+
+ // Parse will payload
+ payload = this._parseBuffer()
+ if (payload === null) return this._emitError(new Error('Cannot parse will payload'))
+ packet.will.payload = payload
+ }
+
+ // Parse username
+ if (flags.username) {
+ username = this._parseString()
+ if (username === null) return this._emitError(new Error('Cannot parse username'))
+ packet.username = username
+ }
+
+ // Parse password
+ if (flags.password) {
+ password = this._parseBuffer()
+ if (password === null) return this._emitError(new Error('Cannot parse password'))
+ packet.password = password
+ }
+ // need for right parse auth packet and self set up
+ this.settings = packet
+
+ return packet
+}
+
+Parser.prototype._parseConnack = function () {
+ var packet = this.packet
+
+ if (this._list.length < 2) return null
+
+ packet.sessionPresent = !!(this._list.readUInt8(this._pos++) & constants.SESSIONPRESENT_MASK)
+ if (this.settings.protocolVersion === 5) {
+ packet.reasonCode = this._list.readUInt8(this._pos++)
+ } else {
+ packet.returnCode = this._list.readUInt8(this._pos++)
+ }
+
+ if (packet.returnCode === -1 || packet.reasonCode === -1) return this._emitError(new Error('Cannot parse return code'))
+ // mqtt 5 properties
+ if (this.settings.protocolVersion === 5) {
+ var properties = this._parseProperties()
+ if (Object.getOwnPropertyNames(properties).length) {
+ packet.properties = properties
+ }
+ }
+}
+
+Parser.prototype._parsePublish = function () {
+ var packet = this.packet
+ packet.topic = this._parseString()
+
+ if (packet.topic === null) return this._emitError(new Error('Cannot parse topic'))
+
+ // Parse messageId
+ if (packet.qos > 0) if (!this._parseMessageId()) { return }
+
+ // Properties mqtt 5
+ if (this.settings.protocolVersion === 5) {
+ var properties = this._parseProperties()
+ if (Object.getOwnPropertyNames(properties).length) {
+ packet.properties = properties
+ }
+ }
+
+ packet.payload = this._list.slice(this._pos, packet.length)
+}
+
+Parser.prototype._parseSubscribe = function () {
+ var packet = this.packet
+ var topic
+ var options
+ var qos
+ var rh
+ var rap
+ var nl
+ var subscription
+
+ if (packet.qos !== 1) {
+ return this._emitError(new Error('Wrong subscribe header'))
+ }
+
+ packet.subscriptions = []
+
+ if (!this._parseMessageId()) { return }
+
+ // Properties mqtt 5
+ if (this.settings.protocolVersion === 5) {
+ var properties = this._parseProperties()
+ if (Object.getOwnPropertyNames(properties).length) {
+ packet.properties = properties
+ }
+ }
+
+ while (this._pos < packet.length) {
+ // Parse topic
+ topic = this._parseString()
+ if (topic === null) return this._emitError(new Error('Cannot parse topic'))
+
+ options = this._parseByte()
+ qos = options & constants.SUBSCRIBE_OPTIONS_QOS_MASK
+ nl = ((options >> constants.SUBSCRIBE_OPTIONS_NL_SHIFT) & constants.SUBSCRIBE_OPTIONS_NL_MASK) !== 0
+ rap = ((options >> constants.SUBSCRIBE_OPTIONS_RAP_SHIFT) & constants.SUBSCRIBE_OPTIONS_RAP_MASK) !== 0
+ rh = (options >> constants.SUBSCRIBE_OPTIONS_RH_SHIFT) & constants.SUBSCRIBE_OPTIONS_RH_MASK
+
+ subscription = { topic: topic, qos: qos }
+
+ // mqtt 5 options
+ if (this.settings.protocolVersion === 5) {
+ subscription.nl = nl
+ subscription.rap = rap
+ subscription.rh = rh
+ }
+
+ // Push pair to subscriptions
+ packet.subscriptions.push(subscription)
+ }
+}
+
+Parser.prototype._parseSuback = function () {
+ var packet = this.packet
+ this.packet.granted = []
+
+ if (!this._parseMessageId()) { return }
+
+ // Properties mqtt 5
+ if (this.settings.protocolVersion === 5) {
+ var properties = this._parseProperties()
+ if (Object.getOwnPropertyNames(properties).length) {
+ packet.properties = properties
+ }
+ }
+
+ // Parse granted QoSes
+ while (this._pos < this.packet.length) {
+ this.packet.granted.push(this._list.readUInt8(this._pos++))
+ }
+}
+
+Parser.prototype._parseUnsubscribe = function () {
+ var packet = this.packet
+
+ packet.unsubscriptions = []
+
+ // Parse messageId
+ if (!this._parseMessageId()) { return }
+
+ // Properties mqtt 5
+ if (this.settings.protocolVersion === 5) {
+ var properties = this._parseProperties()
+ if (Object.getOwnPropertyNames(properties).length) {
+ packet.properties = properties
+ }
+ }
+
+ while (this._pos < packet.length) {
+ var topic
+
+ // Parse topic
+ topic = this._parseString()
+ if (topic === null) return this._emitError(new Error('Cannot parse topic'))
+
+ // Push topic to unsubscriptions
+ packet.unsubscriptions.push(topic)
+ }
+}
+
+Parser.prototype._parseUnsuback = function () {
+ var packet = this.packet
+ if (!this._parseMessageId()) return this._emitError(new Error('Cannot parse messageId'))
+ // Properties mqtt 5
+ if (this.settings.protocolVersion === 5) {
+ var properties = this._parseProperties()
+ if (Object.getOwnPropertyNames(properties).length) {
+ packet.properties = properties
+ }
+ // Parse granted QoSes
+ packet.granted = []
+ while (this._pos < this.packet.length) {
+ this.packet.granted.push(this._list.readUInt8(this._pos++))
+ }
+ }
+}
+
+// parse packets like puback, pubrec, pubrel, pubcomp
+Parser.prototype._parseConfirmation = function () {
+ var packet = this.packet
+
+ this._parseMessageId()
+
+ if (this.settings.protocolVersion === 5) {
+ if (packet.length > 2) {
+ // response code
+ packet.reasonCode = this._parseByte()
+ // properies mqtt 5
+ var properties = this._parseProperties()
+ if (Object.getOwnPropertyNames(properties).length) {
+ packet.properties = properties
+ }
+ }
+ }
+
+ return true
+}
+
+// parse disconnect packet
+Parser.prototype._parseDisconnect = function () {
+ var packet = this.packet
+
+ if (this.settings.protocolVersion === 5) {
+ // response code
+ packet.reasonCode = this._parseByte()
+ // properies mqtt 5
+ var properties = this._parseProperties()
+ if (Object.getOwnPropertyNames(properties).length) {
+ packet.properties = properties
+ }
+ }
+
+ return true
+}
+
+// parse auth packet
+Parser.prototype._parseAuth = function () {
+ var packet = this.packet
+
+ if (this.settings.protocolVersion !== 5) {
+ return this._emitError(new Error('Not supported auth packet for this version MQTT'))
+ }
+
+ // response code
+ packet.reasonCode = this._parseByte()
+ // properies mqtt 5
+ var properties = this._parseProperties()
+ if (Object.getOwnPropertyNames(properties).length) {
+ packet.properties = properties
+ }
+
+ return true
+}
+
+Parser.prototype._parseMessageId = function () {
+ var packet = this.packet
+
+ packet.messageId = this._parseNum()
+
+ if (packet.messageId === null) {
+ this._emitError(new Error('Cannot parse messageId'))
+ return false
+ }
+
+ return true
+}
+
+Parser.prototype._parseString = function (maybeBuffer) {
+ var length = this._parseNum()
+ var result
+ var end = length + this._pos
+
+ if (length === -1 || end > this._list.length || end > this.packet.length) return null
+
+ result = this._list.toString('utf8', this._pos, end)
+ this._pos += length
+
+ return result
+}
+
+Parser.prototype._parseStringPair = function () {
+ return {
+ name: this._parseString(),
+ value: this._parseString()
+ }
+}
+
+Parser.prototype._parseBuffer = function () {
+ var length = this._parseNum()
+ var result
+ var end = length + this._pos
+
+ if (length === -1 || end > this._list.length || end > this.packet.length) return null
+
+ result = this._list.slice(this._pos, end)
+
+ this._pos += length
+
+ return result
+}
+
+Parser.prototype._parseNum = function () {
+ if (this._list.length - this._pos < 2) return -1
+
+ var result = this._list.readUInt16BE(this._pos)
+ this._pos += 2
+
+ return result
+}
+
+Parser.prototype._parse4ByteNum = function () {
+ if (this._list.length - this._pos < 4) return -1
+
+ var result = this._list.readUInt32BE(this._pos)
+ this._pos += 4
+
+ return result
+}
+
+Parser.prototype._parseVarByteNum = function (fullInfoFlag) {
+ var bytes = 0
+ var mul = 1
+ var length = 0
+ var result = true
+ var current
+ var padding = this._pos ? this._pos : 0
+
+ while (bytes < 5) {
+ current = this._list.readUInt8(padding + bytes++)
+ length += mul * (current & constants.LENGTH_MASK)
+ mul *= 0x80
+
+ if ((current & constants.LENGTH_FIN_MASK) === 0) break
+ if (this._list.length <= bytes) {
+ result = false
+ break
+ }
+ }
+
+ if (padding) {
+ this._pos += bytes
+ }
+
+ result = result
+ ? fullInfoFlag ? {
+ bytes: bytes,
+ value: length
+ } : length
+ : false
+
+ return result
+}
+
+Parser.prototype._parseByte = function () {
+ var result = this._list.readUInt8(this._pos)
+ this._pos++
+ return result
+}
+
+Parser.prototype._parseByType = function (type) {
+ switch (type) {
+ case 'byte': {
+ return this._parseByte() !== 0
+ }
+ case 'int8': {
+ return this._parseByte()
+ }
+ case 'int16': {
+ return this._parseNum()
+ }
+ case 'int32': {
+ return this._parse4ByteNum()
+ }
+ case 'var': {
+ return this._parseVarByteNum()
+ }
+ case 'string': {
+ return this._parseString()
+ }
+ case 'pair': {
+ return this._parseStringPair()
+ }
+ case 'binary': {
+ return this._parseBuffer()
+ }
+ }
+}
+
+Parser.prototype._parseProperties = function () {
+ var length = this._parseVarByteNum()
+ var start = this._pos
+ var end = start + length
+ var result = {}
+ while (this._pos < end) {
+ var type = this._parseByte()
+ var name = constants.propertiesCodes[type]
+ if (!name) {
+ this._emitError(new Error('Unknown property'))
+ return false
+ }
+ // user properties process
+ if (name === 'userProperties') {
+ if (!result[name]) {
+ result[name] = {}
+ }
+ var currentUserProperty = this._parseByType(constants.propertiesTypes[name])
+ result[name][currentUserProperty.name] = currentUserProperty.value
+ continue
+ }
+ result[name] = this._parseByType(constants.propertiesTypes[name])
+ }
+ return result
+}
+
+Parser.prototype._newPacket = function () {
+ if (this.packet) {
+ this._list.consume(this.packet.length)
+ this.emit('packet', this.packet)
+ }
+
+ this.packet = new Packet()
+
+ this._pos = 0
+
+ return true
+}
+
+Parser.prototype._emitError = function (err) {
+ this.error = err
+ this.emit('error', err)
+}
+
+module.exports = Parser
+
+},{"./constants":82,"./packet":87,"bl":85,"events":13,"inherits":80}],89:[function(require,module,exports){
+'use strict'
+
+var protocol = require('./constants')
+var Buffer = require('safe-buffer').Buffer
+var empty = Buffer.allocUnsafe(0)
+var zeroBuf = Buffer.from([0])
+var numbers = require('./numbers')
+var nextTick = require('process-nextick-args').nextTick
+
+var numCache = numbers.cache
+var generateNumber = numbers.generateNumber
+var generateCache = numbers.generateCache
+var genBufVariableByteInt = numbers.genBufVariableByteInt
+var generate4ByteBuffer = numbers.generate4ByteBuffer
+var writeNumber = writeNumberCached
+var toGenerate = true
+
+function generate (packet, stream, opts) {
+ if (stream.cork) {
+ stream.cork()
+ nextTick(uncork, stream)
+ }
+
+ if (toGenerate) {
+ toGenerate = false
+ generateCache()
+ }
+
+ switch (packet.cmd) {
+ case 'connect':
+ return connect(packet, stream, opts)
+ case 'connack':
+ return connack(packet, stream, opts)
+ case 'publish':
+ return publish(packet, stream, opts)
+ case 'puback':
+ case 'pubrec':
+ case 'pubrel':
+ case 'pubcomp':
+ return confirmation(packet, stream, opts)
+ case 'subscribe':
+ return subscribe(packet, stream, opts)
+ case 'suback':
+ return suback(packet, stream, opts)
+ case 'unsubscribe':
+ return unsubscribe(packet, stream, opts)
+ case 'unsuback':
+ return unsuback(packet, stream, opts)
+ case 'pingreq':
+ case 'pingresp':
+ return emptyPacket(packet, stream, opts)
+ case 'disconnect':
+ return disconnect(packet, stream, opts)
+ case 'auth':
+ return auth(packet, stream, opts)
+ default:
+ stream.emit('error', new Error('Unknown command'))
+ return false
+ }
+}
+/**
+ * Controls numbers cache.
+ * Set to "false" to allocate buffers on-the-flight instead of pre-generated cache
+ */
+Object.defineProperty(generate, 'cacheNumbers', {
+ get: function () {
+ return writeNumber === writeNumberCached
+ },
+ set: function (value) {
+ if (value) {
+ if (!numCache || Object.keys(numCache).length === 0) toGenerate = true
+ writeNumber = writeNumberCached
+ } else {
+ toGenerate = false
+ writeNumber = writeNumberGenerated
+ }
+ }
+})
+
+function uncork (stream) {
+ stream.uncork()
+}
+
+function connect (packet, stream, opts) {
+ var settings = packet || {}
+ var protocolId = settings.protocolId || 'MQTT'
+ var protocolVersion = settings.protocolVersion || 4
+ var will = settings.will
+ var clean = settings.clean
+ var keepalive = settings.keepalive || 0
+ var clientId = settings.clientId || ''
+ var username = settings.username
+ var password = settings.password
+ /* mqtt5 new oprions */
+ var properties = settings.properties
+
+ if (clean === undefined) clean = true
+
+ var length = 0
+
+ // Must be a string and non-falsy
+ if (!protocolId ||
+ (typeof protocolId !== 'string' && !Buffer.isBuffer(protocolId))) {
+ stream.emit('error', new Error('Invalid protocolId'))
+ return false
+ } else length += protocolId.length + 2
+
+ // Must be 3 or 4 or 5
+ if (protocolVersion !== 3 && protocolVersion !== 4 && protocolVersion !== 5) {
+ stream.emit('error', new Error('Invalid protocol version'))
+ return false
+ } else length += 1
+
+ // ClientId might be omitted in 3.1.1, but only if cleanSession is set to 1
+ if ((typeof clientId === 'string' || Buffer.isBuffer(clientId)) &&
+ (clientId || protocolVersion === 4) && (clientId || clean)) {
+ length += clientId.length + 2
+ } else {
+ if (protocolVersion < 4) {
+ stream.emit('error', new Error('clientId must be supplied before 3.1.1'))
+ return false
+ }
+ if ((clean * 1) === 0) {
+ stream.emit('error', new Error('clientId must be given if cleanSession set to 0'))
+ return false
+ }
+ }
+
+ // Must be a two byte number
+ if (typeof keepalive !== 'number' ||
+ keepalive < 0 ||
+ keepalive > 65535 ||
+ keepalive % 1 !== 0) {
+ stream.emit('error', new Error('Invalid keepalive'))
+ return false
+ } else length += 2
+
+ // Connect flags
+ length += 1
+
+ // Properties
+ if (protocolVersion === 5) {
+ var propertiesData = getProperties(stream, properties)
+ length += propertiesData.length
+ }
+
+ // If will exists...
+ if (will) {
+ // It must be an object
+ if (typeof will !== 'object') {
+ stream.emit('error', new Error('Invalid will'))
+ return false
+ }
+ // It must have topic typeof string
+ if (!will.topic || typeof will.topic !== 'string') {
+ stream.emit('error', new Error('Invalid will topic'))
+ return false
+ } else {
+ length += Buffer.byteLength(will.topic) + 2
+ }
+
+ // Payload
+ if (will.payload) {
+ if (will.payload.length >= 0) {
+ if (typeof will.payload === 'string') {
+ length += Buffer.byteLength(will.payload) + 2
+ } else {
+ length += will.payload.length + 2
+ }
+ } else {
+ stream.emit('error', new Error('Invalid will payload'))
+ return false
+ }
+
+ // will properties
+ var willProperties = {}
+ if (protocolVersion === 5) {
+ willProperties = getProperties(stream, will.properties)
+ length += willProperties.length
+ }
+ }
+ }
+
+ // Username
+ var providedUsername = false
+ if (username != null) {
+ if (isStringOrBuffer(username)) {
+ providedUsername = true
+ length += Buffer.byteLength(username) + 2
+ } else {
+ stream.emit('error', new Error('Invalid username'))
+ return false
+ }
+ }
+
+ // Password
+ if (password != null) {
+ if (!providedUsername) {
+ stream.emit('error', new Error('Username is required to use password'))
+ return false
+ }
+
+ if (isStringOrBuffer(password)) {
+ length += byteLength(password) + 2
+ } else {
+ stream.emit('error', new Error('Invalid password'))
+ return false
+ }
+ }
+
+ // Generate header
+ stream.write(protocol.CONNECT_HEADER)
+
+ // Generate length
+ writeVarByteInt(stream, length)
+
+ // Generate protocol ID
+ writeStringOrBuffer(stream, protocolId)
+ stream.write(
+ protocolVersion === 4
+ ? protocol.VERSION4
+ : protocolVersion === 5
+ ? protocol.VERSION5
+ : protocol.VERSION3
+ )
+
+ // Connect flags
+ var flags = 0
+ flags |= (username != null) ? protocol.USERNAME_MASK : 0
+ flags |= (password != null) ? protocol.PASSWORD_MASK : 0
+ flags |= (will && will.retain) ? protocol.WILL_RETAIN_MASK : 0
+ flags |= (will && will.qos) ? will.qos << protocol.WILL_QOS_SHIFT : 0
+ flags |= will ? protocol.WILL_FLAG_MASK : 0
+ flags |= clean ? protocol.CLEAN_SESSION_MASK : 0
+
+ stream.write(Buffer.from([flags]))
+
+ // Keepalive
+ writeNumber(stream, keepalive)
+
+ // Properties
+ if (protocolVersion === 5) {
+ propertiesData.write()
+ }
+
+ // Client ID
+ writeStringOrBuffer(stream, clientId)
+
+ // Will
+ if (will) {
+ if (protocolVersion === 5) {
+ willProperties.write()
+ }
+ writeString(stream, will.topic)
+ writeStringOrBuffer(stream, will.payload)
+ }
+
+ // Username and password
+ if (username != null) {
+ writeStringOrBuffer(stream, username)
+ }
+ if (password != null) {
+ writeStringOrBuffer(stream, password)
+ }
+ // This is a small packet that happens only once on a stream
+ // We assume the stream is always free to receive more data after this
+ return true
+}
+
+function connack (packet, stream, opts) {
+ var version = opts ? opts.protocolVersion : 4
+ var settings = packet || {}
+ var rc = version === 5 ? settings.reasonCode : settings.returnCode
+ var properties = settings.properties
+ var length = 2 // length of rc and sessionHeader
+
+ // Check return code
+ if (typeof rc !== 'number') {
+ stream.emit('error', new Error('Invalid return code'))
+ return false
+ }
+ // mqtt5 properties
+ var propertiesData = null
+ if (version === 5) {
+ propertiesData = getProperties(stream, properties)
+ length += propertiesData.length
+ }
+
+ stream.write(protocol.CONNACK_HEADER)
+ // length
+ writeVarByteInt(stream, length)
+ stream.write(settings.sessionPresent ? protocol.SESSIONPRESENT_HEADER : zeroBuf)
+
+ stream.write(Buffer.from([rc]))
+ if (propertiesData != null) {
+ propertiesData.write()
+ }
+ return true
+}
+
+function publish (packet, stream, opts) {
+ var version = opts ? opts.protocolVersion : 4
+ var settings = packet || {}
+ var qos = settings.qos || 0
+ var retain = settings.retain ? protocol.RETAIN_MASK : 0
+ var topic = settings.topic
+ var payload = settings.payload || empty
+ var id = settings.messageId
+ var properties = settings.properties
+
+ var length = 0
+
+ // Topic must be a non-empty string or Buffer
+ if (typeof topic === 'string') length += Buffer.byteLength(topic) + 2
+ else if (Buffer.isBuffer(topic)) length += topic.length + 2
+ else {
+ stream.emit('error', new Error('Invalid topic'))
+ return false
+ }
+
+ // Get the payload length
+ if (!Buffer.isBuffer(payload)) length += Buffer.byteLength(payload)
+ else length += payload.length
+
+ // Message ID must a number if qos > 0
+ if (qos && typeof id !== 'number') {
+ stream.emit('error', new Error('Invalid messageId'))
+ return false
+ } else if (qos) length += 2
+
+ // mqtt5 properties
+ var propertiesData = null
+ if (version === 5) {
+ propertiesData = getProperties(stream, properties)
+ length += propertiesData.length
+ }
+
+ // Header
+ stream.write(protocol.PUBLISH_HEADER[qos][settings.dup ? 1 : 0][retain ? 1 : 0])
+
+ // Remaining length
+ writeVarByteInt(stream, length)
+
+ // Topic
+ writeNumber(stream, byteLength(topic))
+ stream.write(topic)
+
+ // Message ID
+ if (qos > 0) writeNumber(stream, id)
+
+ // Properties
+ if (propertiesData != null) {
+ propertiesData.write()
+ }
+
+ // Payload
+ return stream.write(payload)
+}
+
+/* Puback, pubrec, pubrel and pubcomp */
+function confirmation (packet, stream, opts) {
+ var version = opts ? opts.protocolVersion : 4
+ var settings = packet || {}
+ var type = settings.cmd || 'puback'
+ var id = settings.messageId
+ var dup = (settings.dup && type === 'pubrel') ? protocol.DUP_MASK : 0
+ var qos = 0
+ var reasonCode = settings.reasonCode
+ var properties = settings.properties
+ var length = version === 5 ? 3 : 2
+
+ if (type === 'pubrel') qos = 1
+
+ // Check message ID
+ if (typeof id !== 'number') {
+ stream.emit('error', new Error('Invalid messageId'))
+ return false
+ }
+
+ // properies mqtt 5
+ var propertiesData = null
+ if (version === 5) {
+ propertiesData = getPropertiesByMaximumPacketSize(stream, properties, opts, length)
+ if (!propertiesData) { return false }
+ length += propertiesData.length
+ }
+
+ // Header
+ stream.write(protocol.ACKS[type][qos][dup][0])
+
+ // Length
+ writeVarByteInt(stream, length)
+
+ // Message ID
+ writeNumber(stream, id)
+
+ // reason code in header
+ if (version === 5) {
+ stream.write(Buffer.from([reasonCode]))
+ }
+
+ // properies mqtt 5
+ if (propertiesData !== null) {
+ propertiesData.write()
+ }
+ return true
+}
+
+function subscribe (packet, stream, opts) {
+ var version = opts ? opts.protocolVersion : 4
+ var settings = packet || {}
+ var dup = settings.dup ? protocol.DUP_MASK : 0
+ var id = settings.messageId
+ var subs = settings.subscriptions
+ var properties = settings.properties
+
+ var length = 0
+
+ // Check message ID
+ if (typeof id !== 'number') {
+ stream.emit('error', new Error('Invalid messageId'))
+ return false
+ } else length += 2
+
+ // properies mqtt 5
+ var propertiesData = null
+ if (version === 5) {
+ propertiesData = getProperties(stream, properties)
+ length += propertiesData.length
+ }
+
+ // Check subscriptions
+ if (typeof subs === 'object' && subs.length) {
+ for (var i = 0; i < subs.length; i += 1) {
+ var itopic = subs[i].topic
+ var iqos = subs[i].qos
+
+ if (typeof itopic !== 'string') {
+ stream.emit('error', new Error('Invalid subscriptions - invalid topic'))
+ return false
+ }
+ if (typeof iqos !== 'number') {
+ stream.emit('error', new Error('Invalid subscriptions - invalid qos'))
+ return false
+ }
+
+ if (version === 5) {
+ var nl = subs[i].nl || false
+ if (typeof nl !== 'boolean') {
+ stream.emit('error', new Error('Invalid subscriptions - invalid No Local'))
+ return false
+ }
+ var rap = subs[i].rap || false
+ if (typeof rap !== 'boolean') {
+ stream.emit('error', new Error('Invalid subscriptions - invalid Retain as Published'))
+ return false
+ }
+ var rh = subs[i].rh || 0
+ if (typeof rh !== 'number' || rh > 2) {
+ stream.emit('error', new Error('Invalid subscriptions - invalid Retain Handling'))
+ return false
+ }
+ }
+
+ length += Buffer.byteLength(itopic) + 2 + 1
+ }
+ } else {
+ stream.emit('error', new Error('Invalid subscriptions'))
+ return false
+ }
+
+ // Generate header
+ stream.write(protocol.SUBSCRIBE_HEADER[1][dup ? 1 : 0][0])
+
+ // Generate length
+ writeVarByteInt(stream, length)
+
+ // Generate message ID
+ writeNumber(stream, id)
+
+ // properies mqtt 5
+ if (propertiesData !== null) {
+ propertiesData.write()
+ }
+
+ var result = true
+
+ // Generate subs
+ for (var j = 0; j < subs.length; j++) {
+ var sub = subs[j]
+ var jtopic = sub.topic
+ var jqos = sub.qos
+ var jnl = +sub.nl
+ var jrap = +sub.rap
+ var jrh = sub.rh
+ var joptions
+
+ // Write topic string
+ writeString(stream, jtopic)
+
+ // options process
+ joptions = protocol.SUBSCRIBE_OPTIONS_QOS[jqos]
+ if (version === 5) {
+ joptions |= jnl ? protocol.SUBSCRIBE_OPTIONS_NL : 0
+ joptions |= jrap ? protocol.SUBSCRIBE_OPTIONS_RAP : 0
+ joptions |= jrh ? protocol.SUBSCRIBE_OPTIONS_RH[jrh] : 0
+ }
+ // Write options
+ result = stream.write(Buffer.from([joptions]))
+ }
+
+ return result
+}
+
+function suback (packet, stream, opts) {
+ var version = opts ? opts.protocolVersion : 4
+ var settings = packet || {}
+ var id = settings.messageId
+ var granted = settings.granted
+ var properties = settings.properties
+ var length = 0
+
+ // Check message ID
+ if (typeof id !== 'number') {
+ stream.emit('error', new Error('Invalid messageId'))
+ return false
+ } else length += 2
+
+ // Check granted qos vector
+ if (typeof granted === 'object' && granted.length) {
+ for (var i = 0; i < granted.length; i += 1) {
+ if (typeof granted[i] !== 'number') {
+ stream.emit('error', new Error('Invalid qos vector'))
+ return false
+ }
+ length += 1
+ }
+ } else {
+ stream.emit('error', new Error('Invalid qos vector'))
+ return false
+ }
+
+ // properies mqtt 5
+ var propertiesData = null
+ if (version === 5) {
+ propertiesData = getPropertiesByMaximumPacketSize(stream, properties, opts, length)
+ if (!propertiesData) { return false }
+ length += propertiesData.length
+ }
+
+ // header
+ stream.write(protocol.SUBACK_HEADER)
+
+ // Length
+ writeVarByteInt(stream, length)
+
+ // Message ID
+ writeNumber(stream, id)
+
+ // properies mqtt 5
+ if (propertiesData !== null) {
+ propertiesData.write()
+ }
+
+ return stream.write(Buffer.from(granted))
+}
+
+function unsubscribe (packet, stream, opts) {
+ var version = opts ? opts.protocolVersion : 4
+ var settings = packet || {}
+ var id = settings.messageId
+ var dup = settings.dup ? protocol.DUP_MASK : 0
+ var unsubs = settings.unsubscriptions
+ var properties = settings.properties
+
+ var length = 0
+
+ // Check message ID
+ if (typeof id !== 'number') {
+ stream.emit('error', new Error('Invalid messageId'))
+ return false
+ } else {
+ length += 2
+ }
+ // Check unsubs
+ if (typeof unsubs === 'object' && unsubs.length) {
+ for (var i = 0; i < unsubs.length; i += 1) {
+ if (typeof unsubs[i] !== 'string') {
+ stream.emit('error', new Error('Invalid unsubscriptions'))
+ return false
+ }
+ length += Buffer.byteLength(unsubs[i]) + 2
+ }
+ } else {
+ stream.emit('error', new Error('Invalid unsubscriptions'))
+ return false
+ }
+ // properies mqtt 5
+ var propertiesData = null
+ if (version === 5) {
+ propertiesData = getProperties(stream, properties)
+ length += propertiesData.length
+ }
+
+ // Header
+ stream.write(protocol.UNSUBSCRIBE_HEADER[1][dup ? 1 : 0][0])
+
+ // Length
+ writeVarByteInt(stream, length)
+
+ // Message ID
+ writeNumber(stream, id)
+
+ // properies mqtt 5
+ if (propertiesData !== null) {
+ propertiesData.write()
+ }
+
+ // Unsubs
+ var result = true
+ for (var j = 0; j < unsubs.length; j++) {
+ result = writeString(stream, unsubs[j])
+ }
+
+ return result
+}
+
+function unsuback (packet, stream, opts) {
+ var version = opts ? opts.protocolVersion : 4
+ var settings = packet || {}
+ var id = settings.messageId
+ var dup = settings.dup ? protocol.DUP_MASK : 0
+ var granted = settings.granted
+ var properties = settings.properties
+ var type = settings.cmd
+ var qos = 0
+
+ var length = 2
+
+ // Check message ID
+ if (typeof id !== 'number') {
+ stream.emit('error', new Error('Invalid messageId'))
+ return false
+ }
+
+ // Check granted
+ if (version === 5) {
+ if (typeof granted === 'object' && granted.length) {
+ for (var i = 0; i < granted.length; i += 1) {
+ if (typeof granted[i] !== 'number') {
+ stream.emit('error', new Error('Invalid qos vector'))
+ return false
+ }
+ length += 1
+ }
+ } else {
+ stream.emit('error', new Error('Invalid qos vector'))
+ return false
+ }
+ }
+
+ // properies mqtt 5
+ var propertiesData = null
+ if (version === 5) {
+ propertiesData = getPropertiesByMaximumPacketSize(stream, properties, opts, length)
+ if (!propertiesData) { return false }
+ length += propertiesData.length
+ }
+
+ // Header
+ stream.write(protocol.ACKS[type][qos][dup][0])
+
+ // Length
+ writeVarByteInt(stream, length)
+
+ // Message ID
+ writeNumber(stream, id)
+
+ // properies mqtt 5
+ if (propertiesData !== null) {
+ propertiesData.write()
+ }
+
+ // payload
+ if (version === 5) {
+ stream.write(Buffer.from(granted))
+ }
+ return true
+}
+
+function emptyPacket (packet, stream, opts) {
+ return stream.write(protocol.EMPTY[packet.cmd])
+}
+
+function disconnect (packet, stream, opts) {
+ var version = opts ? opts.protocolVersion : 4
+ var settings = packet || {}
+ var reasonCode = settings.reasonCode
+ var properties = settings.properties
+ var length = version === 5 ? 1 : 0
+
+ // properies mqtt 5
+ var propertiesData = null
+ if (version === 5) {
+ propertiesData = getPropertiesByMaximumPacketSize(stream, properties, opts, length)
+ if (!propertiesData) { return false }
+ length += propertiesData.length
+ }
+
+ // Header
+ stream.write(Buffer.from([protocol.codes['disconnect'] << 4]))
+
+ // Length
+ writeVarByteInt(stream, length)
+
+ // reason code in header
+ if (version === 5) {
+ stream.write(Buffer.from([reasonCode]))
+ }
+
+ // properies mqtt 5
+ if (propertiesData !== null) {
+ propertiesData.write()
+ }
+
+ return true
+}
+
+function auth (packet, stream, opts) {
+ var version = opts ? opts.protocolVersion : 4
+ var settings = packet || {}
+ var reasonCode = settings.reasonCode
+ var properties = settings.properties
+ var length = version === 5 ? 1 : 0
+
+ if (version !== 5) stream.emit('error', new Error('Invalid mqtt version for auth packet'))
+
+ // properies mqtt 5
+ var propertiesData = getPropertiesByMaximumPacketSize(stream, properties, opts, length)
+ if (!propertiesData) { return false }
+ length += propertiesData.length
+
+ // Header
+ stream.write(Buffer.from([protocol.codes['auth'] << 4]))
+
+ // Length
+ writeVarByteInt(stream, length)
+
+ // reason code in header
+ stream.write(Buffer.from([reasonCode]))
+
+ // properies mqtt 5
+ if (propertiesData !== null) {
+ propertiesData.write()
+ }
+ return true
+}
+
+/**
+ * writeVarByteInt - write an MQTT style variable byte integer to the buffer
+ *
+ * @param buffer - destination
+ * @param pos - offset
+ * @param length - length (>0)
+ * @returns number of bytes written
+ *
+ * @api private
+ */
+
+var varByteIntCache = {}
+function writeVarByteInt (stream, num) {
+ var buffer = varByteIntCache[num]
+
+ if (!buffer) {
+ buffer = genBufVariableByteInt(num).data
+ if (num < 16384) varByteIntCache[num] = buffer
+ }
+
+ stream.write(buffer)
+}
+
+/**
+ * writeString - write a utf8 string to the buffer
+ *
+ * @param buffer - destination
+ * @param pos - offset
+ * @param string - string to write
+ * @return number of bytes written
+ *
+ * @api private
+ */
+
+function writeString (stream, string) {
+ var strlen = Buffer.byteLength(string)
+ writeNumber(stream, strlen)
+
+ stream.write(string, 'utf8')
+}
+
+/**
+ * writeStringPair - write a utf8 string pairs to the buffer
+ *
+ * @param buffer - destination
+ * @param name - string name to write
+ * @param value - string value to write
+ * @return number of bytes written
+ *
+ * @api private
+ */
+function writeStringPair (stream, name, value) {
+ writeString(stream, name)
+ writeString(stream, value)
+}
+
+/**
+ * writeNumber - write a two byte number to the buffer
+ *
+ * @param buffer - destination
+ * @param pos - offset
+ * @param number - number to write
+ * @return number of bytes written
+ *
+ * @api private
+ */
+function writeNumberCached (stream, number) {
+ return stream.write(numCache[number])
+}
+function writeNumberGenerated (stream, number) {
+ return stream.write(generateNumber(number))
+}
+function write4ByteNumber (stream, number) {
+ return stream.write(generate4ByteBuffer(number))
+}
+/**
+ * writeStringOrBuffer - write a String or Buffer with the its length prefix
+ *
+ * @param buffer - destination
+ * @param pos - offset
+ * @param toWrite - String or Buffer
+ * @return number of bytes written
+ */
+function writeStringOrBuffer (stream, toWrite) {
+ if (typeof toWrite === 'string') {
+ writeString(stream, toWrite)
+ } else if (toWrite) {
+ writeNumber(stream, toWrite.length)
+ stream.write(toWrite)
+ } else writeNumber(stream, 0)
+}
+
+function getProperties (stream, properties) {
+ /* connect properties */
+ if (typeof properties !== 'object' || properties.length != null) {
+ return {
+ length: 1,
+ write: function () {
+ writeProperties(stream, {}, 0)
+ }
+ }
+ }
+ var propertiesLength = 0
+ function getLengthProperty (name) {
+ var type = protocol.propertiesTypes[name]
+ var value = properties[name]
+ var length = 0
+ switch (type) {
+ case 'byte': {
+ if (typeof value !== 'boolean') {
+ stream.emit('error', new Error('Invalid ' + name))
+ return false
+ }
+ length += 1 + 1
+ break
+ }
+ case 'int8': {
+ if (typeof value !== 'number') {
+ stream.emit('error', new Error('Invalid ' + name))
+ return false
+ }
+ length += 1 + 1
+ break
+ }
+ case 'binary': {
+ if (value && value === null) {
+ stream.emit('error', new Error('Invalid ' + name))
+ return false
+ }
+ length += 1 + Buffer.byteLength(value) + 2
+ break
+ }
+ case 'int16': {
+ if (typeof value !== 'number') {
+ stream.emit('error', new Error('Invalid ' + name))
+ return false
+ }
+ length += 1 + 2
+ break
+ }
+ case 'int32': {
+ if (typeof value !== 'number') {
+ stream.emit('error', new Error('Invalid ' + name))
+ return false
+ }
+ length += 1 + 4
+ break
+ }
+ case 'var': {
+ if (typeof value !== 'number') {
+ stream.emit('error', new Error('Invalid ' + name))
+ return false
+ }
+ length += 1 + genBufVariableByteInt(value).length
+ break
+ }
+ case 'string': {
+ if (typeof value !== 'string') {
+ stream.emit('error', new Error('Invalid ' + name))
+ return false
+ }
+ length += 1 + 2 + Buffer.byteLength(value.toString())
+ break
+ }
+ case 'pair': {
+ if (typeof value !== 'object') {
+ stream.emit('error', new Error('Invalid ' + name))
+ return false
+ }
+ length += Object.getOwnPropertyNames(value).reduce(function (result, name) {
+ result += 1 + 2 + Buffer.byteLength(name.toString()) + 2 + Buffer.byteLength(value[name].toString())
+ return result
+ }, 0)
+ break
+ }
+ default: {
+ stream.emit('error', new Error('Invalid property ' + name))
+ return false
+ }
+ }
+ return length
+ }
+ if (properties) {
+ for (var propName in properties) {
+ var propLength = getLengthProperty(propName)
+ if (!propLength) return false
+ propertiesLength += propLength
+ }
+ }
+ var propertiesLengthLength = genBufVariableByteInt(propertiesLength).length
+
+ return {
+ length: propertiesLengthLength + propertiesLength,
+ write: function () {
+ writeProperties(stream, properties, propertiesLength)
+ }
+ }
+}
+
+function getPropertiesByMaximumPacketSize (stream, properties, opts, length) {
+ var mayEmptyProps = ['reasonString', 'userProperties']
+ var maximumPacketSize = opts && opts.properties && opts.properties.maximumPacketSize ? opts.properties.maximumPacketSize : 0
+
+ var propertiesData = getProperties(stream, properties)
+ if (maximumPacketSize) {
+ while (length + propertiesData.length > maximumPacketSize) {
+ var currentMayEmptyProp = mayEmptyProps.shift()
+ if (currentMayEmptyProp && properties[currentMayEmptyProp]) {
+ delete properties[currentMayEmptyProp]
+ propertiesData = getProperties(stream, properties)
+ } else {
+ return false
+ }
+ }
+ }
+ return propertiesData
+}
+
+function writeProperties (stream, properties, propertiesLength) {
+ /* write properties to stream */
+ writeVarByteInt(stream, propertiesLength)
+ for (var propName in properties) {
+ if (properties.hasOwnProperty(propName) && properties[propName] !== null) {
+ var value = properties[propName]
+ var type = protocol.propertiesTypes[propName]
+ switch (type) {
+ case 'byte': {
+ stream.write(Buffer.from([protocol.properties[propName]]))
+ stream.write(Buffer.from([+value]))
+ break
+ }
+ case 'int8': {
+ stream.write(Buffer.from([protocol.properties[propName]]))
+ stream.write(Buffer.from([value]))
+ break
+ }
+ case 'binary': {
+ stream.write(Buffer.from([protocol.properties[propName]]))
+ writeStringOrBuffer(stream, value)
+ break
+ }
+ case 'int16': {
+ stream.write(Buffer.from([protocol.properties[propName]]))
+ writeNumber(stream, value)
+ break
+ }
+ case 'int32': {
+ stream.write(Buffer.from([protocol.properties[propName]]))
+ write4ByteNumber(stream, value)
+ break
+ }
+ case 'var': {
+ stream.write(Buffer.from([protocol.properties[propName]]))
+ writeVarByteInt(stream, value)
+ break
+ }
+ case 'string': {
+ stream.write(Buffer.from([protocol.properties[propName]]))
+ writeString(stream, value)
+ break
+ }
+ case 'pair': {
+ Object.getOwnPropertyNames(value).forEach(function (name) {
+ stream.write(Buffer.from([protocol.properties[propName]]))
+ writeStringPair(stream, name.toString(), value[name].toString())
+ })
+ break
+ }
+ default: {
+ stream.emit('error', new Error('Invalid property ' + propName))
+ return false
+ }
+ }
+ }
+ }
+}
+
+function byteLength (bufOrString) {
+ if (!bufOrString) return 0
+ else if (bufOrString instanceof Buffer) return bufOrString.length
+ else return Buffer.byteLength(bufOrString)
+}
+
+function isStringOrBuffer (field) {
+ return typeof field === 'string' || field instanceof Buffer
+}
+
+module.exports = generate
+
+},{"./constants":82,"./numbers":86,"process-nextick-args":91,"safe-buffer":110}],90:[function(require,module,exports){
+var wrappy = require('wrappy')
+module.exports = wrappy(once)
+module.exports.strict = wrappy(onceStrict)
+
+once.proto = once(function () {
+ Object.defineProperty(Function.prototype, 'once', {
+ value: function () {
+ return once(this)
+ },
+ configurable: true
+ })
+
+ Object.defineProperty(Function.prototype, 'onceStrict', {
+ value: function () {
+ return onceStrict(this)
+ },
+ configurable: true
+ })
+})
+
+function once (fn) {
+ var f = function () {
+ if (f.called) return f.value
+ f.called = true
+ return f.value = fn.apply(this, arguments)
+ }
+ f.called = false
+ return f
+}
+
+function onceStrict (fn) {
+ var f = function () {
+ if (f.called)
+ throw new Error(f.onceError)
+ f.called = true
+ return f.value = fn.apply(this, arguments)
+ }
+ var name = fn.name || 'Function wrapped with `once`'
+ f.onceError = name + " shouldn't be called more than once"
+ f.called = false
+ return f
+}
+
+},{"wrappy":120}],91:[function(require,module,exports){
+(function (process){
+'use strict';
+
+if (!process.version ||
+ process.version.indexOf('v0.') === 0 ||
+ process.version.indexOf('v1.') === 0 && process.version.indexOf('v1.8.') !== 0) {
+ module.exports = { nextTick: nextTick };
+} else {
+ module.exports = process
+}
+
+function nextTick(fn, arg1, arg2, arg3) {
+ if (typeof fn !== 'function') {
+ throw new TypeError('"callback" argument must be a function');
+ }
+ var len = arguments.length;
+ var args, i;
+ switch (len) {
+ case 0:
+ case 1:
+ return process.nextTick(fn);
+ case 2:
+ return process.nextTick(function afterTickOne() {
+ fn.call(null, arg1);
+ });
+ case 3:
+ return process.nextTick(function afterTickTwo() {
+ fn.call(null, arg1, arg2);
+ });
+ case 4:
+ return process.nextTick(function afterTickThree() {
+ fn.call(null, arg1, arg2, arg3);
+ });
+ default:
+ args = new Array(len - 1);
+ i = 0;
+ while (i < args.length) {
+ args[i++] = arguments[i];
+ }
+ return process.nextTick(function afterTick() {
+ fn.apply(null, args);
+ });
+ }
+}
+
+
+}).call(this,require('_process'))
+},{"_process":92}],92:[function(require,module,exports){
+// shim for using process in browser
+var process = module.exports = {};
+
+// cached from whatever global is present so that test runners that stub it
+// don't break things. But we need to wrap it in a try catch in case it is
+// wrapped in strict mode code which doesn't define any globals. It's inside a
+// function because try/catches deoptimize in certain engines.
+
+var cachedSetTimeout;
+var cachedClearTimeout;
+
+function defaultSetTimout() {
+ throw new Error('setTimeout has not been defined');
+}
+function defaultClearTimeout () {
+ throw new Error('clearTimeout has not been defined');
+}
+(function () {
+ try {
+ if (typeof setTimeout === 'function') {
+ cachedSetTimeout = setTimeout;
+ } else {
+ cachedSetTimeout = defaultSetTimout;
+ }
+ } catch (e) {
+ cachedSetTimeout = defaultSetTimout;
+ }
+ try {
+ if (typeof clearTimeout === 'function') {
+ cachedClearTimeout = clearTimeout;
+ } else {
+ cachedClearTimeout = defaultClearTimeout;
+ }
+ } catch (e) {
+ cachedClearTimeout = defaultClearTimeout;
+ }
+} ())
+function runTimeout(fun) {
+ if (cachedSetTimeout === setTimeout) {
+ //normal enviroments in sane situations
+ return setTimeout(fun, 0);
+ }
+ // if setTimeout wasn't available but was latter defined
+ if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
+ cachedSetTimeout = setTimeout;
+ return setTimeout(fun, 0);
+ }
+ try {
+ // when when somebody has screwed with setTimeout but no I.E. maddness
+ return cachedSetTimeout(fun, 0);
+ } catch(e){
+ try {
+ // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
+ return cachedSetTimeout.call(null, fun, 0);
+ } catch(e){
+ // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
+ return cachedSetTimeout.call(this, fun, 0);
+ }
+ }
+
+
+}
+function runClearTimeout(marker) {
+ if (cachedClearTimeout === clearTimeout) {
+ //normal enviroments in sane situations
+ return clearTimeout(marker);
+ }
+ // if clearTimeout wasn't available but was latter defined
+ if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
+ cachedClearTimeout = clearTimeout;
+ return clearTimeout(marker);
+ }
+ try {
+ // when when somebody has screwed with setTimeout but no I.E. maddness
+ return cachedClearTimeout(marker);
+ } catch (e){
+ try {
+ // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
+ return cachedClearTimeout.call(null, marker);
+ } catch (e){
+ // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
+ // Some versions of I.E. have different rules for clearTimeout vs setTimeout
+ return cachedClearTimeout.call(this, marker);
+ }
+ }
+
+
+
+}
+var queue = [];
+var draining = false;
+var currentQueue;
+var queueIndex = -1;
+
+function cleanUpNextTick() {
+ if (!draining || !currentQueue) {
+ return;
+ }
+ draining = false;
+ if (currentQueue.length) {
+ queue = currentQueue.concat(queue);
+ } else {
+ queueIndex = -1;
+ }
+ if (queue.length) {
+ drainQueue();
+ }
+}
+
+function drainQueue() {
+ if (draining) {
+ return;
+ }
+ var timeout = runTimeout(cleanUpNextTick);
+ draining = true;
+
+ var len = queue.length;
+ while(len) {
+ currentQueue = queue;
+ queue = [];
+ while (++queueIndex < len) {
+ if (currentQueue) {
+ currentQueue[queueIndex].run();
+ }
+ }
+ queueIndex = -1;
+ len = queue.length;
+ }
+ currentQueue = null;
+ draining = false;
+ runClearTimeout(timeout);
+}
+
+process.nextTick = function (fun) {
+ var args = new Array(arguments.length - 1);
+ if (arguments.length > 1) {
+ for (var i = 1; i < arguments.length; i++) {
+ args[i - 1] = arguments[i];
+ }
+ }
+ queue.push(new Item(fun, args));
+ if (queue.length === 1 && !draining) {
+ runTimeout(drainQueue);
+ }
+};
+
+// v8 likes predictible objects
+function Item(fun, array) {
+ this.fun = fun;
+ this.array = array;
+}
+Item.prototype.run = function () {
+ this.fun.apply(null, this.array);
+};
+process.title = 'browser';
+process.browser = true;
+process.env = {};
+process.argv = [];
+process.version = ''; // empty string to avoid regexp issues
+process.versions = {};
+
+function noop() {}
+
+process.on = noop;
+process.addListener = noop;
+process.once = noop;
+process.off = noop;
+process.removeListener = noop;
+process.removeAllListeners = noop;
+process.emit = noop;
+process.prependListener = noop;
+process.prependOnceListener = noop;
+
+process.listeners = function (name) { return [] }
+
+process.binding = function (name) {
+ throw new Error('process.binding is not supported');
+};
+
+process.cwd = function () { return '/' };
+process.chdir = function (dir) {
+ throw new Error('process.chdir is not supported');
+};
+process.umask = function() { return 0; };
+
+},{}],93:[function(require,module,exports){
+(function (global){
+/*! https://mths.be/punycode v1.4.1 by @mathias */
+;(function(root) {
+
+ /** Detect free variables */
+ var freeExports = typeof exports == 'object' && exports &&
+ !exports.nodeType && exports;
+ var freeModule = typeof module == 'object' && module &&
+ !module.nodeType && module;
+ var freeGlobal = typeof global == 'object' && global;
+ if (
+ freeGlobal.global === freeGlobal ||
+ freeGlobal.window === freeGlobal ||
+ freeGlobal.self === freeGlobal
+ ) {
+ root = freeGlobal;
+ }
+
+ /**
+ * The `punycode` object.
+ * @name punycode
+ * @type Object
+ */
+ var punycode,
+
+ /** Highest positive signed 32-bit float value */
+ maxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1
+
+ /** Bootstring parameters */
+ base = 36,
+ tMin = 1,
+ tMax = 26,
+ skew = 38,
+ damp = 700,
+ initialBias = 72,
+ initialN = 128, // 0x80
+ delimiter = '-', // '\x2D'
+
+ /** Regular expressions */
+ regexPunycode = /^xn--/,
+ regexNonASCII = /[^\x20-\x7E]/, // unprintable ASCII chars + non-ASCII chars
+ regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g, // RFC 3490 separators
+
+ /** Error messages */
+ errors = {
+ 'overflow': 'Overflow: input needs wider integers to process',
+ 'not-basic': 'Illegal input >= 0x80 (not a basic code point)',
+ 'invalid-input': 'Invalid input'
+ },
+
+ /** Convenience shortcuts */
+ baseMinusTMin = base - tMin,
+ floor = Math.floor,
+ stringFromCharCode = String.fromCharCode,
+
+ /** Temporary variable */
+ key;
+
+ /*--------------------------------------------------------------------------*/
+
+ /**
+ * A generic error utility function.
+ * @private
+ * @param {String} type The error type.
+ * @returns {Error} Throws a `RangeError` with the applicable error message.
+ */
+ function error(type) {
+ throw new RangeError(errors[type]);
+ }
+
+ /**
+ * A generic `Array#map` utility function.
+ * @private
+ * @param {Array} array The array to iterate over.
+ * @param {Function} callback The function that gets called for every array
+ * item.
+ * @returns {Array} A new array of values returned by the callback function.
+ */
+ function map(array, fn) {
+ var length = array.length;
+ var result = [];
+ while (length--) {
+ result[length] = fn(array[length]);
+ }
+ return result;
+ }
+
+ /**
+ * A simple `Array#map`-like wrapper to work with domain name strings or email
+ * addresses.
+ * @private
+ * @param {String} domain The domain name or email address.
+ * @param {Function} callback The function that gets called for every
+ * character.
+ * @returns {Array} A new string of characters returned by the callback
+ * function.
+ */
+ function mapDomain(string, fn) {
+ var parts = string.split('@');
+ var result = '';
+ if (parts.length > 1) {
+ // In email addresses, only the domain name should be punycoded. Leave
+ // the local part (i.e. everything up to `@`) intact.
+ result = parts[0] + '@';
+ string = parts[1];
+ }
+ // Avoid `split(regex)` for IE8 compatibility. See #17.
+ string = string.replace(regexSeparators, '\x2E');
+ var labels = string.split('.');
+ var encoded = map(labels, fn).join('.');
+ return result + encoded;
+ }
+
+ /**
+ * Creates an array containing the numeric code points of each Unicode
+ * character in the string. While JavaScript uses UCS-2 internally,
+ * this function will convert a pair of surrogate halves (each of which
+ * UCS-2 exposes as separate characters) into a single code point,
+ * matching UTF-16.
+ * @see `punycode.ucs2.encode`
+ * @see
+ * @memberOf punycode.ucs2
+ * @name decode
+ * @param {String} string The Unicode input string (UCS-2).
+ * @returns {Array} The new array of code points.
+ */
+ function ucs2decode(string) {
+ var output = [],
+ counter = 0,
+ length = string.length,
+ value,
+ extra;
+ while (counter < length) {
+ value = string.charCodeAt(counter++);
+ if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
+ // high surrogate, and there is a next character
+ extra = string.charCodeAt(counter++);
+ if ((extra & 0xFC00) == 0xDC00) { // low surrogate
+ output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
+ } else {
+ // unmatched surrogate; only append this code unit, in case the next
+ // code unit is the high surrogate of a surrogate pair
+ output.push(value);
+ counter--;
+ }
+ } else {
+ output.push(value);
+ }
+ }
+ return output;
+ }
+
+ /**
+ * Creates a string based on an array of numeric code points.
+ * @see `punycode.ucs2.decode`
+ * @memberOf punycode.ucs2
+ * @name encode
+ * @param {Array} codePoints The array of numeric code points.
+ * @returns {String} The new Unicode string (UCS-2).
+ */
+ function ucs2encode(array) {
+ return map(array, function(value) {
+ var output = '';
+ if (value > 0xFFFF) {
+ value -= 0x10000;
+ output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);
+ value = 0xDC00 | value & 0x3FF;
+ }
+ output += stringFromCharCode(value);
+ return output;
+ }).join('');
+ }
+
+ /**
+ * Converts a basic code point into a digit/integer.
+ * @see `digitToBasic()`
+ * @private
+ * @param {Number} codePoint The basic numeric code point value.
+ * @returns {Number} The numeric value of a basic code point (for use in
+ * representing integers) in the range `0` to `base - 1`, or `base` if
+ * the code point does not represent a value.
+ */
+ function basicToDigit(codePoint) {
+ if (codePoint - 48 < 10) {
+ return codePoint - 22;
+ }
+ if (codePoint - 65 < 26) {
+ return codePoint - 65;
+ }
+ if (codePoint - 97 < 26) {
+ return codePoint - 97;
+ }
+ return base;
+ }
+
+ /**
+ * Converts a digit/integer into a basic code point.
+ * @see `basicToDigit()`
+ * @private
+ * @param {Number} digit The numeric value of a basic code point.
+ * @returns {Number} The basic code point whose value (when used for
+ * representing integers) is `digit`, which needs to be in the range
+ * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is
+ * used; else, the lowercase form is used. The behavior is undefined
+ * if `flag` is non-zero and `digit` has no uppercase form.
+ */
+ function digitToBasic(digit, flag) {
+ // 0..25 map to ASCII a..z or A..Z
+ // 26..35 map to ASCII 0..9
+ return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
+ }
+
+ /**
+ * Bias adaptation function as per section 3.4 of RFC 3492.
+ * https://tools.ietf.org/html/rfc3492#section-3.4
+ * @private
+ */
+ function adapt(delta, numPoints, firstTime) {
+ var k = 0;
+ delta = firstTime ? floor(delta / damp) : delta >> 1;
+ delta += floor(delta / numPoints);
+ for (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {
+ delta = floor(delta / baseMinusTMin);
+ }
+ return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
+ }
+
+ /**
+ * Converts a Punycode string of ASCII-only symbols to a string of Unicode
+ * symbols.
+ * @memberOf punycode
+ * @param {String} input The Punycode string of ASCII-only symbols.
+ * @returns {String} The resulting string of Unicode symbols.
+ */
+ function decode(input) {
+ // Don't use UCS-2
+ var output = [],
+ inputLength = input.length,
+ out,
+ i = 0,
+ n = initialN,
+ bias = initialBias,
+ basic,
+ j,
+ index,
+ oldi,
+ w,
+ k,
+ digit,
+ t,
+ /** Cached calculation results */
+ baseMinusT;
+
+ // Handle the basic code points: let `basic` be the number of input code
+ // points before the last delimiter, or `0` if there is none, then copy
+ // the first basic code points to the output.
+
+ basic = input.lastIndexOf(delimiter);
+ if (basic < 0) {
+ basic = 0;
+ }
+
+ for (j = 0; j < basic; ++j) {
+ // if it's not a basic code point
+ if (input.charCodeAt(j) >= 0x80) {
+ error('not-basic');
+ }
+ output.push(input.charCodeAt(j));
+ }
+
+ // Main decoding loop: start just after the last delimiter if any basic code
+ // points were copied; start at the beginning otherwise.
+
+ for (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {
+
+ // `index` is the index of the next character to be consumed.
+ // Decode a generalized variable-length integer into `delta`,
+ // which gets added to `i`. The overflow checking is easier
+ // if we increase `i` as we go, then subtract off its starting
+ // value at the end to obtain `delta`.
+ for (oldi = i, w = 1, k = base; /* no condition */; k += base) {
+
+ if (index >= inputLength) {
+ error('invalid-input');
+ }
+
+ digit = basicToDigit(input.charCodeAt(index++));
+
+ if (digit >= base || digit > floor((maxInt - i) / w)) {
+ error('overflow');
+ }
+
+ i += digit * w;
+ t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
+
+ if (digit < t) {
+ break;
+ }
+
+ baseMinusT = base - t;
+ if (w > floor(maxInt / baseMinusT)) {
+ error('overflow');
+ }
+
+ w *= baseMinusT;
+
+ }
+
+ out = output.length + 1;
+ bias = adapt(i - oldi, out, oldi == 0);
+
+ // `i` was supposed to wrap around from `out` to `0`,
+ // incrementing `n` each time, so we'll fix that now:
+ if (floor(i / out) > maxInt - n) {
+ error('overflow');
+ }
+
+ n += floor(i / out);
+ i %= out;
+
+ // Insert `n` at position `i` of the output
+ output.splice(i++, 0, n);
+
+ }
+
+ return ucs2encode(output);
+ }
+
+ /**
+ * Converts a string of Unicode symbols (e.g. a domain name label) to a
+ * Punycode string of ASCII-only symbols.
+ * @memberOf punycode
+ * @param {String} input The string of Unicode symbols.
+ * @returns {String} The resulting Punycode string of ASCII-only symbols.
+ */
+ function encode(input) {
+ var n,
+ delta,
+ handledCPCount,
+ basicLength,
+ bias,
+ j,
+ m,
+ q,
+ k,
+ t,
+ currentValue,
+ output = [],
+ /** `inputLength` will hold the number of code points in `input`. */
+ inputLength,
+ /** Cached calculation results */
+ handledCPCountPlusOne,
+ baseMinusT,
+ qMinusT;
+
+ // Convert the input in UCS-2 to Unicode
+ input = ucs2decode(input);
+
+ // Cache the length
+ inputLength = input.length;
+
+ // Initialize the state
+ n = initialN;
+ delta = 0;
+ bias = initialBias;
+
+ // Handle the basic code points
+ for (j = 0; j < inputLength; ++j) {
+ currentValue = input[j];
+ if (currentValue < 0x80) {
+ output.push(stringFromCharCode(currentValue));
+ }
+ }
+
+ handledCPCount = basicLength = output.length;
+
+ // `handledCPCount` is the number of code points that have been handled;
+ // `basicLength` is the number of basic code points.
+
+ // Finish the basic string - if it is not empty - with a delimiter
+ if (basicLength) {
+ output.push(delimiter);
+ }
+
+ // Main encoding loop:
+ while (handledCPCount < inputLength) {
+
+ // All non-basic code points < n have been handled already. Find the next
+ // larger one:
+ for (m = maxInt, j = 0; j < inputLength; ++j) {
+ currentValue = input[j];
+ if (currentValue >= n && currentValue < m) {
+ m = currentValue;
+ }
+ }
+
+ // Increase `delta` enough to advance the decoder's state to ,
+ // but guard against overflow
+ handledCPCountPlusOne = handledCPCount + 1;
+ if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
+ error('overflow');
+ }
+
+ delta += (m - n) * handledCPCountPlusOne;
+ n = m;
+
+ for (j = 0; j < inputLength; ++j) {
+ currentValue = input[j];
+
+ if (currentValue < n && ++delta > maxInt) {
+ error('overflow');
+ }
+
+ if (currentValue == n) {
+ // Represent delta as a generalized variable-length integer
+ for (q = delta, k = base; /* no condition */; k += base) {
+ t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
+ if (q < t) {
+ break;
+ }
+ qMinusT = q - t;
+ baseMinusT = base - t;
+ output.push(
+ stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))
+ );
+ q = floor(qMinusT / baseMinusT);
+ }
+
+ output.push(stringFromCharCode(digitToBasic(q, 0)));
+ bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);
+ delta = 0;
+ ++handledCPCount;
+ }
+ }
+
+ ++delta;
+ ++n;
+
+ }
+ return output.join('');
+ }
+
+ /**
+ * Converts a Punycode string representing a domain name or an email address
+ * to Unicode. Only the Punycoded parts of the input will be converted, i.e.
+ * it doesn't matter if you call it on a string that has already been
+ * converted to Unicode.
+ * @memberOf punycode
+ * @param {String} input The Punycoded domain name or email address to
+ * convert to Unicode.
+ * @returns {String} The Unicode representation of the given Punycode
+ * string.
+ */
+ function toUnicode(input) {
+ return mapDomain(input, function(string) {
+ return regexPunycode.test(string)
+ ? decode(string.slice(4).toLowerCase())
+ : string;
+ });
+ }
+
+ /**
+ * Converts a Unicode string representing a domain name or an email address to
+ * Punycode. Only the non-ASCII parts of the domain name will be converted,
+ * i.e. it doesn't matter if you call it with a domain that's already in
+ * ASCII.
+ * @memberOf punycode
+ * @param {String} input The domain name or email address to convert, as a
+ * Unicode string.
+ * @returns {String} The Punycode representation of the given domain name or
+ * email address.
+ */
+ function toASCII(input) {
+ return mapDomain(input, function(string) {
+ return regexNonASCII.test(string)
+ ? 'xn--' + encode(string)
+ : string;
+ });
+ }
+
+ /*--------------------------------------------------------------------------*/
+
+ /** Define the public API */
+ punycode = {
+ /**
+ * A string representing the current Punycode.js version number.
+ * @memberOf punycode
+ * @type String
+ */
+ 'version': '1.4.1',
+ /**
+ * An object of methods to convert from JavaScript's internal character
+ * representation (UCS-2) to Unicode code points, and back.
+ * @see
+ * @memberOf punycode
+ * @type Object
+ */
+ 'ucs2': {
+ 'decode': ucs2decode,
+ 'encode': ucs2encode
+ },
+ 'decode': decode,
+ 'encode': encode,
+ 'toASCII': toASCII,
+ 'toUnicode': toUnicode
+ };
+
+ /** Expose `punycode` */
+ // Some AMD build optimizers, like r.js, check for specific condition patterns
+ // like the following:
+ if (
+ typeof define == 'function' &&
+ typeof define.amd == 'object' &&
+ define.amd
+ ) {
+ define('punycode', function() {
+ return punycode;
+ });
+ } else if (freeExports && freeModule) {
+ if (module.exports == freeExports) {
+ // in Node.js, io.js, or RingoJS v0.8.0+
+ freeModule.exports = punycode;
+ } else {
+ // in Narwhal or RingoJS v0.7.0-
+ for (key in punycode) {
+ punycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]);
+ }
+ }
+ } else {
+ // in Rhino or a web browser
+ root.punycode = punycode;
+ }
+
+}(this));
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{}],94:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+
+// If obj.hasOwnProperty has been overridden, then calling
+// obj.hasOwnProperty(prop) will break.
+// See: https://github.com/joyent/node/issues/1707
+function hasOwnProperty(obj, prop) {
+ return Object.prototype.hasOwnProperty.call(obj, prop);
+}
+
+module.exports = function(qs, sep, eq, options) {
+ sep = sep || '&';
+ eq = eq || '=';
+ var obj = {};
+
+ if (typeof qs !== 'string' || qs.length === 0) {
+ return obj;
+ }
+
+ var regexp = /\+/g;
+ qs = qs.split(sep);
+
+ var maxKeys = 1000;
+ if (options && typeof options.maxKeys === 'number') {
+ maxKeys = options.maxKeys;
+ }
+
+ var len = qs.length;
+ // maxKeys <= 0 means that we should not limit keys count
+ if (maxKeys > 0 && len > maxKeys) {
+ len = maxKeys;
+ }
+
+ for (var i = 0; i < len; ++i) {
+ var x = qs[i].replace(regexp, '%20'),
+ idx = x.indexOf(eq),
+ kstr, vstr, k, v;
+
+ if (idx >= 0) {
+ kstr = x.substr(0, idx);
+ vstr = x.substr(idx + 1);
+ } else {
+ kstr = x;
+ vstr = '';
+ }
+
+ k = decodeURIComponent(kstr);
+ v = decodeURIComponent(vstr);
+
+ if (!hasOwnProperty(obj, k)) {
+ obj[k] = v;
+ } else if (isArray(obj[k])) {
+ obj[k].push(v);
+ } else {
+ obj[k] = [obj[k], v];
+ }
+ }
+
+ return obj;
+};
+
+var isArray = Array.isArray || function (xs) {
+ return Object.prototype.toString.call(xs) === '[object Array]';
+};
+
+},{}],95:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+
+var stringifyPrimitive = function(v) {
+ switch (typeof v) {
+ case 'string':
+ return v;
+
+ case 'boolean':
+ return v ? 'true' : 'false';
+
+ case 'number':
+ return isFinite(v) ? v : '';
+
+ default:
+ return '';
+ }
+};
+
+module.exports = function(obj, sep, eq, name) {
+ sep = sep || '&';
+ eq = eq || '=';
+ if (obj === null) {
+ obj = undefined;
+ }
+
+ if (typeof obj === 'object') {
+ return map(objectKeys(obj), function(k) {
+ var ks = encodeURIComponent(stringifyPrimitive(k)) + eq;
+ if (isArray(obj[k])) {
+ return map(obj[k], function(v) {
+ return ks + encodeURIComponent(stringifyPrimitive(v));
+ }).join(sep);
+ } else {
+ return ks + encodeURIComponent(stringifyPrimitive(obj[k]));
+ }
+ }).join(sep);
+
+ }
+
+ if (!name) return '';
+ return encodeURIComponent(stringifyPrimitive(name)) + eq +
+ encodeURIComponent(stringifyPrimitive(obj));
+};
+
+var isArray = Array.isArray || function (xs) {
+ return Object.prototype.toString.call(xs) === '[object Array]';
+};
+
+function map (xs, f) {
+ if (xs.map) return xs.map(f);
+ var res = [];
+ for (var i = 0; i < xs.length; i++) {
+ res.push(f(xs[i], i));
+ }
+ return res;
+}
+
+var objectKeys = Object.keys || function (obj) {
+ var res = [];
+ for (var key in obj) {
+ if (Object.prototype.hasOwnProperty.call(obj, key)) res.push(key);
+ }
+ return res;
+};
+
+},{}],96:[function(require,module,exports){
+'use strict';
+
+exports.decode = exports.parse = require('./decode');
+exports.encode = exports.stringify = require('./encode');
+
+},{"./decode":94,"./encode":95}],97:[function(require,module,exports){
+module.exports = require('./lib/_stream_duplex.js');
+
+},{"./lib/_stream_duplex.js":98}],98:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// a duplex stream is just a stream that is both readable and writable.
+// Since JS doesn't have multiple prototypal inheritance, this class
+// prototypally inherits from Readable, and then parasitically from
+// Writable.
+
+'use strict';
+
+/**/
+
+var pna = require('process-nextick-args');
+/**/
+
+/**/
+var objectKeys = Object.keys || function (obj) {
+ var keys = [];
+ for (var key in obj) {
+ keys.push(key);
+ }return keys;
+};
+/**/
+
+module.exports = Duplex;
+
+/**/
+var util = require('core-util-is');
+util.inherits = require('inherits');
+/**/
+
+var Readable = require('./_stream_readable');
+var Writable = require('./_stream_writable');
+
+util.inherits(Duplex, Readable);
+
+{
+ // avoid scope creep, the keys array can then be collected
+ var keys = objectKeys(Writable.prototype);
+ for (var v = 0; v < keys.length; v++) {
+ var method = keys[v];
+ if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];
+ }
+}
+
+function Duplex(options) {
+ if (!(this instanceof Duplex)) return new Duplex(options);
+
+ Readable.call(this, options);
+ Writable.call(this, options);
+
+ if (options && options.readable === false) this.readable = false;
+
+ if (options && options.writable === false) this.writable = false;
+
+ this.allowHalfOpen = true;
+ if (options && options.allowHalfOpen === false) this.allowHalfOpen = false;
+
+ this.once('end', onend);
+}
+
+Object.defineProperty(Duplex.prototype, 'writableHighWaterMark', {
+ // making it explicit this property is not enumerable
+ // because otherwise some prototype manipulation in
+ // userland will fail
+ enumerable: false,
+ get: function () {
+ return this._writableState.highWaterMark;
+ }
+});
+
+// the no-half-open enforcer
+function onend() {
+ // if we allow half-open state, or if the writable side ended,
+ // then we're ok.
+ if (this.allowHalfOpen || this._writableState.ended) return;
+
+ // no more data can be written.
+ // But allow more writes to happen in this tick.
+ pna.nextTick(onEndNT, this);
+}
+
+function onEndNT(self) {
+ self.end();
+}
+
+Object.defineProperty(Duplex.prototype, 'destroyed', {
+ get: function () {
+ if (this._readableState === undefined || this._writableState === undefined) {
+ return false;
+ }
+ return this._readableState.destroyed && this._writableState.destroyed;
+ },
+ set: function (value) {
+ // we ignore the value if the stream
+ // has not been initialized yet
+ if (this._readableState === undefined || this._writableState === undefined) {
+ return;
+ }
+
+ // backward compatibility, the user is explicitly
+ // managing destroyed
+ this._readableState.destroyed = value;
+ this._writableState.destroyed = value;
+ }
+});
+
+Duplex.prototype._destroy = function (err, cb) {
+ this.push(null);
+ this.end();
+
+ pna.nextTick(cb, err);
+};
+},{"./_stream_readable":100,"./_stream_writable":102,"core-util-is":14,"inherits":80,"process-nextick-args":91}],99:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// a passthrough stream.
+// basically just the most minimal sort of Transform stream.
+// Every written chunk gets output as-is.
+
+'use strict';
+
+module.exports = PassThrough;
+
+var Transform = require('./_stream_transform');
+
+/**/
+var util = require('core-util-is');
+util.inherits = require('inherits');
+/**/
+
+util.inherits(PassThrough, Transform);
+
+function PassThrough(options) {
+ if (!(this instanceof PassThrough)) return new PassThrough(options);
+
+ Transform.call(this, options);
+}
+
+PassThrough.prototype._transform = function (chunk, encoding, cb) {
+ cb(null, chunk);
+};
+},{"./_stream_transform":101,"core-util-is":14,"inherits":80}],100:[function(require,module,exports){
+(function (process,global){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+
+/**/
+
+var pna = require('process-nextick-args');
+/**/
+
+module.exports = Readable;
+
+/**/
+var isArray = require('isarray');
+/**/
+
+/**/
+var Duplex;
+/**/
+
+Readable.ReadableState = ReadableState;
+
+/**/
+var EE = require('events').EventEmitter;
+
+var EElistenerCount = function (emitter, type) {
+ return emitter.listeners(type).length;
+};
+/**/
+
+/**/
+var Stream = require('./internal/streams/stream');
+/**/
+
+/**/
+
+var Buffer = require('safe-buffer').Buffer;
+var OurUint8Array = global.Uint8Array || function () {};
+function _uint8ArrayToBuffer(chunk) {
+ return Buffer.from(chunk);
+}
+function _isUint8Array(obj) {
+ return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
+}
+
+/**/
+
+/**/
+var util = require('core-util-is');
+util.inherits = require('inherits');
+/**/
+
+/**/
+var debugUtil = require('util');
+var debug = void 0;
+if (debugUtil && debugUtil.debuglog) {
+ debug = debugUtil.debuglog('stream');
+} else {
+ debug = function () {};
+}
+/**/
+
+var BufferList = require('./internal/streams/BufferList');
+var destroyImpl = require('./internal/streams/destroy');
+var StringDecoder;
+
+util.inherits(Readable, Stream);
+
+var kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];
+
+function prependListener(emitter, event, fn) {
+ // Sadly this is not cacheable as some libraries bundle their own
+ // event emitter implementation with them.
+ if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn);
+
+ // This is a hack to make sure that our error handler is attached before any
+ // userland ones. NEVER DO THIS. This is here only because this code needs
+ // to continue to work with older versions of Node.js that do not include
+ // the prependListener() method. The goal is to eventually remove this hack.
+ if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]];
+}
+
+function ReadableState(options, stream) {
+ Duplex = Duplex || require('./_stream_duplex');
+
+ options = options || {};
+
+ // Duplex streams are both readable and writable, but share
+ // the same options object.
+ // However, some cases require setting options to different
+ // values for the readable and the writable sides of the duplex stream.
+ // These options can be provided separately as readableXXX and writableXXX.
+ var isDuplex = stream instanceof Duplex;
+
+ // object stream flag. Used to make read(n) ignore n and to
+ // make all the buffer merging and length checks go away
+ this.objectMode = !!options.objectMode;
+
+ if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode;
+
+ // the point at which it stops calling _read() to fill the buffer
+ // Note: 0 is a valid value, means "don't call _read preemptively ever"
+ var hwm = options.highWaterMark;
+ var readableHwm = options.readableHighWaterMark;
+ var defaultHwm = this.objectMode ? 16 : 16 * 1024;
+
+ if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (readableHwm || readableHwm === 0)) this.highWaterMark = readableHwm;else this.highWaterMark = defaultHwm;
+
+ // cast to ints.
+ this.highWaterMark = Math.floor(this.highWaterMark);
+
+ // A linked list is used to store data chunks instead of an array because the
+ // linked list can remove elements from the beginning faster than
+ // array.shift()
+ this.buffer = new BufferList();
+ this.length = 0;
+ this.pipes = null;
+ this.pipesCount = 0;
+ this.flowing = null;
+ this.ended = false;
+ this.endEmitted = false;
+ this.reading = false;
+
+ // a flag to be able to tell if the event 'readable'/'data' is emitted
+ // immediately, or on a later tick. We set this to true at first, because
+ // any actions that shouldn't happen until "later" should generally also
+ // not happen before the first read call.
+ this.sync = true;
+
+ // whenever we return null, then we set a flag to say
+ // that we're awaiting a 'readable' event emission.
+ this.needReadable = false;
+ this.emittedReadable = false;
+ this.readableListening = false;
+ this.resumeScheduled = false;
+
+ // has it been destroyed
+ this.destroyed = false;
+
+ // Crypto is kind of old and crusty. Historically, its default string
+ // encoding is 'binary' so we have to make this configurable.
+ // Everything else in the universe uses 'utf8', though.
+ this.defaultEncoding = options.defaultEncoding || 'utf8';
+
+ // the number of writers that are awaiting a drain event in .pipe()s
+ this.awaitDrain = 0;
+
+ // if true, a maybeReadMore has been scheduled
+ this.readingMore = false;
+
+ this.decoder = null;
+ this.encoding = null;
+ if (options.encoding) {
+ if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;
+ this.decoder = new StringDecoder(options.encoding);
+ this.encoding = options.encoding;
+ }
+}
+
+function Readable(options) {
+ Duplex = Duplex || require('./_stream_duplex');
+
+ if (!(this instanceof Readable)) return new Readable(options);
+
+ this._readableState = new ReadableState(options, this);
+
+ // legacy
+ this.readable = true;
+
+ if (options) {
+ if (typeof options.read === 'function') this._read = options.read;
+
+ if (typeof options.destroy === 'function') this._destroy = options.destroy;
+ }
+
+ Stream.call(this);
+}
+
+Object.defineProperty(Readable.prototype, 'destroyed', {
+ get: function () {
+ if (this._readableState === undefined) {
+ return false;
+ }
+ return this._readableState.destroyed;
+ },
+ set: function (value) {
+ // we ignore the value if the stream
+ // has not been initialized yet
+ if (!this._readableState) {
+ return;
+ }
+
+ // backward compatibility, the user is explicitly
+ // managing destroyed
+ this._readableState.destroyed = value;
+ }
+});
+
+Readable.prototype.destroy = destroyImpl.destroy;
+Readable.prototype._undestroy = destroyImpl.undestroy;
+Readable.prototype._destroy = function (err, cb) {
+ this.push(null);
+ cb(err);
+};
+
+// Manually shove something into the read() buffer.
+// This returns true if the highWaterMark has not been hit yet,
+// similar to how Writable.write() returns true if you should
+// write() some more.
+Readable.prototype.push = function (chunk, encoding) {
+ var state = this._readableState;
+ var skipChunkCheck;
+
+ if (!state.objectMode) {
+ if (typeof chunk === 'string') {
+ encoding = encoding || state.defaultEncoding;
+ if (encoding !== state.encoding) {
+ chunk = Buffer.from(chunk, encoding);
+ encoding = '';
+ }
+ skipChunkCheck = true;
+ }
+ } else {
+ skipChunkCheck = true;
+ }
+
+ return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);
+};
+
+// Unshift should *always* be something directly out of read()
+Readable.prototype.unshift = function (chunk) {
+ return readableAddChunk(this, chunk, null, true, false);
+};
+
+function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {
+ var state = stream._readableState;
+ if (chunk === null) {
+ state.reading = false;
+ onEofChunk(stream, state);
+ } else {
+ var er;
+ if (!skipChunkCheck) er = chunkInvalid(state, chunk);
+ if (er) {
+ stream.emit('error', er);
+ } else if (state.objectMode || chunk && chunk.length > 0) {
+ if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {
+ chunk = _uint8ArrayToBuffer(chunk);
+ }
+
+ if (addToFront) {
+ if (state.endEmitted) stream.emit('error', new Error('stream.unshift() after end event'));else addChunk(stream, state, chunk, true);
+ } else if (state.ended) {
+ stream.emit('error', new Error('stream.push() after EOF'));
+ } else {
+ state.reading = false;
+ if (state.decoder && !encoding) {
+ chunk = state.decoder.write(chunk);
+ if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state);
+ } else {
+ addChunk(stream, state, chunk, false);
+ }
+ }
+ } else if (!addToFront) {
+ state.reading = false;
+ }
+ }
+
+ return needMoreData(state);
+}
+
+function addChunk(stream, state, chunk, addToFront) {
+ if (state.flowing && state.length === 0 && !state.sync) {
+ stream.emit('data', chunk);
+ stream.read(0);
+ } else {
+ // update the buffer info.
+ state.length += state.objectMode ? 1 : chunk.length;
+ if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);
+
+ if (state.needReadable) emitReadable(stream);
+ }
+ maybeReadMore(stream, state);
+}
+
+function chunkInvalid(state, chunk) {
+ var er;
+ if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {
+ er = new TypeError('Invalid non-string/buffer chunk');
+ }
+ return er;
+}
+
+// if it's past the high water mark, we can push in some more.
+// Also, if we have no data yet, we can stand some
+// more bytes. This is to work around cases where hwm=0,
+// such as the repl. Also, if the push() triggered a
+// readable event, and the user called read(largeNumber) such that
+// needReadable was set, then we ought to push more, so that another
+// 'readable' event will be triggered.
+function needMoreData(state) {
+ return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0);
+}
+
+Readable.prototype.isPaused = function () {
+ return this._readableState.flowing === false;
+};
+
+// backwards compatibility.
+Readable.prototype.setEncoding = function (enc) {
+ if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;
+ this._readableState.decoder = new StringDecoder(enc);
+ this._readableState.encoding = enc;
+ return this;
+};
+
+// Don't raise the hwm > 8MB
+var MAX_HWM = 0x800000;
+function computeNewHighWaterMark(n) {
+ if (n >= MAX_HWM) {
+ n = MAX_HWM;
+ } else {
+ // Get the next highest power of 2 to prevent increasing hwm excessively in
+ // tiny amounts
+ n--;
+ n |= n >>> 1;
+ n |= n >>> 2;
+ n |= n >>> 4;
+ n |= n >>> 8;
+ n |= n >>> 16;
+ n++;
+ }
+ return n;
+}
+
+// This function is designed to be inlinable, so please take care when making
+// changes to the function body.
+function howMuchToRead(n, state) {
+ if (n <= 0 || state.length === 0 && state.ended) return 0;
+ if (state.objectMode) return 1;
+ if (n !== n) {
+ // Only flow one buffer at a time
+ if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;
+ }
+ // If we're asking for more than the current hwm, then raise the hwm.
+ if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);
+ if (n <= state.length) return n;
+ // Don't have enough
+ if (!state.ended) {
+ state.needReadable = true;
+ return 0;
+ }
+ return state.length;
+}
+
+// you can override either this method, or the async _read(n) below.
+Readable.prototype.read = function (n) {
+ debug('read', n);
+ n = parseInt(n, 10);
+ var state = this._readableState;
+ var nOrig = n;
+
+ if (n !== 0) state.emittedReadable = false;
+
+ // if we're doing read(0) to trigger a readable event, but we
+ // already have a bunch of data in the buffer, then just trigger
+ // the 'readable' event and move on.
+ if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) {
+ debug('read: emitReadable', state.length, state.ended);
+ if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this);
+ return null;
+ }
+
+ n = howMuchToRead(n, state);
+
+ // if we've ended, and we're now clear, then finish it up.
+ if (n === 0 && state.ended) {
+ if (state.length === 0) endReadable(this);
+ return null;
+ }
+
+ // All the actual chunk generation logic needs to be
+ // *below* the call to _read. The reason is that in certain
+ // synthetic stream cases, such as passthrough streams, _read
+ // may be a completely synchronous operation which may change
+ // the state of the read buffer, providing enough data when
+ // before there was *not* enough.
+ //
+ // So, the steps are:
+ // 1. Figure out what the state of things will be after we do
+ // a read from the buffer.
+ //
+ // 2. If that resulting state will trigger a _read, then call _read.
+ // Note that this may be asynchronous, or synchronous. Yes, it is
+ // deeply ugly to write APIs this way, but that still doesn't mean
+ // that the Readable class should behave improperly, as streams are
+ // designed to be sync/async agnostic.
+ // Take note if the _read call is sync or async (ie, if the read call
+ // has returned yet), so that we know whether or not it's safe to emit
+ // 'readable' etc.
+ //
+ // 3. Actually pull the requested chunks out of the buffer and return.
+
+ // if we need a readable event, then we need to do some reading.
+ var doRead = state.needReadable;
+ debug('need readable', doRead);
+
+ // if we currently have less than the highWaterMark, then also read some
+ if (state.length === 0 || state.length - n < state.highWaterMark) {
+ doRead = true;
+ debug('length less than watermark', doRead);
+ }
+
+ // however, if we've ended, then there's no point, and if we're already
+ // reading, then it's unnecessary.
+ if (state.ended || state.reading) {
+ doRead = false;
+ debug('reading or ended', doRead);
+ } else if (doRead) {
+ debug('do read');
+ state.reading = true;
+ state.sync = true;
+ // if the length is currently zero, then we *need* a readable event.
+ if (state.length === 0) state.needReadable = true;
+ // call internal read method
+ this._read(state.highWaterMark);
+ state.sync = false;
+ // If _read pushed data synchronously, then `reading` will be false,
+ // and we need to re-evaluate how much data we can return to the user.
+ if (!state.reading) n = howMuchToRead(nOrig, state);
+ }
+
+ var ret;
+ if (n > 0) ret = fromList(n, state);else ret = null;
+
+ if (ret === null) {
+ state.needReadable = true;
+ n = 0;
+ } else {
+ state.length -= n;
+ }
+
+ if (state.length === 0) {
+ // If we have nothing in the buffer, then we want to know
+ // as soon as we *do* get something into the buffer.
+ if (!state.ended) state.needReadable = true;
+
+ // If we tried to read() past the EOF, then emit end on the next tick.
+ if (nOrig !== n && state.ended) endReadable(this);
+ }
+
+ if (ret !== null) this.emit('data', ret);
+
+ return ret;
+};
+
+function onEofChunk(stream, state) {
+ if (state.ended) return;
+ if (state.decoder) {
+ var chunk = state.decoder.end();
+ if (chunk && chunk.length) {
+ state.buffer.push(chunk);
+ state.length += state.objectMode ? 1 : chunk.length;
+ }
+ }
+ state.ended = true;
+
+ // emit 'readable' now to make sure it gets picked up.
+ emitReadable(stream);
+}
+
+// Don't emit readable right away in sync mode, because this can trigger
+// another read() call => stack overflow. This way, it might trigger
+// a nextTick recursion warning, but that's not so bad.
+function emitReadable(stream) {
+ var state = stream._readableState;
+ state.needReadable = false;
+ if (!state.emittedReadable) {
+ debug('emitReadable', state.flowing);
+ state.emittedReadable = true;
+ if (state.sync) pna.nextTick(emitReadable_, stream);else emitReadable_(stream);
+ }
+}
+
+function emitReadable_(stream) {
+ debug('emit readable');
+ stream.emit('readable');
+ flow(stream);
+}
+
+// at this point, the user has presumably seen the 'readable' event,
+// and called read() to consume some data. that may have triggered
+// in turn another _read(n) call, in which case reading = true if
+// it's in progress.
+// However, if we're not ended, or reading, and the length < hwm,
+// then go ahead and try to read some more preemptively.
+function maybeReadMore(stream, state) {
+ if (!state.readingMore) {
+ state.readingMore = true;
+ pna.nextTick(maybeReadMore_, stream, state);
+ }
+}
+
+function maybeReadMore_(stream, state) {
+ var len = state.length;
+ while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) {
+ debug('maybeReadMore read 0');
+ stream.read(0);
+ if (len === state.length)
+ // didn't get any data, stop spinning.
+ break;else len = state.length;
+ }
+ state.readingMore = false;
+}
+
+// abstract method. to be overridden in specific implementation classes.
+// call cb(er, data) where data is <= n in length.
+// for virtual (non-string, non-buffer) streams, "length" is somewhat
+// arbitrary, and perhaps not very meaningful.
+Readable.prototype._read = function (n) {
+ this.emit('error', new Error('_read() is not implemented'));
+};
+
+Readable.prototype.pipe = function (dest, pipeOpts) {
+ var src = this;
+ var state = this._readableState;
+
+ switch (state.pipesCount) {
+ case 0:
+ state.pipes = dest;
+ break;
+ case 1:
+ state.pipes = [state.pipes, dest];
+ break;
+ default:
+ state.pipes.push(dest);
+ break;
+ }
+ state.pipesCount += 1;
+ debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);
+
+ var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;
+
+ var endFn = doEnd ? onend : unpipe;
+ if (state.endEmitted) pna.nextTick(endFn);else src.once('end', endFn);
+
+ dest.on('unpipe', onunpipe);
+ function onunpipe(readable, unpipeInfo) {
+ debug('onunpipe');
+ if (readable === src) {
+ if (unpipeInfo && unpipeInfo.hasUnpiped === false) {
+ unpipeInfo.hasUnpiped = true;
+ cleanup();
+ }
+ }
+ }
+
+ function onend() {
+ debug('onend');
+ dest.end();
+ }
+
+ // when the dest drains, it reduces the awaitDrain counter
+ // on the source. This would be more elegant with a .once()
+ // handler in flow(), but adding and removing repeatedly is
+ // too slow.
+ var ondrain = pipeOnDrain(src);
+ dest.on('drain', ondrain);
+
+ var cleanedUp = false;
+ function cleanup() {
+ debug('cleanup');
+ // cleanup event handlers once the pipe is broken
+ dest.removeListener('close', onclose);
+ dest.removeListener('finish', onfinish);
+ dest.removeListener('drain', ondrain);
+ dest.removeListener('error', onerror);
+ dest.removeListener('unpipe', onunpipe);
+ src.removeListener('end', onend);
+ src.removeListener('end', unpipe);
+ src.removeListener('data', ondata);
+
+ cleanedUp = true;
+
+ // if the reader is waiting for a drain event from this
+ // specific writer, then it would cause it to never start
+ // flowing again.
+ // So, if this is awaiting a drain, then we just call it now.
+ // If we don't know, then assume that we are waiting for one.
+ if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();
+ }
+
+ // If the user pushes more data while we're writing to dest then we'll end up
+ // in ondata again. However, we only want to increase awaitDrain once because
+ // dest will only emit one 'drain' event for the multiple writes.
+ // => Introduce a guard on increasing awaitDrain.
+ var increasedAwaitDrain = false;
+ src.on('data', ondata);
+ function ondata(chunk) {
+ debug('ondata');
+ increasedAwaitDrain = false;
+ var ret = dest.write(chunk);
+ if (false === ret && !increasedAwaitDrain) {
+ // If the user unpiped during `dest.write()`, it is possible
+ // to get stuck in a permanently paused state if that write
+ // also returned false.
+ // => Check whether `dest` is still a piping destination.
+ if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {
+ debug('false write response, pause', src._readableState.awaitDrain);
+ src._readableState.awaitDrain++;
+ increasedAwaitDrain = true;
+ }
+ src.pause();
+ }
+ }
+
+ // if the dest has an error, then stop piping into it.
+ // however, don't suppress the throwing behavior for this.
+ function onerror(er) {
+ debug('onerror', er);
+ unpipe();
+ dest.removeListener('error', onerror);
+ if (EElistenerCount(dest, 'error') === 0) dest.emit('error', er);
+ }
+
+ // Make sure our error handler is attached before userland ones.
+ prependListener(dest, 'error', onerror);
+
+ // Both close and finish should trigger unpipe, but only once.
+ function onclose() {
+ dest.removeListener('finish', onfinish);
+ unpipe();
+ }
+ dest.once('close', onclose);
+ function onfinish() {
+ debug('onfinish');
+ dest.removeListener('close', onclose);
+ unpipe();
+ }
+ dest.once('finish', onfinish);
+
+ function unpipe() {
+ debug('unpipe');
+ src.unpipe(dest);
+ }
+
+ // tell the dest that it's being piped to
+ dest.emit('pipe', src);
+
+ // start the flow if it hasn't been started already.
+ if (!state.flowing) {
+ debug('pipe resume');
+ src.resume();
+ }
+
+ return dest;
+};
+
+function pipeOnDrain(src) {
+ return function () {
+ var state = src._readableState;
+ debug('pipeOnDrain', state.awaitDrain);
+ if (state.awaitDrain) state.awaitDrain--;
+ if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {
+ state.flowing = true;
+ flow(src);
+ }
+ };
+}
+
+Readable.prototype.unpipe = function (dest) {
+ var state = this._readableState;
+ var unpipeInfo = { hasUnpiped: false };
+
+ // if we're not piping anywhere, then do nothing.
+ if (state.pipesCount === 0) return this;
+
+ // just one destination. most common case.
+ if (state.pipesCount === 1) {
+ // passed in one, but it's not the right one.
+ if (dest && dest !== state.pipes) return this;
+
+ if (!dest) dest = state.pipes;
+
+ // got a match.
+ state.pipes = null;
+ state.pipesCount = 0;
+ state.flowing = false;
+ if (dest) dest.emit('unpipe', this, unpipeInfo);
+ return this;
+ }
+
+ // slow case. multiple pipe destinations.
+
+ if (!dest) {
+ // remove all.
+ var dests = state.pipes;
+ var len = state.pipesCount;
+ state.pipes = null;
+ state.pipesCount = 0;
+ state.flowing = false;
+
+ for (var i = 0; i < len; i++) {
+ dests[i].emit('unpipe', this, unpipeInfo);
+ }return this;
+ }
+
+ // try to find the right one.
+ var index = indexOf(state.pipes, dest);
+ if (index === -1) return this;
+
+ state.pipes.splice(index, 1);
+ state.pipesCount -= 1;
+ if (state.pipesCount === 1) state.pipes = state.pipes[0];
+
+ dest.emit('unpipe', this, unpipeInfo);
+
+ return this;
+};
+
+// set up data events if they are asked for
+// Ensure readable listeners eventually get something
+Readable.prototype.on = function (ev, fn) {
+ var res = Stream.prototype.on.call(this, ev, fn);
+
+ if (ev === 'data') {
+ // Start flowing on next tick if stream isn't explicitly paused
+ if (this._readableState.flowing !== false) this.resume();
+ } else if (ev === 'readable') {
+ var state = this._readableState;
+ if (!state.endEmitted && !state.readableListening) {
+ state.readableListening = state.needReadable = true;
+ state.emittedReadable = false;
+ if (!state.reading) {
+ pna.nextTick(nReadingNextTick, this);
+ } else if (state.length) {
+ emitReadable(this);
+ }
+ }
+ }
+
+ return res;
+};
+Readable.prototype.addListener = Readable.prototype.on;
+
+function nReadingNextTick(self) {
+ debug('readable nexttick read 0');
+ self.read(0);
+}
+
+// pause() and resume() are remnants of the legacy readable stream API
+// If the user uses them, then switch into old mode.
+Readable.prototype.resume = function () {
+ var state = this._readableState;
+ if (!state.flowing) {
+ debug('resume');
+ state.flowing = true;
+ resume(this, state);
+ }
+ return this;
+};
+
+function resume(stream, state) {
+ if (!state.resumeScheduled) {
+ state.resumeScheduled = true;
+ pna.nextTick(resume_, stream, state);
+ }
+}
+
+function resume_(stream, state) {
+ if (!state.reading) {
+ debug('resume read 0');
+ stream.read(0);
+ }
+
+ state.resumeScheduled = false;
+ state.awaitDrain = 0;
+ stream.emit('resume');
+ flow(stream);
+ if (state.flowing && !state.reading) stream.read(0);
+}
+
+Readable.prototype.pause = function () {
+ debug('call pause flowing=%j', this._readableState.flowing);
+ if (false !== this._readableState.flowing) {
+ debug('pause');
+ this._readableState.flowing = false;
+ this.emit('pause');
+ }
+ return this;
+};
+
+function flow(stream) {
+ var state = stream._readableState;
+ debug('flow', state.flowing);
+ while (state.flowing && stream.read() !== null) {}
+}
+
+// wrap an old-style stream as the async data source.
+// This is *not* part of the readable stream interface.
+// It is an ugly unfortunate mess of history.
+Readable.prototype.wrap = function (stream) {
+ var _this = this;
+
+ var state = this._readableState;
+ var paused = false;
+
+ stream.on('end', function () {
+ debug('wrapped end');
+ if (state.decoder && !state.ended) {
+ var chunk = state.decoder.end();
+ if (chunk && chunk.length) _this.push(chunk);
+ }
+
+ _this.push(null);
+ });
+
+ stream.on('data', function (chunk) {
+ debug('wrapped data');
+ if (state.decoder) chunk = state.decoder.write(chunk);
+
+ // don't skip over falsy values in objectMode
+ if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;
+
+ var ret = _this.push(chunk);
+ if (!ret) {
+ paused = true;
+ stream.pause();
+ }
+ });
+
+ // proxy all the other methods.
+ // important when wrapping filters and duplexes.
+ for (var i in stream) {
+ if (this[i] === undefined && typeof stream[i] === 'function') {
+ this[i] = function (method) {
+ return function () {
+ return stream[method].apply(stream, arguments);
+ };
+ }(i);
+ }
+ }
+
+ // proxy certain important events.
+ for (var n = 0; n < kProxyEvents.length; n++) {
+ stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));
+ }
+
+ // when we try to consume some more bytes, simply unpause the
+ // underlying stream.
+ this._read = function (n) {
+ debug('wrapped _read', n);
+ if (paused) {
+ paused = false;
+ stream.resume();
+ }
+ };
+
+ return this;
+};
+
+Object.defineProperty(Readable.prototype, 'readableHighWaterMark', {
+ // making it explicit this property is not enumerable
+ // because otherwise some prototype manipulation in
+ // userland will fail
+ enumerable: false,
+ get: function () {
+ return this._readableState.highWaterMark;
+ }
+});
+
+// exposed for testing purposes only.
+Readable._fromList = fromList;
+
+// Pluck off n bytes from an array of buffers.
+// Length is the combined lengths of all the buffers in the list.
+// This function is designed to be inlinable, so please take care when making
+// changes to the function body.
+function fromList(n, state) {
+ // nothing buffered
+ if (state.length === 0) return null;
+
+ var ret;
+ if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) {
+ // read it all, truncate the list
+ if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.head.data;else ret = state.buffer.concat(state.length);
+ state.buffer.clear();
+ } else {
+ // read part of list
+ ret = fromListPartial(n, state.buffer, state.decoder);
+ }
+
+ return ret;
+}
+
+// Extracts only enough buffered data to satisfy the amount requested.
+// This function is designed to be inlinable, so please take care when making
+// changes to the function body.
+function fromListPartial(n, list, hasStrings) {
+ var ret;
+ if (n < list.head.data.length) {
+ // slice is the same for buffers and strings
+ ret = list.head.data.slice(0, n);
+ list.head.data = list.head.data.slice(n);
+ } else if (n === list.head.data.length) {
+ // first chunk is a perfect match
+ ret = list.shift();
+ } else {
+ // result spans more than one buffer
+ ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list);
+ }
+ return ret;
+}
+
+// Copies a specified amount of characters from the list of buffered data
+// chunks.
+// This function is designed to be inlinable, so please take care when making
+// changes to the function body.
+function copyFromBufferString(n, list) {
+ var p = list.head;
+ var c = 1;
+ var ret = p.data;
+ n -= ret.length;
+ while (p = p.next) {
+ var str = p.data;
+ var nb = n > str.length ? str.length : n;
+ if (nb === str.length) ret += str;else ret += str.slice(0, n);
+ n -= nb;
+ if (n === 0) {
+ if (nb === str.length) {
+ ++c;
+ if (p.next) list.head = p.next;else list.head = list.tail = null;
+ } else {
+ list.head = p;
+ p.data = str.slice(nb);
+ }
+ break;
+ }
+ ++c;
+ }
+ list.length -= c;
+ return ret;
+}
+
+// Copies a specified amount of bytes from the list of buffered data chunks.
+// This function is designed to be inlinable, so please take care when making
+// changes to the function body.
+function copyFromBuffer(n, list) {
+ var ret = Buffer.allocUnsafe(n);
+ var p = list.head;
+ var c = 1;
+ p.data.copy(ret);
+ n -= p.data.length;
+ while (p = p.next) {
+ var buf = p.data;
+ var nb = n > buf.length ? buf.length : n;
+ buf.copy(ret, ret.length - n, 0, nb);
+ n -= nb;
+ if (n === 0) {
+ if (nb === buf.length) {
+ ++c;
+ if (p.next) list.head = p.next;else list.head = list.tail = null;
+ } else {
+ list.head = p;
+ p.data = buf.slice(nb);
+ }
+ break;
+ }
+ ++c;
+ }
+ list.length -= c;
+ return ret;
+}
+
+function endReadable(stream) {
+ var state = stream._readableState;
+
+ // If we get here before consuming all the bytes, then that is a
+ // bug in node. Should never happen.
+ if (state.length > 0) throw new Error('"endReadable()" called on non-empty stream');
+
+ if (!state.endEmitted) {
+ state.ended = true;
+ pna.nextTick(endReadableNT, state, stream);
+ }
+}
+
+function endReadableNT(state, stream) {
+ // Check that we didn't get one last unshift.
+ if (!state.endEmitted && state.length === 0) {
+ state.endEmitted = true;
+ stream.readable = false;
+ stream.emit('end');
+ }
+}
+
+function indexOf(xs, x) {
+ for (var i = 0, l = xs.length; i < l; i++) {
+ if (xs[i] === x) return i;
+ }
+ return -1;
+}
+}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"./_stream_duplex":98,"./internal/streams/BufferList":103,"./internal/streams/destroy":104,"./internal/streams/stream":105,"_process":92,"core-util-is":14,"events":13,"inherits":80,"isarray":106,"process-nextick-args":91,"safe-buffer":110,"string_decoder/":107,"util":11}],101:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// a transform stream is a readable/writable stream where you do
+// something with the data. Sometimes it's called a "filter",
+// but that's not a great name for it, since that implies a thing where
+// some bits pass through, and others are simply ignored. (That would
+// be a valid example of a transform, of course.)
+//
+// While the output is causally related to the input, it's not a
+// necessarily symmetric or synchronous transformation. For example,
+// a zlib stream might take multiple plain-text writes(), and then
+// emit a single compressed chunk some time in the future.
+//
+// Here's how this works:
+//
+// The Transform stream has all the aspects of the readable and writable
+// stream classes. When you write(chunk), that calls _write(chunk,cb)
+// internally, and returns false if there's a lot of pending writes
+// buffered up. When you call read(), that calls _read(n) until
+// there's enough pending readable data buffered up.
+//
+// In a transform stream, the written data is placed in a buffer. When
+// _read(n) is called, it transforms the queued up data, calling the
+// buffered _write cb's as it consumes chunks. If consuming a single
+// written chunk would result in multiple output chunks, then the first
+// outputted bit calls the readcb, and subsequent chunks just go into
+// the read buffer, and will cause it to emit 'readable' if necessary.
+//
+// This way, back-pressure is actually determined by the reading side,
+// since _read has to be called to start processing a new chunk. However,
+// a pathological inflate type of transform can cause excessive buffering
+// here. For example, imagine a stream where every byte of input is
+// interpreted as an integer from 0-255, and then results in that many
+// bytes of output. Writing the 4 bytes {ff,ff,ff,ff} would result in
+// 1kb of data being output. In this case, you could write a very small
+// amount of input, and end up with a very large amount of output. In
+// such a pathological inflating mechanism, there'd be no way to tell
+// the system to stop doing the transform. A single 4MB write could
+// cause the system to run out of memory.
+//
+// However, even in such a pathological case, only a single written chunk
+// would be consumed, and then the rest would wait (un-transformed) until
+// the results of the previous transformed chunk were consumed.
+
+'use strict';
+
+module.exports = Transform;
+
+var Duplex = require('./_stream_duplex');
+
+/**/
+var util = require('core-util-is');
+util.inherits = require('inherits');
+/**/
+
+util.inherits(Transform, Duplex);
+
+function afterTransform(er, data) {
+ var ts = this._transformState;
+ ts.transforming = false;
+
+ var cb = ts.writecb;
+
+ if (!cb) {
+ return this.emit('error', new Error('write callback called multiple times'));
+ }
+
+ ts.writechunk = null;
+ ts.writecb = null;
+
+ if (data != null) // single equals check for both `null` and `undefined`
+ this.push(data);
+
+ cb(er);
+
+ var rs = this._readableState;
+ rs.reading = false;
+ if (rs.needReadable || rs.length < rs.highWaterMark) {
+ this._read(rs.highWaterMark);
+ }
+}
+
+function Transform(options) {
+ if (!(this instanceof Transform)) return new Transform(options);
+
+ Duplex.call(this, options);
+
+ this._transformState = {
+ afterTransform: afterTransform.bind(this),
+ needTransform: false,
+ transforming: false,
+ writecb: null,
+ writechunk: null,
+ writeencoding: null
+ };
+
+ // start out asking for a readable event once data is transformed.
+ this._readableState.needReadable = true;
+
+ // we have implemented the _read method, and done the other things
+ // that Readable wants before the first _read call, so unset the
+ // sync guard flag.
+ this._readableState.sync = false;
+
+ if (options) {
+ if (typeof options.transform === 'function') this._transform = options.transform;
+
+ if (typeof options.flush === 'function') this._flush = options.flush;
+ }
+
+ // When the writable side finishes, then flush out anything remaining.
+ this.on('prefinish', prefinish);
+}
+
+function prefinish() {
+ var _this = this;
+
+ if (typeof this._flush === 'function') {
+ this._flush(function (er, data) {
+ done(_this, er, data);
+ });
+ } else {
+ done(this, null, null);
+ }
+}
+
+Transform.prototype.push = function (chunk, encoding) {
+ this._transformState.needTransform = false;
+ return Duplex.prototype.push.call(this, chunk, encoding);
+};
+
+// This is the part where you do stuff!
+// override this function in implementation classes.
+// 'chunk' is an input chunk.
+//
+// Call `push(newChunk)` to pass along transformed output
+// to the readable side. You may call 'push' zero or more times.
+//
+// Call `cb(err)` when you are done with this chunk. If you pass
+// an error, then that'll put the hurt on the whole operation. If you
+// never call cb(), then you'll never get another chunk.
+Transform.prototype._transform = function (chunk, encoding, cb) {
+ throw new Error('_transform() is not implemented');
+};
+
+Transform.prototype._write = function (chunk, encoding, cb) {
+ var ts = this._transformState;
+ ts.writecb = cb;
+ ts.writechunk = chunk;
+ ts.writeencoding = encoding;
+ if (!ts.transforming) {
+ var rs = this._readableState;
+ if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);
+ }
+};
+
+// Doesn't matter what the args are here.
+// _transform does all the work.
+// That we got here means that the readable side wants more data.
+Transform.prototype._read = function (n) {
+ var ts = this._transformState;
+
+ if (ts.writechunk !== null && ts.writecb && !ts.transforming) {
+ ts.transforming = true;
+ this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
+ } else {
+ // mark that we need a transform, so that any data that comes in
+ // will get processed, now that we've asked for it.
+ ts.needTransform = true;
+ }
+};
+
+Transform.prototype._destroy = function (err, cb) {
+ var _this2 = this;
+
+ Duplex.prototype._destroy.call(this, err, function (err2) {
+ cb(err2);
+ _this2.emit('close');
+ });
+};
+
+function done(stream, er, data) {
+ if (er) return stream.emit('error', er);
+
+ if (data != null) // single equals check for both `null` and `undefined`
+ stream.push(data);
+
+ // if there's nothing in the write buffer, then that means
+ // that nothing more will ever be provided
+ if (stream._writableState.length) throw new Error('Calling transform done when ws.length != 0');
+
+ if (stream._transformState.transforming) throw new Error('Calling transform done when still transforming');
+
+ return stream.push(null);
+}
+},{"./_stream_duplex":98,"core-util-is":14,"inherits":80}],102:[function(require,module,exports){
+(function (process,global,setImmediate){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// A bit simpler than readable streams.
+// Implement an async ._write(chunk, encoding, cb), and it'll handle all
+// the drain event emission and buffering.
+
+'use strict';
+
+/**/
+
+var pna = require('process-nextick-args');
+/**/
+
+module.exports = Writable;
+
+/* */
+function WriteReq(chunk, encoding, cb) {
+ this.chunk = chunk;
+ this.encoding = encoding;
+ this.callback = cb;
+ this.next = null;
+}
+
+// It seems a linked list but it is not
+// there will be only 2 of these for each stream
+function CorkedRequest(state) {
+ var _this = this;
+
+ this.next = null;
+ this.entry = null;
+ this.finish = function () {
+ onCorkedFinish(_this, state);
+ };
+}
+/* */
+
+/**/
+var asyncWrite = !process.browser && ['v0.10', 'v0.9.'].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : pna.nextTick;
+/**/
+
+/**/
+var Duplex;
+/**/
+
+Writable.WritableState = WritableState;
+
+/**/
+var util = require('core-util-is');
+util.inherits = require('inherits');
+/**/
+
+/**/
+var internalUtil = {
+ deprecate: require('util-deprecate')
+};
+/**/
+
+/**/
+var Stream = require('./internal/streams/stream');
+/**/
+
+/**/
+
+var Buffer = require('safe-buffer').Buffer;
+var OurUint8Array = global.Uint8Array || function () {};
+function _uint8ArrayToBuffer(chunk) {
+ return Buffer.from(chunk);
+}
+function _isUint8Array(obj) {
+ return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
+}
+
+/**/
+
+var destroyImpl = require('./internal/streams/destroy');
+
+util.inherits(Writable, Stream);
+
+function nop() {}
+
+function WritableState(options, stream) {
+ Duplex = Duplex || require('./_stream_duplex');
+
+ options = options || {};
+
+ // Duplex streams are both readable and writable, but share
+ // the same options object.
+ // However, some cases require setting options to different
+ // values for the readable and the writable sides of the duplex stream.
+ // These options can be provided separately as readableXXX and writableXXX.
+ var isDuplex = stream instanceof Duplex;
+
+ // object stream flag to indicate whether or not this stream
+ // contains buffers or objects.
+ this.objectMode = !!options.objectMode;
+
+ if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode;
+
+ // the point at which write() starts returning false
+ // Note: 0 is a valid value, means that we always return false if
+ // the entire buffer is not flushed immediately on write()
+ var hwm = options.highWaterMark;
+ var writableHwm = options.writableHighWaterMark;
+ var defaultHwm = this.objectMode ? 16 : 16 * 1024;
+
+ if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (writableHwm || writableHwm === 0)) this.highWaterMark = writableHwm;else this.highWaterMark = defaultHwm;
+
+ // cast to ints.
+ this.highWaterMark = Math.floor(this.highWaterMark);
+
+ // if _final has been called
+ this.finalCalled = false;
+
+ // drain event flag.
+ this.needDrain = false;
+ // at the start of calling end()
+ this.ending = false;
+ // when end() has been called, and returned
+ this.ended = false;
+ // when 'finish' is emitted
+ this.finished = false;
+
+ // has it been destroyed
+ this.destroyed = false;
+
+ // should we decode strings into buffers before passing to _write?
+ // this is here so that some node-core streams can optimize string
+ // handling at a lower level.
+ var noDecode = options.decodeStrings === false;
+ this.decodeStrings = !noDecode;
+
+ // Crypto is kind of old and crusty. Historically, its default string
+ // encoding is 'binary' so we have to make this configurable.
+ // Everything else in the universe uses 'utf8', though.
+ this.defaultEncoding = options.defaultEncoding || 'utf8';
+
+ // not an actual buffer we keep track of, but a measurement
+ // of how much we're waiting to get pushed to some underlying
+ // socket or file.
+ this.length = 0;
+
+ // a flag to see when we're in the middle of a write.
+ this.writing = false;
+
+ // when true all writes will be buffered until .uncork() call
+ this.corked = 0;
+
+ // a flag to be able to tell if the onwrite cb is called immediately,
+ // or on a later tick. We set this to true at first, because any
+ // actions that shouldn't happen until "later" should generally also
+ // not happen before the first write call.
+ this.sync = true;
+
+ // a flag to know if we're processing previously buffered items, which
+ // may call the _write() callback in the same tick, so that we don't
+ // end up in an overlapped onwrite situation.
+ this.bufferProcessing = false;
+
+ // the callback that's passed to _write(chunk,cb)
+ this.onwrite = function (er) {
+ onwrite(stream, er);
+ };
+
+ // the callback that the user supplies to write(chunk,encoding,cb)
+ this.writecb = null;
+
+ // the amount that is being written when _write is called.
+ this.writelen = 0;
+
+ this.bufferedRequest = null;
+ this.lastBufferedRequest = null;
+
+ // number of pending user-supplied write callbacks
+ // this must be 0 before 'finish' can be emitted
+ this.pendingcb = 0;
+
+ // emit prefinish if the only thing we're waiting for is _write cbs
+ // This is relevant for synchronous Transform streams
+ this.prefinished = false;
+
+ // True if the error was already emitted and should not be thrown again
+ this.errorEmitted = false;
+
+ // count buffered requests
+ this.bufferedRequestCount = 0;
+
+ // allocate the first CorkedRequest, there is always
+ // one allocated and free to use, and we maintain at most two
+ this.corkedRequestsFree = new CorkedRequest(this);
+}
+
+WritableState.prototype.getBuffer = function getBuffer() {
+ var current = this.bufferedRequest;
+ var out = [];
+ while (current) {
+ out.push(current);
+ current = current.next;
+ }
+ return out;
+};
+
+(function () {
+ try {
+ Object.defineProperty(WritableState.prototype, 'buffer', {
+ get: internalUtil.deprecate(function () {
+ return this.getBuffer();
+ }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')
+ });
+ } catch (_) {}
+})();
+
+// Test _writableState for inheritance to account for Duplex streams,
+// whose prototype chain only points to Readable.
+var realHasInstance;
+if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {
+ realHasInstance = Function.prototype[Symbol.hasInstance];
+ Object.defineProperty(Writable, Symbol.hasInstance, {
+ value: function (object) {
+ if (realHasInstance.call(this, object)) return true;
+ if (this !== Writable) return false;
+
+ return object && object._writableState instanceof WritableState;
+ }
+ });
+} else {
+ realHasInstance = function (object) {
+ return object instanceof this;
+ };
+}
+
+function Writable(options) {
+ Duplex = Duplex || require('./_stream_duplex');
+
+ // Writable ctor is applied to Duplexes, too.
+ // `realHasInstance` is necessary because using plain `instanceof`
+ // would return false, as no `_writableState` property is attached.
+
+ // Trying to use the custom `instanceof` for Writable here will also break the
+ // Node.js LazyTransform implementation, which has a non-trivial getter for
+ // `_writableState` that would lead to infinite recursion.
+ if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) {
+ return new Writable(options);
+ }
+
+ this._writableState = new WritableState(options, this);
+
+ // legacy.
+ this.writable = true;
+
+ if (options) {
+ if (typeof options.write === 'function') this._write = options.write;
+
+ if (typeof options.writev === 'function') this._writev = options.writev;
+
+ if (typeof options.destroy === 'function') this._destroy = options.destroy;
+
+ if (typeof options.final === 'function') this._final = options.final;
+ }
+
+ Stream.call(this);
+}
+
+// Otherwise people can pipe Writable streams, which is just wrong.
+Writable.prototype.pipe = function () {
+ this.emit('error', new Error('Cannot pipe, not readable'));
+};
+
+function writeAfterEnd(stream, cb) {
+ var er = new Error('write after end');
+ // TODO: defer error events consistently everywhere, not just the cb
+ stream.emit('error', er);
+ pna.nextTick(cb, er);
+}
+
+// Checks that a user-supplied chunk is valid, especially for the particular
+// mode the stream is in. Currently this means that `null` is never accepted
+// and undefined/non-string values are only allowed in object mode.
+function validChunk(stream, state, chunk, cb) {
+ var valid = true;
+ var er = false;
+
+ if (chunk === null) {
+ er = new TypeError('May not write null values to stream');
+ } else if (typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {
+ er = new TypeError('Invalid non-string/buffer chunk');
+ }
+ if (er) {
+ stream.emit('error', er);
+ pna.nextTick(cb, er);
+ valid = false;
+ }
+ return valid;
+}
+
+Writable.prototype.write = function (chunk, encoding, cb) {
+ var state = this._writableState;
+ var ret = false;
+ var isBuf = !state.objectMode && _isUint8Array(chunk);
+
+ if (isBuf && !Buffer.isBuffer(chunk)) {
+ chunk = _uint8ArrayToBuffer(chunk);
+ }
+
+ if (typeof encoding === 'function') {
+ cb = encoding;
+ encoding = null;
+ }
+
+ if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;
+
+ if (typeof cb !== 'function') cb = nop;
+
+ if (state.ended) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {
+ state.pendingcb++;
+ ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);
+ }
+
+ return ret;
+};
+
+Writable.prototype.cork = function () {
+ var state = this._writableState;
+
+ state.corked++;
+};
+
+Writable.prototype.uncork = function () {
+ var state = this._writableState;
+
+ if (state.corked) {
+ state.corked--;
+
+ if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);
+ }
+};
+
+Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
+ // node::ParseEncoding() requires lower case.
+ if (typeof encoding === 'string') encoding = encoding.toLowerCase();
+ if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new TypeError('Unknown encoding: ' + encoding);
+ this._writableState.defaultEncoding = encoding;
+ return this;
+};
+
+function decodeChunk(state, chunk, encoding) {
+ if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {
+ chunk = Buffer.from(chunk, encoding);
+ }
+ return chunk;
+}
+
+Object.defineProperty(Writable.prototype, 'writableHighWaterMark', {
+ // making it explicit this property is not enumerable
+ // because otherwise some prototype manipulation in
+ // userland will fail
+ enumerable: false,
+ get: function () {
+ return this._writableState.highWaterMark;
+ }
+});
+
+// if we're already writing something, then just put this
+// in the queue, and wait our turn. Otherwise, call _write
+// If we return false, then we need a drain event, so set that flag.
+function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {
+ if (!isBuf) {
+ var newChunk = decodeChunk(state, chunk, encoding);
+ if (chunk !== newChunk) {
+ isBuf = true;
+ encoding = 'buffer';
+ chunk = newChunk;
+ }
+ }
+ var len = state.objectMode ? 1 : chunk.length;
+
+ state.length += len;
+
+ var ret = state.length < state.highWaterMark;
+ // we must ensure that previous needDrain will not be reset to false.
+ if (!ret) state.needDrain = true;
+
+ if (state.writing || state.corked) {
+ var last = state.lastBufferedRequest;
+ state.lastBufferedRequest = {
+ chunk: chunk,
+ encoding: encoding,
+ isBuf: isBuf,
+ callback: cb,
+ next: null
+ };
+ if (last) {
+ last.next = state.lastBufferedRequest;
+ } else {
+ state.bufferedRequest = state.lastBufferedRequest;
+ }
+ state.bufferedRequestCount += 1;
+ } else {
+ doWrite(stream, state, false, len, chunk, encoding, cb);
+ }
+
+ return ret;
+}
+
+function doWrite(stream, state, writev, len, chunk, encoding, cb) {
+ state.writelen = len;
+ state.writecb = cb;
+ state.writing = true;
+ state.sync = true;
+ if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);
+ state.sync = false;
+}
+
+function onwriteError(stream, state, sync, er, cb) {
+ --state.pendingcb;
+
+ if (sync) {
+ // defer the callback if we are being called synchronously
+ // to avoid piling up things on the stack
+ pna.nextTick(cb, er);
+ // this can emit finish, and it will always happen
+ // after error
+ pna.nextTick(finishMaybe, stream, state);
+ stream._writableState.errorEmitted = true;
+ stream.emit('error', er);
+ } else {
+ // the caller expect this to happen before if
+ // it is async
+ cb(er);
+ stream._writableState.errorEmitted = true;
+ stream.emit('error', er);
+ // this can emit finish, but finish must
+ // always follow error
+ finishMaybe(stream, state);
+ }
+}
+
+function onwriteStateUpdate(state) {
+ state.writing = false;
+ state.writecb = null;
+ state.length -= state.writelen;
+ state.writelen = 0;
+}
+
+function onwrite(stream, er) {
+ var state = stream._writableState;
+ var sync = state.sync;
+ var cb = state.writecb;
+
+ onwriteStateUpdate(state);
+
+ if (er) onwriteError(stream, state, sync, er, cb);else {
+ // Check if we're actually ready to finish, but don't emit yet
+ var finished = needFinish(state);
+
+ if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {
+ clearBuffer(stream, state);
+ }
+
+ if (sync) {
+ /**/
+ asyncWrite(afterWrite, stream, state, finished, cb);
+ /**/
+ } else {
+ afterWrite(stream, state, finished, cb);
+ }
+ }
+}
+
+function afterWrite(stream, state, finished, cb) {
+ if (!finished) onwriteDrain(stream, state);
+ state.pendingcb--;
+ cb();
+ finishMaybe(stream, state);
+}
+
+// Must force callback to be called on nextTick, so that we don't
+// emit 'drain' before the write() consumer gets the 'false' return
+// value, and has a chance to attach a 'drain' listener.
+function onwriteDrain(stream, state) {
+ if (state.length === 0 && state.needDrain) {
+ state.needDrain = false;
+ stream.emit('drain');
+ }
+}
+
+// if there's something in the buffer waiting, then process it
+function clearBuffer(stream, state) {
+ state.bufferProcessing = true;
+ var entry = state.bufferedRequest;
+
+ if (stream._writev && entry && entry.next) {
+ // Fast case, write everything using _writev()
+ var l = state.bufferedRequestCount;
+ var buffer = new Array(l);
+ var holder = state.corkedRequestsFree;
+ holder.entry = entry;
+
+ var count = 0;
+ var allBuffers = true;
+ while (entry) {
+ buffer[count] = entry;
+ if (!entry.isBuf) allBuffers = false;
+ entry = entry.next;
+ count += 1;
+ }
+ buffer.allBuffers = allBuffers;
+
+ doWrite(stream, state, true, state.length, buffer, '', holder.finish);
+
+ // doWrite is almost always async, defer these to save a bit of time
+ // as the hot path ends with doWrite
+ state.pendingcb++;
+ state.lastBufferedRequest = null;
+ if (holder.next) {
+ state.corkedRequestsFree = holder.next;
+ holder.next = null;
+ } else {
+ state.corkedRequestsFree = new CorkedRequest(state);
+ }
+ state.bufferedRequestCount = 0;
+ } else {
+ // Slow case, write chunks one-by-one
+ while (entry) {
+ var chunk = entry.chunk;
+ var encoding = entry.encoding;
+ var cb = entry.callback;
+ var len = state.objectMode ? 1 : chunk.length;
+
+ doWrite(stream, state, false, len, chunk, encoding, cb);
+ entry = entry.next;
+ state.bufferedRequestCount--;
+ // if we didn't call the onwrite immediately, then
+ // it means that we need to wait until it does.
+ // also, that means that the chunk and cb are currently
+ // being processed, so move the buffer counter past them.
+ if (state.writing) {
+ break;
+ }
+ }
+
+ if (entry === null) state.lastBufferedRequest = null;
+ }
+
+ state.bufferedRequest = entry;
+ state.bufferProcessing = false;
+}
+
+Writable.prototype._write = function (chunk, encoding, cb) {
+ cb(new Error('_write() is not implemented'));
+};
+
+Writable.prototype._writev = null;
+
+Writable.prototype.end = function (chunk, encoding, cb) {
+ var state = this._writableState;
+
+ if (typeof chunk === 'function') {
+ cb = chunk;
+ chunk = null;
+ encoding = null;
+ } else if (typeof encoding === 'function') {
+ cb = encoding;
+ encoding = null;
+ }
+
+ if (chunk !== null && chunk !== undefined) this.write(chunk, encoding);
+
+ // .end() fully uncorks
+ if (state.corked) {
+ state.corked = 1;
+ this.uncork();
+ }
+
+ // ignore unnecessary end() calls.
+ if (!state.ending && !state.finished) endWritable(this, state, cb);
+};
+
+function needFinish(state) {
+ return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;
+}
+function callFinal(stream, state) {
+ stream._final(function (err) {
+ state.pendingcb--;
+ if (err) {
+ stream.emit('error', err);
+ }
+ state.prefinished = true;
+ stream.emit('prefinish');
+ finishMaybe(stream, state);
+ });
+}
+function prefinish(stream, state) {
+ if (!state.prefinished && !state.finalCalled) {
+ if (typeof stream._final === 'function') {
+ state.pendingcb++;
+ state.finalCalled = true;
+ pna.nextTick(callFinal, stream, state);
+ } else {
+ state.prefinished = true;
+ stream.emit('prefinish');
+ }
+ }
+}
+
+function finishMaybe(stream, state) {
+ var need = needFinish(state);
+ if (need) {
+ prefinish(stream, state);
+ if (state.pendingcb === 0) {
+ state.finished = true;
+ stream.emit('finish');
+ }
+ }
+ return need;
+}
+
+function endWritable(stream, state, cb) {
+ state.ending = true;
+ finishMaybe(stream, state);
+ if (cb) {
+ if (state.finished) pna.nextTick(cb);else stream.once('finish', cb);
+ }
+ state.ended = true;
+ stream.writable = false;
+}
+
+function onCorkedFinish(corkReq, state, err) {
+ var entry = corkReq.entry;
+ corkReq.entry = null;
+ while (entry) {
+ var cb = entry.callback;
+ state.pendingcb--;
+ cb(err);
+ entry = entry.next;
+ }
+ if (state.corkedRequestsFree) {
+ state.corkedRequestsFree.next = corkReq;
+ } else {
+ state.corkedRequestsFree = corkReq;
+ }
+}
+
+Object.defineProperty(Writable.prototype, 'destroyed', {
+ get: function () {
+ if (this._writableState === undefined) {
+ return false;
+ }
+ return this._writableState.destroyed;
+ },
+ set: function (value) {
+ // we ignore the value if the stream
+ // has not been initialized yet
+ if (!this._writableState) {
+ return;
+ }
+
+ // backward compatibility, the user is explicitly
+ // managing destroyed
+ this._writableState.destroyed = value;
+ }
+});
+
+Writable.prototype.destroy = destroyImpl.destroy;
+Writable.prototype._undestroy = destroyImpl.undestroy;
+Writable.prototype._destroy = function (err, cb) {
+ this.end();
+ cb(err);
+};
+}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {},require("timers").setImmediate)
+},{"./_stream_duplex":98,"./internal/streams/destroy":104,"./internal/streams/stream":105,"_process":92,"core-util-is":14,"inherits":80,"process-nextick-args":91,"safe-buffer":110,"timers":112,"util-deprecate":115}],103:[function(require,module,exports){
+'use strict';
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var Buffer = require('safe-buffer').Buffer;
+var util = require('util');
+
+function copyBuffer(src, target, offset) {
+ src.copy(target, offset);
+}
+
+module.exports = function () {
+ function BufferList() {
+ _classCallCheck(this, BufferList);
+
+ this.head = null;
+ this.tail = null;
+ this.length = 0;
+ }
+
+ BufferList.prototype.push = function push(v) {
+ var entry = { data: v, next: null };
+ if (this.length > 0) this.tail.next = entry;else this.head = entry;
+ this.tail = entry;
+ ++this.length;
+ };
+
+ BufferList.prototype.unshift = function unshift(v) {
+ var entry = { data: v, next: this.head };
+ if (this.length === 0) this.tail = entry;
+ this.head = entry;
+ ++this.length;
+ };
+
+ BufferList.prototype.shift = function shift() {
+ if (this.length === 0) return;
+ var ret = this.head.data;
+ if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next;
+ --this.length;
+ return ret;
+ };
+
+ BufferList.prototype.clear = function clear() {
+ this.head = this.tail = null;
+ this.length = 0;
+ };
+
+ BufferList.prototype.join = function join(s) {
+ if (this.length === 0) return '';
+ var p = this.head;
+ var ret = '' + p.data;
+ while (p = p.next) {
+ ret += s + p.data;
+ }return ret;
+ };
+
+ BufferList.prototype.concat = function concat(n) {
+ if (this.length === 0) return Buffer.alloc(0);
+ if (this.length === 1) return this.head.data;
+ var ret = Buffer.allocUnsafe(n >>> 0);
+ var p = this.head;
+ var i = 0;
+ while (p) {
+ copyBuffer(p.data, ret, i);
+ i += p.data.length;
+ p = p.next;
+ }
+ return ret;
+ };
+
+ return BufferList;
+}();
+
+if (util && util.inspect && util.inspect.custom) {
+ module.exports.prototype[util.inspect.custom] = function () {
+ var obj = util.inspect({ length: this.length });
+ return this.constructor.name + ' ' + obj;
+ };
+}
+},{"safe-buffer":110,"util":11}],104:[function(require,module,exports){
+'use strict';
+
+/**/
+
+var pna = require('process-nextick-args');
+/**/
+
+// undocumented cb() API, needed for core, not for public API
+function destroy(err, cb) {
+ var _this = this;
+
+ var readableDestroyed = this._readableState && this._readableState.destroyed;
+ var writableDestroyed = this._writableState && this._writableState.destroyed;
+
+ if (readableDestroyed || writableDestroyed) {
+ if (cb) {
+ cb(err);
+ } else if (err && (!this._writableState || !this._writableState.errorEmitted)) {
+ pna.nextTick(emitErrorNT, this, err);
+ }
+ return this;
+ }
+
+ // we set destroyed to true before firing error callbacks in order
+ // to make it re-entrance safe in case destroy() is called within callbacks
+
+ if (this._readableState) {
+ this._readableState.destroyed = true;
+ }
+
+ // if this is a duplex stream mark the writable part as destroyed as well
+ if (this._writableState) {
+ this._writableState.destroyed = true;
+ }
+
+ this._destroy(err || null, function (err) {
+ if (!cb && err) {
+ pna.nextTick(emitErrorNT, _this, err);
+ if (_this._writableState) {
+ _this._writableState.errorEmitted = true;
+ }
+ } else if (cb) {
+ cb(err);
+ }
+ });
+
+ return this;
+}
+
+function undestroy() {
+ if (this._readableState) {
+ this._readableState.destroyed = false;
+ this._readableState.reading = false;
+ this._readableState.ended = false;
+ this._readableState.endEmitted = false;
+ }
+
+ if (this._writableState) {
+ this._writableState.destroyed = false;
+ this._writableState.ended = false;
+ this._writableState.ending = false;
+ this._writableState.finished = false;
+ this._writableState.errorEmitted = false;
+ }
+}
+
+function emitErrorNT(self, err) {
+ self.emit('error', err);
+}
+
+module.exports = {
+ destroy: destroy,
+ undestroy: undestroy
+};
+},{"process-nextick-args":91}],105:[function(require,module,exports){
+module.exports = require('events').EventEmitter;
+
+},{"events":13}],106:[function(require,module,exports){
+var toString = {}.toString;
+
+module.exports = Array.isArray || function (arr) {
+ return toString.call(arr) == '[object Array]';
+};
+
+},{}],107:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+
+/**/
+
+var Buffer = require('safe-buffer').Buffer;
+/**/
+
+var isEncoding = Buffer.isEncoding || function (encoding) {
+ encoding = '' + encoding;
+ switch (encoding && encoding.toLowerCase()) {
+ case 'hex':case 'utf8':case 'utf-8':case 'ascii':case 'binary':case 'base64':case 'ucs2':case 'ucs-2':case 'utf16le':case 'utf-16le':case 'raw':
+ return true;
+ default:
+ return false;
+ }
+};
+
+function _normalizeEncoding(enc) {
+ if (!enc) return 'utf8';
+ var retried;
+ while (true) {
+ switch (enc) {
+ case 'utf8':
+ case 'utf-8':
+ return 'utf8';
+ case 'ucs2':
+ case 'ucs-2':
+ case 'utf16le':
+ case 'utf-16le':
+ return 'utf16le';
+ case 'latin1':
+ case 'binary':
+ return 'latin1';
+ case 'base64':
+ case 'ascii':
+ case 'hex':
+ return enc;
+ default:
+ if (retried) return; // undefined
+ enc = ('' + enc).toLowerCase();
+ retried = true;
+ }
+ }
+};
+
+// Do not cache `Buffer.isEncoding` when checking encoding names as some
+// modules monkey-patch it to support additional encodings
+function normalizeEncoding(enc) {
+ var nenc = _normalizeEncoding(enc);
+ if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc);
+ return nenc || enc;
+}
+
+// StringDecoder provides an interface for efficiently splitting a series of
+// buffers into a series of JS strings without breaking apart multi-byte
+// characters.
+exports.StringDecoder = StringDecoder;
+function StringDecoder(encoding) {
+ this.encoding = normalizeEncoding(encoding);
+ var nb;
+ switch (this.encoding) {
+ case 'utf16le':
+ this.text = utf16Text;
+ this.end = utf16End;
+ nb = 4;
+ break;
+ case 'utf8':
+ this.fillLast = utf8FillLast;
+ nb = 4;
+ break;
+ case 'base64':
+ this.text = base64Text;
+ this.end = base64End;
+ nb = 3;
+ break;
+ default:
+ this.write = simpleWrite;
+ this.end = simpleEnd;
+ return;
+ }
+ this.lastNeed = 0;
+ this.lastTotal = 0;
+ this.lastChar = Buffer.allocUnsafe(nb);
+}
+
+StringDecoder.prototype.write = function (buf) {
+ if (buf.length === 0) return '';
+ var r;
+ var i;
+ if (this.lastNeed) {
+ r = this.fillLast(buf);
+ if (r === undefined) return '';
+ i = this.lastNeed;
+ this.lastNeed = 0;
+ } else {
+ i = 0;
+ }
+ if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);
+ return r || '';
+};
+
+StringDecoder.prototype.end = utf8End;
+
+// Returns only complete characters in a Buffer
+StringDecoder.prototype.text = utf8Text;
+
+// Attempts to complete a partial non-UTF-8 character using bytes from a Buffer
+StringDecoder.prototype.fillLast = function (buf) {
+ if (this.lastNeed <= buf.length) {
+ buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);
+ return this.lastChar.toString(this.encoding, 0, this.lastTotal);
+ }
+ buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);
+ this.lastNeed -= buf.length;
+};
+
+// Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a
+// continuation byte. If an invalid byte is detected, -2 is returned.
+function utf8CheckByte(byte) {
+ if (byte <= 0x7F) return 0;else if (byte >> 5 === 0x06) return 2;else if (byte >> 4 === 0x0E) return 3;else if (byte >> 3 === 0x1E) return 4;
+ return byte >> 6 === 0x02 ? -1 : -2;
+}
+
+// Checks at most 3 bytes at the end of a Buffer in order to detect an
+// incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4)
+// needed to complete the UTF-8 character (if applicable) are returned.
+function utf8CheckIncomplete(self, buf, i) {
+ var j = buf.length - 1;
+ if (j < i) return 0;
+ var nb = utf8CheckByte(buf[j]);
+ if (nb >= 0) {
+ if (nb > 0) self.lastNeed = nb - 1;
+ return nb;
+ }
+ if (--j < i || nb === -2) return 0;
+ nb = utf8CheckByte(buf[j]);
+ if (nb >= 0) {
+ if (nb > 0) self.lastNeed = nb - 2;
+ return nb;
+ }
+ if (--j < i || nb === -2) return 0;
+ nb = utf8CheckByte(buf[j]);
+ if (nb >= 0) {
+ if (nb > 0) {
+ if (nb === 2) nb = 0;else self.lastNeed = nb - 3;
+ }
+ return nb;
+ }
+ return 0;
+}
+
+// Validates as many continuation bytes for a multi-byte UTF-8 character as
+// needed or are available. If we see a non-continuation byte where we expect
+// one, we "replace" the validated continuation bytes we've seen so far with
+// a single UTF-8 replacement character ('\ufffd'), to match v8's UTF-8 decoding
+// behavior. The continuation byte check is included three times in the case
+// where all of the continuation bytes for a character exist in the same buffer.
+// It is also done this way as a slight performance increase instead of using a
+// loop.
+function utf8CheckExtraBytes(self, buf, p) {
+ if ((buf[0] & 0xC0) !== 0x80) {
+ self.lastNeed = 0;
+ return '\ufffd';
+ }
+ if (self.lastNeed > 1 && buf.length > 1) {
+ if ((buf[1] & 0xC0) !== 0x80) {
+ self.lastNeed = 1;
+ return '\ufffd';
+ }
+ if (self.lastNeed > 2 && buf.length > 2) {
+ if ((buf[2] & 0xC0) !== 0x80) {
+ self.lastNeed = 2;
+ return '\ufffd';
+ }
+ }
+ }
+}
+
+// Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer.
+function utf8FillLast(buf) {
+ var p = this.lastTotal - this.lastNeed;
+ var r = utf8CheckExtraBytes(this, buf, p);
+ if (r !== undefined) return r;
+ if (this.lastNeed <= buf.length) {
+ buf.copy(this.lastChar, p, 0, this.lastNeed);
+ return this.lastChar.toString(this.encoding, 0, this.lastTotal);
+ }
+ buf.copy(this.lastChar, p, 0, buf.length);
+ this.lastNeed -= buf.length;
+}
+
+// Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a
+// partial character, the character's bytes are buffered until the required
+// number of bytes are available.
+function utf8Text(buf, i) {
+ var total = utf8CheckIncomplete(this, buf, i);
+ if (!this.lastNeed) return buf.toString('utf8', i);
+ this.lastTotal = total;
+ var end = buf.length - (total - this.lastNeed);
+ buf.copy(this.lastChar, 0, end);
+ return buf.toString('utf8', i, end);
+}
+
+// For UTF-8, a replacement character is added when ending on a partial
+// character.
+function utf8End(buf) {
+ var r = buf && buf.length ? this.write(buf) : '';
+ if (this.lastNeed) return r + '\ufffd';
+ return r;
+}
+
+// UTF-16LE typically needs two bytes per character, but even if we have an even
+// number of bytes available, we need to check if we end on a leading/high
+// surrogate. In that case, we need to wait for the next two bytes in order to
+// decode the last character properly.
+function utf16Text(buf, i) {
+ if ((buf.length - i) % 2 === 0) {
+ var r = buf.toString('utf16le', i);
+ if (r) {
+ var c = r.charCodeAt(r.length - 1);
+ if (c >= 0xD800 && c <= 0xDBFF) {
+ this.lastNeed = 2;
+ this.lastTotal = 4;
+ this.lastChar[0] = buf[buf.length - 2];
+ this.lastChar[1] = buf[buf.length - 1];
+ return r.slice(0, -1);
+ }
+ }
+ return r;
+ }
+ this.lastNeed = 1;
+ this.lastTotal = 2;
+ this.lastChar[0] = buf[buf.length - 1];
+ return buf.toString('utf16le', i, buf.length - 1);
+}
+
+// For UTF-16LE we do not explicitly append special replacement characters if we
+// end on a partial character, we simply let v8 handle that.
+function utf16End(buf) {
+ var r = buf && buf.length ? this.write(buf) : '';
+ if (this.lastNeed) {
+ var end = this.lastTotal - this.lastNeed;
+ return r + this.lastChar.toString('utf16le', 0, end);
+ }
+ return r;
+}
+
+function base64Text(buf, i) {
+ var n = (buf.length - i) % 3;
+ if (n === 0) return buf.toString('base64', i);
+ this.lastNeed = 3 - n;
+ this.lastTotal = 3;
+ if (n === 1) {
+ this.lastChar[0] = buf[buf.length - 1];
+ } else {
+ this.lastChar[0] = buf[buf.length - 2];
+ this.lastChar[1] = buf[buf.length - 1];
+ }
+ return buf.toString('base64', i, buf.length - n);
+}
+
+function base64End(buf) {
+ var r = buf && buf.length ? this.write(buf) : '';
+ if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed);
+ return r;
+}
+
+// Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex)
+function simpleWrite(buf) {
+ return buf.toString(this.encoding);
+}
+
+function simpleEnd(buf) {
+ return buf && buf.length ? this.write(buf) : '';
+}
+},{"safe-buffer":110}],108:[function(require,module,exports){
+exports = module.exports = require('./lib/_stream_readable.js');
+exports.Stream = exports;
+exports.Readable = exports;
+exports.Writable = require('./lib/_stream_writable.js');
+exports.Duplex = require('./lib/_stream_duplex.js');
+exports.Transform = require('./lib/_stream_transform.js');
+exports.PassThrough = require('./lib/_stream_passthrough.js');
+
+},{"./lib/_stream_duplex.js":98,"./lib/_stream_passthrough.js":99,"./lib/_stream_readable.js":100,"./lib/_stream_transform.js":101,"./lib/_stream_writable.js":102}],109:[function(require,module,exports){
+'use strict'
+
+function ReInterval (callback, interval, args) {
+ var self = this;
+
+ this._callback = callback;
+ this._args = args;
+
+ this._interval = setInterval(callback, interval, this._args);
+
+ this.reschedule = function (interval) {
+ // if no interval entered, use the interval passed in on creation
+ if (!interval)
+ interval = self._interval;
+
+ if (self._interval)
+ clearInterval(self._interval);
+ self._interval = setInterval(self._callback, interval, self._args);
+ };
+
+ this.clear = function () {
+ if (self._interval) {
+ clearInterval(self._interval);
+ self._interval = undefined;
+ }
+ };
+
+ this.destroy = function () {
+ if (self._interval) {
+ clearInterval(self._interval);
+ }
+ self._callback = undefined;
+ self._interval = undefined;
+ self._args = undefined;
+ };
+}
+
+function reInterval () {
+ if (typeof arguments[0] !== 'function')
+ throw new Error('callback needed');
+ if (typeof arguments[1] !== 'number')
+ throw new Error('interval needed');
+
+ var args;
+
+ if (arguments.length > 0) {
+ args = new Array(arguments.length - 2);
+
+ for (var i = 0; i < args.length; i++) {
+ args[i] = arguments[i + 2];
+ }
+ }
+
+ return new ReInterval(arguments[0], arguments[1], args);
+}
+
+module.exports = reInterval;
+
+},{}],110:[function(require,module,exports){
+/* eslint-disable node/no-deprecated-api */
+var buffer = require('buffer')
+var Buffer = buffer.Buffer
+
+// alternative to using Object.keys for old browsers
+function copyProps (src, dst) {
+ for (var key in src) {
+ dst[key] = src[key]
+ }
+}
+if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {
+ module.exports = buffer
+} else {
+ // Copy properties from require('buffer')
+ copyProps(buffer, exports)
+ exports.Buffer = SafeBuffer
+}
+
+function SafeBuffer (arg, encodingOrOffset, length) {
+ return Buffer(arg, encodingOrOffset, length)
+}
+
+// Copy static methods from Buffer
+copyProps(Buffer, SafeBuffer)
+
+SafeBuffer.from = function (arg, encodingOrOffset, length) {
+ if (typeof arg === 'number') {
+ throw new TypeError('Argument must not be a number')
+ }
+ return Buffer(arg, encodingOrOffset, length)
+}
+
+SafeBuffer.alloc = function (size, fill, encoding) {
+ if (typeof size !== 'number') {
+ throw new TypeError('Argument must be a number')
+ }
+ var buf = Buffer(size)
+ if (fill !== undefined) {
+ if (typeof encoding === 'string') {
+ buf.fill(fill, encoding)
+ } else {
+ buf.fill(fill)
+ }
+ } else {
+ buf.fill(0)
+ }
+ return buf
+}
+
+SafeBuffer.allocUnsafe = function (size) {
+ if (typeof size !== 'number') {
+ throw new TypeError('Argument must be a number')
+ }
+ return Buffer(size)
+}
+
+SafeBuffer.allocUnsafeSlow = function (size) {
+ if (typeof size !== 'number') {
+ throw new TypeError('Argument must be a number')
+ }
+ return buffer.SlowBuffer(size)
+}
+
+},{"buffer":12}],111:[function(require,module,exports){
+module.exports = shift
+
+function shift (stream) {
+ var rs = stream._readableState
+ if (!rs) return null
+ return rs.objectMode ? stream.read() : stream.read(getStateLength(rs))
+}
+
+function getStateLength (state) {
+ if (state.buffer.length) {
+ // Since node 6.3.0 state.buffer is a BufferList not an array
+ if (state.buffer.head) {
+ return state.buffer.head.data.length
+ }
+
+ return state.buffer[0].length
+ }
+
+ return state.length
+}
+
+},{}],112:[function(require,module,exports){
+(function (setImmediate,clearImmediate){
+var nextTick = require('process/browser.js').nextTick;
+var apply = Function.prototype.apply;
+var slice = Array.prototype.slice;
+var immediateIds = {};
+var nextImmediateId = 0;
+
+// DOM APIs, for completeness
+
+exports.setTimeout = function() {
+ return new Timeout(apply.call(setTimeout, window, arguments), clearTimeout);
+};
+exports.setInterval = function() {
+ return new Timeout(apply.call(setInterval, window, arguments), clearInterval);
+};
+exports.clearTimeout =
+exports.clearInterval = function(timeout) { timeout.close(); };
+
+function Timeout(id, clearFn) {
+ this._id = id;
+ this._clearFn = clearFn;
+}
+Timeout.prototype.unref = Timeout.prototype.ref = function() {};
+Timeout.prototype.close = function() {
+ this._clearFn.call(window, this._id);
+};
+
+// Does not start the time, just sets up the members needed.
+exports.enroll = function(item, msecs) {
+ clearTimeout(item._idleTimeoutId);
+ item._idleTimeout = msecs;
+};
+
+exports.unenroll = function(item) {
+ clearTimeout(item._idleTimeoutId);
+ item._idleTimeout = -1;
+};
+
+exports._unrefActive = exports.active = function(item) {
+ clearTimeout(item._idleTimeoutId);
+
+ var msecs = item._idleTimeout;
+ if (msecs >= 0) {
+ item._idleTimeoutId = setTimeout(function onTimeout() {
+ if (item._onTimeout)
+ item._onTimeout();
+ }, msecs);
+ }
+};
+
+// That's not how node.js implements it but the exposed api is the same.
+exports.setImmediate = typeof setImmediate === "function" ? setImmediate : function(fn) {
+ var id = nextImmediateId++;
+ var args = arguments.length < 2 ? false : slice.call(arguments, 1);
+
+ immediateIds[id] = true;
+
+ nextTick(function onNextTick() {
+ if (immediateIds[id]) {
+ // fn.call() is faster so we optimize for the common use-case
+ // @see http://jsperf.com/call-apply-segu
+ if (args) {
+ fn.apply(null, args);
+ } else {
+ fn.call(null);
+ }
+ // Prevent ids from leaking
+ exports.clearImmediate(id);
+ }
+ });
+
+ return id;
+};
+
+exports.clearImmediate = typeof clearImmediate === "function" ? clearImmediate : function(id) {
+ delete immediateIds[id];
+};
+}).call(this,require("timers").setImmediate,require("timers").clearImmediate)
+},{"process/browser.js":92,"timers":112}],113:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+
+var punycode = require('punycode');
+var util = require('./util');
+
+exports.parse = urlParse;
+exports.resolve = urlResolve;
+exports.resolveObject = urlResolveObject;
+exports.format = urlFormat;
+
+exports.Url = Url;
+
+function Url() {
+ this.protocol = null;
+ this.slashes = null;
+ this.auth = null;
+ this.host = null;
+ this.port = null;
+ this.hostname = null;
+ this.hash = null;
+ this.search = null;
+ this.query = null;
+ this.pathname = null;
+ this.path = null;
+ this.href = null;
+}
+
+// Reference: RFC 3986, RFC 1808, RFC 2396
+
+// define these here so at least they only have to be
+// compiled once on the first module load.
+var protocolPattern = /^([a-z0-9.+-]+:)/i,
+ portPattern = /:[0-9]*$/,
+
+ // Special case for a simple path URL
+ simplePathPattern = /^(\/\/?(?!\/)[^\?\s]*)(\?[^\s]*)?$/,
+
+ // RFC 2396: characters reserved for delimiting URLs.
+ // We actually just auto-escape these.
+ delims = ['<', '>', '"', '`', ' ', '\r', '\n', '\t'],
+
+ // RFC 2396: characters not allowed for various reasons.
+ unwise = ['{', '}', '|', '\\', '^', '`'].concat(delims),
+
+ // Allowed by RFCs, but cause of XSS attacks. Always escape these.
+ autoEscape = ['\''].concat(unwise),
+ // Characters that are never ever allowed in a hostname.
+ // Note that any invalid chars are also handled, but these
+ // are the ones that are *expected* to be seen, so we fast-path
+ // them.
+ nonHostChars = ['%', '/', '?', ';', '#'].concat(autoEscape),
+ hostEndingChars = ['/', '?', '#'],
+ hostnameMaxLen = 255,
+ hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/,
+ hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/,
+ // protocols that can allow "unsafe" and "unwise" chars.
+ unsafeProtocol = {
+ 'javascript': true,
+ 'javascript:': true
+ },
+ // protocols that never have a hostname.
+ hostlessProtocol = {
+ 'javascript': true,
+ 'javascript:': true
+ },
+ // protocols that always contain a // bit.
+ slashedProtocol = {
+ 'http': true,
+ 'https': true,
+ 'ftp': true,
+ 'gopher': true,
+ 'file': true,
+ 'http:': true,
+ 'https:': true,
+ 'ftp:': true,
+ 'gopher:': true,
+ 'file:': true
+ },
+ querystring = require('querystring');
+
+function urlParse(url, parseQueryString, slashesDenoteHost) {
+ if (url && util.isObject(url) && url instanceof Url) return url;
+
+ var u = new Url;
+ u.parse(url, parseQueryString, slashesDenoteHost);
+ return u;
+}
+
+Url.prototype.parse = function(url, parseQueryString, slashesDenoteHost) {
+ if (!util.isString(url)) {
+ throw new TypeError("Parameter 'url' must be a string, not " + typeof url);
+ }
+
+ // Copy chrome, IE, opera backslash-handling behavior.
+ // Back slashes before the query string get converted to forward slashes
+ // See: https://code.google.com/p/chromium/issues/detail?id=25916
+ var queryIndex = url.indexOf('?'),
+ splitter =
+ (queryIndex !== -1 && queryIndex < url.indexOf('#')) ? '?' : '#',
+ uSplit = url.split(splitter),
+ slashRegex = /\\/g;
+ uSplit[0] = uSplit[0].replace(slashRegex, '/');
+ url = uSplit.join(splitter);
+
+ var rest = url;
+
+ // trim before proceeding.
+ // This is to support parse stuff like " http://foo.com \n"
+ rest = rest.trim();
+
+ if (!slashesDenoteHost && url.split('#').length === 1) {
+ // Try fast path regexp
+ var simplePath = simplePathPattern.exec(rest);
+ if (simplePath) {
+ this.path = rest;
+ this.href = rest;
+ this.pathname = simplePath[1];
+ if (simplePath[2]) {
+ this.search = simplePath[2];
+ if (parseQueryString) {
+ this.query = querystring.parse(this.search.substr(1));
+ } else {
+ this.query = this.search.substr(1);
+ }
+ } else if (parseQueryString) {
+ this.search = '';
+ this.query = {};
+ }
+ return this;
+ }
+ }
+
+ var proto = protocolPattern.exec(rest);
+ if (proto) {
+ proto = proto[0];
+ var lowerProto = proto.toLowerCase();
+ this.protocol = lowerProto;
+ rest = rest.substr(proto.length);
+ }
+
+ // figure out if it's got a host
+ // user@server is *always* interpreted as a hostname, and url
+ // resolution will treat //foo/bar as host=foo,path=bar because that's
+ // how the browser resolves relative URLs.
+ if (slashesDenoteHost || proto || rest.match(/^\/\/[^@\/]+@[^@\/]+/)) {
+ var slashes = rest.substr(0, 2) === '//';
+ if (slashes && !(proto && hostlessProtocol[proto])) {
+ rest = rest.substr(2);
+ this.slashes = true;
+ }
+ }
+
+ if (!hostlessProtocol[proto] &&
+ (slashes || (proto && !slashedProtocol[proto]))) {
+
+ // there's a hostname.
+ // the first instance of /, ?, ;, or # ends the host.
+ //
+ // If there is an @ in the hostname, then non-host chars *are* allowed
+ // to the left of the last @ sign, unless some host-ending character
+ // comes *before* the @-sign.
+ // URLs are obnoxious.
+ //
+ // ex:
+ // http://a@b@c/ => user:a@b host:c
+ // http://a@b?@c => user:a host:c path:/?@c
+
+ // v0.12 TODO(isaacs): This is not quite how Chrome does things.
+ // Review our test case against browsers more comprehensively.
+
+ // find the first instance of any hostEndingChars
+ var hostEnd = -1;
+ for (var i = 0; i < hostEndingChars.length; i++) {
+ var hec = rest.indexOf(hostEndingChars[i]);
+ if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
+ hostEnd = hec;
+ }
+
+ // at this point, either we have an explicit point where the
+ // auth portion cannot go past, or the last @ char is the decider.
+ var auth, atSign;
+ if (hostEnd === -1) {
+ // atSign can be anywhere.
+ atSign = rest.lastIndexOf('@');
+ } else {
+ // atSign must be in auth portion.
+ // http://a@b/c@d => host:b auth:a path:/c@d
+ atSign = rest.lastIndexOf('@', hostEnd);
+ }
+
+ // Now we have a portion which is definitely the auth.
+ // Pull that off.
+ if (atSign !== -1) {
+ auth = rest.slice(0, atSign);
+ rest = rest.slice(atSign + 1);
+ this.auth = decodeURIComponent(auth);
+ }
+
+ // the host is the remaining to the left of the first non-host char
+ hostEnd = -1;
+ for (var i = 0; i < nonHostChars.length; i++) {
+ var hec = rest.indexOf(nonHostChars[i]);
+ if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
+ hostEnd = hec;
+ }
+ // if we still have not hit it, then the entire thing is a host.
+ if (hostEnd === -1)
+ hostEnd = rest.length;
+
+ this.host = rest.slice(0, hostEnd);
+ rest = rest.slice(hostEnd);
+
+ // pull out port.
+ this.parseHost();
+
+ // we've indicated that there is a hostname,
+ // so even if it's empty, it has to be present.
+ this.hostname = this.hostname || '';
+
+ // if hostname begins with [ and ends with ]
+ // assume that it's an IPv6 address.
+ var ipv6Hostname = this.hostname[0] === '[' &&
+ this.hostname[this.hostname.length - 1] === ']';
+
+ // validate a little.
+ if (!ipv6Hostname) {
+ var hostparts = this.hostname.split(/\./);
+ for (var i = 0, l = hostparts.length; i < l; i++) {
+ var part = hostparts[i];
+ if (!part) continue;
+ if (!part.match(hostnamePartPattern)) {
+ var newpart = '';
+ for (var j = 0, k = part.length; j < k; j++) {
+ if (part.charCodeAt(j) > 127) {
+ // we replace non-ASCII char with a temporary placeholder
+ // we need this to make sure size of hostname is not
+ // broken by replacing non-ASCII by nothing
+ newpart += 'x';
+ } else {
+ newpart += part[j];
+ }
+ }
+ // we test again with ASCII char only
+ if (!newpart.match(hostnamePartPattern)) {
+ var validParts = hostparts.slice(0, i);
+ var notHost = hostparts.slice(i + 1);
+ var bit = part.match(hostnamePartStart);
+ if (bit) {
+ validParts.push(bit[1]);
+ notHost.unshift(bit[2]);
+ }
+ if (notHost.length) {
+ rest = '/' + notHost.join('.') + rest;
+ }
+ this.hostname = validParts.join('.');
+ break;
+ }
+ }
+ }
+ }
+
+ if (this.hostname.length > hostnameMaxLen) {
+ this.hostname = '';
+ } else {
+ // hostnames are always lower case.
+ this.hostname = this.hostname.toLowerCase();
+ }
+
+ if (!ipv6Hostname) {
+ // IDNA Support: Returns a punycoded representation of "domain".
+ // It only converts parts of the domain name that
+ // have non-ASCII characters, i.e. it doesn't matter if
+ // you call it with a domain that already is ASCII-only.
+ this.hostname = punycode.toASCII(this.hostname);
+ }
+
+ var p = this.port ? ':' + this.port : '';
+ var h = this.hostname || '';
+ this.host = h + p;
+ this.href += this.host;
+
+ // strip [ and ] from the hostname
+ // the host field still retains them, though
+ if (ipv6Hostname) {
+ this.hostname = this.hostname.substr(1, this.hostname.length - 2);
+ if (rest[0] !== '/') {
+ rest = '/' + rest;
+ }
+ }
+ }
+
+ // now rest is set to the post-host stuff.
+ // chop off any delim chars.
+ if (!unsafeProtocol[lowerProto]) {
+
+ // First, make 100% sure that any "autoEscape" chars get
+ // escaped, even if encodeURIComponent doesn't think they
+ // need to be.
+ for (var i = 0, l = autoEscape.length; i < l; i++) {
+ var ae = autoEscape[i];
+ if (rest.indexOf(ae) === -1)
+ continue;
+ var esc = encodeURIComponent(ae);
+ if (esc === ae) {
+ esc = escape(ae);
+ }
+ rest = rest.split(ae).join(esc);
+ }
+ }
+
+
+ // chop off from the tail first.
+ var hash = rest.indexOf('#');
+ if (hash !== -1) {
+ // got a fragment string.
+ this.hash = rest.substr(hash);
+ rest = rest.slice(0, hash);
+ }
+ var qm = rest.indexOf('?');
+ if (qm !== -1) {
+ this.search = rest.substr(qm);
+ this.query = rest.substr(qm + 1);
+ if (parseQueryString) {
+ this.query = querystring.parse(this.query);
+ }
+ rest = rest.slice(0, qm);
+ } else if (parseQueryString) {
+ // no query string, but parseQueryString still requested
+ this.search = '';
+ this.query = {};
+ }
+ if (rest) this.pathname = rest;
+ if (slashedProtocol[lowerProto] &&
+ this.hostname && !this.pathname) {
+ this.pathname = '/';
+ }
+
+ //to support http.request
+ if (this.pathname || this.search) {
+ var p = this.pathname || '';
+ var s = this.search || '';
+ this.path = p + s;
+ }
+
+ // finally, reconstruct the href based on what has been validated.
+ this.href = this.format();
+ return this;
+};
+
+// format a parsed object into a url string
+function urlFormat(obj) {
+ // ensure it's an object, and not a string url.
+ // If it's an obj, this is a no-op.
+ // this way, you can call url_format() on strings
+ // to clean up potentially wonky urls.
+ if (util.isString(obj)) obj = urlParse(obj);
+ if (!(obj instanceof Url)) return Url.prototype.format.call(obj);
+ return obj.format();
+}
+
+Url.prototype.format = function() {
+ var auth = this.auth || '';
+ if (auth) {
+ auth = encodeURIComponent(auth);
+ auth = auth.replace(/%3A/i, ':');
+ auth += '@';
+ }
+
+ var protocol = this.protocol || '',
+ pathname = this.pathname || '',
+ hash = this.hash || '',
+ host = false,
+ query = '';
+
+ if (this.host) {
+ host = auth + this.host;
+ } else if (this.hostname) {
+ host = auth + (this.hostname.indexOf(':') === -1 ?
+ this.hostname :
+ '[' + this.hostname + ']');
+ if (this.port) {
+ host += ':' + this.port;
+ }
+ }
+
+ if (this.query &&
+ util.isObject(this.query) &&
+ Object.keys(this.query).length) {
+ query = querystring.stringify(this.query);
+ }
+
+ var search = this.search || (query && ('?' + query)) || '';
+
+ if (protocol && protocol.substr(-1) !== ':') protocol += ':';
+
+ // only the slashedProtocols get the //. Not mailto:, xmpp:, etc.
+ // unless they had them to begin with.
+ if (this.slashes ||
+ (!protocol || slashedProtocol[protocol]) && host !== false) {
+ host = '//' + (host || '');
+ if (pathname && pathname.charAt(0) !== '/') pathname = '/' + pathname;
+ } else if (!host) {
+ host = '';
+ }
+
+ if (hash && hash.charAt(0) !== '#') hash = '#' + hash;
+ if (search && search.charAt(0) !== '?') search = '?' + search;
+
+ pathname = pathname.replace(/[?#]/g, function(match) {
+ return encodeURIComponent(match);
+ });
+ search = search.replace('#', '%23');
+
+ return protocol + host + pathname + search + hash;
+};
+
+function urlResolve(source, relative) {
+ return urlParse(source, false, true).resolve(relative);
+}
+
+Url.prototype.resolve = function(relative) {
+ return this.resolveObject(urlParse(relative, false, true)).format();
+};
+
+function urlResolveObject(source, relative) {
+ if (!source) return relative;
+ return urlParse(source, false, true).resolveObject(relative);
+}
+
+Url.prototype.resolveObject = function(relative) {
+ if (util.isString(relative)) {
+ var rel = new Url();
+ rel.parse(relative, false, true);
+ relative = rel;
+ }
+
+ var result = new Url();
+ var tkeys = Object.keys(this);
+ for (var tk = 0; tk < tkeys.length; tk++) {
+ var tkey = tkeys[tk];
+ result[tkey] = this[tkey];
+ }
+
+ // hash is always overridden, no matter what.
+ // even href="" will remove it.
+ result.hash = relative.hash;
+
+ // if the relative url is empty, then there's nothing left to do here.
+ if (relative.href === '') {
+ result.href = result.format();
+ return result;
+ }
+
+ // hrefs like //foo/bar always cut to the protocol.
+ if (relative.slashes && !relative.protocol) {
+ // take everything except the protocol from relative
+ var rkeys = Object.keys(relative);
+ for (var rk = 0; rk < rkeys.length; rk++) {
+ var rkey = rkeys[rk];
+ if (rkey !== 'protocol')
+ result[rkey] = relative[rkey];
+ }
+
+ //urlParse appends trailing / to urls like http://www.example.com
+ if (slashedProtocol[result.protocol] &&
+ result.hostname && !result.pathname) {
+ result.path = result.pathname = '/';
+ }
+
+ result.href = result.format();
+ return result;
+ }
+
+ if (relative.protocol && relative.protocol !== result.protocol) {
+ // if it's a known url protocol, then changing
+ // the protocol does weird things
+ // first, if it's not file:, then we MUST have a host,
+ // and if there was a path
+ // to begin with, then we MUST have a path.
+ // if it is file:, then the host is dropped,
+ // because that's known to be hostless.
+ // anything else is assumed to be absolute.
+ if (!slashedProtocol[relative.protocol]) {
+ var keys = Object.keys(relative);
+ for (var v = 0; v < keys.length; v++) {
+ var k = keys[v];
+ result[k] = relative[k];
+ }
+ result.href = result.format();
+ return result;
+ }
+
+ result.protocol = relative.protocol;
+ if (!relative.host && !hostlessProtocol[relative.protocol]) {
+ var relPath = (relative.pathname || '').split('/');
+ while (relPath.length && !(relative.host = relPath.shift()));
+ if (!relative.host) relative.host = '';
+ if (!relative.hostname) relative.hostname = '';
+ if (relPath[0] !== '') relPath.unshift('');
+ if (relPath.length < 2) relPath.unshift('');
+ result.pathname = relPath.join('/');
+ } else {
+ result.pathname = relative.pathname;
+ }
+ result.search = relative.search;
+ result.query = relative.query;
+ result.host = relative.host || '';
+ result.auth = relative.auth;
+ result.hostname = relative.hostname || relative.host;
+ result.port = relative.port;
+ // to support http.request
+ if (result.pathname || result.search) {
+ var p = result.pathname || '';
+ var s = result.search || '';
+ result.path = p + s;
+ }
+ result.slashes = result.slashes || relative.slashes;
+ result.href = result.format();
+ return result;
+ }
+
+ var isSourceAbs = (result.pathname && result.pathname.charAt(0) === '/'),
+ isRelAbs = (
+ relative.host ||
+ relative.pathname && relative.pathname.charAt(0) === '/'
+ ),
+ mustEndAbs = (isRelAbs || isSourceAbs ||
+ (result.host && relative.pathname)),
+ removeAllDots = mustEndAbs,
+ srcPath = result.pathname && result.pathname.split('/') || [],
+ relPath = relative.pathname && relative.pathname.split('/') || [],
+ psychotic = result.protocol && !slashedProtocol[result.protocol];
+
+ // if the url is a non-slashed url, then relative
+ // links like ../.. should be able
+ // to crawl up to the hostname, as well. This is strange.
+ // result.protocol has already been set by now.
+ // Later on, put the first path part into the host field.
+ if (psychotic) {
+ result.hostname = '';
+ result.port = null;
+ if (result.host) {
+ if (srcPath[0] === '') srcPath[0] = result.host;
+ else srcPath.unshift(result.host);
+ }
+ result.host = '';
+ if (relative.protocol) {
+ relative.hostname = null;
+ relative.port = null;
+ if (relative.host) {
+ if (relPath[0] === '') relPath[0] = relative.host;
+ else relPath.unshift(relative.host);
+ }
+ relative.host = null;
+ }
+ mustEndAbs = mustEndAbs && (relPath[0] === '' || srcPath[0] === '');
+ }
+
+ if (isRelAbs) {
+ // it's absolute.
+ result.host = (relative.host || relative.host === '') ?
+ relative.host : result.host;
+ result.hostname = (relative.hostname || relative.hostname === '') ?
+ relative.hostname : result.hostname;
+ result.search = relative.search;
+ result.query = relative.query;
+ srcPath = relPath;
+ // fall through to the dot-handling below.
+ } else if (relPath.length) {
+ // it's relative
+ // throw away the existing file, and take the new path instead.
+ if (!srcPath) srcPath = [];
+ srcPath.pop();
+ srcPath = srcPath.concat(relPath);
+ result.search = relative.search;
+ result.query = relative.query;
+ } else if (!util.isNullOrUndefined(relative.search)) {
+ // just pull out the search.
+ // like href='?foo'.
+ // Put this after the other two cases because it simplifies the booleans
+ if (psychotic) {
+ result.hostname = result.host = srcPath.shift();
+ //occationaly the auth can get stuck only in host
+ //this especially happens in cases like
+ //url.resolveObject('mailto:local1@domain1', 'local2@domain2')
+ var authInHost = result.host && result.host.indexOf('@') > 0 ?
+ result.host.split('@') : false;
+ if (authInHost) {
+ result.auth = authInHost.shift();
+ result.host = result.hostname = authInHost.shift();
+ }
+ }
+ result.search = relative.search;
+ result.query = relative.query;
+ //to support http.request
+ if (!util.isNull(result.pathname) || !util.isNull(result.search)) {
+ result.path = (result.pathname ? result.pathname : '') +
+ (result.search ? result.search : '');
+ }
+ result.href = result.format();
+ return result;
+ }
+
+ if (!srcPath.length) {
+ // no path at all. easy.
+ // we've already handled the other stuff above.
+ result.pathname = null;
+ //to support http.request
+ if (result.search) {
+ result.path = '/' + result.search;
+ } else {
+ result.path = null;
+ }
+ result.href = result.format();
+ return result;
+ }
+
+ // if a url ENDs in . or .., then it must get a trailing slash.
+ // however, if it ends in anything else non-slashy,
+ // then it must NOT get a trailing slash.
+ var last = srcPath.slice(-1)[0];
+ var hasTrailingSlash = (
+ (result.host || relative.host || srcPath.length > 1) &&
+ (last === '.' || last === '..') || last === '');
+
+ // strip single dots, resolve double dots to parent dir
+ // if the path tries to go above the root, `up` ends up > 0
+ var up = 0;
+ for (var i = srcPath.length; i >= 0; i--) {
+ last = srcPath[i];
+ if (last === '.') {
+ srcPath.splice(i, 1);
+ } else if (last === '..') {
+ srcPath.splice(i, 1);
+ up++;
+ } else if (up) {
+ srcPath.splice(i, 1);
+ up--;
+ }
+ }
+
+ // if the path is allowed to go above the root, restore leading ..s
+ if (!mustEndAbs && !removeAllDots) {
+ for (; up--; up) {
+ srcPath.unshift('..');
+ }
+ }
+
+ if (mustEndAbs && srcPath[0] !== '' &&
+ (!srcPath[0] || srcPath[0].charAt(0) !== '/')) {
+ srcPath.unshift('');
+ }
+
+ if (hasTrailingSlash && (srcPath.join('/').substr(-1) !== '/')) {
+ srcPath.push('');
+ }
+
+ var isAbsolute = srcPath[0] === '' ||
+ (srcPath[0] && srcPath[0].charAt(0) === '/');
+
+ // put the host back
+ if (psychotic) {
+ result.hostname = result.host = isAbsolute ? '' :
+ srcPath.length ? srcPath.shift() : '';
+ //occationaly the auth can get stuck only in host
+ //this especially happens in cases like
+ //url.resolveObject('mailto:local1@domain1', 'local2@domain2')
+ var authInHost = result.host && result.host.indexOf('@') > 0 ?
+ result.host.split('@') : false;
+ if (authInHost) {
+ result.auth = authInHost.shift();
+ result.host = result.hostname = authInHost.shift();
+ }
+ }
+
+ mustEndAbs = mustEndAbs || (result.host && srcPath.length);
+
+ if (mustEndAbs && !isAbsolute) {
+ srcPath.unshift('');
+ }
+
+ if (!srcPath.length) {
+ result.pathname = null;
+ result.path = null;
+ } else {
+ result.pathname = srcPath.join('/');
+ }
+
+ //to support request.http
+ if (!util.isNull(result.pathname) || !util.isNull(result.search)) {
+ result.path = (result.pathname ? result.pathname : '') +
+ (result.search ? result.search : '');
+ }
+ result.auth = relative.auth || result.auth;
+ result.slashes = result.slashes || relative.slashes;
+ result.href = result.format();
+ return result;
+};
+
+Url.prototype.parseHost = function() {
+ var host = this.host;
+ var port = portPattern.exec(host);
+ if (port) {
+ port = port[0];
+ if (port !== ':') {
+ this.port = port.substr(1);
+ }
+ host = host.substr(0, host.length - port.length);
+ }
+ if (host) this.hostname = host;
+};
+
+},{"./util":114,"punycode":93,"querystring":96}],114:[function(require,module,exports){
+'use strict';
+
+module.exports = {
+ isString: function(arg) {
+ return typeof(arg) === 'string';
+ },
+ isObject: function(arg) {
+ return typeof(arg) === 'object' && arg !== null;
+ },
+ isNull: function(arg) {
+ return arg === null;
+ },
+ isNullOrUndefined: function(arg) {
+ return arg == null;
+ }
+};
+
+},{}],115:[function(require,module,exports){
+(function (global){
+
+/**
+ * Module exports.
+ */
+
+module.exports = deprecate;
+
+/**
+ * Mark that a method should not be used.
+ * Returns a modified function which warns once by default.
+ *
+ * If `localStorage.noDeprecation = true` is set, then it is a no-op.
+ *
+ * If `localStorage.throwDeprecation = true` is set, then deprecated functions
+ * will throw an Error when invoked.
+ *
+ * If `localStorage.traceDeprecation = true` is set, then deprecated functions
+ * will invoke `console.trace()` instead of `console.error()`.
+ *
+ * @param {Function} fn - the function to deprecate
+ * @param {String} msg - the string to print to the console when `fn` is invoked
+ * @returns {Function} a new "deprecated" version of `fn`
+ * @api public
+ */
+
+function deprecate (fn, msg) {
+ if (config('noDeprecation')) {
+ return fn;
+ }
+
+ var warned = false;
+ function deprecated() {
+ if (!warned) {
+ if (config('throwDeprecation')) {
+ throw new Error(msg);
+ } else if (config('traceDeprecation')) {
+ console.trace(msg);
+ } else {
+ console.warn(msg);
+ }
+ warned = true;
+ }
+ return fn.apply(this, arguments);
+ }
+
+ return deprecated;
+}
+
+/**
+ * Checks `localStorage` for boolean values for the given `name`.
+ *
+ * @param {String} name
+ * @returns {Boolean}
+ * @api private
+ */
+
+function config (name) {
+ // accessing global.localStorage can trigger a DOMException in sandboxed iframes
+ try {
+ if (!global.localStorage) return false;
+ } catch (_) {
+ return false;
+ }
+ var val = global.localStorage[name];
+ if (null == val) return false;
+ return String(val).toLowerCase() === 'true';
+}
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{}],116:[function(require,module,exports){
+module.exports = function isBuffer(arg) {
+ return arg && typeof arg === 'object'
+ && typeof arg.copy === 'function'
+ && typeof arg.fill === 'function'
+ && typeof arg.readUInt8 === 'function';
+}
+},{}],117:[function(require,module,exports){
+(function (process,global){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+var formatRegExp = /%[sdj%]/g;
+exports.format = function(f) {
+ if (!isString(f)) {
+ var objects = [];
+ for (var i = 0; i < arguments.length; i++) {
+ objects.push(inspect(arguments[i]));
+ }
+ return objects.join(' ');
+ }
+
+ var i = 1;
+ var args = arguments;
+ var len = args.length;
+ var str = String(f).replace(formatRegExp, function(x) {
+ if (x === '%%') return '%';
+ if (i >= len) return x;
+ switch (x) {
+ case '%s': return String(args[i++]);
+ case '%d': return Number(args[i++]);
+ case '%j':
+ try {
+ return JSON.stringify(args[i++]);
+ } catch (_) {
+ return '[Circular]';
+ }
+ default:
+ return x;
+ }
+ });
+ for (var x = args[i]; i < len; x = args[++i]) {
+ if (isNull(x) || !isObject(x)) {
+ str += ' ' + x;
+ } else {
+ str += ' ' + inspect(x);
+ }
+ }
+ return str;
+};
+
+
+// Mark that a method should not be used.
+// Returns a modified function which warns once by default.
+// If --no-deprecation is set, then it is a no-op.
+exports.deprecate = function(fn, msg) {
+ // Allow for deprecating things in the process of starting up.
+ if (isUndefined(global.process)) {
+ return function() {
+ return exports.deprecate(fn, msg).apply(this, arguments);
+ };
+ }
+
+ if (process.noDeprecation === true) {
+ return fn;
+ }
+
+ var warned = false;
+ function deprecated() {
+ if (!warned) {
+ if (process.throwDeprecation) {
+ throw new Error(msg);
+ } else if (process.traceDeprecation) {
+ console.trace(msg);
+ } else {
+ console.error(msg);
+ }
+ warned = true;
+ }
+ return fn.apply(this, arguments);
+ }
+
+ return deprecated;
+};
+
+
+var debugs = {};
+var debugEnviron;
+exports.debuglog = function(set) {
+ if (isUndefined(debugEnviron))
+ debugEnviron = process.env.NODE_DEBUG || '';
+ set = set.toUpperCase();
+ if (!debugs[set]) {
+ if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) {
+ var pid = process.pid;
+ debugs[set] = function() {
+ var msg = exports.format.apply(exports, arguments);
+ console.error('%s %d: %s', set, pid, msg);
+ };
+ } else {
+ debugs[set] = function() {};
+ }
+ }
+ return debugs[set];
+};
+
+
+/**
+ * Echos the value of a value. Trys to print the value out
+ * in the best way possible given the different types.
+ *
+ * @param {Object} obj The object to print out.
+ * @param {Object} opts Optional options object that alters the output.
+ */
+/* legacy: obj, showHidden, depth, colors*/
+function inspect(obj, opts) {
+ // default options
+ var ctx = {
+ seen: [],
+ stylize: stylizeNoColor
+ };
+ // legacy...
+ if (arguments.length >= 3) ctx.depth = arguments[2];
+ if (arguments.length >= 4) ctx.colors = arguments[3];
+ if (isBoolean(opts)) {
+ // legacy...
+ ctx.showHidden = opts;
+ } else if (opts) {
+ // got an "options" object
+ exports._extend(ctx, opts);
+ }
+ // set default options
+ if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
+ if (isUndefined(ctx.depth)) ctx.depth = 2;
+ if (isUndefined(ctx.colors)) ctx.colors = false;
+ if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
+ if (ctx.colors) ctx.stylize = stylizeWithColor;
+ return formatValue(ctx, obj, ctx.depth);
+}
+exports.inspect = inspect;
+
+
+// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
+inspect.colors = {
+ 'bold' : [1, 22],
+ 'italic' : [3, 23],
+ 'underline' : [4, 24],
+ 'inverse' : [7, 27],
+ 'white' : [37, 39],
+ 'grey' : [90, 39],
+ 'black' : [30, 39],
+ 'blue' : [34, 39],
+ 'cyan' : [36, 39],
+ 'green' : [32, 39],
+ 'magenta' : [35, 39],
+ 'red' : [31, 39],
+ 'yellow' : [33, 39]
+};
+
+// Don't use 'blue' not visible on cmd.exe
+inspect.styles = {
+ 'special': 'cyan',
+ 'number': 'yellow',
+ 'boolean': 'yellow',
+ 'undefined': 'grey',
+ 'null': 'bold',
+ 'string': 'green',
+ 'date': 'magenta',
+ // "name": intentionally not styling
+ 'regexp': 'red'
+};
+
+
+function stylizeWithColor(str, styleType) {
+ var style = inspect.styles[styleType];
+
+ if (style) {
+ return '\u001b[' + inspect.colors[style][0] + 'm' + str +
+ '\u001b[' + inspect.colors[style][1] + 'm';
+ } else {
+ return str;
+ }
+}
+
+
+function stylizeNoColor(str, styleType) {
+ return str;
+}
+
+
+function arrayToHash(array) {
+ var hash = {};
+
+ array.forEach(function(val, idx) {
+ hash[val] = true;
+ });
+
+ return hash;
+}
+
+
+function formatValue(ctx, value, recurseTimes) {
+ // Provide a hook for user-specified inspect functions.
+ // Check that value is an object with an inspect function on it
+ if (ctx.customInspect &&
+ value &&
+ isFunction(value.inspect) &&
+ // Filter out the util module, it's inspect function is special
+ value.inspect !== exports.inspect &&
+ // Also filter out any prototype objects using the circular check.
+ !(value.constructor && value.constructor.prototype === value)) {
+ var ret = value.inspect(recurseTimes, ctx);
+ if (!isString(ret)) {
+ ret = formatValue(ctx, ret, recurseTimes);
+ }
+ return ret;
+ }
+
+ // Primitive types cannot have properties
+ var primitive = formatPrimitive(ctx, value);
+ if (primitive) {
+ return primitive;
+ }
+
+ // Look up the keys of the object.
+ var keys = Object.keys(value);
+ var visibleKeys = arrayToHash(keys);
+
+ if (ctx.showHidden) {
+ keys = Object.getOwnPropertyNames(value);
+ }
+
+ // IE doesn't make error fields non-enumerable
+ // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
+ if (isError(value)
+ && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
+ return formatError(value);
+ }
+
+ // Some type of object without properties can be shortcutted.
+ if (keys.length === 0) {
+ if (isFunction(value)) {
+ var name = value.name ? ': ' + value.name : '';
+ return ctx.stylize('[Function' + name + ']', 'special');
+ }
+ if (isRegExp(value)) {
+ return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
+ }
+ if (isDate(value)) {
+ return ctx.stylize(Date.prototype.toString.call(value), 'date');
+ }
+ if (isError(value)) {
+ return formatError(value);
+ }
+ }
+
+ var base = '', array = false, braces = ['{', '}'];
+
+ // Make Array say that they are Array
+ if (isArray(value)) {
+ array = true;
+ braces = ['[', ']'];
+ }
+
+ // Make functions say that they are functions
+ if (isFunction(value)) {
+ var n = value.name ? ': ' + value.name : '';
+ base = ' [Function' + n + ']';
+ }
+
+ // Make RegExps say that they are RegExps
+ if (isRegExp(value)) {
+ base = ' ' + RegExp.prototype.toString.call(value);
+ }
+
+ // Make dates with properties first say the date
+ if (isDate(value)) {
+ base = ' ' + Date.prototype.toUTCString.call(value);
+ }
+
+ // Make error with message first say the error
+ if (isError(value)) {
+ base = ' ' + formatError(value);
+ }
+
+ if (keys.length === 0 && (!array || value.length == 0)) {
+ return braces[0] + base + braces[1];
+ }
+
+ if (recurseTimes < 0) {
+ if (isRegExp(value)) {
+ return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
+ } else {
+ return ctx.stylize('[Object]', 'special');
+ }
+ }
+
+ ctx.seen.push(value);
+
+ var output;
+ if (array) {
+ output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
+ } else {
+ output = keys.map(function(key) {
+ return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
+ });
+ }
+
+ ctx.seen.pop();
+
+ return reduceToSingleString(output, base, braces);
+}
+
+
+function formatPrimitive(ctx, value) {
+ if (isUndefined(value))
+ return ctx.stylize('undefined', 'undefined');
+ if (isString(value)) {
+ var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
+ .replace(/'/g, "\\'")
+ .replace(/\\"/g, '"') + '\'';
+ return ctx.stylize(simple, 'string');
+ }
+ if (isNumber(value))
+ return ctx.stylize('' + value, 'number');
+ if (isBoolean(value))
+ return ctx.stylize('' + value, 'boolean');
+ // For some reason typeof null is "object", so special case here.
+ if (isNull(value))
+ return ctx.stylize('null', 'null');
+}
+
+
+function formatError(value) {
+ return '[' + Error.prototype.toString.call(value) + ']';
+}
+
+
+function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
+ var output = [];
+ for (var i = 0, l = value.length; i < l; ++i) {
+ if (hasOwnProperty(value, String(i))) {
+ output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
+ String(i), true));
+ } else {
+ output.push('');
+ }
+ }
+ keys.forEach(function(key) {
+ if (!key.match(/^\d+$/)) {
+ output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
+ key, true));
+ }
+ });
+ return output;
+}
+
+
+function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
+ var name, str, desc;
+ desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };
+ if (desc.get) {
+ if (desc.set) {
+ str = ctx.stylize('[Getter/Setter]', 'special');
+ } else {
+ str = ctx.stylize('[Getter]', 'special');
+ }
+ } else {
+ if (desc.set) {
+ str = ctx.stylize('[Setter]', 'special');
+ }
+ }
+ if (!hasOwnProperty(visibleKeys, key)) {
+ name = '[' + key + ']';
+ }
+ if (!str) {
+ if (ctx.seen.indexOf(desc.value) < 0) {
+ if (isNull(recurseTimes)) {
+ str = formatValue(ctx, desc.value, null);
+ } else {
+ str = formatValue(ctx, desc.value, recurseTimes - 1);
+ }
+ if (str.indexOf('\n') > -1) {
+ if (array) {
+ str = str.split('\n').map(function(line) {
+ return ' ' + line;
+ }).join('\n').substr(2);
+ } else {
+ str = '\n' + str.split('\n').map(function(line) {
+ return ' ' + line;
+ }).join('\n');
+ }
+ }
+ } else {
+ str = ctx.stylize('[Circular]', 'special');
+ }
+ }
+ if (isUndefined(name)) {
+ if (array && key.match(/^\d+$/)) {
+ return str;
+ }
+ name = JSON.stringify('' + key);
+ if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
+ name = name.substr(1, name.length - 2);
+ name = ctx.stylize(name, 'name');
+ } else {
+ name = name.replace(/'/g, "\\'")
+ .replace(/\\"/g, '"')
+ .replace(/(^"|"$)/g, "'");
+ name = ctx.stylize(name, 'string');
+ }
+ }
+
+ return name + ': ' + str;
+}
+
+
+function reduceToSingleString(output, base, braces) {
+ var numLinesEst = 0;
+ var length = output.reduce(function(prev, cur) {
+ numLinesEst++;
+ if (cur.indexOf('\n') >= 0) numLinesEst++;
+ return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
+ }, 0);
+
+ if (length > 60) {
+ return braces[0] +
+ (base === '' ? '' : base + '\n ') +
+ ' ' +
+ output.join(',\n ') +
+ ' ' +
+ braces[1];
+ }
+
+ return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
+}
+
+
+// NOTE: These type checking functions intentionally don't use `instanceof`
+// because it is fragile and can be easily faked with `Object.create()`.
+function isArray(ar) {
+ return Array.isArray(ar);
+}
+exports.isArray = isArray;
+
+function isBoolean(arg) {
+ return typeof arg === 'boolean';
+}
+exports.isBoolean = isBoolean;
+
+function isNull(arg) {
+ return arg === null;
+}
+exports.isNull = isNull;
+
+function isNullOrUndefined(arg) {
+ return arg == null;
+}
+exports.isNullOrUndefined = isNullOrUndefined;
+
+function isNumber(arg) {
+ return typeof arg === 'number';
+}
+exports.isNumber = isNumber;
+
+function isString(arg) {
+ return typeof arg === 'string';
+}
+exports.isString = isString;
+
+function isSymbol(arg) {
+ return typeof arg === 'symbol';
+}
+exports.isSymbol = isSymbol;
+
+function isUndefined(arg) {
+ return arg === void 0;
+}
+exports.isUndefined = isUndefined;
+
+function isRegExp(re) {
+ return isObject(re) && objectToString(re) === '[object RegExp]';
+}
+exports.isRegExp = isRegExp;
+
+function isObject(arg) {
+ return typeof arg === 'object' && arg !== null;
+}
+exports.isObject = isObject;
+
+function isDate(d) {
+ return isObject(d) && objectToString(d) === '[object Date]';
+}
+exports.isDate = isDate;
+
+function isError(e) {
+ return isObject(e) &&
+ (objectToString(e) === '[object Error]' || e instanceof Error);
+}
+exports.isError = isError;
+
+function isFunction(arg) {
+ return typeof arg === 'function';
+}
+exports.isFunction = isFunction;
+
+function isPrimitive(arg) {
+ return arg === null ||
+ typeof arg === 'boolean' ||
+ typeof arg === 'number' ||
+ typeof arg === 'string' ||
+ typeof arg === 'symbol' || // ES6 symbol
+ typeof arg === 'undefined';
+}
+exports.isPrimitive = isPrimitive;
+
+exports.isBuffer = require('./support/isBuffer');
+
+function objectToString(o) {
+ return Object.prototype.toString.call(o);
+}
+
+
+function pad(n) {
+ return n < 10 ? '0' + n.toString(10) : n.toString(10);
+}
+
+
+var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
+ 'Oct', 'Nov', 'Dec'];
+
+// 26 Feb 16:19:34
+function timestamp() {
+ var d = new Date();
+ var time = [pad(d.getHours()),
+ pad(d.getMinutes()),
+ pad(d.getSeconds())].join(':');
+ return [d.getDate(), months[d.getMonth()], time].join(' ');
+}
+
+
+// log is just a thin wrapper to console.log that prepends a timestamp
+exports.log = function() {
+ console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));
+};
+
+
+/**
+ * Inherit the prototype methods from one constructor into another.
+ *
+ * The Function.prototype.inherits from lang.js rewritten as a standalone
+ * function (not on Function.prototype). NOTE: If this file is to be loaded
+ * during bootstrapping this function needs to be rewritten using some native
+ * functions as prototype setup using normal JavaScript does not work as
+ * expected during bootstrapping (see mirror.js in r114903).
+ *
+ * @param {function} ctor Constructor function which needs to inherit the
+ * prototype.
+ * @param {function} superCtor Constructor function to inherit prototype from.
+ */
+exports.inherits = require('inherits');
+
+exports._extend = function(origin, add) {
+ // Don't do anything if add isn't an object
+ if (!add || !isObject(add)) return origin;
+
+ var keys = Object.keys(add);
+ var i = keys.length;
+ while (i--) {
+ origin[keys[i]] = add[keys[i]];
+ }
+ return origin;
+};
+
+function hasOwnProperty(obj, prop) {
+ return Object.prototype.hasOwnProperty.call(obj, prop);
+}
+
+}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"./support/isBuffer":116,"_process":92,"inherits":80}],118:[function(require,module,exports){
+(function (process,global){
+'use strict'
+
+var Transform = require('readable-stream').Transform
+var duplexify = require('duplexify')
+var WS = require('ws')
+var Buffer = require('safe-buffer').Buffer
+
+module.exports = WebSocketStream
+
+function buildProxy (options, socketWrite, socketEnd) {
+ var proxy = new Transform({
+ objectMode: options.objectMode
+ })
+
+ proxy._write = socketWrite
+ proxy._flush = socketEnd
+
+ return proxy
+}
+
+function WebSocketStream(target, protocols, options) {
+ var stream, socket
+
+ var isBrowser = process.title === 'browser'
+ var isNative = !!global.WebSocket
+ var socketWrite = isBrowser ? socketWriteBrowser : socketWriteNode
+
+ if (protocols && !Array.isArray(protocols) && 'object' === typeof protocols) {
+ // accept the "options" Object as the 2nd argument
+ options = protocols
+ protocols = null
+
+ if (typeof options.protocol === 'string' || Array.isArray(options.protocol)) {
+ protocols = options.protocol;
+ }
+ }
+
+ if (!options) options = {}
+
+ if (options.objectMode === undefined) {
+ options.objectMode = !(options.binary === true || options.binary === undefined)
+ }
+
+ var proxy = buildProxy(options, socketWrite, socketEnd)
+
+ if (!options.objectMode) {
+ proxy._writev = writev
+ }
+
+ // browser only: sets the maximum socket buffer size before throttling
+ var bufferSize = options.browserBufferSize || 1024 * 512
+
+ // browser only: how long to wait when throttling
+ var bufferTimeout = options.browserBufferTimeout || 1000
+
+ // use existing WebSocket object that was passed in
+ if (typeof target === 'object') {
+ socket = target
+ // otherwise make a new one
+ } else {
+ // special constructor treatment for native websockets in browsers, see
+ // https://github.com/maxogden/websocket-stream/issues/82
+ if (isNative && isBrowser) {
+ socket = new WS(target, protocols)
+ } else {
+ socket = new WS(target, protocols, options)
+ }
+
+ socket.binaryType = 'arraybuffer'
+ }
+
+ // was already open when passed in
+ if (socket.readyState === socket.OPEN) {
+ stream = proxy
+ } else {
+ stream = duplexify.obj()
+ socket.onopen = onopen
+ }
+
+ stream.socket = socket
+
+ socket.onclose = onclose
+ socket.onerror = onerror
+ socket.onmessage = onmessage
+
+ proxy.on('close', destroy)
+
+ var coerceToBuffer = !options.objectMode
+
+ function socketWriteNode(chunk, enc, next) {
+ // avoid errors, this never happens unless
+ // destroy() is called
+ if (socket.readyState !== socket.OPEN) {
+ next()
+ return
+ }
+
+ if (coerceToBuffer && typeof chunk === 'string') {
+ chunk = Buffer.from(chunk, 'utf8')
+ }
+ socket.send(chunk, next)
+ }
+
+ function socketWriteBrowser(chunk, enc, next) {
+ if (socket.bufferedAmount > bufferSize) {
+ setTimeout(socketWriteBrowser, bufferTimeout, chunk, enc, next)
+ return
+ }
+
+ if (coerceToBuffer && typeof chunk === 'string') {
+ chunk = Buffer.from(chunk, 'utf8')
+ }
+
+ try {
+ socket.send(chunk)
+ } catch(err) {
+ return next(err)
+ }
+
+ next()
+ }
+
+ function socketEnd(done) {
+ socket.close()
+ done()
+ }
+
+ function onopen() {
+ stream.setReadable(proxy)
+ stream.setWritable(proxy)
+ stream.emit('connect')
+ }
+
+ function onclose() {
+ stream.end()
+ stream.destroy()
+ }
+
+ function onerror(err) {
+ stream.destroy(err)
+ }
+
+ function onmessage(event) {
+ var data = event.data
+ if (data instanceof ArrayBuffer) data = Buffer.from(data)
+ else data = Buffer.from(data, 'utf8')
+ proxy.push(data)
+ }
+
+ function destroy() {
+ socket.close()
+ }
+
+ // this is to be enabled only if objectMode is false
+ function writev (chunks, cb) {
+ var buffers = new Array(chunks.length)
+ for (var i = 0; i < chunks.length; i++) {
+ if (typeof chunks[i].chunk === 'string') {
+ buffers[i] = Buffer.from(chunks[i], 'utf8')
+ } else {
+ buffers[i] = chunks[i].chunk
+ }
+ }
+
+ this._write(Buffer.concat(buffers), 'binary', cb)
+ }
+
+ return stream
+}
+
+}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"_process":92,"duplexify":17,"readable-stream":108,"safe-buffer":110,"ws":119}],119:[function(require,module,exports){
+
+var ws = null
+
+if (typeof WebSocket !== 'undefined') {
+ ws = WebSocket
+} else if (typeof MozWebSocket !== 'undefined') {
+ ws = MozWebSocket
+} else if (typeof window !== 'undefined') {
+ ws = window.WebSocket || window.MozWebSocket
+}
+
+module.exports = ws
+
+},{}],120:[function(require,module,exports){
+// Returns a wrapper function that returns a wrapped callback
+// The wrapper function should do some stuff, and return a
+// presumably different callback function.
+// This makes sure that own properties are retained, so that
+// decorations and such are not lost along the way.
+module.exports = wrappy
+function wrappy (fn, cb) {
+ if (fn && cb) return wrappy(fn)(cb)
+
+ if (typeof fn !== 'function')
+ throw new TypeError('need wrapper function')
+
+ Object.keys(fn).forEach(function (k) {
+ wrapper[k] = fn[k]
+ })
+
+ return wrapper
+
+ function wrapper() {
+ var args = new Array(arguments.length)
+ for (var i = 0; i < args.length; i++) {
+ args[i] = arguments[i]
+ }
+ var ret = fn.apply(this, args)
+ var cb = args[args.length-1]
+ if (typeof ret === 'function' && ret !== cb) {
+ Object.keys(cb).forEach(function (k) {
+ ret[k] = cb[k]
+ })
+ }
+ return ret
+ }
+}
+
+},{}],121:[function(require,module,exports){
+module.exports = extend
+
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+
+function extend() {
+ var target = {}
+
+ for (var i = 0; i < arguments.length; i++) {
+ var source = arguments[i]
+
+ for (var key in source) {
+ if (hasOwnProperty.call(source, key)) {
+ target[key] = source[key]
+ }
+ }
+ }
+
+ return target
+}
+
+},{}]},{},[9])(9)
+});
diff --git a/src/components/kk-printer/utils/mqtt.min.js b/src/components/kk-printer/utils/mqtt.min.js
new file mode 100644
index 00000000..7fdd259b
--- /dev/null
+++ b/src/components/kk-printer/utils/mqtt.min.js
@@ -0,0 +1 @@
+(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.mqtt=f()}})(function(){var define,module,exports;return function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;ioptions.properties.topicAliasMaximum||!options.properties.topicAliasMaximum&&opts.properties.topicAlias)){delete packet.properties.topicAlias}}switch(opts.qos){case 1:case 2:this.outgoing[packet.messageId]={volatile:false,cb:callback||nop};if(this._storeProcessing){this._packetIdsDuringStoreProcessing[packet.messageId]=false;this._storePacket(packet,undefined,opts.cbStorePut)}else{this._sendPacket(packet,undefined,opts.cbStorePut)}break;default:if(this._storeProcessing){this._storePacket(packet,callback,opts.cbStorePut)}else{this._sendPacket(packet,callback,opts.cbStorePut)}break}return this};MqttClient.prototype.subscribe=function(){var packet;var args=new Array(arguments.length);for(var i=0;i0){var topic={qos:sub.qos};if(version===5){topic.nl=sub.nl||false;topic.rap=sub.rap||false;topic.rh=sub.rh||0;topic.properties=sub.properties}that._resubscribeTopics[sub.topic]=topic;topics.push(sub.topic)}});that.messageIdToTopic[packet.messageId]=topics}this.outgoing[packet.messageId]={volatile:true,cb:function(err,packet){if(!err){var granted=packet.granted;for(var i=0;i0){this.once("outgoingEmpty",setTimeout.bind(null,finish,10))}else{finish()}return this};MqttClient.prototype.removeOutgoingMessage=function(mid){var cb=this.outgoing[mid]?this.outgoing[mid].cb:null;delete this.outgoing[mid];this.outgoingStore.del({messageId:mid},function(){cb(new Error("Message removed"))});return this};MqttClient.prototype.reconnect=function(opts){var that=this;var f=function(){if(opts){that.options.incomingStore=opts.incomingStore;that.options.outgoingStore=opts.outgoingStore}else{that.options.incomingStore=null;that.options.outgoingStore=null}that.incomingStore=that.options.incomingStore||new Store;that.outgoingStore=that.options.outgoingStore||new Store;that.disconnecting=false;that.disconnected=false;that._deferredReconnect=null;that._reconnect()};if(this.disconnecting&&!this.disconnected){this._deferredReconnect=f}else{f()}return this};MqttClient.prototype._reconnect=function(){this.emit("reconnect");this._setupStream()};MqttClient.prototype._setupReconnect=function(){var that=this;if(!that.disconnecting&&!that.reconnectTimer&&that.options.reconnectPeriod>0){if(!this.reconnecting){this.emit("offline");this.reconnecting=true}that.reconnectTimer=setInterval(function(){that._reconnect()},that.options.reconnectPeriod)}};MqttClient.prototype._clearReconnect=function(){if(this.reconnectTimer){clearInterval(this.reconnectTimer);this.reconnectTimer=null}};MqttClient.prototype._cleanUp=function(forced,done){var opts=arguments[2];if(done){this.stream.on("close",done)}if(forced){if(this.options.reconnectPeriod===0&&this.options.clean){flush(this.outgoing)}this.stream.destroy()}else{var packet=xtend({cmd:"disconnect"},opts);this._sendPacket(packet,setImmediate.bind(null,this.stream.end.bind(this.stream)))}if(!this.disconnecting){this._clearReconnect();this._setupReconnect()}if(this.pingTimer!==null){this.pingTimer.clear();this.pingTimer=null}if(done&&!this.connected){this.stream.removeListener("close",done);done()}};MqttClient.prototype._sendPacket=function(packet,cb,cbStorePut){cbStorePut=cbStorePut||nop;if(!this.connected){this._storePacket(packet,cb,cbStorePut);return}this._shiftPingInterval();switch(packet.cmd){case"publish":break;case"pubrel":storeAndSend(this,packet,cb,cbStorePut);return;default:sendPacket(this,packet,cb);return}switch(packet.qos){case 2:case 1:storeAndSend(this,packet,cb,cbStorePut);break;case 0:default:sendPacket(this,packet,cb);break}};MqttClient.prototype._storePacket=function(packet,cb,cbStorePut){cbStorePut=cbStorePut||nop;if((packet.qos||0)===0&&this.queueQoSZero||packet.cmd!=="publish"){this.queue.push({packet:packet,cb:cb})}else if(packet.qos>0){cb=this.outgoing[packet.messageId]?this.outgoing[packet.messageId].cb:null;this.outgoingStore.put(packet,function(err){if(err){return cb&&cb(err)}cbStorePut()})}else if(cb){cb(new Error("No connection to broker"))}};MqttClient.prototype._setupPingTimer=function(){var that=this;if(!this.pingTimer&&this.options.keepalive){this.pingResp=true;this.pingTimer=reInterval(function(){that._checkPing()},this.options.keepalive*1e3)}};MqttClient.prototype._shiftPingInterval=function(){if(this.pingTimer&&this.options.keepalive&&this.options.reschedulePings){this.pingTimer.reschedule(this.options.keepalive*1e3)}};MqttClient.prototype._checkPing=function(){if(this.pingResp){this.pingResp=false;this._sendPacket({cmd:"pingreq"})}else{this._cleanUp(true)}};MqttClient.prototype._handlePingresp=function(){this.pingResp=true};MqttClient.prototype._handleConnack=function(packet){var options=this.options;var version=options.protocolVersion;var rc=version===5?packet.reasonCode:packet.returnCode;clearTimeout(this.connackTimer);if(packet.properties){if(packet.properties.topicAliasMaximum){if(!options.properties){options.properties={}}options.properties.topicAliasMaximum=packet.properties.topicAliasMaximum}if(packet.properties.serverKeepAlive&&options.keepalive){options.keepalive=packet.properties.serverKeepAlive;this._shiftPingInterval()}if(packet.properties.maximumPacketSize){if(!options.properties){options.properties={}}options.properties.maximumPacketSize=packet.properties.maximumPacketSize}}if(rc===0){this.reconnecting=false;this._onConnect(packet)}else if(rc>0){var err=new Error("Connection refused: "+errors[rc]);err.code=rc;this.emit("error",err)}};MqttClient.prototype._handlePublish=function(packet,done){done=typeof done!=="undefined"?done:nop;var topic=packet.topic.toString();var message=packet.payload;var qos=packet.qos;var mid=packet.messageId;var that=this;var options=this.options;var validReasonCodes=[0,16,128,131,135,144,145,151,153];switch(qos){case 2:{options.customHandleAcks(topic,message,packet,function(error,code){if(!(error instanceof Error)){code=error;error=null}if(error){return that.emit("error",error)}if(validReasonCodes.indexOf(code)===-1){return that.emit("error",new Error("Wrong reason code for pubrec"))}if(code){that._sendPacket({cmd:"pubrec",messageId:mid,reasonCode:code},done)}else{that.incomingStore.put(packet,function(){that._sendPacket({cmd:"pubrec",messageId:mid},done)})}});break}case 1:{options.customHandleAcks(topic,message,packet,function(error,code){if(!(error instanceof Error)){code=error;error=null}if(error){return that.emit("error",error)}if(validReasonCodes.indexOf(code)===-1){return that.emit("error",new Error("Wrong reason code for puback"))}if(!code){that.emit("message",topic,message,packet)}that.handleMessage(packet,function(err){if(err){return done&&done(err)}that._sendPacket({cmd:"puback",messageId:mid,reasonCode:code},done)})});break}case 0:this.emit("message",topic,message,packet);this.handleMessage(packet,done);break;default:break}};MqttClient.prototype.handleMessage=function(packet,callback){callback()};MqttClient.prototype._handleAck=function(packet){var mid=packet.messageId;var type=packet.cmd;var response=null;var cb=this.outgoing[mid]?this.outgoing[mid].cb:null;var that=this;var err;if(!cb){return}switch(type){case"pubcomp":case"puback":var pubackRC=packet.reasonCode;if(pubackRC&&pubackRC>0&&pubackRC!==16){err=new Error("Publish error: "+errors[pubackRC]);err.code=pubackRC;cb(err,packet)}delete this.outgoing[mid];this.outgoingStore.del(packet,cb);break;case"pubrec":response={cmd:"pubrel",qos:2,messageId:mid};var pubrecRC=packet.reasonCode;if(pubrecRC&&pubrecRC>0&&pubrecRC!==16){err=new Error("Publish error: "+errors[pubrecRC]);err.code=pubrecRC;cb(err,packet)}else{this._sendPacket(response)}break;case"suback":delete this.outgoing[mid];for(var grantedI=0;grantedI0){if(this.options.resubscribe){if(this.options.protocolVersion===5){for(var topicI=0;topicI<_resubscribeTopicsKeys.length;topicI++){var resubscribeTopic={};resubscribeTopic[_resubscribeTopicsKeys[topicI]]=this._resubscribeTopics[_resubscribeTopicsKeys[topicI]];resubscribeTopic.resubscribe=true;this.subscribe(resubscribeTopic,{properties:resubscribeTopic[_resubscribeTopicsKeys[topicI]].properties})}}else{this._resubscribeTopics.resubscribe=true;this.subscribe(this._resubscribeTopics)}}else{this._resubscribeTopics={}}}this._firstConnection=false};MqttClient.prototype._onConnect=function(packet){if(this.disconnected){this.emit("connect",packet);return}var that=this;this._setupPingTimer();this._resubscribe(packet);this.connected=true;function startStreamProcess(){var outStore=that.outgoingStore.createStream();function clearStoreProcessing(){that._storeProcessing=false;that._packetIdsDuringStoreProcessing={}}that.once("close",remove);outStore.on("error",function(err){clearStoreProcessing();that.removeListener("close",remove);that.emit("error",err)});function remove(){outStore.destroy();outStore=null;clearStoreProcessing()}function storeDeliver(){if(!outStore){return}that._storeProcessing=true;var packet=outStore.read(1);var cb;if(!packet){outStore.once("readable",storeDeliver);return}if(that._packetIdsDuringStoreProcessing[packet.messageId]){storeDeliver();return}if(!that.disconnecting&&!that.reconnectTimer){cb=that.outgoing[packet.messageId]?that.outgoing[packet.messageId].cb:null;that.outgoing[packet.messageId]={volatile:false,cb:function(err,status){if(cb){cb(err,status)}storeDeliver()}};that._packetIdsDuringStoreProcessing[packet.messageId]=true;that._sendPacket(packet)}else if(outStore.destroy){outStore.destroy()}}outStore.on("end",function(){var allProcessed=true;for(var id in that._packetIdsDuringStoreProcessing){if(!that._packetIdsDuringStoreProcessing[id]){allProcessed=false;break}}if(allProcessed){clearStoreProcessing();that.removeListener("close",remove);that.emit("connect",packet)}else{startStreamProcess()}});storeDeliver()}startStreamProcess()};module.exports=MqttClient}).call(this,require("_process"),typeof global!=="undefined"?global:typeof self!=="undefined"?self:typeof window!=="undefined"?window:{})},{"./store":7,"./validations":8,_process:92,events:13,inherits:80,"mqtt-packet":84,"readable-stream":108,reinterval:109,xtend:121}],2:[function(require,module,exports){(function(Buffer){"use strict";var Transform=require("readable-stream").Transform;var duplexify=require("duplexify");var base64=require("base64-js");var my;var proxy;var stream;var isInitialized=false;function buildProxy(){var proxy=new Transform;proxy._write=function(chunk,encoding,next){my.sendSocketMessage({data:chunk.buffer,success:function(){next()},fail:function(){next(new Error)}})};proxy._flush=function socketEnd(done){my.closeSocket({success:function(){done()}})};return proxy}function setDefaultOpts(opts){if(!opts.hostname){opts.hostname="localhost"}if(!opts.path){opts.path="/"}if(!opts.wsOptions){opts.wsOptions={}}}function buildUrl(opts,client){var protocol=opts.protocol==="alis"?"wss":"ws";var url=protocol+"://"+opts.hostname+opts.path;if(opts.port&&opts.port!==80&&opts.port!==443){url=protocol+"://"+opts.hostname+":"+opts.port+opts.path}if(typeof opts.transformWsUrl==="function"){url=opts.transformWsUrl(url,opts,client)}return url}function bindEventHandler(){if(isInitialized)return;isInitialized=true;my.onSocketOpen(function(){stream.setReadable(proxy);stream.setWritable(proxy);stream.emit("connect")});my.onSocketMessage(function(res){if(typeof res.data==="string"){var array=base64.toByteArray(res.data);var buffer=Buffer.from(array);proxy.push(buffer)}else{var reader=new FileReader;reader.addEventListener("load",function(){var data=reader.result;if(data instanceof ArrayBuffer)data=Buffer.from(data);else data=Buffer.from(data,"utf8");proxy.push(data)});reader.readAsArrayBuffer(res.data)}});my.onSocketClose(function(){stream.end();stream.destroy()});my.onSocketError(function(res){stream.destroy(res)})}function buildStream(client,opts){opts.hostname=opts.hostname||opts.host;if(!opts.hostname){throw new Error("Could not determine host. Specify host manually.")}var websocketSubProtocol=opts.protocolId==="MQIsdp"&&opts.protocolVersion===3?"mqttv3.1":"mqtt";setDefaultOpts(opts);var url=buildUrl(opts,client);my=opts.my;my.connectSocket({url:url,protocols:websocketSubProtocol});proxy=buildProxy();stream=duplexify.obj();bindEventHandler();return stream}module.exports=buildStream}).call(this,require("buffer").Buffer)},{"base64-js":10,buffer:12,duplexify:17,"readable-stream":108}],3:[function(require,module,exports){"use strict";var net=require("net");function buildBuilder(client,opts){var port,host;opts.port=opts.port||1883;opts.hostname=opts.hostname||opts.host||"localhost";port=opts.port;host=opts.hostname;return net.createConnection(port,host)}module.exports=buildBuilder},{net:11}],4:[function(require,module,exports){"use strict";var tls=require("tls");function buildBuilder(mqttClient,opts){var connection;opts.port=opts.port||8883;opts.host=opts.hostname||opts.host||"localhost";opts.rejectUnauthorized=opts.rejectUnauthorized!==false;delete opts.path;connection=tls.connect(opts);connection.on("secureConnect",function(){if(opts.rejectUnauthorized&&!connection.authorized){connection.emit("error",new Error("TLS not authorized"))}else{connection.removeListener("error",handleTLSerrors)}});function handleTLSerrors(err){if(opts.rejectUnauthorized){mqttClient.emit("error",err)}connection.end()}connection.on("error",handleTLSerrors);return connection}module.exports=buildBuilder},{tls:11}],5:[function(require,module,exports){(function(process){"use strict";var websocket=require("websocket-stream");var urlModule=require("url");var WSS_OPTIONS=["rejectUnauthorized","ca","cert","key","pfx","passphrase"];var IS_BROWSER=process.title==="browser";function buildUrl(opts,client){var url=opts.protocol+"://"+opts.hostname+":"+opts.port+opts.path;if(typeof opts.transformWsUrl==="function"){url=opts.transformWsUrl(url,opts,client)}return url}function setDefaultOpts(opts){if(!opts.hostname){opts.hostname="localhost"}if(!opts.port){if(opts.protocol==="wss"){opts.port=443}else{opts.port=80}}if(!opts.path){opts.path="/"}if(!opts.wsOptions){opts.wsOptions={}}if(!IS_BROWSER&&opts.protocol==="wss"){WSS_OPTIONS.forEach(function(prop){if(opts.hasOwnProperty(prop)&&!opts.wsOptions.hasOwnProperty(prop)){opts.wsOptions[prop]=opts[prop]}})}}function createWebSocket(client,opts){var websocketSubProtocol=opts.protocolId==="MQIsdp"&&opts.protocolVersion===3?"mqttv3.1":"mqtt";setDefaultOpts(opts);var url=buildUrl(opts,client);return websocket(url,[websocketSubProtocol],opts.wsOptions)}function buildBuilder(client,opts){return createWebSocket(client,opts)}function buildBuilderBrowser(client,opts){if(!opts.hostname){opts.hostname=opts.host}if(!opts.hostname){if(typeof document==="undefined"){throw new Error("Could not determine host. Specify host manually.")}var parsed=urlModule.parse(document.URL);opts.hostname=parsed.hostname;if(!opts.port){opts.port=parsed.port}}return createWebSocket(client,opts)}if(IS_BROWSER){module.exports=buildBuilderBrowser}else{module.exports=buildBuilder}}).call(this,require("_process"))},{_process:92,url:113,"websocket-stream":118}],6:[function(require,module,exports){(function(process,Buffer){"use strict";var Transform=require("readable-stream").Transform;var duplexify=require("duplexify");var socketTask;var proxy;var stream;function buildProxy(){var proxy=new Transform;proxy._write=function(chunk,encoding,next){socketTask.send({data:chunk.buffer,success:function(){next()},fail:function(errMsg){next(new Error(errMsg))}})};proxy._flush=function socketEnd(done){socketTask.close({success:function(){done()}})};return proxy}function setDefaultOpts(opts){if(!opts.hostname){opts.hostname="localhost"}if(!opts.path){opts.path="/"}if(!opts.wsOptions){opts.wsOptions={}}}function buildUrl(opts,client){var protocol=opts.protocol==="wxs"?"wss":"ws";var url=protocol+"://"+opts.hostname+opts.path;if(opts.port&&opts.port!==80&&opts.port!==443){url=protocol+"://"+opts.hostname+":"+opts.port+opts.path}if(typeof opts.transformWsUrl==="function"){url=opts.transformWsUrl(url,opts,client)}return url}function bindEventHandler(){socketTask.onOpen(function(){stream.setReadable(proxy);stream.setWritable(proxy);stream.emit("connect")});socketTask.onMessage(function(res){var data=res.data;if(data instanceof ArrayBuffer)data=Buffer.from(data);else data=Buffer.from(data,"utf8");proxy.push(data)});socketTask.onClose(function(){stream.end();stream.destroy()});socketTask.onError(function(res){stream.destroy(new Error(res.errMsg))})}function buildStream(client,opts){opts.hostname=opts.hostname||opts.host;if(!opts.hostname){throw new Error("Could not determine host. Specify host manually.")}var websocketSubProtocol=opts.protocolId==="MQIsdp"&&opts.protocolVersion===3?"mqttv3.1":"mqtt";setDefaultOpts(opts);var url=buildUrl(opts,client);socketTask=wx.connectSocket({url:url,protocols:websocketSubProtocol});proxy=buildProxy();stream=duplexify.obj();stream._destroy=function(err,cb){socketTask.close({success:function(){cb&&cb(err)}})};var destroyRef=stream.destroy;stream.destroy=function(){stream.destroy=destroyRef;var self=this;process.nextTick(function(){socketTask.close({fail:function(){self._destroy(new Error)}})})}.bind(stream);bindEventHandler();return stream}module.exports=buildStream}).call(this,require("_process"),require("buffer").Buffer)},{_process:92,buffer:12,duplexify:17,"readable-stream":108}],7:[function(require,module,exports){(function(process){"use strict";var xtend=require("xtend");var Readable=require("readable-stream").Readable;var streamsOpts={objectMode:true};var defaultStoreOptions={clean:true};var Map=require("es6-map");function Store(options){if(!(this instanceof Store)){return new Store(options)}this.options=options||{};this.options=xtend(defaultStoreOptions,options);this._inflights=new Map}Store.prototype.put=function(packet,cb){this._inflights.set(packet.messageId,packet);if(cb){cb()}return this};Store.prototype.createStream=function(){var stream=new Readable(streamsOpts);var destroyed=false;var values=[];var i=0;this._inflights.forEach(function(value,key){values.push(value)});stream._read=function(){if(!destroyed&&i0){throw new Error("Invalid string. Length must be a multiple of 4")}var validLen=b64.indexOf("=");if(validLen===-1)validLen=len;var placeHoldersLen=validLen===len?0:4-validLen%4;return[validLen,placeHoldersLen]}function byteLength(b64){var lens=getLens(b64);var validLen=lens[0];var placeHoldersLen=lens[1];return(validLen+placeHoldersLen)*3/4-placeHoldersLen}function _byteLength(b64,validLen,placeHoldersLen){return(validLen+placeHoldersLen)*3/4-placeHoldersLen}function toByteArray(b64){var tmp;var lens=getLens(b64);var validLen=lens[0];var placeHoldersLen=lens[1];var arr=new Arr(_byteLength(b64,validLen,placeHoldersLen));var curByte=0;var len=placeHoldersLen>0?validLen-4:validLen;for(var i=0;i>16&255;arr[curByte++]=tmp>>8&255;arr[curByte++]=tmp&255}if(placeHoldersLen===2){tmp=revLookup[b64.charCodeAt(i)]<<2|revLookup[b64.charCodeAt(i+1)]>>4;arr[curByte++]=tmp&255}if(placeHoldersLen===1){tmp=revLookup[b64.charCodeAt(i)]<<10|revLookup[b64.charCodeAt(i+1)]<<4|revLookup[b64.charCodeAt(i+2)]>>2;arr[curByte++]=tmp>>8&255;arr[curByte++]=tmp&255}return arr}function tripletToBase64(num){return lookup[num>>18&63]+lookup[num>>12&63]+lookup[num>>6&63]+lookup[num&63]}function encodeChunk(uint8,start,end){var tmp;var output=[];for(var i=start;ilen2?len2:i+maxChunkLength))}if(extraBytes===1){tmp=uint8[len-1];parts.push(lookup[tmp>>2]+lookup[tmp<<4&63]+"==")}else if(extraBytes===2){tmp=(uint8[len-2]<<8)+uint8[len-1];parts.push(lookup[tmp>>10]+lookup[tmp>>4&63]+lookup[tmp<<2&63]+"=")}return parts.join("")}},{}],11:[function(require,module,exports){},{}],12:[function(require,module,exports){"use strict";var base64=require("base64-js");var ieee754=require("ieee754");exports.Buffer=Buffer;exports.SlowBuffer=SlowBuffer;exports.INSPECT_MAX_BYTES=50;var K_MAX_LENGTH=2147483647;exports.kMaxLength=K_MAX_LENGTH;Buffer.TYPED_ARRAY_SUPPORT=typedArraySupport();if(!Buffer.TYPED_ARRAY_SUPPORT&&typeof console!=="undefined"&&typeof console.error==="function"){console.error("This browser lacks typed array (Uint8Array) support which is required by "+"`buffer` v5.x. Use `buffer` v4.x if you require old browser support.")}function typedArraySupport(){try{var arr=new Uint8Array(1);arr.__proto__={__proto__:Uint8Array.prototype,foo:function(){return 42}};return arr.foo()===42}catch(e){return false}}Object.defineProperty(Buffer.prototype,"parent",{enumerable:true,get:function(){if(!Buffer.isBuffer(this))return undefined;return this.buffer}});Object.defineProperty(Buffer.prototype,"offset",{enumerable:true,get:function(){if(!Buffer.isBuffer(this))return undefined;return this.byteOffset}});function createBuffer(length){if(length>K_MAX_LENGTH){throw new RangeError('The value "'+length+'" is invalid for option "size"')}var buf=new Uint8Array(length);buf.__proto__=Buffer.prototype;return buf}function Buffer(arg,encodingOrOffset,length){if(typeof arg==="number"){if(typeof encodingOrOffset==="string"){throw new TypeError('The "string" argument must be of type string. Received type number')}return allocUnsafe(arg)}return from(arg,encodingOrOffset,length)}if(typeof Symbol!=="undefined"&&Symbol.species!=null&&Buffer[Symbol.species]===Buffer){Object.defineProperty(Buffer,Symbol.species,{value:null,configurable:true,enumerable:false,writable:false})}Buffer.poolSize=8192;function from(value,encodingOrOffset,length){if(typeof value==="string"){return fromString(value,encodingOrOffset)}if(ArrayBuffer.isView(value)){return fromArrayLike(value)}if(value==null){throw TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, "+"or Array-like Object. Received type "+typeof value)}if(isInstance(value,ArrayBuffer)||value&&isInstance(value.buffer,ArrayBuffer)){return fromArrayBuffer(value,encodingOrOffset,length)}if(typeof value==="number"){throw new TypeError('The "value" argument must not be of type number. Received type number')}var valueOf=value.valueOf&&value.valueOf();if(valueOf!=null&&valueOf!==value){return Buffer.from(valueOf,encodingOrOffset,length)}var b=fromObject(value);if(b)return b;if(typeof Symbol!=="undefined"&&Symbol.toPrimitive!=null&&typeof value[Symbol.toPrimitive]==="function"){return Buffer.from(value[Symbol.toPrimitive]("string"),encodingOrOffset,length)}throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, "+"or Array-like Object. Received type "+typeof value)}Buffer.from=function(value,encodingOrOffset,length){return from(value,encodingOrOffset,length)};Buffer.prototype.__proto__=Uint8Array.prototype;Buffer.__proto__=Uint8Array;function assertSize(size){if(typeof size!=="number"){throw new TypeError('"size" argument must be of type number')}else if(size<0){throw new RangeError('The value "'+size+'" is invalid for option "size"')}}function alloc(size,fill,encoding){assertSize(size);if(size<=0){return createBuffer(size)}if(fill!==undefined){return typeof encoding==="string"?createBuffer(size).fill(fill,encoding):createBuffer(size).fill(fill)}return createBuffer(size)}Buffer.alloc=function(size,fill,encoding){return alloc(size,fill,encoding)};function allocUnsafe(size){assertSize(size);return createBuffer(size<0?0:checked(size)|0)}Buffer.allocUnsafe=function(size){return allocUnsafe(size)};Buffer.allocUnsafeSlow=function(size){return allocUnsafe(size)};function fromString(string,encoding){if(typeof encoding!=="string"||encoding===""){encoding="utf8"}if(!Buffer.isEncoding(encoding)){throw new TypeError("Unknown encoding: "+encoding)}var length=byteLength(string,encoding)|0;var buf=createBuffer(length);var actual=buf.write(string,encoding);if(actual!==length){buf=buf.slice(0,actual)}return buf}function fromArrayLike(array){var length=array.length<0?0:checked(array.length)|0;var buf=createBuffer(length);for(var i=0;i=K_MAX_LENGTH){throw new RangeError("Attempt to allocate Buffer larger than maximum "+"size: 0x"+K_MAX_LENGTH.toString(16)+" bytes")}return length|0}function SlowBuffer(length){if(+length!=length){length=0}return Buffer.alloc(+length)}Buffer.isBuffer=function isBuffer(b){return b!=null&&b._isBuffer===true&&b!==Buffer.prototype};Buffer.compare=function compare(a,b){if(isInstance(a,Uint8Array))a=Buffer.from(a,a.offset,a.byteLength);if(isInstance(b,Uint8Array))b=Buffer.from(b,b.offset,b.byteLength);if(!Buffer.isBuffer(a)||!Buffer.isBuffer(b)){throw new TypeError('The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array')}if(a===b)return 0;var x=a.length;var y=b.length;for(var i=0,len=Math.min(x,y);i2&&arguments[2]===true;if(!mustMatch&&len===0)return 0;var loweredCase=false;for(;;){switch(encoding){case"ascii":case"latin1":case"binary":return len;case"utf8":case"utf-8":return utf8ToBytes(string).length;case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return len*2;case"hex":return len>>>1;case"base64":return base64ToBytes(string).length;default:if(loweredCase){return mustMatch?-1:utf8ToBytes(string).length}encoding=(""+encoding).toLowerCase();loweredCase=true}}}Buffer.byteLength=byteLength;function slowToString(encoding,start,end){var loweredCase=false;if(start===undefined||start<0){start=0}if(start>this.length){return""}if(end===undefined||end>this.length){end=this.length}if(end<=0){return""}end>>>=0;start>>>=0;if(end<=start){return""}if(!encoding)encoding="utf8";while(true){switch(encoding){case"hex":return hexSlice(this,start,end);case"utf8":case"utf-8":return utf8Slice(this,start,end);case"ascii":return asciiSlice(this,start,end);case"latin1":case"binary":return latin1Slice(this,start,end);case"base64":return base64Slice(this,start,end);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return utf16leSlice(this,start,end);default:if(loweredCase)throw new TypeError("Unknown encoding: "+encoding);encoding=(encoding+"").toLowerCase();loweredCase=true}}}Buffer.prototype._isBuffer=true;function swap(b,n,m){var i=b[n];b[n]=b[m];b[m]=i}Buffer.prototype.swap16=function swap16(){var len=this.length;if(len%2!==0){throw new RangeError("Buffer size must be a multiple of 16-bits")}for(var i=0;imax)str+=" ... ";return""};Buffer.prototype.compare=function compare(target,start,end,thisStart,thisEnd){if(isInstance(target,Uint8Array)){target=Buffer.from(target,target.offset,target.byteLength)}if(!Buffer.isBuffer(target)){throw new TypeError('The "target" argument must be one of type Buffer or Uint8Array. '+"Received type "+typeof target)}if(start===undefined){start=0}if(end===undefined){end=target?target.length:0}if(thisStart===undefined){thisStart=0}if(thisEnd===undefined){thisEnd=this.length}if(start<0||end>target.length||thisStart<0||thisEnd>this.length){throw new RangeError("out of range index")}if(thisStart>=thisEnd&&start>=end){return 0}if(thisStart>=thisEnd){return-1}if(start>=end){return 1}start>>>=0;end>>>=0;thisStart>>>=0;thisEnd>>>=0;if(this===target)return 0;var x=thisEnd-thisStart;var y=end-start;var len=Math.min(x,y);var thisCopy=this.slice(thisStart,thisEnd);var targetCopy=target.slice(start,end);for(var i=0;i2147483647){byteOffset=2147483647}else if(byteOffset<-2147483648){byteOffset=-2147483648}byteOffset=+byteOffset;if(numberIsNaN(byteOffset)){byteOffset=dir?0:buffer.length-1}if(byteOffset<0)byteOffset=buffer.length+byteOffset;if(byteOffset>=buffer.length){if(dir)return-1;else byteOffset=buffer.length-1}else if(byteOffset<0){if(dir)byteOffset=0;else return-1}if(typeof val==="string"){val=Buffer.from(val,encoding)}if(Buffer.isBuffer(val)){if(val.length===0){return-1}return arrayIndexOf(buffer,val,byteOffset,encoding,dir)}else if(typeof val==="number"){val=val&255;if(typeof Uint8Array.prototype.indexOf==="function"){if(dir){return Uint8Array.prototype.indexOf.call(buffer,val,byteOffset)}else{return Uint8Array.prototype.lastIndexOf.call(buffer,val,byteOffset)}}return arrayIndexOf(buffer,[val],byteOffset,encoding,dir)}throw new TypeError("val must be string, number or Buffer")}function arrayIndexOf(arr,val,byteOffset,encoding,dir){var indexSize=1;var arrLength=arr.length;var valLength=val.length;if(encoding!==undefined){encoding=String(encoding).toLowerCase();if(encoding==="ucs2"||encoding==="ucs-2"||encoding==="utf16le"||encoding==="utf-16le"){if(arr.length<2||val.length<2){return-1}indexSize=2;arrLength/=2;valLength/=2;byteOffset/=2}}function read(buf,i){if(indexSize===1){return buf[i]}else{return buf.readUInt16BE(i*indexSize)}}var i;if(dir){var foundIndex=-1;for(i=byteOffset;iarrLength)byteOffset=arrLength-valLength;for(i=byteOffset;i>=0;i--){var found=true;for(var j=0;jremaining){length=remaining}}var strLen=string.length;if(length>strLen/2){length=strLen/2}for(var i=0;i>>0;if(isFinite(length)){length=length>>>0;if(encoding===undefined)encoding="utf8"}else{encoding=length;length=undefined}}else{throw new Error("Buffer.write(string, encoding, offset[, length]) is no longer supported")}var remaining=this.length-offset;if(length===undefined||length>remaining)length=remaining;if(string.length>0&&(length<0||offset<0)||offset>this.length){throw new RangeError("Attempt to write outside buffer bounds")}if(!encoding)encoding="utf8";var loweredCase=false;for(;;){switch(encoding){case"hex":return hexWrite(this,string,offset,length);case"utf8":case"utf-8":return utf8Write(this,string,offset,length);case"ascii":return asciiWrite(this,string,offset,length);case"latin1":case"binary":return latin1Write(this,string,offset,length);case"base64":return base64Write(this,string,offset,length);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return ucs2Write(this,string,offset,length);default:if(loweredCase)throw new TypeError("Unknown encoding: "+encoding);encoding=(""+encoding).toLowerCase();loweredCase=true}}};Buffer.prototype.toJSON=function toJSON(){return{type:"Buffer",data:Array.prototype.slice.call(this._arr||this,0)}};function base64Slice(buf,start,end){if(start===0&&end===buf.length){return base64.fromByteArray(buf)}else{return base64.fromByteArray(buf.slice(start,end))}}function utf8Slice(buf,start,end){end=Math.min(buf.length,end);var res=[];var i=start;while(i239?4:firstByte>223?3:firstByte>191?2:1;if(i+bytesPerSequence<=end){var secondByte,thirdByte,fourthByte,tempCodePoint;switch(bytesPerSequence){case 1:if(firstByte<128){codePoint=firstByte}break;case 2:secondByte=buf[i+1];if((secondByte&192)===128){tempCodePoint=(firstByte&31)<<6|secondByte&63;if(tempCodePoint>127){codePoint=tempCodePoint}}break;case 3:secondByte=buf[i+1];thirdByte=buf[i+2];if((secondByte&192)===128&&(thirdByte&192)===128){tempCodePoint=(firstByte&15)<<12|(secondByte&63)<<6|thirdByte&63;if(tempCodePoint>2047&&(tempCodePoint<55296||tempCodePoint>57343)){codePoint=tempCodePoint}}break;case 4:secondByte=buf[i+1];thirdByte=buf[i+2];fourthByte=buf[i+3];if((secondByte&192)===128&&(thirdByte&192)===128&&(fourthByte&192)===128){tempCodePoint=(firstByte&15)<<18|(secondByte&63)<<12|(thirdByte&63)<<6|fourthByte&63;if(tempCodePoint>65535&&tempCodePoint<1114112){codePoint=tempCodePoint}}}}if(codePoint===null){codePoint=65533;bytesPerSequence=1}else if(codePoint>65535){codePoint-=65536;res.push(codePoint>>>10&1023|55296);codePoint=56320|codePoint&1023}res.push(codePoint);i+=bytesPerSequence}return decodeCodePointsArray(res)}var MAX_ARGUMENTS_LENGTH=4096;function decodeCodePointsArray(codePoints){var len=codePoints.length;if(len<=MAX_ARGUMENTS_LENGTH){return String.fromCharCode.apply(String,codePoints)}var res="";var i=0;while(ilen)end=len;var out="";for(var i=start;ilen){start=len}if(end<0){end+=len;if(end<0)end=0}else if(end>len){end=len}if(endlength)throw new RangeError("Trying to access beyond buffer length")}Buffer.prototype.readUIntLE=function readUIntLE(offset,byteLength,noAssert){offset=offset>>>0;byteLength=byteLength>>>0;if(!noAssert)checkOffset(offset,byteLength,this.length);var val=this[offset];var mul=1;var i=0;while(++i>>0;byteLength=byteLength>>>0;if(!noAssert){checkOffset(offset,byteLength,this.length)}var val=this[offset+--byteLength];var mul=1;while(byteLength>0&&(mul*=256)){val+=this[offset+--byteLength]*mul}return val};Buffer.prototype.readUInt8=function readUInt8(offset,noAssert){offset=offset>>>0;if(!noAssert)checkOffset(offset,1,this.length);return this[offset]};Buffer.prototype.readUInt16LE=function readUInt16LE(offset,noAssert){offset=offset>>>0;if(!noAssert)checkOffset(offset,2,this.length);return this[offset]|this[offset+1]<<8};Buffer.prototype.readUInt16BE=function readUInt16BE(offset,noAssert){offset=offset>>>0;if(!noAssert)checkOffset(offset,2,this.length);return this[offset]<<8|this[offset+1]};Buffer.prototype.readUInt32LE=function readUInt32LE(offset,noAssert){offset=offset>>>0;if(!noAssert)checkOffset(offset,4,this.length);return(this[offset]|this[offset+1]<<8|this[offset+2]<<16)+this[offset+3]*16777216};Buffer.prototype.readUInt32BE=function readUInt32BE(offset,noAssert){offset=offset>>>0;if(!noAssert)checkOffset(offset,4,this.length);return this[offset]*16777216+(this[offset+1]<<16|this[offset+2]<<8|this[offset+3])};Buffer.prototype.readIntLE=function readIntLE(offset,byteLength,noAssert){offset=offset>>>0;byteLength=byteLength>>>0;if(!noAssert)checkOffset(offset,byteLength,this.length);var val=this[offset];var mul=1;var i=0;while(++i=mul)val-=Math.pow(2,8*byteLength);return val};Buffer.prototype.readIntBE=function readIntBE(offset,byteLength,noAssert){offset=offset>>>0;byteLength=byteLength>>>0;if(!noAssert)checkOffset(offset,byteLength,this.length);var i=byteLength;var mul=1;var val=this[offset+--i];while(i>0&&(mul*=256)){val+=this[offset+--i]*mul}mul*=128;if(val>=mul)val-=Math.pow(2,8*byteLength);return val};Buffer.prototype.readInt8=function readInt8(offset,noAssert){offset=offset>>>0;if(!noAssert)checkOffset(offset,1,this.length);if(!(this[offset]&128))return this[offset];return(255-this[offset]+1)*-1};Buffer.prototype.readInt16LE=function readInt16LE(offset,noAssert){offset=offset>>>0;if(!noAssert)checkOffset(offset,2,this.length);var val=this[offset]|this[offset+1]<<8;return val&32768?val|4294901760:val};Buffer.prototype.readInt16BE=function readInt16BE(offset,noAssert){offset=offset>>>0;if(!noAssert)checkOffset(offset,2,this.length);var val=this[offset+1]|this[offset]<<8;return val&32768?val|4294901760:val};Buffer.prototype.readInt32LE=function readInt32LE(offset,noAssert){offset=offset>>>0;if(!noAssert)checkOffset(offset,4,this.length);return this[offset]|this[offset+1]<<8|this[offset+2]<<16|this[offset+3]<<24};Buffer.prototype.readInt32BE=function readInt32BE(offset,noAssert){offset=offset>>>0;if(!noAssert)checkOffset(offset,4,this.length);return this[offset]<<24|this[offset+1]<<16|this[offset+2]<<8|this[offset+3]};Buffer.prototype.readFloatLE=function readFloatLE(offset,noAssert){offset=offset>>>0;if(!noAssert)checkOffset(offset,4,this.length);return ieee754.read(this,offset,true,23,4)};Buffer.prototype.readFloatBE=function readFloatBE(offset,noAssert){offset=offset>>>0;if(!noAssert)checkOffset(offset,4,this.length);return ieee754.read(this,offset,false,23,4)};Buffer.prototype.readDoubleLE=function readDoubleLE(offset,noAssert){offset=offset>>>0;if(!noAssert)checkOffset(offset,8,this.length);return ieee754.read(this,offset,true,52,8)};Buffer.prototype.readDoubleBE=function readDoubleBE(offset,noAssert){offset=offset>>>0;if(!noAssert)checkOffset(offset,8,this.length);return ieee754.read(this,offset,false,52,8)};function checkInt(buf,value,offset,ext,max,min){if(!Buffer.isBuffer(buf))throw new TypeError('"buffer" argument must be a Buffer instance');if(value>max||valuebuf.length)throw new RangeError("Index out of range")}Buffer.prototype.writeUIntLE=function writeUIntLE(value,offset,byteLength,noAssert){value=+value;offset=offset>>>0;byteLength=byteLength>>>0;if(!noAssert){var maxBytes=Math.pow(2,8*byteLength)-1;checkInt(this,value,offset,byteLength,maxBytes,0)}var mul=1;var i=0;this[offset]=value&255;while(++i>>0;byteLength=byteLength>>>0;if(!noAssert){var maxBytes=Math.pow(2,8*byteLength)-1;checkInt(this,value,offset,byteLength,maxBytes,0)}var i=byteLength-1;var mul=1;this[offset+i]=value&255;while(--i>=0&&(mul*=256)){this[offset+i]=value/mul&255}return offset+byteLength};Buffer.prototype.writeUInt8=function writeUInt8(value,offset,noAssert){value=+value;offset=offset>>>0;if(!noAssert)checkInt(this,value,offset,1,255,0);this[offset]=value&255;return offset+1};Buffer.prototype.writeUInt16LE=function writeUInt16LE(value,offset,noAssert){value=+value;offset=offset>>>0;if(!noAssert)checkInt(this,value,offset,2,65535,0);this[offset]=value&255;this[offset+1]=value>>>8;return offset+2};Buffer.prototype.writeUInt16BE=function writeUInt16BE(value,offset,noAssert){value=+value;offset=offset>>>0;if(!noAssert)checkInt(this,value,offset,2,65535,0);this[offset]=value>>>8;this[offset+1]=value&255;return offset+2};Buffer.prototype.writeUInt32LE=function writeUInt32LE(value,offset,noAssert){value=+value;offset=offset>>>0;if(!noAssert)checkInt(this,value,offset,4,4294967295,0);this[offset+3]=value>>>24;this[offset+2]=value>>>16;this[offset+1]=value>>>8;this[offset]=value&255;return offset+4};Buffer.prototype.writeUInt32BE=function writeUInt32BE(value,offset,noAssert){value=+value;offset=offset>>>0;if(!noAssert)checkInt(this,value,offset,4,4294967295,0);this[offset]=value>>>24;this[offset+1]=value>>>16;this[offset+2]=value>>>8;this[offset+3]=value&255;return offset+4};Buffer.prototype.writeIntLE=function writeIntLE(value,offset,byteLength,noAssert){value=+value;offset=offset>>>0;if(!noAssert){var limit=Math.pow(2,8*byteLength-1);checkInt(this,value,offset,byteLength,limit-1,-limit)}var i=0;var mul=1;var sub=0;this[offset]=value&255;while(++i>0)-sub&255}return offset+byteLength};Buffer.prototype.writeIntBE=function writeIntBE(value,offset,byteLength,noAssert){value=+value;offset=offset>>>0;if(!noAssert){var limit=Math.pow(2,8*byteLength-1);checkInt(this,value,offset,byteLength,limit-1,-limit)}var i=byteLength-1;var mul=1;var sub=0;this[offset+i]=value&255;while(--i>=0&&(mul*=256)){if(value<0&&sub===0&&this[offset+i+1]!==0){sub=1}this[offset+i]=(value/mul>>0)-sub&255}return offset+byteLength};Buffer.prototype.writeInt8=function writeInt8(value,offset,noAssert){value=+value;offset=offset>>>0;if(!noAssert)checkInt(this,value,offset,1,127,-128);if(value<0)value=255+value+1;this[offset]=value&255;return offset+1};Buffer.prototype.writeInt16LE=function writeInt16LE(value,offset,noAssert){value=+value;offset=offset>>>0;if(!noAssert)checkInt(this,value,offset,2,32767,-32768);this[offset]=value&255;this[offset+1]=value>>>8;return offset+2};Buffer.prototype.writeInt16BE=function writeInt16BE(value,offset,noAssert){value=+value;offset=offset>>>0;if(!noAssert)checkInt(this,value,offset,2,32767,-32768);this[offset]=value>>>8;this[offset+1]=value&255;return offset+2};Buffer.prototype.writeInt32LE=function writeInt32LE(value,offset,noAssert){value=+value;offset=offset>>>0;if(!noAssert)checkInt(this,value,offset,4,2147483647,-2147483648);this[offset]=value&255;this[offset+1]=value>>>8;this[offset+2]=value>>>16;this[offset+3]=value>>>24;return offset+4};Buffer.prototype.writeInt32BE=function writeInt32BE(value,offset,noAssert){value=+value;offset=offset>>>0;if(!noAssert)checkInt(this,value,offset,4,2147483647,-2147483648);if(value<0)value=4294967295+value+1;this[offset]=value>>>24;this[offset+1]=value>>>16;this[offset+2]=value>>>8;this[offset+3]=value&255;return offset+4};function checkIEEE754(buf,value,offset,ext,max,min){if(offset+ext>buf.length)throw new RangeError("Index out of range");if(offset<0)throw new RangeError("Index out of range")}function writeFloat(buf,value,offset,littleEndian,noAssert){value=+value;offset=offset>>>0;if(!noAssert){checkIEEE754(buf,value,offset,4,34028234663852886e22,-34028234663852886e22)}ieee754.write(buf,value,offset,littleEndian,23,4);return offset+4}Buffer.prototype.writeFloatLE=function writeFloatLE(value,offset,noAssert){return writeFloat(this,value,offset,true,noAssert)};Buffer.prototype.writeFloatBE=function writeFloatBE(value,offset,noAssert){return writeFloat(this,value,offset,false,noAssert)};function writeDouble(buf,value,offset,littleEndian,noAssert){value=+value;offset=offset>>>0;if(!noAssert){checkIEEE754(buf,value,offset,8,17976931348623157e292,-17976931348623157e292)}ieee754.write(buf,value,offset,littleEndian,52,8);return offset+8}Buffer.prototype.writeDoubleLE=function writeDoubleLE(value,offset,noAssert){return writeDouble(this,value,offset,true,noAssert)};Buffer.prototype.writeDoubleBE=function writeDoubleBE(value,offset,noAssert){return writeDouble(this,value,offset,false,noAssert)};Buffer.prototype.copy=function copy(target,targetStart,start,end){if(!Buffer.isBuffer(target))throw new TypeError("argument should be a Buffer");if(!start)start=0;if(!end&&end!==0)end=this.length;if(targetStart>=target.length)targetStart=target.length;if(!targetStart)targetStart=0;if(end>0&&end=this.length)throw new RangeError("Index out of range");if(end<0)throw new RangeError("sourceEnd out of bounds");if(end>this.length)end=this.length;if(target.length-targetStart=0;--i){target[i+targetStart]=this[i+start]}}else{Uint8Array.prototype.set.call(target,this.subarray(start,end),targetStart)}return len};Buffer.prototype.fill=function fill(val,start,end,encoding){if(typeof val==="string"){if(typeof start==="string"){encoding=start;start=0;end=this.length}else if(typeof end==="string"){encoding=end;end=this.length}if(encoding!==undefined&&typeof encoding!=="string"){throw new TypeError("encoding must be a string")}if(typeof encoding==="string"&&!Buffer.isEncoding(encoding)){throw new TypeError("Unknown encoding: "+encoding)}if(val.length===1){var code=val.charCodeAt(0);if(encoding==="utf8"&&code<128||encoding==="latin1"){val=code}}}else if(typeof val==="number"){val=val&255}if(start<0||this.length>>0;end=end===undefined?this.length:end>>>0;if(!val)val=0;var i;if(typeof val==="number"){for(i=start;i55295&&codePoint<57344){if(!leadSurrogate){if(codePoint>56319){if((units-=3)>-1)bytes.push(239,191,189);continue}else if(i+1===length){if((units-=3)>-1)bytes.push(239,191,189);continue}leadSurrogate=codePoint;continue}if(codePoint<56320){if((units-=3)>-1)bytes.push(239,191,189);leadSurrogate=codePoint;continue}codePoint=(leadSurrogate-55296<<10|codePoint-56320)+65536}else if(leadSurrogate){if((units-=3)>-1)bytes.push(239,191,189)}leadSurrogate=null;if(codePoint<128){if((units-=1)<0)break;bytes.push(codePoint)}else if(codePoint<2048){if((units-=2)<0)break;bytes.push(codePoint>>6|192,codePoint&63|128)}else if(codePoint<65536){if((units-=3)<0)break;bytes.push(codePoint>>12|224,codePoint>>6&63|128,codePoint&63|128)}else if(codePoint<1114112){if((units-=4)<0)break;bytes.push(codePoint>>18|240,codePoint>>12&63|128,codePoint>>6&63|128,codePoint&63|128)}else{throw new Error("Invalid code point")}}return bytes}function asciiToBytes(str){var byteArray=[];for(var i=0;i>8;lo=c%256;byteArray.push(lo);byteArray.push(hi)}return byteArray}function base64ToBytes(str){return base64.toByteArray(base64clean(str))}function blitBuffer(src,dst,offset,length){for(var i=0;i=dst.length||i>=src.length)break;dst[i+offset]=src[i]}return i}function isInstance(obj,type){return obj instanceof type||obj!=null&&obj.constructor!=null&&obj.constructor.name!=null&&obj.constructor.name===type.name}function numberIsNaN(obj){return obj!==obj}},{"base64-js":10,ieee754:79}],13:[function(require,module,exports){var objectCreate=Object.create||objectCreatePolyfill;var objectKeys=Object.keys||objectKeysPolyfill;var bind=Function.prototype.bind||functionBindPolyfill;function EventEmitter(){if(!this._events||!Object.prototype.hasOwnProperty.call(this,"_events")){this._events=objectCreate(null);this._eventsCount=0}this._maxListeners=this._maxListeners||undefined}module.exports=EventEmitter;EventEmitter.EventEmitter=EventEmitter;EventEmitter.prototype._events=undefined;EventEmitter.prototype._maxListeners=undefined;var defaultMaxListeners=10;var hasDefineProperty;try{var o={};if(Object.defineProperty)Object.defineProperty(o,"x",{value:0});hasDefineProperty=o.x===0}catch(err){hasDefineProperty=false}if(hasDefineProperty){Object.defineProperty(EventEmitter,"defaultMaxListeners",{enumerable:true,get:function(){return defaultMaxListeners},set:function(arg){if(typeof arg!=="number"||arg<0||arg!==arg)throw new TypeError('"defaultMaxListeners" must be a positive number');defaultMaxListeners=arg}})}else{EventEmitter.defaultMaxListeners=defaultMaxListeners}EventEmitter.prototype.setMaxListeners=function setMaxListeners(n){if(typeof n!=="number"||n<0||isNaN(n))throw new TypeError('"n" argument must be a positive number');this._maxListeners=n;return this};function $getMaxListeners(that){if(that._maxListeners===undefined)return EventEmitter.defaultMaxListeners;return that._maxListeners}EventEmitter.prototype.getMaxListeners=function getMaxListeners(){return $getMaxListeners(this)};function emitNone(handler,isFn,self){if(isFn)handler.call(self);else{var len=handler.length;var listeners=arrayClone(handler,len);for(var i=0;i1)er=arguments[1];if(er instanceof Error){throw er}else{var err=new Error('Unhandled "error" event. ('+er+")");err.context=er;throw err}return false}handler=events[type];if(!handler)return false;var isFn=typeof handler==="function";len=arguments.length;switch(len){case 1:emitNone(handler,isFn,this);break;case 2:emitOne(handler,isFn,this,arguments[1]);break;case 3:emitTwo(handler,isFn,this,arguments[1],arguments[2]);break;case 4:emitThree(handler,isFn,this,arguments[1],arguments[2],arguments[3]);break;default:args=new Array(len-1);for(i=1;i0&&existing.length>m){existing.warned=true;var w=new Error("Possible EventEmitter memory leak detected. "+existing.length+' "'+String(type)+'" listeners '+"added. Use emitter.setMaxListeners() to "+"increase limit.");w.name="MaxListenersExceededWarning";w.emitter=target;w.type=type;w.count=existing.length;if(typeof console==="object"&&console.warn){console.warn("%s: %s",w.name,w.message)}}}}return target}EventEmitter.prototype.addListener=function addListener(type,listener){return _addListener(this,type,listener,false)};EventEmitter.prototype.on=EventEmitter.prototype.addListener;EventEmitter.prototype.prependListener=function prependListener(type,listener){return _addListener(this,type,listener,true)};function onceWrapper(){if(!this.fired){this.target.removeListener(this.type,this.wrapFn);this.fired=true;switch(arguments.length){case 0:return this.listener.call(this.target);case 1:return this.listener.call(this.target,arguments[0]);case 2:return this.listener.call(this.target,arguments[0],arguments[1]);case 3:return this.listener.call(this.target,arguments[0],arguments[1],arguments[2]);default:var args=new Array(arguments.length);for(var i=0;i=0;i--){if(list[i]===listener||list[i].listener===listener){originalListener=list[i].listener;position=i;break}}if(position<0)return this;if(position===0)list.shift();else spliceOne(list,position);if(list.length===1)events[type]=list[0];if(events.removeListener)this.emit("removeListener",type,originalListener||listener)}return this};EventEmitter.prototype.removeAllListeners=function removeAllListeners(type){var listeners,events,i;events=this._events;if(!events)return this;if(!events.removeListener){if(arguments.length===0){this._events=objectCreate(null);this._eventsCount=0}else if(events[type]){if(--this._eventsCount===0)this._events=objectCreate(null);else delete events[type]}return this}if(arguments.length===0){var keys=objectKeys(events);var key;for(i=0;i=0;i--){this.removeListener(type,listeners[i])}}return this};function _listeners(target,type,unwrap){var events=target._events;if(!events)return[];var evlistener=events[type];if(!evlistener)return[];if(typeof evlistener==="function")return unwrap?[evlistener.listener||evlistener]:[evlistener];return unwrap?unwrapListeners(evlistener):arrayClone(evlistener,evlistener.length)}EventEmitter.prototype.listeners=function listeners(type){return _listeners(this,type,true)};EventEmitter.prototype.rawListeners=function rawListeners(type){return _listeners(this,type,false)};EventEmitter.listenerCount=function(emitter,type){if(typeof emitter.listenerCount==="function"){return emitter.listenerCount(type)}else{return listenerCount.call(emitter,type)}};EventEmitter.prototype.listenerCount=listenerCount;function listenerCount(type){var events=this._events;if(events){var evlistener=events[type];if(typeof evlistener==="function"){return 1}else if(evlistener){return evlistener.length}}return 0}EventEmitter.prototype.eventNames=function eventNames(){return this._eventsCount>0?Reflect.ownKeys(this._events):[]};function spliceOne(list,index){for(var i=index,k=i+1,n=list.length;k=0)fromIndex=floor(fromIndex);else fromIndex=toPosInt(this.length)-floor(abs(fromIndex));for(i=fromIndex;i=55296&&code<=56319)value+=arrayLike[++i]}value=mapFn?call.call(mapFn,thisArg,value,j):value;if(Context){desc.value=value;defineProperty(arr,j,desc)}else{arr[j]=value}++j}length=j}}if(length===undefined){length=toPosInt(arrayLike.length);if(Context)arr=new Context(length);for(i=0;i0?1:-1}},{}],30:[function(require,module,exports){"use strict";module.exports=require("./is-implemented")()?Number.isNaN:require("./shim")},{"./is-implemented":31,"./shim":32}],31:[function(require,module,exports){"use strict";module.exports=function(){var numberIsNaN=Number.isNaN;if(typeof numberIsNaN!=="function")return false;return!numberIsNaN({})&&numberIsNaN(NaN)&&!numberIsNaN(34)}},{}],32:[function(require,module,exports){"use strict";module.exports=function(value){return value!==value}},{}],33:[function(require,module,exports){"use strict";var sign=require("../math/sign"),abs=Math.abs,floor=Math.floor;module.exports=function(value){if(isNaN(value))return 0;value=Number(value);if(value===0||!isFinite(value))return value;return sign(value)*floor(abs(value))}},{"../math/sign":27}],34:[function(require,module,exports){"use strict";var toInteger=require("./to-integer"),max=Math.max;module.exports=function(value){return max(0,toInteger(value))}},{"./to-integer":33}],35:[function(require,module,exports){"use strict";var callable=require("./valid-callable"),value=require("./valid-value"),bind=Function.prototype.bind,call=Function.prototype.call,keys=Object.keys,objPropertyIsEnumerable=Object.prototype.propertyIsEnumerable;module.exports=function(method,defVal){return function(obj,cb){var list,thisArg=arguments[2],compareFn=arguments[3];obj=Object(value(obj));callable(cb);list=keys(obj);if(compareFn){list.sort(typeof compareFn==="function"?bind.call(compareFn,obj):undefined)}if(typeof method!=="function")method=list[method];return call.call(method,list,function(key,index){if(!objPropertyIsEnumerable.call(obj,key))return defVal;return call.call(cb,thisArg,obj[key],key,obj,index)})}}},{"./valid-callable":54,"./valid-value":55}],36:[function(require,module,exports){"use strict";module.exports=require("./is-implemented")()?Object.assign:require("./shim")},{"./is-implemented":37,"./shim":38}],37:[function(require,module,exports){"use strict";module.exports=function(){var assign=Object.assign,obj;if(typeof assign!=="function")return false;obj={foo:"raz"};assign(obj,{bar:"dwa"},{trzy:"trzy"});return obj.foo+obj.bar+obj.trzy==="razdwatrzy"}},{}],38:[function(require,module,exports){"use strict";var keys=require("../keys"),value=require("../valid-value"),max=Math.max;module.exports=function(dest,src){var error,i,length=max(arguments.length,2),assign;dest=Object(value(dest));assign=function(key){try{dest[key]=src[key]}catch(e){if(!error)error=e}};for(i=1;i-1}},{}],59:[function(require,module,exports){"use strict";var objToString=Object.prototype.toString,id=objToString.call("");module.exports=function(value){return typeof value==="string"||value&&typeof value==="object"&&(value instanceof String||objToString.call(value)===id)||false}},{}],60:[function(require,module,exports){"use strict";var setPrototypeOf=require("es5-ext/object/set-prototype-of"),contains=require("es5-ext/string/#/contains"),d=require("d"),Symbol=require("es6-symbol"),Iterator=require("./");var defineProperty=Object.defineProperty,ArrayIterator;ArrayIterator=module.exports=function(arr,kind){if(!(this instanceof ArrayIterator))throw new TypeError("Constructor requires 'new'");Iterator.call(this,arr);if(!kind)kind="value";else if(contains.call(kind,"key+value"))kind="key+value";else if(contains.call(kind,"key"))kind="key";else kind="value";defineProperty(this,"__kind__",d("",kind))};if(setPrototypeOf)setPrototypeOf(ArrayIterator,Iterator);delete ArrayIterator.prototype.constructor;ArrayIterator.prototype=Object.create(Iterator.prototype,{_resolve:d(function(i){if(this.__kind__==="value")return this.__list__[i];if(this.__kind__==="key+value")return[i,this.__list__[i]];return i})});defineProperty(ArrayIterator.prototype,Symbol.toStringTag,d("c","Array Iterator"))},{"./":63,d:16,"es5-ext/object/set-prototype-of":51,"es5-ext/string/#/contains":56,"es6-symbol":73}],61:[function(require,module,exports){"use strict";var isArguments=require("es5-ext/function/is-arguments"),callable=require("es5-ext/object/valid-callable"),isString=require("es5-ext/string/is-string"),get=require("./get");var isArray=Array.isArray,call=Function.prototype.call,some=Array.prototype.some;module.exports=function(iterable,cb){var mode,thisArg=arguments[2],result,doBreak,broken,i,length,char,code;if(isArray(iterable)||isArguments(iterable))mode="array";else if(isString(iterable))mode="string";else iterable=get(iterable);callable(cb);doBreak=function(){broken=true};if(mode==="array"){some.call(iterable,function(value){call.call(cb,thisArg,value,doBreak);return broken});return}if(mode==="string"){length=iterable.length;for(i=0;i=55296&&code<=56319)char+=iterable[++i]}call.call(cb,thisArg,char,doBreak);if(broken)break}return}result=iterable.next();while(!result.done){call.call(cb,thisArg,result.value,doBreak);if(broken)return;result=iterable.next()}}},{"./get":62,"es5-ext/function/is-arguments":24,"es5-ext/object/valid-callable":54,"es5-ext/string/is-string":59}],62:[function(require,module,exports){"use strict";var isArguments=require("es5-ext/function/is-arguments"),isString=require("es5-ext/string/is-string"),ArrayIterator=require("./array"),StringIterator=require("./string"),iterable=require("./valid-iterable"),iteratorSymbol=require("es6-symbol").iterator;module.exports=function(obj){if(typeof iterable(obj)[iteratorSymbol]==="function")return obj[iteratorSymbol]();if(isArguments(obj))return new ArrayIterator(obj);if(isString(obj))return new StringIterator(obj);return new ArrayIterator(obj)}},{"./array":60,"./string":65,"./valid-iterable":66,"es5-ext/function/is-arguments":24,"es5-ext/string/is-string":59,"es6-symbol":73}],63:[function(require,module,exports){"use strict";var clear=require("es5-ext/array/#/clear"),assign=require("es5-ext/object/assign"),callable=require("es5-ext/object/valid-callable"),value=require("es5-ext/object/valid-value"),d=require("d"),autoBind=require("d/auto-bind"),Symbol=require("es6-symbol");var defineProperty=Object.defineProperty,defineProperties=Object.defineProperties,Iterator;module.exports=Iterator=function(list,context){if(!(this instanceof Iterator))throw new TypeError("Constructor requires 'new'");defineProperties(this,{__list__:d("w",value(list)),__context__:d("w",context),__nextIndex__:d("w",0)});if(!context)return;callable(context.on);context.on("_add",this._onAdd);context.on("_delete",this._onDelete);context.on("_clear",this._onClear)};delete Iterator.prototype.constructor;defineProperties(Iterator.prototype,assign({_next:d(function(){var i;if(!this.__list__)return undefined;if(this.__redo__){i=this.__redo__.shift();if(i!==undefined)return i}if(this.__nextIndex__=this.__nextIndex__)return;++this.__nextIndex__;if(!this.__redo__){defineProperty(this,"__redo__",d("c",[index]));return}this.__redo__.forEach(function(redo,i){if(redo>=index)this.__redo__[i]=++redo},this);this.__redo__.push(index)}),_onDelete:d(function(index){var i;if(index>=this.__nextIndex__)return;--this.__nextIndex__;if(!this.__redo__)return;i=this.__redo__.indexOf(index);if(i!==-1)this.__redo__.splice(i,1);this.__redo__.forEach(function(redo,j){if(redo>index)this.__redo__[j]=--redo},this)}),_onClear:d(function(){if(this.__redo__)clear.call(this.__redo__);this.__nextIndex__=0})})));defineProperty(Iterator.prototype,Symbol.iterator,d(function(){return this}))},{d:16,"d/auto-bind":15,"es5-ext/array/#/clear":19,"es5-ext/object/assign":36,"es5-ext/object/valid-callable":54,"es5-ext/object/valid-value":55,"es6-symbol":73}],64:[function(require,module,exports){"use strict";var isArguments=require("es5-ext/function/is-arguments"),isValue=require("es5-ext/object/is-value"),isString=require("es5-ext/string/is-string");var iteratorSymbol=require("es6-symbol").iterator,isArray=Array.isArray;module.exports=function(value){if(!isValue(value))return false;if(isArray(value))return true;if(isString(value))return true;if(isArguments(value))return true;return typeof value[iteratorSymbol]==="function"}},{"es5-ext/function/is-arguments":24,"es5-ext/object/is-value":44,"es5-ext/string/is-string":59,"es6-symbol":73}],65:[function(require,module,exports){"use strict";var setPrototypeOf=require("es5-ext/object/set-prototype-of"),d=require("d"),Symbol=require("es6-symbol"),Iterator=require("./");var defineProperty=Object.defineProperty,StringIterator;StringIterator=module.exports=function(str){if(!(this instanceof StringIterator))throw new TypeError("Constructor requires 'new'");str=String(str);Iterator.call(this,str);defineProperty(this,"__length__",d("",str.length))};if(setPrototypeOf)setPrototypeOf(StringIterator,Iterator);delete StringIterator.prototype.constructor;StringIterator.prototype=Object.create(Iterator.prototype,{_next:d(function(){if(!this.__list__)return undefined;if(this.__nextIndex__=55296&&code<=56319)return char+this.__list__[this.__nextIndex__++];return char})});defineProperty(StringIterator.prototype,Symbol.toStringTag,d("c","String Iterator"))},{"./":63,d:16,"es5-ext/object/set-prototype-of":51,"es6-symbol":73}],66:[function(require,module,exports){"use strict";var isIterable=require("./is-iterable");module.exports=function(value){if(!isIterable(value))throw new TypeError(value+" is not iterable");return value}},{"./is-iterable":64}],67:[function(require,module,exports){"use strict";module.exports=require("./is-implemented")()?Map:require("./polyfill")},{"./is-implemented":68,"./polyfill":72}],68:[function(require,module,exports){"use strict";module.exports=function(){var map,iterator,result;if(typeof Map!=="function")return false;try{map=new Map([["raz","one"],["dwa","two"],["trzy","three"]])}catch(e){return false}if(String(map)!=="[object Map]")return false;if(map.size!==3)return false;if(typeof map.clear!=="function")return false;if(typeof map.delete!=="function")return false;if(typeof map.entries!=="function")return false;if(typeof map.forEach!=="function")return false;if(typeof map.get!=="function")return false;if(typeof map.has!=="function")return false;if(typeof map.keys!=="function")return false;if(typeof map.set!=="function")return false;if(typeof map.values!=="function")return false;iterator=map.entries();result=iterator.next();if(result.done!==false)return false;if(!result.value)return false;if(result.value[0]!=="raz")return false;if(result.value[1]!=="one")return false;return true}},{}],69:[function(require,module,exports){"use strict";module.exports=function(){if(typeof Map==="undefined")return false;return Object.prototype.toString.call(new Map)==="[object Map]"}()},{}],70:[function(require,module,exports){"use strict";module.exports=require("es5-ext/object/primitive-set")("key","value","key+value")},{"es5-ext/object/primitive-set":50}],71:[function(require,module,exports){"use strict";var setPrototypeOf=require("es5-ext/object/set-prototype-of"),d=require("d"),Iterator=require("es6-iterator"),toStringTagSymbol=require("es6-symbol").toStringTag,kinds=require("./iterator-kinds"),defineProperties=Object.defineProperties,unBind=Iterator.prototype._unBind,MapIterator;MapIterator=module.exports=function(map,kind){if(!(this instanceof MapIterator))return new MapIterator(map,kind);Iterator.call(this,map.__mapKeysData__,map);if(!kind||!kinds[kind])kind="key+value";defineProperties(this,{__kind__:d("",kind),__values__:d("w",map.__mapValuesData__)})};if(setPrototypeOf)setPrototypeOf(MapIterator,Iterator);MapIterator.prototype=Object.create(Iterator.prototype,{constructor:d(MapIterator),_resolve:d(function(i){if(this.__kind__==="value")return this.__values__[i];if(this.__kind__==="key")return this.__list__[i];return[this.__list__[i],this.__values__[i]]}),_unBind:d(function(){this.__values__=null;unBind.call(this)}),toString:d(function(){return"[object Map Iterator]"})});Object.defineProperty(MapIterator.prototype,toStringTagSymbol,d("c","Map Iterator"))},{"./iterator-kinds":70,d:16,"es5-ext/object/set-prototype-of":51,"es6-iterator":63,"es6-symbol":73}],72:[function(require,module,exports){"use strict";var clear=require("es5-ext/array/#/clear"),eIndexOf=require("es5-ext/array/#/e-index-of"),setPrototypeOf=require("es5-ext/object/set-prototype-of"),callable=require("es5-ext/object/valid-callable"),validValue=require("es5-ext/object/valid-value"),d=require("d"),ee=require("event-emitter"),Symbol=require("es6-symbol"),iterator=require("es6-iterator/valid-iterable"),forOf=require("es6-iterator/for-of"),Iterator=require("./lib/iterator"),isNative=require("./is-native-implemented"),call=Function.prototype.call,defineProperties=Object.defineProperties,getPrototypeOf=Object.getPrototypeOf,MapPoly;module.exports=MapPoly=function(){var iterable=arguments[0],keys,values,self;if(!(this instanceof MapPoly))throw new TypeError("Constructor requires 'new'");if(isNative&&setPrototypeOf&&Map!==MapPoly){self=setPrototypeOf(new Map,getPrototypeOf(this))}else{self=this}if(iterable!=null)iterator(iterable);defineProperties(self,{__mapKeysData__:d("c",keys=[]),__mapValuesData__:d("c",values=[])});if(!iterable)return self;forOf(iterable,function(value){var key=validValue(value)[0];value=value[1];if(eIndexOf.call(keys,key)!==-1)return;keys.push(key);values.push(value)},self);return self};if(isNative){if(setPrototypeOf)setPrototypeOf(MapPoly,Map);MapPoly.prototype=Object.create(Map.prototype,{constructor:d(MapPoly)})}ee(defineProperties(MapPoly.prototype,{clear:d(function(){if(!this.__mapKeysData__.length)return;clear.call(this.__mapKeysData__);clear.call(this.__mapValuesData__);this.emit("_clear")}),delete:d(function(key){var index=eIndexOf.call(this.__mapKeysData__,key);if(index===-1)return false;this.__mapKeysData__.splice(index,1);this.__mapValuesData__.splice(index,1);this.emit("_delete",index,key);return true}),entries:d(function(){return new Iterator(this,"key+value")}),forEach:d(function(cb){var thisArg=arguments[1],iterator,result;callable(cb);iterator=this.entries();result=iterator._next();while(result!==undefined){call.call(cb,thisArg,this.__mapValuesData__[result],this.__mapKeysData__[result],this);result=iterator._next()}}),get:d(function(key){var index=eIndexOf.call(this.__mapKeysData__,key);if(index===-1)return;return this.__mapValuesData__[index]}),has:d(function(key){return eIndexOf.call(this.__mapKeysData__,key)!==-1}),keys:d(function(){return new Iterator(this,"key")}),set:d(function(key,value){var index=eIndexOf.call(this.__mapKeysData__,key),emit;if(index===-1){index=this.__mapKeysData__.push(key)-1;emit=true}this.__mapValuesData__[index]=value;if(emit)this.emit("_add",index,key);return this}),size:d.gs(function(){return this.__mapKeysData__.length}),values:d(function(){return new Iterator(this,"value")}),toString:d(function(){return"[object Map]"})}));Object.defineProperty(MapPoly.prototype,Symbol.iterator,d(function(){return this.entries()}));Object.defineProperty(MapPoly.prototype,Symbol.toStringTag,d("c","Map"))},{"./is-native-implemented":69,"./lib/iterator":71,d:16,"es5-ext/array/#/clear":19,"es5-ext/array/#/e-index-of":20,"es5-ext/object/set-prototype-of":51,"es5-ext/object/valid-callable":54,"es5-ext/object/valid-value":55,"es6-iterator/for-of":61,"es6-iterator/valid-iterable":66,"es6-symbol":73,"event-emitter":78}],73:[function(require,module,exports){"use strict";module.exports=require("./is-implemented")()?Symbol:require("./polyfill")},{"./is-implemented":74,"./polyfill":76}],74:[function(require,module,exports){"use strict";var validTypes={object:true,symbol:true};module.exports=function(){var symbol;if(typeof Symbol!=="function")return false;symbol=Symbol("test symbol");try{String(symbol)}catch(e){return false}if(!validTypes[typeof Symbol.iterator])return false;if(!validTypes[typeof Symbol.toPrimitive])return false;if(!validTypes[typeof Symbol.toStringTag])return false;return true}},{}],75:[function(require,module,exports){"use strict";module.exports=function(x){if(!x)return false;if(typeof x==="symbol")return true;if(!x.constructor)return false;if(x.constructor.name!=="Symbol")return false;return x[x.constructor.toStringTag]==="Symbol"}},{}],76:[function(require,module,exports){"use strict";var d=require("d"),validateSymbol=require("./validate-symbol"),create=Object.create,defineProperties=Object.defineProperties,defineProperty=Object.defineProperty,objPrototype=Object.prototype,NativeSymbol,SymbolPolyfill,HiddenSymbol,globalSymbols=create(null),isNativeSafe;if(typeof Symbol==="function"){NativeSymbol=Symbol;try{String(NativeSymbol());isNativeSafe=true}catch(ignore){}}var generateName=function(){var created=create(null);return function(desc){var postfix=0,name,ie11BugWorkaround;while(created[desc+(postfix||"")])++postfix;desc+=postfix||"";created[desc]=true;name="@@"+desc;defineProperty(objPrototype,name,d.gs(null,function(value){if(ie11BugWorkaround)return;ie11BugWorkaround=true;defineProperty(this,name,d(value));ie11BugWorkaround=false}));return name}}();HiddenSymbol=function Symbol(description){if(this instanceof HiddenSymbol)throw new TypeError("Symbol is not a constructor");return SymbolPolyfill(description)};module.exports=SymbolPolyfill=function Symbol(description){var symbol;if(this instanceof Symbol)throw new TypeError("Symbol is not a constructor");if(isNativeSafe)return NativeSymbol(description);symbol=create(HiddenSymbol.prototype);description=description===undefined?"":String(description);return defineProperties(symbol,{__description__:d("",description),__name__:d("",generateName(description))})};defineProperties(SymbolPolyfill,{for:d(function(key){if(globalSymbols[key])return globalSymbols[key];return globalSymbols[key]=SymbolPolyfill(String(key))}),keyFor:d(function(s){var key;validateSymbol(s);for(key in globalSymbols)if(globalSymbols[key]===s)return key}),hasInstance:d("",NativeSymbol&&NativeSymbol.hasInstance||SymbolPolyfill("hasInstance")),isConcatSpreadable:d("",NativeSymbol&&NativeSymbol.isConcatSpreadable||SymbolPolyfill("isConcatSpreadable")),iterator:d("",NativeSymbol&&NativeSymbol.iterator||SymbolPolyfill("iterator")),match:d("",NativeSymbol&&NativeSymbol.match||SymbolPolyfill("match")),replace:d("",NativeSymbol&&NativeSymbol.replace||SymbolPolyfill("replace")),search:d("",NativeSymbol&&NativeSymbol.search||SymbolPolyfill("search")),species:d("",NativeSymbol&&NativeSymbol.species||SymbolPolyfill("species")),split:d("",NativeSymbol&&NativeSymbol.split||SymbolPolyfill("split")),toPrimitive:d("",NativeSymbol&&NativeSymbol.toPrimitive||SymbolPolyfill("toPrimitive")),toStringTag:d("",NativeSymbol&&NativeSymbol.toStringTag||SymbolPolyfill("toStringTag")),unscopables:d("",NativeSymbol&&NativeSymbol.unscopables||SymbolPolyfill("unscopables"))});defineProperties(HiddenSymbol.prototype,{constructor:d(SymbolPolyfill),toString:d("",function(){return this.__name__})});defineProperties(SymbolPolyfill.prototype,{toString:d(function(){return"Symbol ("+validateSymbol(this).__description__+")"}),valueOf:d(function(){return validateSymbol(this)})});defineProperty(SymbolPolyfill.prototype,SymbolPolyfill.toPrimitive,d("",function(){var symbol=validateSymbol(this);if(typeof symbol==="symbol")return symbol;return symbol.toString()}));defineProperty(SymbolPolyfill.prototype,SymbolPolyfill.toStringTag,d("c","Symbol"));defineProperty(HiddenSymbol.prototype,SymbolPolyfill.toStringTag,d("c",SymbolPolyfill.prototype[SymbolPolyfill.toStringTag]));defineProperty(HiddenSymbol.prototype,SymbolPolyfill.toPrimitive,d("c",SymbolPolyfill.prototype[SymbolPolyfill.toPrimitive]))},{"./validate-symbol":77,d:16}],77:[function(require,module,exports){"use strict";var isSymbol=require("./is-symbol");module.exports=function(value){if(!isSymbol(value))throw new TypeError(value+" is not a symbol");return value}},{"./is-symbol":75}],78:[function(require,module,exports){"use strict";var d=require("d"),callable=require("es5-ext/object/valid-callable"),apply=Function.prototype.apply,call=Function.prototype.call,create=Object.create,defineProperty=Object.defineProperty,defineProperties=Object.defineProperties,hasOwnProperty=Object.prototype.hasOwnProperty,descriptor={configurable:true,enumerable:false,writable:true},on,once,off,emit,methods,descriptors,base;on=function(type,listener){var data;callable(listener);if(!hasOwnProperty.call(this,"__ee__")){data=descriptor.value=create(null);defineProperty(this,"__ee__",descriptor);descriptor.value=null}else{data=this.__ee__}if(!data[type])data[type]=listener;else if(typeof data[type]==="object")data[type].push(listener);else data[type]=[data[type],listener];return this};once=function(type,listener){var once,self;callable(listener);self=this;on.call(this,type,once=function(){off.call(self,type,once);apply.call(listener,this,arguments)});once.__eeOnceListener__=listener;return this};off=function(type,listener){var data,listeners,candidate,i;callable(listener);if(!hasOwnProperty.call(this,"__ee__"))return this;data=this.__ee__;if(!data[type])return this;listeners=data[type];if(typeof listeners==="object"){for(i=0;candidate=listeners[i];++i){if(candidate===listener||candidate.__eeOnceListener__===listener){if(listeners.length===2)data[type]=listeners[i?0:1];else listeners.splice(i,1)}}}else{if(listeners===listener||listeners.__eeOnceListener__===listener){delete data[type]}}return this};emit=function(type){var i,l,listener,listeners,args;if(!hasOwnProperty.call(this,"__ee__"))return;listeners=this.__ee__[type];if(!listeners)return;if(typeof listeners==="object"){l=arguments.length;args=new Array(l-1);for(i=1;i>1;var nBits=-7;var i=isLE?nBytes-1:0;var d=isLE?-1:1;var s=buffer[offset+i];i+=d;e=s&(1<<-nBits)-1;s>>=-nBits;nBits+=eLen;for(;nBits>0;e=e*256+buffer[offset+i],i+=d,nBits-=8){}m=e&(1<<-nBits)-1;e>>=-nBits;nBits+=mLen;for(;nBits>0;m=m*256+buffer[offset+i],i+=d,nBits-=8){}if(e===0){e=1-eBias}else if(e===eMax){return m?NaN:(s?-1:1)*Infinity}else{m=m+Math.pow(2,mLen);e=e-eBias}return(s?-1:1)*m*Math.pow(2,e-mLen)};exports.write=function(buffer,value,offset,isLE,mLen,nBytes){var e,m,c;var eLen=nBytes*8-mLen-1;var eMax=(1<>1;var rt=mLen===23?Math.pow(2,-24)-Math.pow(2,-77):0;var i=isLE?0:nBytes-1;var d=isLE?1:-1;var s=value<0||value===0&&1/value<0?1:0;value=Math.abs(value);if(isNaN(value)||value===Infinity){m=isNaN(value)?1:0;e=eMax}else{e=Math.floor(Math.log(value)/Math.LN2);if(value*(c=Math.pow(2,-e))<1){e--;c*=2}if(e+eBias>=1){value+=rt/c}else{value+=rt*Math.pow(2,1-eBias)}if(value*c>=2){e++;c/=2}if(e+eBias>=eMax){m=0;e=eMax}else if(e+eBias>=1){m=(value*c-1)*Math.pow(2,mLen);e=e+eBias}else{m=value*Math.pow(2,eBias-1)*Math.pow(2,mLen);e=0}}for(;mLen>=8;buffer[offset+i]=m&255,i+=d,m/=256,mLen-=8){}e=e<0;buffer[offset+i]=e&255,i+=d,e/=256,eLen-=8){}buffer[offset+i-d]|=s*128}},{}],80:[function(require,module,exports){if(typeof Object.create==="function"){module.exports=function inherits(ctor,superCtor){ctor.super_=superCtor;ctor.prototype=Object.create(superCtor.prototype,{constructor:{value:ctor,enumerable:false,writable:true,configurable:true}})}}else{module.exports=function inherits(ctor,superCtor){ctor.super_=superCtor;var TempCtor=function(){};TempCtor.prototype=superCtor.prototype;ctor.prototype=new TempCtor;ctor.prototype.constructor=ctor}}},{}],81:[function(require,module,exports){module.exports=function(obj){return obj!=null&&(isBuffer(obj)||isSlowBuffer(obj)||!!obj._isBuffer)};function isBuffer(obj){return!!obj.constructor&&typeof obj.constructor.isBuffer==="function"&&obj.constructor.isBuffer(obj)}function isSlowBuffer(obj){return typeof obj.readFloatLE==="function"&&typeof obj.slice==="function"&&isBuffer(obj.slice(0,0))}},{}],82:[function(require,module,exports){"use strict";var Buffer=require("safe-buffer").Buffer;var protocol=module.exports;protocol.types={0:"reserved",1:"connect",2:"connack",3:"publish",4:"puback",5:"pubrec",6:"pubrel",7:"pubcomp",8:"subscribe",9:"suback",10:"unsubscribe",11:"unsuback",12:"pingreq",13:"pingresp",14:"disconnect",15:"auth"};protocol.codes={};for(var k in protocol.types){var v=protocol.types[k];protocol.codes[v]=k}protocol.CMD_SHIFT=4;protocol.CMD_MASK=240;protocol.DUP_MASK=8;protocol.QOS_MASK=3;protocol.QOS_SHIFT=1;protocol.RETAIN_MASK=1;protocol.LENGTH_MASK=127;protocol.LENGTH_FIN_MASK=128;protocol.SESSIONPRESENT_MASK=1;protocol.SESSIONPRESENT_HEADER=Buffer.from([protocol.SESSIONPRESENT_MASK]);protocol.CONNACK_HEADER=Buffer.from([protocol.codes["connack"]<this.length)srcEnd=this.length;if(srcStart>=this.length)return dst||Buffer.alloc(0);if(srcEnd<=0)return dst||Buffer.alloc(0);var copy=!!dst,off=this._offset(srcStart),len=srcEnd-srcStart,bytes=len,bufoff=copy&&dstStart||0,start=off[1],l,i;if(srcStart===0&&srcEnd==this.length){if(!copy){return this._bufs.length===1?this._bufs[0]:Buffer.concat(this._bufs,this.length)}for(i=0;il){this._bufs[i].copy(dst,bufoff,start)}else{this._bufs[i].copy(dst,bufoff,start,start+bytes);break}bufoff+=l;bytes-=l;if(start)start=0}return dst};BufferList.prototype.shallowSlice=function shallowSlice(start,end){start=start||0;end=end||this.length;if(start<0)start+=this.length;if(end<0)end+=this.length;var startOffset=this._offset(start),endOffset=this._offset(end),buffers=this._bufs.slice(startOffset[0],endOffset[0]+1);if(endOffset[1]==0)buffers.pop();else buffers[buffers.length-1]=buffers[buffers.length-1].slice(0,endOffset[1]);if(startOffset[1]!=0)buffers[0]=buffers[0].slice(startOffset[1]);return new BufferList(buffers)};BufferList.prototype.toString=function toString(encoding,start,end){return this.slice(start,end).toString(encoding)};BufferList.prototype.consume=function consume(bytes){while(this._bufs.length){if(bytes>=this._bufs[0].length){bytes-=this._bufs[0].length;this.length-=this._bufs[0].length;this._bufs.shift()}else{this._bufs[0]=this._bufs[0].slice(bytes);this.length-=bytes;break}}return this};BufferList.prototype.duplicate=function duplicate(){var i=0,copy=new BufferList;for(;i>8,0);buffer.writeUInt8(i&255,0+1);return buffer}function generateCache(){for(var i=0;i=0&&length<128)return 1;else if(length>=128&&length<16384)return 2;else if(length>=16384&&length<2097152)return 3;else if(length>=2097152&&length<268435456)return 4;else return 0}function genBufVariableByteInt(num){var digit=0;var pos=0;var length=calcVariableByteIntLength(num);var buffer=Buffer.allocUnsafe(length);do{digit=num%128|0;num=num/128|0;if(num>0)digit=digit|128;buffer.writeUInt8(digit,pos++)}while(num>0);return{data:buffer,length:length}}function generate4ByteBuffer(num){var buffer=Buffer.allocUnsafe(4);buffer.writeUInt32BE(num,0);return buffer}module.exports={cache:cache,generateCache:generateCache,generateNumber:generateBuffer,genBufVariableByteInt:genBufVariableByteInt,generate4ByteBuffer:generate4ByteBuffer}},{"safe-buffer":110}],87:[function(require,module,exports){function Packet(){this.cmd=null;this.retain=false;this.qos=0;this.dup=false;this.length=-1;this.topic=null;this.payload=null}module.exports=Packet},{}],88:[function(require,module,exports){"use strict";var bl=require("bl");var inherits=require("inherits");var EE=require("events").EventEmitter;var Packet=require("./packet");var constants=require("./constants");function Parser(opt){if(!(this instanceof Parser))return new Parser(opt);this.settings=opt||{};this._states=["_parseHeader","_parseLength","_parsePayload","_newPacket"];this._resetState()}inherits(Parser,EE);Parser.prototype._resetState=function(){this.packet=new Packet;this.error=null;this._list=bl();this._stateCounter=0};Parser.prototype.parse=function(buf){if(this.error)this._resetState();this._list.append(buf);while((this.packet.length!==-1||this._list.length>0)&&this[this._states[this._stateCounter]]()&&!this.error){this._stateCounter++;if(this._stateCounter>=this._states.length)this._stateCounter=0}return this._list.length};Parser.prototype._parseHeader=function(){var zero=this._list.readUInt8(0);this.packet.cmd=constants.types[zero>>constants.CMD_SHIFT];this.packet.retain=(zero&constants.RETAIN_MASK)!==0;this.packet.qos=zero>>constants.QOS_SHIFT&constants.QOS_MASK;this.packet.dup=(zero&constants.DUP_MASK)!==0;this._list.consume(1);return true};Parser.prototype._parseLength=function(){var result=this._parseVarByteNum(true);if(result){this.packet.length=result.value;this._list.consume(result.bytes)}return!!result};Parser.prototype._parsePayload=function(){var result=false;if(this.packet.length===0||this._list.length>=this.packet.length){this._pos=0;switch(this.packet.cmd){case"connect":this._parseConnect();break;case"connack":this._parseConnack();break;case"publish":this._parsePublish();break;case"puback":case"pubrec":case"pubrel":case"pubcomp":this._parseConfirmation();break;case"subscribe":this._parseSubscribe();break;case"suback":this._parseSuback();break;case"unsubscribe":this._parseUnsubscribe();break;case"unsuback":this._parseUnsuback();break;case"pingreq":case"pingresp":break;case"disconnect":this._parseDisconnect();break;case"auth":this._parseAuth();break;default:this._emitError(new Error("Not supported"))}result=true}return result};Parser.prototype._parseConnect=function(){var protocolId;var clientId;var topic;var payload;var password;var username;var flags={};var packet=this.packet;protocolId=this._parseString();if(protocolId===null)return this._emitError(new Error("Cannot parse protocolId"));if(protocolId!=="MQTT"&&protocolId!=="MQIsdp"){return this._emitError(new Error("Invalid protocolId"))}packet.protocolId=protocolId;if(this._pos>=this._list.length)return this._emitError(new Error("Packet too short"));packet.protocolVersion=this._list.readUInt8(this._pos);if(packet.protocolVersion!==3&&packet.protocolVersion!==4&&packet.protocolVersion!==5){return this._emitError(new Error("Invalid protocol version"))}this._pos++;if(this._pos>=this._list.length){return this._emitError(new Error("Packet too short"))}flags.username=this._list.readUInt8(this._pos)&constants.USERNAME_MASK;flags.password=this._list.readUInt8(this._pos)&constants.PASSWORD_MASK;flags.will=this._list.readUInt8(this._pos)&constants.WILL_FLAG_MASK;if(flags.will){packet.will={};packet.will.retain=(this._list.readUInt8(this._pos)&constants.WILL_RETAIN_MASK)!==0;packet.will.qos=(this._list.readUInt8(this._pos)&constants.WILL_QOS_MASK)>>constants.WILL_QOS_SHIFT}packet.clean=(this._list.readUInt8(this._pos)&constants.CLEAN_SESSION_MASK)!==0;this._pos++;packet.keepalive=this._parseNum();if(packet.keepalive===-1)return this._emitError(new Error("Packet too short"));if(packet.protocolVersion===5){var properties=this._parseProperties();if(Object.getOwnPropertyNames(properties).length){packet.properties=properties}}clientId=this._parseString();if(clientId===null)return this._emitError(new Error("Packet too short"));packet.clientId=clientId;if(flags.will){if(packet.protocolVersion===5){var willProperties=this._parseProperties();if(Object.getOwnPropertyNames(willProperties).length){packet.will.properties=willProperties}}topic=this._parseString();if(topic===null)return this._emitError(new Error("Cannot parse will topic"));packet.will.topic=topic;payload=this._parseBuffer();if(payload===null)return this._emitError(new Error("Cannot parse will payload"));packet.will.payload=payload}if(flags.username){username=this._parseString();if(username===null)return this._emitError(new Error("Cannot parse username"));packet.username=username}if(flags.password){password=this._parseBuffer();if(password===null)return this._emitError(new Error("Cannot parse password"));packet.password=password}this.settings=packet;return packet};Parser.prototype._parseConnack=function(){var packet=this.packet;if(this._list.length<2)return null;packet.sessionPresent=!!(this._list.readUInt8(this._pos++)&constants.SESSIONPRESENT_MASK);if(this.settings.protocolVersion===5){packet.reasonCode=this._list.readUInt8(this._pos++)}else{packet.returnCode=this._list.readUInt8(this._pos++)}if(packet.returnCode===-1||packet.reasonCode===-1)return this._emitError(new Error("Cannot parse return code"));if(this.settings.protocolVersion===5){var properties=this._parseProperties();if(Object.getOwnPropertyNames(properties).length){packet.properties=properties}}};Parser.prototype._parsePublish=function(){var packet=this.packet;packet.topic=this._parseString();if(packet.topic===null)return this._emitError(new Error("Cannot parse topic"));if(packet.qos>0)if(!this._parseMessageId()){return}if(this.settings.protocolVersion===5){var properties=this._parseProperties();if(Object.getOwnPropertyNames(properties).length){packet.properties=properties}}packet.payload=this._list.slice(this._pos,packet.length)};Parser.prototype._parseSubscribe=function(){var packet=this.packet;var topic;var options;var qos;var rh;var rap;var nl;var subscription;if(packet.qos!==1){return this._emitError(new Error("Wrong subscribe header"))}packet.subscriptions=[];if(!this._parseMessageId()){return}if(this.settings.protocolVersion===5){var properties=this._parseProperties();if(Object.getOwnPropertyNames(properties).length){packet.properties=properties}}while(this._pos>constants.SUBSCRIBE_OPTIONS_NL_SHIFT&constants.SUBSCRIBE_OPTIONS_NL_MASK)!==0;rap=(options>>constants.SUBSCRIBE_OPTIONS_RAP_SHIFT&constants.SUBSCRIBE_OPTIONS_RAP_MASK)!==0;rh=options>>constants.SUBSCRIBE_OPTIONS_RH_SHIFT&constants.SUBSCRIBE_OPTIONS_RH_MASK;subscription={topic:topic,qos:qos};if(this.settings.protocolVersion===5){subscription.nl=nl;subscription.rap=rap;subscription.rh=rh}packet.subscriptions.push(subscription)}};Parser.prototype._parseSuback=function(){var packet=this.packet;this.packet.granted=[];if(!this._parseMessageId()){return}if(this.settings.protocolVersion===5){var properties=this._parseProperties();if(Object.getOwnPropertyNames(properties).length){packet.properties=properties}}while(this._pos2){packet.reasonCode=this._parseByte();var properties=this._parseProperties();if(Object.getOwnPropertyNames(properties).length){packet.properties=properties}}}return true};Parser.prototype._parseDisconnect=function(){var packet=this.packet;if(this.settings.protocolVersion===5){packet.reasonCode=this._parseByte();var properties=this._parseProperties();if(Object.getOwnPropertyNames(properties).length){packet.properties=properties}}return true};Parser.prototype._parseAuth=function(){var packet=this.packet;if(this.settings.protocolVersion!==5){return this._emitError(new Error("Not supported auth packet for this version MQTT"))}packet.reasonCode=this._parseByte();var properties=this._parseProperties();if(Object.getOwnPropertyNames(properties).length){packet.properties=properties}return true};Parser.prototype._parseMessageId=function(){var packet=this.packet;packet.messageId=this._parseNum();if(packet.messageId===null){this._emitError(new Error("Cannot parse messageId"));return false}return true};Parser.prototype._parseString=function(maybeBuffer){var length=this._parseNum();var result;var end=length+this._pos;if(length===-1||end>this._list.length||end>this.packet.length)return null;result=this._list.toString("utf8",this._pos,end);this._pos+=length;return result};Parser.prototype._parseStringPair=function(){return{name:this._parseString(),value:this._parseString()}};Parser.prototype._parseBuffer=function(){var length=this._parseNum();var result;var end=length+this._pos;if(length===-1||end>this._list.length||end>this.packet.length)return null;result=this._list.slice(this._pos,end);this._pos+=length;return result};Parser.prototype._parseNum=function(){if(this._list.length-this._pos<2)return-1;var result=this._list.readUInt16BE(this._pos);this._pos+=2;return result};Parser.prototype._parse4ByteNum=function(){if(this._list.length-this._pos<4)return-1;var result=this._list.readUInt32BE(this._pos);this._pos+=4;return result};Parser.prototype._parseVarByteNum=function(fullInfoFlag){var bytes=0;var mul=1;var length=0;var result=true;var current;var padding=this._pos?this._pos:0;while(bytes<5){current=this._list.readUInt8(padding+bytes++);length+=mul*(current&constants.LENGTH_MASK);mul*=128;if((current&constants.LENGTH_FIN_MASK)===0)break;if(this._list.length<=bytes){result=false;break}}if(padding){this._pos+=bytes}result=result?fullInfoFlag?{bytes:bytes,value:length}:length:false;return result};Parser.prototype._parseByte=function(){var result=this._list.readUInt8(this._pos);this._pos++;return result};Parser.prototype._parseByType=function(type){switch(type){case"byte":{return this._parseByte()!==0}case"int8":{return this._parseByte()}case"int16":{return this._parseNum()}case"int32":{return this._parse4ByteNum()}case"var":{return this._parseVarByteNum()}case"string":{return this._parseString()}case"pair":{return this._parseStringPair()}case"binary":{return this._parseBuffer()}}};Parser.prototype._parseProperties=function(){var length=this._parseVarByteNum();var start=this._pos;var end=start+length;var result={};while(this._pos65535||keepalive%1!==0){stream.emit("error",new Error("Invalid keepalive"));return false}else length+=2;length+=1;if(protocolVersion===5){var propertiesData=getProperties(stream,properties);length+=propertiesData.length}if(will){if(typeof will!=="object"){stream.emit("error",new Error("Invalid will"));return false}if(!will.topic||typeof will.topic!=="string"){stream.emit("error",new Error("Invalid will topic"));return false}else{length+=Buffer.byteLength(will.topic)+2}if(will.payload){if(will.payload.length>=0){if(typeof will.payload==="string"){length+=Buffer.byteLength(will.payload)+2}else{length+=will.payload.length+2}}else{stream.emit("error",new Error("Invalid will payload"));return false}var willProperties={};if(protocolVersion===5){willProperties=getProperties(stream,will.properties);length+=willProperties.length}}}var providedUsername=false;if(username!=null){if(isStringOrBuffer(username)){providedUsername=true;length+=Buffer.byteLength(username)+2}else{stream.emit("error",new Error("Invalid username"));return false}}if(password!=null){if(!providedUsername){stream.emit("error",new Error("Username is required to use password"));return false}if(isStringOrBuffer(password)){length+=byteLength(password)+2}else{stream.emit("error",new Error("Invalid password"));return false}}stream.write(protocol.CONNECT_HEADER);writeVarByteInt(stream,length);writeStringOrBuffer(stream,protocolId);stream.write(protocolVersion===4?protocol.VERSION4:protocolVersion===5?protocol.VERSION5:protocol.VERSION3);var flags=0;flags|=username!=null?protocol.USERNAME_MASK:0;flags|=password!=null?protocol.PASSWORD_MASK:0;flags|=will&&will.retain?protocol.WILL_RETAIN_MASK:0;flags|=will&&will.qos?will.qos<0)writeNumber(stream,id);if(propertiesData!=null){propertiesData.write()}return stream.write(payload)}function confirmation(packet,stream,opts){var version=opts?opts.protocolVersion:4;var settings=packet||{};var type=settings.cmd||"puback";var id=settings.messageId;var dup=settings.dup&&type==="pubrel"?protocol.DUP_MASK:0;var qos=0;var reasonCode=settings.reasonCode;var properties=settings.properties;var length=version===5?3:2;if(type==="pubrel")qos=1;if(typeof id!=="number"){stream.emit("error",new Error("Invalid messageId"));return false}var propertiesData=null;if(version===5){propertiesData=getPropertiesByMaximumPacketSize(stream,properties,opts,length);if(!propertiesData){return false}length+=propertiesData.length}stream.write(protocol.ACKS[type][qos][dup][0]);writeVarByteInt(stream,length);writeNumber(stream,id);if(version===5){stream.write(Buffer.from([reasonCode]))}if(propertiesData!==null){propertiesData.write()}return true}function subscribe(packet,stream,opts){var version=opts?opts.protocolVersion:4;var settings=packet||{};var dup=settings.dup?protocol.DUP_MASK:0;var id=settings.messageId;var subs=settings.subscriptions;var properties=settings.properties;var length=0;if(typeof id!=="number"){stream.emit("error",new Error("Invalid messageId"));return false}else length+=2;var propertiesData=null;if(version===5){propertiesData=getProperties(stream,properties);length+=propertiesData.length}if(typeof subs==="object"&&subs.length){for(var i=0;i2){stream.emit("error",new Error("Invalid subscriptions - invalid Retain Handling"));return false}}length+=Buffer.byteLength(itopic)+2+1}}else{stream.emit("error",new Error("Invalid subscriptions"));return false}stream.write(protocol.SUBSCRIBE_HEADER[1][dup?1:0][0]);writeVarByteInt(stream,length);writeNumber(stream,id);if(propertiesData!==null){propertiesData.write()}var result=true;for(var j=0;jmaximumPacketSize){var currentMayEmptyProp=mayEmptyProps.shift();if(currentMayEmptyProp&&properties[currentMayEmptyProp]){delete properties[currentMayEmptyProp];propertiesData=getProperties(stream,properties)}else{return false}}}return propertiesData}function writeProperties(stream,properties,propertiesLength){writeVarByteInt(stream,propertiesLength);for(var propName in properties){if(properties.hasOwnProperty(propName)&&properties[propName]!==null){var value=properties[propName];var type=protocol.propertiesTypes[propName];switch(type){case"byte":{stream.write(Buffer.from([protocol.properties[propName]]));stream.write(Buffer.from([+value]));break}case"int8":{stream.write(Buffer.from([protocol.properties[propName]]));stream.write(Buffer.from([value]));break}case"binary":{stream.write(Buffer.from([protocol.properties[propName]]));writeStringOrBuffer(stream,value);break}case"int16":{stream.write(Buffer.from([protocol.properties[propName]]));writeNumber(stream,value);break}case"int32":{stream.write(Buffer.from([protocol.properties[propName]]));write4ByteNumber(stream,value);break}case"var":{stream.write(Buffer.from([protocol.properties[propName]]));writeVarByteInt(stream,value);break}case"string":{stream.write(Buffer.from([protocol.properties[propName]]));writeString(stream,value);break}case"pair":{Object.getOwnPropertyNames(value).forEach(function(name){stream.write(Buffer.from([protocol.properties[propName]]));writeStringPair(stream,name.toString(),value[name].toString())});break}default:{stream.emit("error",new Error("Invalid property "+propName));return false}}}}}function byteLength(bufOrString){if(!bufOrString)return 0;else if(bufOrString instanceof Buffer)return bufOrString.length;else return Buffer.byteLength(bufOrString)}function isStringOrBuffer(field){return typeof field==="string"||field instanceof Buffer}module.exports=generate},{"./constants":82,"./numbers":86,"process-nextick-args":91,"safe-buffer":110}],90:[function(require,module,exports){var wrappy=require("wrappy");module.exports=wrappy(once);module.exports.strict=wrappy(onceStrict);once.proto=once(function(){Object.defineProperty(Function.prototype,"once",{value:function(){return once(this)},configurable:true});Object.defineProperty(Function.prototype,"onceStrict",{value:function(){return onceStrict(this)},configurable:true})});function once(fn){var f=function(){if(f.called)return f.value;f.called=true;return f.value=fn.apply(this,arguments)};f.called=false;return f}function onceStrict(fn){var f=function(){if(f.called)throw new Error(f.onceError);f.called=true;return f.value=fn.apply(this,arguments)};var name=fn.name||"Function wrapped with `once`";f.onceError=name+" shouldn't be called more than once";f.called=false;return f}},{wrappy:120}],91:[function(require,module,exports){(function(process){"use strict";if(!process.version||process.version.indexOf("v0.")===0||process.version.indexOf("v1.")===0&&process.version.indexOf("v1.8.")!==0){module.exports={nextTick:nextTick}}else{module.exports=process}function nextTick(fn,arg1,arg2,arg3){if(typeof fn!=="function"){throw new TypeError('"callback" argument must be a function')}var len=arguments.length;var args,i;switch(len){case 0:case 1:return process.nextTick(fn);case 2:return process.nextTick(function afterTickOne(){fn.call(null,arg1)});case 3:return process.nextTick(function afterTickTwo(){fn.call(null,arg1,arg2)});case 4:return process.nextTick(function afterTickThree(){fn.call(null,arg1,arg2,arg3)});default:args=new Array(len-1);i=0;while(i1){for(var i=1;i= 0x80 (not a basic code point)","invalid-input":"Invalid input"},baseMinusTMin=base-tMin,floor=Math.floor,stringFromCharCode=String.fromCharCode,key;function error(type){throw new RangeError(errors[type])}function map(array,fn){var length=array.length;var result=[];while(length--){result[length]=fn(array[length])}return result}function mapDomain(string,fn){var parts=string.split("@");var result="";if(parts.length>1){result=parts[0]+"@";string=parts[1]}string=string.replace(regexSeparators,".");var labels=string.split(".");var encoded=map(labels,fn).join(".");return result+encoded}function ucs2decode(string){var output=[],counter=0,length=string.length,value,extra;while(counter=55296&&value<=56319&&counter65535){value-=65536;output+=stringFromCharCode(value>>>10&1023|55296);value=56320|value&1023}output+=stringFromCharCode(value);return output}).join("")}function basicToDigit(codePoint){if(codePoint-48<10){return codePoint-22}if(codePoint-65<26){return codePoint-65}if(codePoint-97<26){return codePoint-97}return base}function digitToBasic(digit,flag){return digit+22+75*(digit<26)-((flag!=0)<<5)}function adapt(delta,numPoints,firstTime){var k=0;delta=firstTime?floor(delta/damp):delta>>1;delta+=floor(delta/numPoints);for(;delta>baseMinusTMin*tMax>>1;k+=base){delta=floor(delta/baseMinusTMin)}return floor(k+(baseMinusTMin+1)*delta/(delta+skew))}function decode(input){var output=[],inputLength=input.length,out,i=0,n=initialN,bias=initialBias,basic,j,index,oldi,w,k,digit,t,baseMinusT;basic=input.lastIndexOf(delimiter);if(basic<0){basic=0}for(j=0;j=128){error("not-basic")}output.push(input.charCodeAt(j))}for(index=basic>0?basic+1:0;index=inputLength){error("invalid-input")}digit=basicToDigit(input.charCodeAt(index++));if(digit>=base||digit>floor((maxInt-i)/w)){error("overflow")}i+=digit*w;t=k<=bias?tMin:k>=bias+tMax?tMax:k-bias;if(digitfloor(maxInt/baseMinusT)){error("overflow")}w*=baseMinusT}out=output.length+1;bias=adapt(i-oldi,out,oldi==0);if(floor(i/out)>maxInt-n){error("overflow")}n+=floor(i/out);i%=out;output.splice(i++,0,n)}return ucs2encode(output)}function encode(input){var n,delta,handledCPCount,basicLength,bias,j,m,q,k,t,currentValue,output=[],inputLength,handledCPCountPlusOne,baseMinusT,qMinusT;input=ucs2decode(input);inputLength=input.length;n=initialN;delta=0;bias=initialBias;for(j=0;j=n&¤tValuefloor((maxInt-delta)/handledCPCountPlusOne)){error("overflow")}delta+=(m-n)*handledCPCountPlusOne;n=m;for(j=0;jmaxInt){error("overflow")}if(currentValue==n){for(q=delta,k=base;;k+=base){t=k<=bias?tMin:k>=bias+tMax?tMax:k-bias;if(q0&&len>maxKeys){len=maxKeys}for(var i=0;i=0){kstr=x.substr(0,idx);vstr=x.substr(idx+1)}else{kstr=x;vstr=""}k=decodeURIComponent(kstr);v=decodeURIComponent(vstr);if(!hasOwnProperty(obj,k)){obj[k]=v}else if(isArray(obj[k])){obj[k].push(v)}else{obj[k]=[obj[k],v]}}return obj};var isArray=Array.isArray||function(xs){return Object.prototype.toString.call(xs)==="[object Array]"}},{}],95:[function(require,module,exports){"use strict";var stringifyPrimitive=function(v){switch(typeof v){case"string":return v;case"boolean":return v?"true":"false";case"number":return isFinite(v)?v:"";default:return""}};module.exports=function(obj,sep,eq,name){sep=sep||"&";eq=eq||"=";if(obj===null){obj=undefined}if(typeof obj==="object"){return map(objectKeys(obj),function(k){var ks=encodeURIComponent(stringifyPrimitive(k))+eq;if(isArray(obj[k])){return map(obj[k],function(v){return ks+encodeURIComponent(stringifyPrimitive(v))}).join(sep)}else{return ks+encodeURIComponent(stringifyPrimitive(obj[k]))}}).join(sep)}if(!name)return"";return encodeURIComponent(stringifyPrimitive(name))+eq+encodeURIComponent(stringifyPrimitive(obj))};var isArray=Array.isArray||function(xs){return Object.prototype.toString.call(xs)==="[object Array]"};function map(xs,f){if(xs.map)return xs.map(f);var res=[];for(var i=0;i0){if(typeof chunk!=="string"&&!state.objectMode&&Object.getPrototypeOf(chunk)!==Buffer.prototype){chunk=_uint8ArrayToBuffer(chunk)}if(addToFront){if(state.endEmitted)stream.emit("error",new Error("stream.unshift() after end event"));else addChunk(stream,state,chunk,true)}else if(state.ended){stream.emit("error",new Error("stream.push() after EOF"))}else{state.reading=false;if(state.decoder&&!encoding){chunk=state.decoder.write(chunk);if(state.objectMode||chunk.length!==0)addChunk(stream,state,chunk,false);else maybeReadMore(stream,state)}else{addChunk(stream,state,chunk,false)}}}else if(!addToFront){state.reading=false}}return needMoreData(state)}function addChunk(stream,state,chunk,addToFront){if(state.flowing&&state.length===0&&!state.sync){stream.emit("data",chunk);stream.read(0)}else{state.length+=state.objectMode?1:chunk.length;if(addToFront)state.buffer.unshift(chunk);else state.buffer.push(chunk);if(state.needReadable)emitReadable(stream)}maybeReadMore(stream,state)}function chunkInvalid(state,chunk){var er;if(!_isUint8Array(chunk)&&typeof chunk!=="string"&&chunk!==undefined&&!state.objectMode){er=new TypeError("Invalid non-string/buffer chunk")}return er}function needMoreData(state){return!state.ended&&(state.needReadable||state.length=MAX_HWM){n=MAX_HWM}else{n--;n|=n>>>1;n|=n>>>2;n|=n>>>4;n|=n>>>8;n|=n>>>16;n++}return n}function howMuchToRead(n,state){if(n<=0||state.length===0&&state.ended)return 0;if(state.objectMode)return 1;if(n!==n){if(state.flowing&&state.length)return state.buffer.head.data.length;else return state.length}if(n>state.highWaterMark)state.highWaterMark=computeNewHighWaterMark(n);if(n<=state.length)return n;if(!state.ended){state.needReadable=true;return 0}return state.length}Readable.prototype.read=function(n){debug("read",n);n=parseInt(n,10);var state=this._readableState;var nOrig=n;if(n!==0)state.emittedReadable=false;if(n===0&&state.needReadable&&(state.length>=state.highWaterMark||state.ended)){debug("read: emitReadable",state.length,state.ended);if(state.length===0&&state.ended)endReadable(this);else emitReadable(this);return null}n=howMuchToRead(n,state);if(n===0&&state.ended){if(state.length===0)endReadable(this);return null}var doRead=state.needReadable;debug("need readable",doRead);if(state.length===0||state.length-n0)ret=fromList(n,state);else ret=null;if(ret===null){state.needReadable=true;n=0}else{state.length-=n}if(state.length===0){if(!state.ended)state.needReadable=true;if(nOrig!==n&&state.ended)endReadable(this)}if(ret!==null)this.emit("data",ret);return ret};function onEofChunk(stream,state){if(state.ended)return;if(state.decoder){var chunk=state.decoder.end();if(chunk&&chunk.length){state.buffer.push(chunk);state.length+=state.objectMode?1:chunk.length}}state.ended=true;emitReadable(stream)}function emitReadable(stream){var state=stream._readableState;state.needReadable=false;if(!state.emittedReadable){debug("emitReadable",state.flowing);state.emittedReadable=true;if(state.sync)pna.nextTick(emitReadable_,stream);else emitReadable_(stream)}}function emitReadable_(stream){debug("emit readable");stream.emit("readable");flow(stream)}function maybeReadMore(stream,state){if(!state.readingMore){state.readingMore=true;pna.nextTick(maybeReadMore_,stream,state)}}function maybeReadMore_(stream,state){var len=state.length;while(!state.reading&&!state.flowing&&!state.ended&&state.length1&&indexOf(state.pipes,dest)!==-1)&&!cleanedUp){debug("false write response, pause",src._readableState.awaitDrain);src._readableState.awaitDrain++;increasedAwaitDrain=true}src.pause()}}function onerror(er){debug("onerror",er);unpipe();dest.removeListener("error",onerror);if(EElistenerCount(dest,"error")===0)dest.emit("error",er)}prependListener(dest,"error",onerror);function onclose(){dest.removeListener("finish",onfinish);unpipe()}dest.once("close",onclose);function onfinish(){debug("onfinish");dest.removeListener("close",onclose);unpipe()}dest.once("finish",onfinish);function unpipe(){debug("unpipe");src.unpipe(dest)}dest.emit("pipe",src);if(!state.flowing){debug("pipe resume");src.resume()}return dest};function pipeOnDrain(src){return function(){var state=src._readableState;debug("pipeOnDrain",state.awaitDrain);if(state.awaitDrain)state.awaitDrain--;if(state.awaitDrain===0&&EElistenerCount(src,"data")){state.flowing=true;flow(src)}}}Readable.prototype.unpipe=function(dest){var state=this._readableState;var unpipeInfo={hasUnpiped:false};if(state.pipesCount===0)return this;if(state.pipesCount===1){if(dest&&dest!==state.pipes)return this;if(!dest)dest=state.pipes;state.pipes=null;state.pipesCount=0;state.flowing=false;if(dest)dest.emit("unpipe",this,unpipeInfo);return this}if(!dest){var dests=state.pipes;var len=state.pipesCount;state.pipes=null;state.pipesCount=0;state.flowing=false;for(var i=0;i=state.length){if(state.decoder)ret=state.buffer.join("");else if(state.buffer.length===1)ret=state.buffer.head.data;else ret=state.buffer.concat(state.length);state.buffer.clear()}else{ret=fromListPartial(n,state.buffer,state.decoder)}return ret}function fromListPartial(n,list,hasStrings){var ret;if(nstr.length?str.length:n;if(nb===str.length)ret+=str;else ret+=str.slice(0,n);n-=nb;if(n===0){if(nb===str.length){++c;if(p.next)list.head=p.next;else list.head=list.tail=null}else{list.head=p;p.data=str.slice(nb)}break}++c}list.length-=c;return ret}function copyFromBuffer(n,list){var ret=Buffer.allocUnsafe(n);var p=list.head;var c=1;p.data.copy(ret);n-=p.data.length;while(p=p.next){var buf=p.data;var nb=n>buf.length?buf.length:n;buf.copy(ret,ret.length-n,0,nb);n-=nb;if(n===0){if(nb===buf.length){++c;if(p.next)list.head=p.next;else list.head=list.tail=null}else{list.head=p;p.data=buf.slice(nb)}break}++c}list.length-=c;return ret}function endReadable(stream){var state=stream._readableState;if(state.length>0)throw new Error('"endReadable()" called on non-empty stream');if(!state.endEmitted){state.ended=true;pna.nextTick(endReadableNT,state,stream)}}function endReadableNT(state,stream){if(!state.endEmitted&&state.length===0){state.endEmitted=true;stream.readable=false;stream.emit("end")}}function indexOf(xs,x){for(var i=0,l=xs.length;i-1?setImmediate:pna.nextTick;var Duplex;Writable.WritableState=WritableState;var util=require("core-util-is");util.inherits=require("inherits");var internalUtil={deprecate:require("util-deprecate")};var Stream=require("./internal/streams/stream");var Buffer=require("safe-buffer").Buffer;var OurUint8Array=global.Uint8Array||function(){};function _uint8ArrayToBuffer(chunk){return Buffer.from(chunk)}function _isUint8Array(obj){return Buffer.isBuffer(obj)||obj instanceof OurUint8Array}var destroyImpl=require("./internal/streams/destroy");util.inherits(Writable,Stream);function nop(){}function WritableState(options,stream){Duplex=Duplex||require("./_stream_duplex");options=options||{};var isDuplex=stream instanceof Duplex;this.objectMode=!!options.objectMode;if(isDuplex)this.objectMode=this.objectMode||!!options.writableObjectMode;var hwm=options.highWaterMark;var writableHwm=options.writableHighWaterMark;var defaultHwm=this.objectMode?16:16*1024;if(hwm||hwm===0)this.highWaterMark=hwm;else if(isDuplex&&(writableHwm||writableHwm===0))this.highWaterMark=writableHwm;else this.highWaterMark=defaultHwm;this.highWaterMark=Math.floor(this.highWaterMark);this.finalCalled=false;this.needDrain=false;this.ending=false;this.ended=false;this.finished=false;this.destroyed=false;var noDecode=options.decodeStrings===false;this.decodeStrings=!noDecode;this.defaultEncoding=options.defaultEncoding||"utf8";this.length=0;this.writing=false;this.corked=0;this.sync=true;this.bufferProcessing=false;this.onwrite=function(er){onwrite(stream,er)};this.writecb=null;this.writelen=0;this.bufferedRequest=null;this.lastBufferedRequest=null;this.pendingcb=0;this.prefinished=false;this.errorEmitted=false;this.bufferedRequestCount=0;this.corkedRequestsFree=new CorkedRequest(this)}WritableState.prototype.getBuffer=function getBuffer(){var current=this.bufferedRequest;var out=[];while(current){out.push(current);current=current.next}return out};(function(){try{Object.defineProperty(WritableState.prototype,"buffer",{get:internalUtil.deprecate(function(){return this.getBuffer()},"_writableState.buffer is deprecated. Use _writableState.getBuffer "+"instead.","DEP0003")})}catch(_){}})();var realHasInstance;if(typeof Symbol==="function"&&Symbol.hasInstance&&typeof Function.prototype[Symbol.hasInstance]==="function"){realHasInstance=Function.prototype[Symbol.hasInstance];Object.defineProperty(Writable,Symbol.hasInstance,{value:function(object){if(realHasInstance.call(this,object))return true;if(this!==Writable)return false;return object&&object._writableState instanceof WritableState}})}else{realHasInstance=function(object){return object instanceof this}}function Writable(options){Duplex=Duplex||require("./_stream_duplex");if(!realHasInstance.call(Writable,this)&&!(this instanceof Duplex)){return new Writable(options)}this._writableState=new WritableState(options,this);this.writable=true;if(options){if(typeof options.write==="function")this._write=options.write;if(typeof options.writev==="function")this._writev=options.writev;if(typeof options.destroy==="function")this._destroy=options.destroy;if(typeof options.final==="function")this._final=options.final}Stream.call(this)}Writable.prototype.pipe=function(){this.emit("error",new Error("Cannot pipe, not readable"))};function writeAfterEnd(stream,cb){var er=new Error("write after end");stream.emit("error",er);pna.nextTick(cb,er)}function validChunk(stream,state,chunk,cb){var valid=true;var er=false;if(chunk===null){er=new TypeError("May not write null values to stream")}else if(typeof chunk!=="string"&&chunk!==undefined&&!state.objectMode){er=new TypeError("Invalid non-string/buffer chunk")}if(er){stream.emit("error",er);pna.nextTick(cb,er);valid=false}return valid}Writable.prototype.write=function(chunk,encoding,cb){var state=this._writableState;var ret=false;var isBuf=!state.objectMode&&_isUint8Array(chunk);if(isBuf&&!Buffer.isBuffer(chunk)){chunk=_uint8ArrayToBuffer(chunk)}if(typeof encoding==="function"){cb=encoding;encoding=null}if(isBuf)encoding="buffer";else if(!encoding)encoding=state.defaultEncoding;if(typeof cb!=="function")cb=nop;if(state.ended)writeAfterEnd(this,cb);else if(isBuf||validChunk(this,state,chunk,cb)){state.pendingcb++;ret=writeOrBuffer(this,state,isBuf,chunk,encoding,cb)}return ret};Writable.prototype.cork=function(){var state=this._writableState;state.corked++};Writable.prototype.uncork=function(){var state=this._writableState;if(state.corked){state.corked--;if(!state.writing&&!state.corked&&!state.finished&&!state.bufferProcessing&&state.bufferedRequest)clearBuffer(this,state)}};Writable.prototype.setDefaultEncoding=function setDefaultEncoding(encoding){if(typeof encoding==="string")encoding=encoding.toLowerCase();if(!(["hex","utf8","utf-8","ascii","binary","base64","ucs2","ucs-2","utf16le","utf-16le","raw"].indexOf((encoding+"").toLowerCase())>-1))throw new TypeError("Unknown encoding: "+encoding);this._writableState.defaultEncoding=encoding;return this};function decodeChunk(state,chunk,encoding){if(!state.objectMode&&state.decodeStrings!==false&&typeof chunk==="string"){chunk=Buffer.from(chunk,encoding)}return chunk}Object.defineProperty(Writable.prototype,"writableHighWaterMark",{enumerable:false,get:function(){return this._writableState.highWaterMark}});function writeOrBuffer(stream,state,isBuf,chunk,encoding,cb){if(!isBuf){var newChunk=decodeChunk(state,chunk,encoding);if(chunk!==newChunk){isBuf=true;encoding="buffer";chunk=newChunk}}var len=state.objectMode?1:chunk.length;state.length+=len;var ret=state.length0)this.tail.next=entry;else this.head=entry;this.tail=entry;++this.length};BufferList.prototype.unshift=function unshift(v){var entry={data:v,next:this.head};if(this.length===0)this.tail=entry;this.head=entry;++this.length};BufferList.prototype.shift=function shift(){if(this.length===0)return;var ret=this.head.data;if(this.length===1)this.head=this.tail=null;else this.head=this.head.next;--this.length;return ret};BufferList.prototype.clear=function clear(){this.head=this.tail=null;this.length=0};BufferList.prototype.join=function join(s){if(this.length===0)return"";var p=this.head;var ret=""+p.data;while(p=p.next){ret+=s+p.data}return ret};BufferList.prototype.concat=function concat(n){if(this.length===0)return Buffer.alloc(0);if(this.length===1)return this.head.data;var ret=Buffer.allocUnsafe(n>>>0);var p=this.head;var i=0;while(p){copyBuffer(p.data,ret,i);i+=p.data.length;p=p.next}return ret};return BufferList}();if(util&&util.inspect&&util.inspect.custom){module.exports.prototype[util.inspect.custom]=function(){var obj=util.inspect({length:this.length});return this.constructor.name+" "+obj}}},{"safe-buffer":110,util:11}],104:[function(require,module,exports){"use strict";var pna=require("process-nextick-args");function destroy(err,cb){var _this=this;var readableDestroyed=this._readableState&&this._readableState.destroyed;var writableDestroyed=this._writableState&&this._writableState.destroyed;if(readableDestroyed||writableDestroyed){if(cb){cb(err)}else if(err&&(!this._writableState||!this._writableState.errorEmitted)){pna.nextTick(emitErrorNT,this,err)}return this}if(this._readableState){this._readableState.destroyed=true}if(this._writableState){this._writableState.destroyed=true}this._destroy(err||null,function(err){if(!cb&&err){pna.nextTick(emitErrorNT,_this,err);if(_this._writableState){_this._writableState.errorEmitted=true}}else if(cb){cb(err)}});return this}function undestroy(){if(this._readableState){this._readableState.destroyed=false;this._readableState.reading=false;this._readableState.ended=false;this._readableState.endEmitted=false}if(this._writableState){this._writableState.destroyed=false;this._writableState.ended=false;this._writableState.ending=false;this._writableState.finished=false;this._writableState.errorEmitted=false}}function emitErrorNT(self,err){self.emit("error",err)}module.exports={destroy:destroy,undestroy:undestroy}},{"process-nextick-args":91}],105:[function(require,module,exports){module.exports=require("events").EventEmitter},{events:13}],106:[function(require,module,exports){var toString={}.toString;module.exports=Array.isArray||function(arr){return toString.call(arr)=="[object Array]"}},{}],107:[function(require,module,exports){"use strict";var Buffer=require("safe-buffer").Buffer;var isEncoding=Buffer.isEncoding||function(encoding){encoding=""+encoding;switch(encoding&&encoding.toLowerCase()){case"hex":case"utf8":case"utf-8":case"ascii":case"binary":case"base64":case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":case"raw":return true;default:return false}};function _normalizeEncoding(enc){if(!enc)return"utf8";var retried;while(true){switch(enc){case"utf8":case"utf-8":return"utf8";case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return"utf16le";case"latin1":case"binary":return"latin1";case"base64":case"ascii":case"hex":return enc;default:if(retried)return;enc=(""+enc).toLowerCase();retried=true}}}function normalizeEncoding(enc){var nenc=_normalizeEncoding(enc);if(typeof nenc!=="string"&&(Buffer.isEncoding===isEncoding||!isEncoding(enc)))throw new Error("Unknown encoding: "+enc);return nenc||enc}exports.StringDecoder=StringDecoder;function StringDecoder(encoding){this.encoding=normalizeEncoding(encoding);var nb;switch(this.encoding){case"utf16le":this.text=utf16Text;this.end=utf16End;nb=4;break;case"utf8":this.fillLast=utf8FillLast;nb=4;break;case"base64":this.text=base64Text;this.end=base64End;nb=3;break;default:this.write=simpleWrite;this.end=simpleEnd;return}this.lastNeed=0;this.lastTotal=0;this.lastChar=Buffer.allocUnsafe(nb)}StringDecoder.prototype.write=function(buf){if(buf.length===0)return"";var r;var i;if(this.lastNeed){r=this.fillLast(buf);if(r===undefined)return"";i=this.lastNeed;this.lastNeed=0}else{i=0}if(i>5===6)return 2;else if(byte>>4===14)return 3;else if(byte>>3===30)return 4;return byte>>6===2?-1:-2}function utf8CheckIncomplete(self,buf,i){var j=buf.length-1;if(j=0){if(nb>0)self.lastNeed=nb-1;return nb}if(--j=0){if(nb>0)self.lastNeed=nb-2;return nb}if(--j=0){if(nb>0){if(nb===2)nb=0;else self.lastNeed=nb-3}return nb}return 0}function utf8CheckExtraBytes(self,buf,p){if((buf[0]&192)!==128){self.lastNeed=0;return"�"}if(self.lastNeed>1&&buf.length>1){if((buf[1]&192)!==128){self.lastNeed=1;return"�"}if(self.lastNeed>2&&buf.length>2){if((buf[2]&192)!==128){self.lastNeed=2;return"�"}}}}function utf8FillLast(buf){var p=this.lastTotal-this.lastNeed;var r=utf8CheckExtraBytes(this,buf,p);if(r!==undefined)return r;if(this.lastNeed<=buf.length){buf.copy(this.lastChar,p,0,this.lastNeed);return this.lastChar.toString(this.encoding,0,this.lastTotal)}buf.copy(this.lastChar,p,0,buf.length);this.lastNeed-=buf.length}function utf8Text(buf,i){var total=utf8CheckIncomplete(this,buf,i);if(!this.lastNeed)return buf.toString("utf8",i);this.lastTotal=total;var end=buf.length-(total-this.lastNeed);buf.copy(this.lastChar,0,end);return buf.toString("utf8",i,end)}function utf8End(buf){var r=buf&&buf.length?this.write(buf):"";if(this.lastNeed)return r+"�";return r}function utf16Text(buf,i){if((buf.length-i)%2===0){var r=buf.toString("utf16le",i);if(r){var c=r.charCodeAt(r.length-1);if(c>=55296&&c<=56319){this.lastNeed=2;this.lastTotal=4;this.lastChar[0]=buf[buf.length-2];this.lastChar[1]=buf[buf.length-1];return r.slice(0,-1)}}return r}this.lastNeed=1;this.lastTotal=2;this.lastChar[0]=buf[buf.length-1];return buf.toString("utf16le",i,buf.length-1)}function utf16End(buf){var r=buf&&buf.length?this.write(buf):"";if(this.lastNeed){var end=this.lastTotal-this.lastNeed;return r+this.lastChar.toString("utf16le",0,end)}return r}function base64Text(buf,i){var n=(buf.length-i)%3;if(n===0)return buf.toString("base64",i);this.lastNeed=3-n;this.lastTotal=3;if(n===1){this.lastChar[0]=buf[buf.length-1]}else{this.lastChar[0]=buf[buf.length-2];this.lastChar[1]=buf[buf.length-1]}return buf.toString("base64",i,buf.length-n)}function base64End(buf){var r=buf&&buf.length?this.write(buf):"";if(this.lastNeed)return r+this.lastChar.toString("base64",0,3-this.lastNeed);return r}function simpleWrite(buf){return buf.toString(this.encoding)}function simpleEnd(buf){return buf&&buf.length?this.write(buf):""}},{"safe-buffer":110}],108:[function(require,module,exports){exports=module.exports=require("./lib/_stream_readable.js");exports.Stream=exports;exports.Readable=exports;exports.Writable=require("./lib/_stream_writable.js");exports.Duplex=require("./lib/_stream_duplex.js");exports.Transform=require("./lib/_stream_transform.js");exports.PassThrough=require("./lib/_stream_passthrough.js")},{"./lib/_stream_duplex.js":98,"./lib/_stream_passthrough.js":99,"./lib/_stream_readable.js":100,"./lib/_stream_transform.js":101,"./lib/_stream_writable.js":102}],109:[function(require,module,exports){"use strict";function ReInterval(callback,interval,args){var self=this;this._callback=callback;this._args=args;this._interval=setInterval(callback,interval,this._args);this.reschedule=function(interval){if(!interval)interval=self._interval;if(self._interval)clearInterval(self._interval);self._interval=setInterval(self._callback,interval,self._args)};this.clear=function(){if(self._interval){clearInterval(self._interval);self._interval=undefined}};this.destroy=function(){if(self._interval){clearInterval(self._interval)}self._callback=undefined;self._interval=undefined;self._args=undefined}}function reInterval(){if(typeof arguments[0]!=="function")throw new Error("callback needed");if(typeof arguments[1]!=="number")throw new Error("interval needed");var args;if(arguments.length>0){args=new Array(arguments.length-2);for(var i=0;i=0){item._idleTimeoutId=setTimeout(function onTimeout(){if(item._onTimeout)item._onTimeout()},msecs)}};exports.setImmediate=typeof setImmediate==="function"?setImmediate:function(fn){var id=nextImmediateId++;var args=arguments.length<2?false:slice.call(arguments,1);immediateIds[id]=true;nextTick(function onNextTick(){if(immediateIds[id]){if(args){fn.apply(null,args)}else{fn.call(null)}exports.clearImmediate(id)}});return id};exports.clearImmediate=typeof clearImmediate==="function"?clearImmediate:function(id){delete immediateIds[id]}}).call(this,require("timers").setImmediate,require("timers").clearImmediate)},{"process/browser.js":92,timers:112}],113:[function(require,module,exports){"use strict";var punycode=require("punycode");var util=require("./util");exports.parse=urlParse;exports.resolve=urlResolve;exports.resolveObject=urlResolveObject;exports.format=urlFormat;exports.Url=Url;function Url(){this.protocol=null;this.slashes=null;this.auth=null;this.host=null;this.port=null;this.hostname=null;this.hash=null;this.search=null;this.query=null;this.pathname=null;this.path=null;this.href=null}var protocolPattern=/^([a-z0-9.+-]+:)/i,portPattern=/:[0-9]*$/,simplePathPattern=/^(\/\/?(?!\/)[^\?\s]*)(\?[^\s]*)?$/,delims=["<",">",'"',"`"," ","\r","\n","\t"],unwise=["{","}","|","\\","^","`"].concat(delims),autoEscape=["'"].concat(unwise),nonHostChars=["%","/","?",";","#"].concat(autoEscape),hostEndingChars=["/","?","#"],hostnameMaxLen=255,hostnamePartPattern=/^[+a-z0-9A-Z_-]{0,63}$/,hostnamePartStart=/^([+a-z0-9A-Z_-]{0,63})(.*)$/,unsafeProtocol={javascript:true,"javascript:":true},hostlessProtocol={javascript:true,"javascript:":true},slashedProtocol={http:true,https:true,ftp:true,gopher:true,file:true,"http:":true,"https:":true,"ftp:":true,"gopher:":true,"file:":true},querystring=require("querystring");function urlParse(url,parseQueryString,slashesDenoteHost){if(url&&util.isObject(url)&&url instanceof Url)return url;var u=new Url;u.parse(url,parseQueryString,slashesDenoteHost);return u}Url.prototype.parse=function(url,parseQueryString,slashesDenoteHost){if(!util.isString(url)){throw new TypeError("Parameter 'url' must be a string, not "+typeof url)}var queryIndex=url.indexOf("?"),splitter=queryIndex!==-1&&queryIndex127){newpart+="x"}else{newpart+=part[j]}}if(!newpart.match(hostnamePartPattern)){var validParts=hostparts.slice(0,i);var notHost=hostparts.slice(i+1);var bit=part.match(hostnamePartStart);if(bit){validParts.push(bit[1]);notHost.unshift(bit[2])}if(notHost.length){rest="/"+notHost.join(".")+rest}this.hostname=validParts.join(".");break}}}}if(this.hostname.length>hostnameMaxLen){this.hostname=""}else{this.hostname=this.hostname.toLowerCase()}if(!ipv6Hostname){this.hostname=punycode.toASCII(this.hostname)}var p=this.port?":"+this.port:"";var h=this.hostname||"";this.host=h+p;this.href+=this.host;if(ipv6Hostname){this.hostname=this.hostname.substr(1,this.hostname.length-2);if(rest[0]!=="/"){rest="/"+rest}}}if(!unsafeProtocol[lowerProto]){for(var i=0,l=autoEscape.length;i0?result.host.split("@"):false;if(authInHost){result.auth=authInHost.shift();result.host=result.hostname=authInHost.shift()}}result.search=relative.search;result.query=relative.query;if(!util.isNull(result.pathname)||!util.isNull(result.search)){result.path=(result.pathname?result.pathname:"")+(result.search?result.search:"")}result.href=result.format();return result}if(!srcPath.length){result.pathname=null;if(result.search){result.path="/"+result.search}else{result.path=null}result.href=result.format();return result}var last=srcPath.slice(-1)[0];var hasTrailingSlash=(result.host||relative.host||srcPath.length>1)&&(last==="."||last==="..")||last==="";var up=0;for(var i=srcPath.length;i>=0;i--){last=srcPath[i];if(last==="."){srcPath.splice(i,1)}else if(last===".."){srcPath.splice(i,1);up++}else if(up){srcPath.splice(i,1);up--}}if(!mustEndAbs&&!removeAllDots){for(;up--;up){srcPath.unshift("..")}}if(mustEndAbs&&srcPath[0]!==""&&(!srcPath[0]||srcPath[0].charAt(0)!=="/")){srcPath.unshift("")}if(hasTrailingSlash&&srcPath.join("/").substr(-1)!=="/"){srcPath.push("")}var isAbsolute=srcPath[0]===""||srcPath[0]&&srcPath[0].charAt(0)==="/";if(psychotic){result.hostname=result.host=isAbsolute?"":srcPath.length?srcPath.shift():"";var authInHost=result.host&&result.host.indexOf("@")>0?result.host.split("@"):false;if(authInHost){result.auth=authInHost.shift();result.host=result.hostname=authInHost.shift()}}mustEndAbs=mustEndAbs||result.host&&srcPath.length;if(mustEndAbs&&!isAbsolute){srcPath.unshift("")}if(!srcPath.length){result.pathname=null;result.path=null}else{result.pathname=srcPath.join("/")}if(!util.isNull(result.pathname)||!util.isNull(result.search)){result.path=(result.pathname?result.pathname:"")+(result.search?result.search:"")}result.auth=relative.auth||result.auth;result.slashes=result.slashes||relative.slashes;result.href=result.format();return result};Url.prototype.parseHost=function(){var host=this.host;var port=portPattern.exec(host);if(port){port=port[0];if(port!==":"){this.port=port.substr(1)}host=host.substr(0,host.length-port.length)}if(host)this.hostname=host}},{"./util":114,punycode:93,querystring:96}],114:[function(require,module,exports){"use strict";module.exports={isString:function(arg){return typeof arg==="string"},isObject:function(arg){return typeof arg==="object"&&arg!==null},isNull:function(arg){return arg===null},isNullOrUndefined:function(arg){return arg==null}}},{}],115:[function(require,module,exports){(function(global){module.exports=deprecate;function deprecate(fn,msg){if(config("noDeprecation")){return fn}var warned=false;function deprecated(){if(!warned){if(config("throwDeprecation")){throw new Error(msg)}else if(config("traceDeprecation")){console.trace(msg)}else{console.warn(msg)}warned=true}return fn.apply(this,arguments)}return deprecated}function config(name){try{if(!global.localStorage)return false}catch(_){return false}var val=global.localStorage[name];if(null==val)return false;return String(val).toLowerCase()==="true"}}).call(this,typeof global!=="undefined"?global:typeof self!=="undefined"?self:typeof window!=="undefined"?window:{})},{}],116:[function(require,module,exports){module.exports=function isBuffer(arg){return arg&&typeof arg==="object"&&typeof arg.copy==="function"&&typeof arg.fill==="function"&&typeof arg.readUInt8==="function"}},{}],117:[function(require,module,exports){(function(process,global){var formatRegExp=/%[sdj%]/g;exports.format=function(f){if(!isString(f)){var objects=[];for(var i=0;i=len)return x;switch(x){case"%s":return String(args[i++]);case"%d":return Number(args[i++]);case"%j":try{return JSON.stringify(args[i++])}catch(_){return"[Circular]"}default:return x}});for(var x=args[i];i=3)ctx.depth=arguments[2];if(arguments.length>=4)ctx.colors=arguments[3];if(isBoolean(opts)){ctx.showHidden=opts}else if(opts){exports._extend(ctx,opts)}if(isUndefined(ctx.showHidden))ctx.showHidden=false;if(isUndefined(ctx.depth))ctx.depth=2;if(isUndefined(ctx.colors))ctx.colors=false;if(isUndefined(ctx.customInspect))ctx.customInspect=true;if(ctx.colors)ctx.stylize=stylizeWithColor;return formatValue(ctx,obj,ctx.depth)}exports.inspect=inspect;inspect.colors={bold:[1,22],italic:[3,23],underline:[4,24],inverse:[7,27],white:[37,39],grey:[90,39],black:[30,39],blue:[34,39],cyan:[36,39],green:[32,39],magenta:[35,39],red:[31,39],yellow:[33,39]};inspect.styles={special:"cyan",number:"yellow",boolean:"yellow",undefined:"grey",null:"bold",string:"green",date:"magenta",regexp:"red"};function stylizeWithColor(str,styleType){var style=inspect.styles[styleType];if(style){return"["+inspect.colors[style][0]+"m"+str+"["+inspect.colors[style][1]+"m"}else{return str}}function stylizeNoColor(str,styleType){return str}function arrayToHash(array){var hash={};array.forEach(function(val,idx){hash[val]=true});return hash}function formatValue(ctx,value,recurseTimes){if(ctx.customInspect&&value&&isFunction(value.inspect)&&value.inspect!==exports.inspect&&!(value.constructor&&value.constructor.prototype===value)){var ret=value.inspect(recurseTimes,ctx);if(!isString(ret)){ret=formatValue(ctx,ret,recurseTimes)}return ret}var primitive=formatPrimitive(ctx,value);if(primitive){return primitive}var keys=Object.keys(value);var visibleKeys=arrayToHash(keys);if(ctx.showHidden){keys=Object.getOwnPropertyNames(value)}if(isError(value)&&(keys.indexOf("message")>=0||keys.indexOf("description")>=0)){return formatError(value)}if(keys.length===0){if(isFunction(value)){var name=value.name?": "+value.name:"";return ctx.stylize("[Function"+name+"]","special")}if(isRegExp(value)){return ctx.stylize(RegExp.prototype.toString.call(value),"regexp")}if(isDate(value)){return ctx.stylize(Date.prototype.toString.call(value),"date")}if(isError(value)){return formatError(value)}}var base="",array=false,braces=["{","}"];if(isArray(value)){array=true;braces=["[","]"]}if(isFunction(value)){var n=value.name?": "+value.name:"";base=" [Function"+n+"]"}if(isRegExp(value)){base=" "+RegExp.prototype.toString.call(value)}if(isDate(value)){base=" "+Date.prototype.toUTCString.call(value)}if(isError(value)){base=" "+formatError(value)}if(keys.length===0&&(!array||value.length==0)){return braces[0]+base+braces[1]}if(recurseTimes<0){if(isRegExp(value)){return ctx.stylize(RegExp.prototype.toString.call(value),"regexp")}else{return ctx.stylize("[Object]","special")}}ctx.seen.push(value);var output;if(array){output=formatArray(ctx,value,recurseTimes,visibleKeys,keys)}else{output=keys.map(function(key){return formatProperty(ctx,value,recurseTimes,visibleKeys,key,array)})}ctx.seen.pop();return reduceToSingleString(output,base,braces)}function formatPrimitive(ctx,value){if(isUndefined(value))return ctx.stylize("undefined","undefined");if(isString(value)){var simple="'"+JSON.stringify(value).replace(/^"|"$/g,"").replace(/'/g,"\\'").replace(/\\"/g,'"')+"'";return ctx.stylize(simple,"string")}if(isNumber(value))return ctx.stylize(""+value,"number");if(isBoolean(value))return ctx.stylize(""+value,"boolean");if(isNull(value))return ctx.stylize("null","null")}function formatError(value){return"["+Error.prototype.toString.call(value)+"]"}function formatArray(ctx,value,recurseTimes,visibleKeys,keys){var output=[];for(var i=0,l=value.length;i-1){if(array){str=str.split("\n").map(function(line){return" "+line}).join("\n").substr(2)}else{str="\n"+str.split("\n").map(function(line){return" "+line}).join("\n")}}}else{str=ctx.stylize("[Circular]","special")}}if(isUndefined(name)){if(array&&key.match(/^\d+$/)){return str}name=JSON.stringify(""+key);if(name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)){name=name.substr(1,name.length-2);name=ctx.stylize(name,"name")}else{name=name.replace(/'/g,"\\'").replace(/\\"/g,'"').replace(/(^"|"$)/g,"'");name=ctx.stylize(name,"string")}}return name+": "+str}function reduceToSingleString(output,base,braces){var numLinesEst=0;var length=output.reduce(function(prev,cur){numLinesEst++;if(cur.indexOf("\n")>=0)numLinesEst++;return prev+cur.replace(/\u001b\[\d\d?m/g,"").length+1},0);if(length>60){return braces[0]+(base===""?"":base+"\n ")+" "+output.join(",\n ")+" "+braces[1]}return braces[0]+base+" "+output.join(", ")+" "+braces[1]}function isArray(ar){return Array.isArray(ar)}exports.isArray=isArray;function isBoolean(arg){return typeof arg==="boolean"}exports.isBoolean=isBoolean;function isNull(arg){return arg===null}exports.isNull=isNull;function isNullOrUndefined(arg){return arg==null}exports.isNullOrUndefined=isNullOrUndefined;function isNumber(arg){return typeof arg==="number"}exports.isNumber=isNumber;function isString(arg){return typeof arg==="string"}exports.isString=isString;function isSymbol(arg){return typeof arg==="symbol"}exports.isSymbol=isSymbol;function isUndefined(arg){return arg===void 0}exports.isUndefined=isUndefined;function isRegExp(re){return isObject(re)&&objectToString(re)==="[object RegExp]"}exports.isRegExp=isRegExp;function isObject(arg){return typeof arg==="object"&&arg!==null}exports.isObject=isObject;function isDate(d){return isObject(d)&&objectToString(d)==="[object Date]"}exports.isDate=isDate;function isError(e){return isObject(e)&&(objectToString(e)==="[object Error]"||e instanceof Error)}exports.isError=isError;function isFunction(arg){return typeof arg==="function"}exports.isFunction=isFunction;function isPrimitive(arg){return arg===null||typeof arg==="boolean"||typeof arg==="number"||typeof arg==="string"||typeof arg==="symbol"||typeof arg==="undefined"}exports.isPrimitive=isPrimitive;exports.isBuffer=require("./support/isBuffer");function objectToString(o){return Object.prototype.toString.call(o)}function pad(n){return n<10?"0"+n.toString(10):n.toString(10)}var months=["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"];function timestamp(){var d=new Date;var time=[pad(d.getHours()),pad(d.getMinutes()),pad(d.getSeconds())].join(":");return[d.getDate(),months[d.getMonth()],time].join(" ")}exports.log=function(){console.log("%s - %s",timestamp(),exports.format.apply(exports,arguments))};exports.inherits=require("inherits");exports._extend=function(origin,add){if(!add||!isObject(add))return origin;var keys=Object.keys(add);var i=keys.length;while(i--){origin[keys[i]]=add[keys[i]]}return origin};function hasOwnProperty(obj,prop){return Object.prototype.hasOwnProperty.call(obj,prop)}}).call(this,require("_process"),typeof global!=="undefined"?global:typeof self!=="undefined"?self:typeof window!=="undefined"?window:{})},{"./support/isBuffer":116,_process:92,inherits:80}],118:[function(require,module,exports){(function(process,global){"use strict";var Transform=require("readable-stream").Transform;var duplexify=require("duplexify");var WS=require("ws");var Buffer=require("safe-buffer").Buffer;module.exports=WebSocketStream;function buildProxy(options,socketWrite,socketEnd){var proxy=new Transform({objectMode:options.objectMode});proxy._write=socketWrite;proxy._flush=socketEnd;return proxy}function WebSocketStream(target,protocols,options){var stream,socket;var isBrowser=process.title==="browser";var isNative=!!global.WebSocket;var socketWrite=isBrowser?socketWriteBrowser:socketWriteNode;if(protocols&&!Array.isArray(protocols)&&"object"===typeof protocols){options=protocols;protocols=null;if(typeof options.protocol==="string"||Array.isArray(options.protocol)){protocols=options.protocol}}if(!options)options={};if(options.objectMode===undefined){options.objectMode=!(options.binary===true||options.binary===undefined)}var proxy=buildProxy(options,socketWrite,socketEnd);if(!options.objectMode){proxy._writev=writev}var bufferSize=options.browserBufferSize||1024*512;var bufferTimeout=options.browserBufferTimeout||1e3;if(typeof target==="object"){socket=target}else{if(isNative&&isBrowser){socket=new WS(target,protocols)}else{socket=new WS(target,protocols,options)}socket.binaryType="arraybuffer"}if(socket.readyState===socket.OPEN){stream=proxy}else{stream=duplexify.obj();socket.onopen=onopen}stream.socket=socket;socket.onclose=onclose;socket.onerror=onerror;socket.onmessage=onmessage;proxy.on("close",destroy);var coerceToBuffer=!options.objectMode;function socketWriteNode(chunk,enc,next){if(socket.readyState!==socket.OPEN){next();return}if(coerceToBuffer&&typeof chunk==="string"){chunk=Buffer.from(chunk,"utf8")}socket.send(chunk,next)}function socketWriteBrowser(chunk,enc,next){if(socket.bufferedAmount>bufferSize){setTimeout(socketWriteBrowser,bufferTimeout,chunk,enc,next);return}if(coerceToBuffer&&typeof chunk==="string"){chunk=Buffer.from(chunk,"utf8")}try{socket.send(chunk)}catch(err){return next(err)}next()}function socketEnd(done){socket.close();done()}function onopen(){stream.setReadable(proxy);stream.setWritable(proxy);stream.emit("connect")}function onclose(){stream.end();stream.destroy()}function onerror(err){stream.destroy(err)}function onmessage(event){var data=event.data;if(data instanceof ArrayBuffer)data=Buffer.from(data);else data=Buffer.from(data,"utf8");proxy.push(data)}function destroy(){socket.close()}function writev(chunks,cb){var buffers=new Array(chunks.length);for(var i=0;i> 6),
+ 0x80 | (charcode & 0x3f));
+ }
+ else if (charcode < 0xd800 || charcode >= 0xe000) {
+ utf8.push(0xe0 | (charcode >> 12),
+ 0x80 | ((charcode >> 6) & 0x3f),
+ 0x80 | (charcode & 0x3f));
+ }
+ // surrogate pair
+ else {
+ i++;
+ // UTF-16 encodes 0x10000-0x10FFFF by
+ // subtracting 0x10000 and splitting the
+ // 20 bits of 0x0-0xFFFFF into two halves
+ charcode = 0x10000 + (((charcode & 0x3ff) << 10)
+ | (str.charCodeAt(i) & 0x3ff));
+ utf8.push(0xf0 | (charcode >> 18),
+ 0x80 | ((charcode >> 12) & 0x3f),
+ 0x80 | ((charcode >> 6) & 0x3f),
+ 0x80 | (charcode & 0x3f));
+ }
+ }
+ return utf8;
+}
+
+//字符串转GBK十六进制内码
+export function strToGBKHex(str) {
+ var ch, pos, val, ret = "", strSpecial = "!\"#$%&'()*+,/:;<=>?@[\]^`{|}~%";
+ console.log('GBK123');
+ for (var i = 0; i < str.length; i++) {
+ ch = str.charAt(i);
+ val = str.charCodeAt(i);
+ if (val >= 0x4e00 && val < 0x9FA5){
+ if ((pos = GBhz.indexOf(ch)) != -1)
+ ret += ("%" + (0xB0 + parseInt(pos / 94)).toString(16) + "%" + (0xA1 + pos % 94).toString(16)).toUpperCase();
+ }
+ else if ((pos = GBfh.indexOf(ch)) != -1){
+ console.log('GBfh'+ch)
+ ret += ("%" + (0xA1 + parseInt(pos / 94)).toString(16) + "%" + (0xA1 + pos % 94).toString(16)).toUpperCase();
+ }
+ else if ((pos = GBK_A940.indexOf(ch)) != -1){
+ console.log(pos)
+ ret += ("%" + (0xA9).toString(16) + "%" + (0x40 + pos).toString(16)).toUpperCase();
+ }
+ else if (strSpecial.indexOf(ch) != -1) {
+ // ret += "%" + val.toString(16);
+ ret += val.toString(16);
+ }
+ else if (ch == " ") {
+ // ret += "+";
+ ret += "20";
+ }
+ else {
+ //
+ ret += strToHexCharCode(ch);
+ }
+
+ }
+ return ret;
+}
+
+export function stringToByte(str) {
+ var bytes = new Array();
+ var len, c;
+ len = str.length;
+ for (var i = 0; i < len; i++) {
+ c = str.charCodeAt(i);
+ console.log('c', c)
+ if (c >= 0x010000 && c <= 0x10FFFF) {
+ bytes.push(((c >> 18) & 0x07) | 0xF0);
+ bytes.push(((c >> 12) & 0x3F) | 0x80);
+ bytes.push(((c >> 6) & 0x3F) | 0x80);
+ bytes.push((c & 0x3F) | 0x80);
+ } else if (c >= 0x000800 && c <= 0x00FFFF) {
+ bytes.push(((c >> 12) & 0x0F) | 0xE0);
+ bytes.push(((c >> 6) & 0x3F) | 0x80);
+ bytes.push((c & 0x3F) | 0x80);
+ } else if (c >= 0x000080 && c <= 0x0007FF) {
+ bytes.push(((c >> 6) & 0x1F) | 0xC0);
+ bytes.push((c & 0x3F) | 0x80);
+ } else {
+ bytes.push(c & 0xFF);
+ }
+ }
+ return bytes;
+}
+
+export function strToGBKByte(str) {
+ var bytes = new Array();
+ /*********改自qiushuiwuhen(2002-9-16)********/
+ var ch, pos, val, strSpecial = "!\"#$%&'()*+,/:;<=>?@[\]^`{|}~%";
+ for (var i = 0; i < str.length; i++) {
+ ch = str.charAt(i);
+ val = str.charCodeAt(i);
+ //console.log(ch, val)
+ if (val >= 0x4e00 && val < 0x9FA5) {
+ if ((pos = GBhz.indexOf(ch)) != -1){ bytes.push(0xB0 + parseInt(pos / 94)); bytes.push(0xA1 + pos % 94);}
+ }
+ else if ((pos = GBfh.indexOf(ch)) != -1){
+ bytes.push(0xA1 + parseInt(pos / 94)); bytes.push(0xA1 + pos % 94);
+ }
+ else if((pos = GBK_A940.indexOf(ch)) != -1){
+ bytes.push(0xA9); bytes.push(0x40+pos);
+ }
+ else if (strSpecial.indexOf(ch) != -1) {
+ bytes.push(val);
+ }
+ else if (ch == " ") {
+ bytes.push(0x20);
+ }
+ else {
+ bytes.push(val);
+ }
+ }
+
+ const buffer = new Uint8Array(bytes).buffer;;
+ return buffer;
+}
+
+/**
+ * utf8 byte to unicode string
+ * @param utf8Bytes
+ * @returns {string}
+ */
+export function utf8ByteToUnicodeStr(utf8Bytes) {
+ var unicodeStr = "";
+ for (var pos = 0; pos < utf8Bytes.length;) {
+ // var flag = utf8Bytes[pos];
+ var flag = utf8Bytes.charCodeAt(pos);
+ var unicode = 0;
+ if ((flag >>> 7) === 0) {
+ unicodeStr += String.fromCharCode(utf8Bytes[pos]);
+ pos += 1;
+
+ } else if ((flag & 0xFC) === 0xFC) {
+ unicode = (utf8Bytes[pos] & 0x3) << 30;
+ unicode |= (utf8Bytes[pos + 1] & 0x3F) << 24;
+ unicode |= (utf8Bytes[pos + 2] & 0x3F) << 18;
+ unicode |= (utf8Bytes[pos + 3] & 0x3F) << 12;
+ unicode |= (utf8Bytes[pos + 4] & 0x3F) << 6;
+ unicode |= (utf8Bytes[pos + 5] & 0x3F);
+ unicodeStr += String.fromCharCode(unicode);
+ pos += 6;
+
+ } else if ((flag & 0xF8) === 0xF8) {
+ unicode = (utf8Bytes[pos] & 0x7) << 24;
+ unicode |= (utf8Bytes[pos + 1] & 0x3F) << 18;
+ unicode |= (utf8Bytes[pos + 2] & 0x3F) << 12;
+ unicode |= (utf8Bytes[pos + 3] & 0x3F) << 6;
+ unicode |= (utf8Bytes[pos + 4] & 0x3F);
+ unicodeStr += String.fromCharCode(unicode);
+ pos += 5;
+
+ } else if ((flag & 0xF0) === 0xF0) {
+ unicode = (utf8Bytes[pos] & 0xF) << 18;
+ unicode |= (utf8Bytes[pos + 1] & 0x3F) << 12;
+ unicode |= (utf8Bytes[pos + 2] & 0x3F) << 6;
+ unicode |= (utf8Bytes[pos + 3] & 0x3F);
+ unicodeStr += String.fromCharCode(unicode);
+ pos += 4;
+
+ } else if ((flag & 0xE0) === 0xE0) {
+ unicode = (utf8Bytes[pos] & 0x1F) << 12;;
+ unicode |= (utf8Bytes[pos + 1] & 0x3F) << 6;
+ unicode |= (utf8Bytes[pos + 2] & 0x3F);
+ unicodeStr += String.fromCharCode(unicode);
+ pos += 3;
+
+ } else if ((flag & 0xC0) === 0xC0) { //110
+ unicode = (utf8Bytes[pos] & 0x3F) << 6;
+ unicode |= (utf8Bytes[pos + 1] & 0x3F);
+ unicodeStr += String.fromCharCode(unicode);
+ pos += 2;
+
+ } else {
+ unicodeStr += String.fromCharCode(utf8Bytes[pos]);
+ pos += 1;
+ }
+ }
+ return unicodeStr;
+}
\ No newline at end of file
diff --git a/src/components/kk-printer/utils/qrcode.js b/src/components/kk-printer/utils/qrcode.js
new file mode 100644
index 00000000..e4c994eb
--- /dev/null
+++ b/src/components/kk-printer/utils/qrcode.js
@@ -0,0 +1,778 @@
+var QR = (function () {
+
+ // alignment pattern
+ var adelta = [
+ 0, 11, 15, 19, 23, 27, 31, // force 1 pat
+ 16, 18, 20, 22, 24, 26, 28, 20, 22, 24, 24, 26, 28, 28, 22, 24, 24,
+ 26, 26, 28, 28, 24, 24, 26, 26, 26, 28, 28, 24, 26, 26, 26, 28, 28
+ ];
+
+ // version block
+ var vpat = [
+ 0xc94, 0x5bc, 0xa99, 0x4d3, 0xbf6, 0x762, 0x847, 0x60d,
+ 0x928, 0xb78, 0x45d, 0xa17, 0x532, 0x9a6, 0x683, 0x8c9,
+ 0x7ec, 0xec4, 0x1e1, 0xfab, 0x08e, 0xc1a, 0x33f, 0xd75,
+ 0x250, 0x9d5, 0x6f0, 0x8ba, 0x79f, 0xb0b, 0x42e, 0xa64,
+ 0x541, 0xc69
+ ];
+
+ // final format bits with mask: level << 3 | mask
+ var fmtword = [
+ 0x77c4, 0x72f3, 0x7daa, 0x789d, 0x662f, 0x6318, 0x6c41, 0x6976, //L
+ 0x5412, 0x5125, 0x5e7c, 0x5b4b, 0x45f9, 0x40ce, 0x4f97, 0x4aa0, //M
+ 0x355f, 0x3068, 0x3f31, 0x3a06, 0x24b4, 0x2183, 0x2eda, 0x2bed, //Q
+ 0x1689, 0x13be, 0x1ce7, 0x19d0, 0x0762, 0x0255, 0x0d0c, 0x083b //H
+ ];
+
+ // 4 per version: number of blocks 1,2; data width; ecc width
+ var eccblocks = [
+ 1, 0, 19, 7, 1, 0, 16, 10, 1, 0, 13, 13, 1, 0, 9, 17,
+ 1, 0, 34, 10, 1, 0, 28, 16, 1, 0, 22, 22, 1, 0, 16, 28,
+ 1, 0, 55, 15, 1, 0, 44, 26, 2, 0, 17, 18, 2, 0, 13, 22,
+ 1, 0, 80, 20, 2, 0, 32, 18, 2, 0, 24, 26, 4, 0, 9, 16,
+ 1, 0, 108, 26, 2, 0, 43, 24, 2, 2, 15, 18, 2, 2, 11, 22,
+ 2, 0, 68, 18, 4, 0, 27, 16, 4, 0, 19, 24, 4, 0, 15, 28,
+ 2, 0, 78, 20, 4, 0, 31, 18, 2, 4, 14, 18, 4, 1, 13, 26,
+ 2, 0, 97, 24, 2, 2, 38, 22, 4, 2, 18, 22, 4, 2, 14, 26,
+ 2, 0, 116, 30, 3, 2, 36, 22, 4, 4, 16, 20, 4, 4, 12, 24,
+ 2, 2, 68, 18, 4, 1, 43, 26, 6, 2, 19, 24, 6, 2, 15, 28,
+ 4, 0, 81, 20, 1, 4, 50, 30, 4, 4, 22, 28, 3, 8, 12, 24,
+ 2, 2, 92, 24, 6, 2, 36, 22, 4, 6, 20, 26, 7, 4, 14, 28,
+ 4, 0, 107, 26, 8, 1, 37, 22, 8, 4, 20, 24, 12, 4, 11, 22,
+ 3, 1, 115, 30, 4, 5, 40, 24, 11, 5, 16, 20, 11, 5, 12, 24,
+ 5, 1, 87, 22, 5, 5, 41, 24, 5, 7, 24, 30, 11, 7, 12, 24,
+ 5, 1, 98, 24, 7, 3, 45, 28, 15, 2, 19, 24, 3, 13, 15, 30,
+ 1, 5, 107, 28, 10, 1, 46, 28, 1, 15, 22, 28, 2, 17, 14, 28,
+ 5, 1, 120, 30, 9, 4, 43, 26, 17, 1, 22, 28, 2, 19, 14, 28,
+ 3, 4, 113, 28, 3, 11, 44, 26, 17, 4, 21, 26, 9, 16, 13, 26,
+ 3, 5, 107, 28, 3, 13, 41, 26, 15, 5, 24, 30, 15, 10, 15, 28,
+ 4, 4, 116, 28, 17, 0, 42, 26, 17, 6, 22, 28, 19, 6, 16, 30,
+ 2, 7, 111, 28, 17, 0, 46, 28, 7, 16, 24, 30, 34, 0, 13, 24,
+ 4, 5, 121, 30, 4, 14, 47, 28, 11, 14, 24, 30, 16, 14, 15, 30,
+ 6, 4, 117, 30, 6, 14, 45, 28, 11, 16, 24, 30, 30, 2, 16, 30,
+ 8, 4, 106, 26, 8, 13, 47, 28, 7, 22, 24, 30, 22, 13, 15, 30,
+ 10, 2, 114, 28, 19, 4, 46, 28, 28, 6, 22, 28, 33, 4, 16, 30,
+ 8, 4, 122, 30, 22, 3, 45, 28, 8, 26, 23, 30, 12, 28, 15, 30,
+ 3, 10, 117, 30, 3, 23, 45, 28, 4, 31, 24, 30, 11, 31, 15, 30,
+ 7, 7, 116, 30, 21, 7, 45, 28, 1, 37, 23, 30, 19, 26, 15, 30,
+ 5, 10, 115, 30, 19, 10, 47, 28, 15, 25, 24, 30, 23, 25, 15, 30,
+ 13, 3, 115, 30, 2, 29, 46, 28, 42, 1, 24, 30, 23, 28, 15, 30,
+ 17, 0, 115, 30, 10, 23, 46, 28, 10, 35, 24, 30, 19, 35, 15, 30,
+ 17, 1, 115, 30, 14, 21, 46, 28, 29, 19, 24, 30, 11, 46, 15, 30,
+ 13, 6, 115, 30, 14, 23, 46, 28, 44, 7, 24, 30, 59, 1, 16, 30,
+ 12, 7, 121, 30, 12, 26, 47, 28, 39, 14, 24, 30, 22, 41, 15, 30,
+ 6, 14, 121, 30, 6, 34, 47, 28, 46, 10, 24, 30, 2, 64, 15, 30,
+ 17, 4, 122, 30, 29, 14, 46, 28, 49, 10, 24, 30, 24, 46, 15, 30,
+ 4, 18, 122, 30, 13, 32, 46, 28, 48, 14, 24, 30, 42, 32, 15, 30,
+ 20, 4, 117, 30, 40, 7, 47, 28, 43, 22, 24, 30, 10, 67, 15, 30,
+ 19, 6, 118, 30, 18, 31, 47, 28, 34, 34, 24, 30, 20, 61, 15, 30
+ ];
+
+ // Galois field log table
+ var glog = [
+ 0xff, 0x00, 0x01, 0x19, 0x02, 0x32, 0x1a, 0xc6, 0x03, 0xdf, 0x33, 0xee, 0x1b, 0x68, 0xc7, 0x4b,
+ 0x04, 0x64, 0xe0, 0x0e, 0x34, 0x8d, 0xef, 0x81, 0x1c, 0xc1, 0x69, 0xf8, 0xc8, 0x08, 0x4c, 0x71,
+ 0x05, 0x8a, 0x65, 0x2f, 0xe1, 0x24, 0x0f, 0x21, 0x35, 0x93, 0x8e, 0xda, 0xf0, 0x12, 0x82, 0x45,
+ 0x1d, 0xb5, 0xc2, 0x7d, 0x6a, 0x27, 0xf9, 0xb9, 0xc9, 0x9a, 0x09, 0x78, 0x4d, 0xe4, 0x72, 0xa6,
+ 0x06, 0xbf, 0x8b, 0x62, 0x66, 0xdd, 0x30, 0xfd, 0xe2, 0x98, 0x25, 0xb3, 0x10, 0x91, 0x22, 0x88,
+ 0x36, 0xd0, 0x94, 0xce, 0x8f, 0x96, 0xdb, 0xbd, 0xf1, 0xd2, 0x13, 0x5c, 0x83, 0x38, 0x46, 0x40,
+ 0x1e, 0x42, 0xb6, 0xa3, 0xc3, 0x48, 0x7e, 0x6e, 0x6b, 0x3a, 0x28, 0x54, 0xfa, 0x85, 0xba, 0x3d,
+ 0xca, 0x5e, 0x9b, 0x9f, 0x0a, 0x15, 0x79, 0x2b, 0x4e, 0xd4, 0xe5, 0xac, 0x73, 0xf3, 0xa7, 0x57,
+ 0x07, 0x70, 0xc0, 0xf7, 0x8c, 0x80, 0x63, 0x0d, 0x67, 0x4a, 0xde, 0xed, 0x31, 0xc5, 0xfe, 0x18,
+ 0xe3, 0xa5, 0x99, 0x77, 0x26, 0xb8, 0xb4, 0x7c, 0x11, 0x44, 0x92, 0xd9, 0x23, 0x20, 0x89, 0x2e,
+ 0x37, 0x3f, 0xd1, 0x5b, 0x95, 0xbc, 0xcf, 0xcd, 0x90, 0x87, 0x97, 0xb2, 0xdc, 0xfc, 0xbe, 0x61,
+ 0xf2, 0x56, 0xd3, 0xab, 0x14, 0x2a, 0x5d, 0x9e, 0x84, 0x3c, 0x39, 0x53, 0x47, 0x6d, 0x41, 0xa2,
+ 0x1f, 0x2d, 0x43, 0xd8, 0xb7, 0x7b, 0xa4, 0x76, 0xc4, 0x17, 0x49, 0xec, 0x7f, 0x0c, 0x6f, 0xf6,
+ 0x6c, 0xa1, 0x3b, 0x52, 0x29, 0x9d, 0x55, 0xaa, 0xfb, 0x60, 0x86, 0xb1, 0xbb, 0xcc, 0x3e, 0x5a,
+ 0xcb, 0x59, 0x5f, 0xb0, 0x9c, 0xa9, 0xa0, 0x51, 0x0b, 0xf5, 0x16, 0xeb, 0x7a, 0x75, 0x2c, 0xd7,
+ 0x4f, 0xae, 0xd5, 0xe9, 0xe6, 0xe7, 0xad, 0xe8, 0x74, 0xd6, 0xf4, 0xea, 0xa8, 0x50, 0x58, 0xaf
+ ];
+
+ // Galios field exponent table
+ var gexp = [
+ 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1d, 0x3a, 0x74, 0xe8, 0xcd, 0x87, 0x13, 0x26,
+ 0x4c, 0x98, 0x2d, 0x5a, 0xb4, 0x75, 0xea, 0xc9, 0x8f, 0x03, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0,
+ 0x9d, 0x27, 0x4e, 0x9c, 0x25, 0x4a, 0x94, 0x35, 0x6a, 0xd4, 0xb5, 0x77, 0xee, 0xc1, 0x9f, 0x23,
+ 0x46, 0x8c, 0x05, 0x0a, 0x14, 0x28, 0x50, 0xa0, 0x5d, 0xba, 0x69, 0xd2, 0xb9, 0x6f, 0xde, 0xa1,
+ 0x5f, 0xbe, 0x61, 0xc2, 0x99, 0x2f, 0x5e, 0xbc, 0x65, 0xca, 0x89, 0x0f, 0x1e, 0x3c, 0x78, 0xf0,
+ 0xfd, 0xe7, 0xd3, 0xbb, 0x6b, 0xd6, 0xb1, 0x7f, 0xfe, 0xe1, 0xdf, 0xa3, 0x5b, 0xb6, 0x71, 0xe2,
+ 0xd9, 0xaf, 0x43, 0x86, 0x11, 0x22, 0x44, 0x88, 0x0d, 0x1a, 0x34, 0x68, 0xd0, 0xbd, 0x67, 0xce,
+ 0x81, 0x1f, 0x3e, 0x7c, 0xf8, 0xed, 0xc7, 0x93, 0x3b, 0x76, 0xec, 0xc5, 0x97, 0x33, 0x66, 0xcc,
+ 0x85, 0x17, 0x2e, 0x5c, 0xb8, 0x6d, 0xda, 0xa9, 0x4f, 0x9e, 0x21, 0x42, 0x84, 0x15, 0x2a, 0x54,
+ 0xa8, 0x4d, 0x9a, 0x29, 0x52, 0xa4, 0x55, 0xaa, 0x49, 0x92, 0x39, 0x72, 0xe4, 0xd5, 0xb7, 0x73,
+ 0xe6, 0xd1, 0xbf, 0x63, 0xc6, 0x91, 0x3f, 0x7e, 0xfc, 0xe5, 0xd7, 0xb3, 0x7b, 0xf6, 0xf1, 0xff,
+ 0xe3, 0xdb, 0xab, 0x4b, 0x96, 0x31, 0x62, 0xc4, 0x95, 0x37, 0x6e, 0xdc, 0xa5, 0x57, 0xae, 0x41,
+ 0x82, 0x19, 0x32, 0x64, 0xc8, 0x8d, 0x07, 0x0e, 0x1c, 0x38, 0x70, 0xe0, 0xdd, 0xa7, 0x53, 0xa6,
+ 0x51, 0xa2, 0x59, 0xb2, 0x79, 0xf2, 0xf9, 0xef, 0xc3, 0x9b, 0x2b, 0x56, 0xac, 0x45, 0x8a, 0x09,
+ 0x12, 0x24, 0x48, 0x90, 0x3d, 0x7a, 0xf4, 0xf5, 0xf7, 0xf3, 0xfb, 0xeb, 0xcb, 0x8b, 0x0b, 0x16,
+ 0x2c, 0x58, 0xb0, 0x7d, 0xfa, 0xe9, 0xcf, 0x83, 0x1b, 0x36, 0x6c, 0xd8, 0xad, 0x47, 0x8e, 0x00
+ ];
+
+ // Working buffers:
+ // data input and ecc append, image working buffer, fixed part of image, run lengths for badness
+ var strinbuf=[], eccbuf=[], qrframe=[], framask=[], rlens=[];
+ // Control values - width is based on version, last 4 are from table.
+ var version, width, neccblk1, neccblk2, datablkw, eccblkwid;
+ var ecclevel = 2;
+ // set bit to indicate cell in qrframe is immutable. symmetric around diagonal
+ function setmask(x, y)
+ {
+ var bt;
+ if (x > y) {
+ bt = x;
+ x = y;
+ y = bt;
+ }
+ // y*y = 1+3+5...
+ bt = y;
+ bt *= y;
+ bt += y;
+ bt >>= 1;
+ bt += x;
+ framask[bt] = 1;
+ }
+
+ // enter alignment pattern - black to qrframe, white to mask (later black frame merged to mask)
+ function putalign(x, y)
+ {
+ var j;
+
+ qrframe[x + width * y] = 1;
+ for (j = -2; j < 2; j++) {
+ qrframe[(x + j) + width * (y - 2)] = 1;
+ qrframe[(x - 2) + width * (y + j + 1)] = 1;
+ qrframe[(x + 2) + width * (y + j)] = 1;
+ qrframe[(x + j + 1) + width * (y + 2)] = 1;
+ }
+ for (j = 0; j < 2; j++) {
+ setmask(x - 1, y + j);
+ setmask(x + 1, y - j);
+ setmask(x - j, y - 1);
+ setmask(x + j, y + 1);
+ }
+ }
+
+ //========================================================================
+ // Reed Solomon error correction
+ // exponentiation mod N
+ function modnn(x)
+ {
+ while (x >= 255) {
+ x -= 255;
+ x = (x >> 8) + (x & 255);
+ }
+ return x;
+ }
+
+ var genpoly = [];
+
+ // Calculate and append ECC data to data block. Block is in strinbuf, indexes to buffers given.
+ function appendrs(data, dlen, ecbuf, eclen)
+ {
+ var i, j, fb;
+
+ for (i = 0; i < eclen; i++)
+ strinbuf[ecbuf + i] = 0;
+ for (i = 0; i < dlen; i++) {
+ fb = glog[strinbuf[data + i] ^ strinbuf[ecbuf]];
+ if (fb != 255) /* fb term is non-zero */
+ for (j = 1; j < eclen; j++)
+ strinbuf[ecbuf + j - 1] = strinbuf[ecbuf + j] ^ gexp[modnn(fb + genpoly[eclen - j])];
+ else
+ for( j = ecbuf ; j < ecbuf + eclen; j++ )
+ strinbuf[j] = strinbuf[j + 1];
+ strinbuf[ ecbuf + eclen - 1] = fb == 255 ? 0 : gexp[modnn(fb + genpoly[0])];
+ }
+ }
+
+ //========================================================================
+ // Frame data insert following the path rules
+
+ // check mask - since symmetrical use half.
+ function ismasked(x, y)
+ {
+ var bt;
+ if (x > y) {
+ bt = x;
+ x = y;
+ y = bt;
+ }
+ bt = y;
+ bt += y * y;
+ bt >>= 1;
+ bt += x;
+ return framask[bt];
+ }
+
+ //========================================================================
+ // Apply the selected mask out of the 8.
+ function applymask(m)
+ {
+ var x, y, r3x, r3y;
+
+ switch (m) {
+ case 0:
+ for (y = 0; y < width; y++)
+ for (x = 0; x < width; x++)
+ if (!((x + y) & 1) && !ismasked(x, y))
+ qrframe[x + y * width] ^= 1;
+ break;
+ case 1:
+ for (y = 0; y < width; y++)
+ for (x = 0; x < width; x++)
+ if (!(y & 1) && !ismasked(x, y))
+ qrframe[x + y * width] ^= 1;
+ break;
+ case 2:
+ for (y = 0; y < width; y++)
+ for (r3x = 0, x = 0; x < width; x++, r3x++) {
+ if (r3x == 3)
+ r3x = 0;
+ if (!r3x && !ismasked(x, y))
+ qrframe[x + y * width] ^= 1;
+ }
+ break;
+ case 3:
+ for (r3y = 0, y = 0; y < width; y++, r3y++) {
+ if (r3y == 3)
+ r3y = 0;
+ for (r3x = r3y, x = 0; x < width; x++, r3x++) {
+ if (r3x == 3)
+ r3x = 0;
+ if (!r3x && !ismasked(x, y))
+ qrframe[x + y * width] ^= 1;
+ }
+ }
+ break;
+ case 4:
+ for (y = 0; y < width; y++)
+ for (r3x = 0, r3y = ((y >> 1) & 1), x = 0; x < width; x++, r3x++) {
+ if (r3x == 3) {
+ r3x = 0;
+ r3y = !r3y;
+ }
+ if (!r3y && !ismasked(x, y))
+ qrframe[x + y * width] ^= 1;
+ }
+ break;
+ case 5:
+ for (r3y = 0, y = 0; y < width; y++, r3y++) {
+ if (r3y == 3)
+ r3y = 0;
+ for (r3x = 0, x = 0; x < width; x++, r3x++) {
+ if (r3x == 3)
+ r3x = 0;
+ if (!((x & y & 1) + !(!r3x | !r3y)) && !ismasked(x, y))
+ qrframe[x + y * width] ^= 1;
+ }
+ }
+ break;
+ case 6:
+ for (r3y = 0, y = 0; y < width; y++, r3y++) {
+ if (r3y == 3)
+ r3y = 0;
+ for (r3x = 0, x = 0; x < width; x++, r3x++) {
+ if (r3x == 3)
+ r3x = 0;
+ if (!(((x & y & 1) + (r3x && (r3x == r3y))) & 1) && !ismasked(x, y))
+ qrframe[x + y * width] ^= 1;
+ }
+ }
+ break;
+ case 7:
+ for (r3y = 0, y = 0; y < width; y++, r3y++) {
+ if (r3y == 3)
+ r3y = 0;
+ for (r3x = 0, x = 0; x < width; x++, r3x++) {
+ if (r3x == 3)
+ r3x = 0;
+ if (!(((r3x && (r3x == r3y)) + ((x + y) & 1)) & 1) && !ismasked(x, y))
+ qrframe[x + y * width] ^= 1;
+ }
+ }
+ break;
+ }
+ return;
+ }
+
+ // Badness coefficients.
+ var N1 = 3, N2 = 3, N3 = 40, N4 = 10;
+
+ // Using the table of the length of each run, calculate the amount of bad image
+ // - long runs or those that look like finders; called twice, once each for X and Y
+ function badruns(length)
+ {
+ var i;
+ var runsbad = 0;
+ for (i = 0; i <= length; i++)
+ if (rlens[i] >= 5)
+ runsbad += N1 + rlens[i] - 5;
+ // BwBBBwB as in finder
+ for (i = 3; i < length - 1; i += 2)
+ if (rlens[i - 2] == rlens[i + 2]
+ && rlens[i + 2] == rlens[i - 1]
+ && rlens[i - 1] == rlens[i + 1]
+ && rlens[i - 1] * 3 == rlens[i]
+ // white around the black pattern? Not part of spec
+ && (rlens[i - 3] == 0 // beginning
+ || i + 3 > length // end
+ || rlens[i - 3] * 3 >= rlens[i] * 4 || rlens[i + 3] * 3 >= rlens[i] * 4)
+ )
+ runsbad += N3;
+ return runsbad;
+ }
+
+ // Calculate how bad the masked image is - blocks, imbalance, runs, or finders.
+ function badcheck()
+ {
+ var x, y, h, b, b1;
+ var thisbad = 0;
+ var bw = 0;
+
+ // blocks of same color.
+ for (y = 0; y < width - 1; y++)
+ for (x = 0; x < width - 1; x++)
+ if ((qrframe[x + width * y] && qrframe[(x + 1) + width * y]
+ && qrframe[x + width * (y + 1)] && qrframe[(x + 1) + width * (y + 1)]) // all black
+ || !(qrframe[x + width * y] || qrframe[(x + 1) + width * y]
+ || qrframe[x + width * (y + 1)] || qrframe[(x + 1) + width * (y + 1)])) // all white
+ thisbad += N2;
+
+ // X runs
+ for (y = 0; y < width; y++) {
+ rlens[0] = 0;
+ for (h = b = x = 0; x < width; x++) {
+ if ((b1 = qrframe[x + width * y]) == b)
+ rlens[h]++;
+ else
+ rlens[++h] = 1;
+ b = b1;
+ bw += b ? 1 : -1;
+ }
+ thisbad += badruns(h);
+ }
+
+ // black/white imbalance
+ if (bw < 0)
+ bw = -bw;
+
+ var big = bw;
+ var count = 0;
+ big += big << 2;
+ big <<= 1;
+ while (big > width * width)
+ big -= width * width, count++;
+ thisbad += count * N4;
+
+ // Y runs
+ for (x = 0; x < width; x++) {
+ rlens[0] = 0;
+ for (h = b = y = 0; y < width; y++) {
+ if ((b1 = qrframe[x + width * y]) == b)
+ rlens[h]++;
+ else
+ rlens[++h] = 1;
+ b = b1;
+ }
+ thisbad += badruns(h);
+ }
+ return thisbad;
+ }
+
+ function genframe(instring)
+ {
+ var x, y, k, t, v, i, j, m;
+
+ // find the smallest version that fits the string
+ t = instring.length;
+ version = 0;
+ do {
+ version++;
+ k = (ecclevel - 1) * 4 + (version - 1) * 16;
+ neccblk1 = eccblocks[k++];
+ neccblk2 = eccblocks[k++];
+ datablkw = eccblocks[k++];
+ eccblkwid = eccblocks[k];
+ k = datablkw * (neccblk1 + neccblk2) + neccblk2 - 3 + (version <= 9);
+ if (t <= k)
+ break;
+ } while (version < 40);
+
+ // FIXME - insure that it fits insted of being truncated
+ width = 17 + 4 * version;
+
+ // allocate, clear and setup data structures
+ v = datablkw + (datablkw + eccblkwid) * (neccblk1 + neccblk2) + neccblk2;
+ for( t = 0; t < v; t++ )
+ eccbuf[t] = 0;
+ strinbuf = instring.slice(0);
+
+ for( t = 0; t < width * width; t++ )
+ qrframe[t] = 0;
+
+ for( t = 0 ; t < (width * (width + 1) + 1) / 2; t++)
+ framask[t] = 0;
+
+ // insert finders - black to frame, white to mask
+ for (t = 0; t < 3; t++) {
+ k = 0;
+ y = 0;
+ if (t == 1)
+ k = (width - 7);
+ if (t == 2)
+ y = (width - 7);
+ qrframe[(y + 3) + width * (k + 3)] = 1;
+ for (x = 0; x < 6; x++) {
+ qrframe[(y + x) + width * k] = 1;
+ qrframe[y + width * (k + x + 1)] = 1;
+ qrframe[(y + 6) + width * (k + x)] = 1;
+ qrframe[(y + x + 1) + width * (k + 6)] = 1;
+ }
+ for (x = 1; x < 5; x++) {
+ setmask(y + x, k + 1);
+ setmask(y + 1, k + x + 1);
+ setmask(y + 5, k + x);
+ setmask(y + x + 1, k + 5);
+ }
+ for (x = 2; x < 4; x++) {
+ qrframe[(y + x) + width * (k + 2)] = 1;
+ qrframe[(y + 2) + width * (k + x + 1)] = 1;
+ qrframe[(y + 4) + width * (k + x)] = 1;
+ qrframe[(y + x + 1) + width * (k + 4)] = 1;
+ }
+ }
+
+ // alignment blocks
+ if (version > 1) {
+ t = adelta[version];
+ y = width - 7;
+ for (;;) {
+ x = width - 7;
+ while (x > t - 3) {
+ putalign(x, y);
+ if (x < t)
+ break;
+ x -= t;
+ }
+ if (y <= t + 9)
+ break;
+ y -= t;
+ putalign(6, y);
+ putalign(y, 6);
+ }
+ }
+
+ // single black
+ qrframe[8 + width * (width - 8)] = 1;
+
+ // timing gap - mask only
+ for (y = 0; y < 7; y++) {
+ setmask(7, y);
+ setmask(width - 8, y);
+ setmask(7, y + width - 7);
+ }
+ for (x = 0; x < 8; x++) {
+ setmask(x, 7);
+ setmask(x + width - 8, 7);
+ setmask(x, width - 8);
+ }
+
+ // reserve mask-format area
+ for (x = 0; x < 9; x++)
+ setmask(x, 8);
+ for (x = 0; x < 8; x++) {
+ setmask(x + width - 8, 8);
+ setmask(8, x);
+ }
+ for (y = 0; y < 7; y++)
+ setmask(8, y + width - 7);
+
+ // timing row/col
+ for (x = 0; x < width - 14; x++)
+ if (x & 1) {
+ setmask(8 + x, 6);
+ setmask(6, 8 + x);
+ }
+ else {
+ qrframe[(8 + x) + width * 6] = 1;
+ qrframe[6 + width * (8 + x)] = 1;
+ }
+
+ // version block
+ if (version > 6) {
+ t = vpat[version - 7];
+ k = 17;
+ for (x = 0; x < 6; x++)
+ for (y = 0; y < 3; y++, k--)
+ if (1 & (k > 11 ? version >> (k - 12) : t >> k)) {
+ qrframe[(5 - x) + width * (2 - y + width - 11)] = 1;
+ qrframe[(2 - y + width - 11) + width * (5 - x)] = 1;
+ }
+ else {
+ setmask(5 - x, 2 - y + width - 11);
+ setmask(2 - y + width - 11, 5 - x);
+ }
+ }
+
+ // sync mask bits - only set above for white spaces, so add in black bits
+ for (y = 0; y < width; y++)
+ for (x = 0; x <= y; x++)
+ if (qrframe[x + width * y])
+ setmask(x, y);
+
+ // convert string to bitstream
+ // 8 bit data to QR-coded 8 bit data (numeric or alphanum, or kanji not supported)
+ v = strinbuf.length;
+
+ // string to array
+ for( i = 0 ; i < v; i++ )
+ eccbuf[i] = strinbuf.charCodeAt(i);
+ strinbuf = eccbuf.slice(0);
+
+ // calculate max string length
+ x = datablkw * (neccblk1 + neccblk2) + neccblk2;
+ if (v >= x - 2) {
+ v = x - 2;
+ if (version > 9)
+ v--;
+ }
+
+ // shift and repack to insert length prefix
+ i = v;
+ if (version > 9) {
+ strinbuf[i + 2] = 0;
+ strinbuf[i + 3] = 0;
+ while (i--) {
+ t = strinbuf[i];
+ strinbuf[i + 3] |= 255 & (t << 4);
+ strinbuf[i + 2] = t >> 4;
+ }
+ strinbuf[2] |= 255 & (v << 4);
+ strinbuf[1] = v >> 4;
+ strinbuf[0] = 0x40 | (v >> 12);
+ }
+ else {
+ strinbuf[i + 1] = 0;
+ strinbuf[i + 2] = 0;
+ while (i--) {
+ t = strinbuf[i];
+ strinbuf[i + 2] |= 255 & (t << 4);
+ strinbuf[i + 1] = t >> 4;
+ }
+ strinbuf[1] |= 255 & (v << 4);
+ strinbuf[0] = 0x40 | (v >> 4);
+ }
+ // fill to end with pad pattern
+ i = v + 3 - (version < 10);
+ while (i < x) {
+ strinbuf[i++] = 0xec;
+ // buffer has room if (i == x) break;
+ strinbuf[i++] = 0x11;
+ }
+
+ // calculate and append ECC
+
+ // calculate generator polynomial
+ genpoly[0] = 1;
+ for (i = 0; i < eccblkwid; i++) {
+ genpoly[i + 1] = 1;
+ for (j = i; j > 0; j--)
+ genpoly[j] = genpoly[j]
+ ? genpoly[j - 1] ^ gexp[modnn(glog[genpoly[j]] + i)] : genpoly[j - 1];
+ genpoly[0] = gexp[modnn(glog[genpoly[0]] + i)];
+ }
+ for (i = 0; i <= eccblkwid; i++)
+ genpoly[i] = glog[genpoly[i]]; // use logs for genpoly[] to save calc step
+
+ // append ecc to data buffer
+ k = x;
+ y = 0;
+ for (i = 0; i < neccblk1; i++) {
+ appendrs(y, datablkw, k, eccblkwid);
+ y += datablkw;
+ k += eccblkwid;
+ }
+ for (i = 0; i < neccblk2; i++) {
+ appendrs(y, datablkw + 1, k, eccblkwid);
+ y += datablkw + 1;
+ k += eccblkwid;
+ }
+ // interleave blocks
+ y = 0;
+ for (i = 0; i < datablkw; i++) {
+ for (j = 0; j < neccblk1; j++)
+ eccbuf[y++] = strinbuf[i + j * datablkw];
+ for (j = 0; j < neccblk2; j++)
+ eccbuf[y++] = strinbuf[(neccblk1 * datablkw) + i + (j * (datablkw + 1))];
+ }
+ for (j = 0; j < neccblk2; j++)
+ eccbuf[y++] = strinbuf[(neccblk1 * datablkw) + i + (j * (datablkw + 1))];
+ for (i = 0; i < eccblkwid; i++)
+ for (j = 0; j < neccblk1 + neccblk2; j++)
+ eccbuf[y++] = strinbuf[x + i + j * eccblkwid];
+ strinbuf = eccbuf;
+
+ // pack bits into frame avoiding masked area.
+ x = y = width - 1;
+ k = v = 1; // up, minus
+ /* inteleaved data and ecc codes */
+ m = (datablkw + eccblkwid) * (neccblk1 + neccblk2) + neccblk2;
+ for (i = 0; i < m; i++) {
+ t = strinbuf[i];
+ for (j = 0; j < 8; j++, t <<= 1) {
+ if (0x80 & t)
+ qrframe[x + width * y] = 1;
+ do { // find next fill position
+ if (v)
+ x--;
+ else {
+ x++;
+ if (k) {
+ if (y != 0)
+ y--;
+ else {
+ x -= 2;
+ k = !k;
+ if (x == 6) {
+ x--;
+ y = 9;
+ }
+ }
+ }
+ else {
+ if (y != width - 1)
+ y++;
+ else {
+ x -= 2;
+ k = !k;
+ if (x == 6) {
+ x--;
+ y -= 8;
+ }
+ }
+ }
+ }
+ v = !v;
+ } while (ismasked(x, y));
+ }
+ }
+
+ // save pre-mask copy of frame
+ strinbuf = qrframe.slice(0);
+ t = 0; // best
+ y = 30000; // demerit
+ // for instead of while since in original arduino code
+ // if an early mask was "good enough" it wouldn't try for a better one
+ // since they get more complex and take longer.
+ for (k = 0; k < 8; k++) {
+ applymask(k); // returns black-white imbalance
+ x = badcheck();
+ if (x < y) { // current mask better than previous best?
+ y = x;
+ t = k;
+ }
+ if (t == 7)
+ break; // don't increment i to a void redoing mask
+ qrframe = strinbuf.slice(0); // reset for next pass
+ }
+ if (t != k) // redo best mask - none good enough, last wasn't t
+ applymask(t);
+
+ // add in final mask/ecclevel bytes
+ y = fmtword[t + ((ecclevel - 1) << 3)];
+ // low byte
+ for (k = 0; k < 8; k++, y >>= 1)
+ if (y & 1) {
+ qrframe[(width - 1 - k) + width * 8] = 1;
+ if (k < 6)
+ qrframe[8 + width * k] = 1;
+ else
+ qrframe[8 + width * (k + 1)] = 1;
+ }
+ // high byte
+ for (k = 0; k < 7; k++, y >>= 1)
+ if (y & 1) {
+ qrframe[8 + width * (width - 7 + k)] = 1;
+ if (k)
+ qrframe[(6 - k) + width * 8] = 1;
+ else
+ qrframe[7 + width * 8] = 1;
+ }
+
+ // return image
+ return qrframe;
+ }
+
+ var _canvas = null,
+ _size = null;
+
+ var api = {
+
+ get ecclevel () {
+ return ecclevel;
+ },
+
+ set ecclevel (val) {
+ ecclevel = val;
+ },
+
+ get size () {
+ return _size;
+ },
+
+ set size (val) {
+ _size = val
+ },
+
+ get canvas () {
+ return _canvas;
+ },
+
+ set canvas (el) {
+ _canvas = el;
+ },
+
+ getFrame: function (string) {
+ return genframe(string);
+ },
+
+ draw: function (string, canvas, size, ecc) {
+
+ ecclevel = ecc || ecclevel;
+ canvas = canvas || _canvas;
+
+ if (!canvas) {
+ console.warn('No canvas provided to draw QR code in!')
+ return;
+ }
+
+ size = size || _size || Math.min(canvas.width, canvas.height);
+
+ var frame = genframe(string),
+ ctx = canvas.ctx,
+ px = Math.round(size / (width + 8));
+
+ var roundedSize = px * (width + 8),
+ offset = Math.floor((size - roundedSize) / 2);
+
+ size = roundedSize;
+
+ ctx.clearRect(0, 0, canvas.width, canvas.height);
+ ctx.setFillStyle('#000000');
+
+ for (var i = 0; i < width; i++) {
+ for (var j = 0; j < width; j++) {
+ if (frame[j * width + i]) {
+ ctx.fillRect(px * (4 + i) + offset, px * (4 + j) + offset, px, px);
+ }
+ }
+ }
+ ctx.draw();
+ }
+ }
+
+ module.exports = {
+ api: api
+ }
+
+})()
\ No newline at end of file
diff --git a/src/components/kk-printer/utils/util.js b/src/components/kk-printer/utils/util.js
new file mode 100644
index 00000000..80c04d20
--- /dev/null
+++ b/src/components/kk-printer/utils/util.js
@@ -0,0 +1,171 @@
+//const gbk = require('./gbk.js');
+//console.log("sasas" + gbk);
+const formatTime = date => {
+ const year = date.getFullYear()
+ const month = date.getMonth() + 1
+ const day = date.getDate()
+ const hour = date.getHours()
+ const minute = date.getMinutes()
+ const second = date.getSeconds()
+
+ return [year, month, day].map(formatNumber).join('/') + ' ' + [hour, minute, second].map(formatNumber).join(':')
+}
+
+const formatNumber = n => {
+ n = n.toString()
+ return n[1] ? n : '0' + n
+}
+
+/*
+const hexStringToBuff = str => { //str='中国:WXHSH'
+ const buffer = new ArrayBuffer((sumStrLength(str)) * 4)
+ const dataView = new DataView(buffer)
+ var data = str.toString();
+ var p = 0; //ArrayBuffer 偏移量
+ for (var i = 0; i < data.length; i++) {
+ if (isCN(data[i])) { //是中文
+ //调用GBK 转码
+ var t = gbk.encode(data[i]);
+ for (var j = 0; j < 2; j++) {
+ //var code = t[j * 2] + t[j * 2 + 1];
+ var code = t[j * 3 + 1] + t[j * 3 + 2];
+ var temp = parseInt(code, 16)
+ //var temp = strToHexCharCode(code);
+ dataView.setUint8(p++, temp)
+ }
+ } else {
+ var temp = data.charCodeAt(i);
+ dataView.setUint8(p++, temp)
+ }
+ }
+ return buffer;
+}
+*/
+function toUnicode(s) {
+ var str = "";
+ for (var i = 0; i < s.length; i++) {
+ str += "\\u" + s.charCodeAt(i).toString(16) + "\t";
+ }
+ return str;
+}
+
+function strToHexCharCode(str) {
+ if (str === "")
+ return "";
+ var hexCharCode = [];
+ hexCharCode.push("0x");
+ for (var i = 0; i < str.length; i++) {
+ hexCharCode.push((str.charCodeAt(i)).toString(16));
+ }
+ return hexCharCode.join("");
+}
+
+function sumStrLength(str) {
+ var length = 0;
+ var data = str.toString();
+ for (var i = 0; i < data.length; i++) {
+ if (isCN(data[i])) { //是中文
+ length += 2;
+ } else {
+ length += 1;
+ }
+ }
+ return length;
+}
+
+function isCN(str) {
+ if (/^[\u3220-\uFA29]+$/.test(str)) {
+ return true;
+ } else {
+ return false;
+ }
+}
+
+//汉字转码
+export function hexStringToArrayBuffer(str) {
+ const buffer = new ArrayBuffer((str.length / 2) + 1)
+ const dataView = new DataView(buffer)
+ for (var i = 0; i < str.length / 2; i++) {
+ var temp = parseInt(str[i * 2] + str[i * 2 + 1], 16)
+ dataView.setUint8(i, temp)
+ }
+ dataView.setUint8((str.length / 2), 0x0a)
+ return buffer;
+}
+
+//返回八位数组
+function subString(str) {
+ var arr = [];
+ if (str.length > 8) { //大于8
+ for (var i = 0;
+ (i * 8) < str.length; i++) {
+ var temp = str.substring(i * 8, 8 * i + 8);
+ arr.push(temp)
+ }
+ return arr;
+ } else {
+ return str
+ }
+}
+
+//不带有汉字
+function hexStringToArrayBufferstr(str) {
+ let val = ""
+ for (let i = 0; i < str.length; i++) {
+ if (val === '') {
+ val = str.charCodeAt(i).toString(16)
+ } else {
+ val += ',' + str.charCodeAt(i).toString(16)
+ }
+ }
+ val += "," + "0x0a";
+ console.log(val)
+ // 将16进制转化为ArrayBuffer
+ return new Uint8Array(val.match(/[\da-f]{2}/gi).map(function(h) {
+ return parseInt(h, 16)
+ })).buffer
+}
+
+export function ab2hex(buffer) {
+ let hexArr = Array.prototype.map.call(
+ new Uint8Array(buffer),
+ function (bit) {
+ return ('00' + bit.toString(16)).slice(-2)
+ })
+ return hexArr.join('');
+}
+
+// ArrayBuffer转为字符串,参数为ArrayBuffer对象
+export function ab2str(buf) {
+ return String.fromCharCode.apply(null, new Uint8Array(buf));
+}
+
+// 字符串转为ArrayBuffer对象,参数为字符串
+export function str2ab(str) {
+ var buf = new ArrayBuffer(str.length+1); // 补充/0
+ var bufView = new Uint8Array(buf);
+ for (var i = 0, strLen = str.length; i < strLen; i++) {
+ bufView[i] = str.charCodeAt(i);
+ }
+ return buf;
+}
+
+export function send0X0A() {
+ const buffer = new ArrayBuffer(1)
+ const dataView = new DataView(buffer)
+ dataView.setUint8(0, 0x0a)
+ return buffer;
+}
+
+export function buf2hex(buffer) {
+ return Array.prototype.map.call(new Uint8Array(buffer), x => ('00' + x.toString(16)).slice(-2)).join('');
+}
+
+// module.exports = {
+// hexStringToArrayBuffer: hexStringToArrayBuffer,
+// send0X0A: send0X0A,
+// ab2hex: ab2hex,
+// str2ab: str2ab,
+// ab2str: ab2str,
+// buf2hex: buf2hex
+// }
\ No newline at end of file
diff --git a/src/pages.json b/src/pages.json
index b0d37241..21f5d93d 100644
--- a/src/pages.json
+++ b/src/pages.json
@@ -2021,6 +2021,12 @@
"navigationBarTitleText": "翻包任务详情",
"enablePullDownRefresh": false
}
+ },{
+ "path": "pages/point/index",
+ "style": {
+ "navigationBarTitleText": "打印",
+ "enablePullDownRefresh": false
+ }
}
diff --git a/src/pages/point/index.vue b/src/pages/point/index.vue
new file mode 100644
index 00000000..3ce1abaf
--- /dev/null
+++ b/src/pages/point/index.vue
@@ -0,0 +1,70 @@
+
+
+
+
+
+
+
+
+
+
+