设备控制页上传logo图联调

Reviewed-on: #2

.env.development

@@ -1,2 +0,0 @@
-# 开发环境 API 地址
-VUE_APP_BASE_API=YOUR_DEVELOPMENT_API_URL

.env.production

@@ -1,2 +0,0 @@
-    # 生产环境 API 地址
-    VUE_APP_BASE_API=YOUR_PRODUCTION_API_URL

.gitignore

@@ -0,0 +1,5 @@
+*node_modules/*
+*dist/*
+*unpackage/*
+
+

App.vue

@@ -2,7 +2,7 @@
 	export default {
 
 		onLaunch: function() {
-
+			
 		},
 		onShow: function() {
 			console.log('App Show')
@@ -15,27 +15,43 @@
 
 <style lang="scss">
 	@import 'vk-uview-ui/index.scss';
-	uni-slider .uni-slider-handle-wrapper{
+
+	uni-slider .uni-slider-handle-wrapper {
 		border-radius: 20rpx;
-		
+
 	}
-	uni-slider .uni-slider-thumb{
+
+	uni-slider .uni-slider-thumb {
 		width: 66rpx !important;
-		height:80rpx !important;
+		height: 80rpx !important;
 		margin-top: -40rpx !important;
 		border-radius: 16rpx !important;
 		margin-left: -72rpx !important;
-		
+
 	}
-	uni-slider .uni-slider-handle-wrapper{
+
+	uni-slider .uni-slider-handle-wrapper {
 		height: 88rpx;
 		position: relative;
 	}
-	uni-slider .uni-slider-value{
-		position: absolute;
-		color: rgba(255, 255, 255,0.8);
-		font-size: 32rpx;
-		right:2.5%;
-		top:-60rpx
+	.custom-file-picker .file-picker__box-content {
+		background: rgba(26, 26, 26, 1);
+		border: none !important;
+		border-radius: 45rpx;
+		width: 180rpx;
+		height: 180rpx;
+	}
+
+	.uni-file-picker.custom-file-picker {
+		overflow: inherit !important;
+	}
+
+	.custom-file-picker .icon-add {
+		height: 5rpx !important;
+		width: 70rpx !important;
+	}
+
+	.custom-file-picker .file-picker__box-content {
+		// display: none
 	}
 </style>

api/6155/BlueHelper.js

@@ -0,0 +1,671 @@
+export default {
+	featrueValueCallback: null,//蓝牙特征变化回调
+	BleChangeCallback:null,//蓝牙状态变化回调
+	//引导用户打开蓝牙
+	showBluetoothGuide: function(showTip) {
+		let platform = process.env.UNI_PLATFORM;
+
+
+		var openBlueSetting = function() {
+			// 判断平台类型
+			if (platform === 'mp-weixin') {
+				uni.openSetting();
+			} else if (platform === 'app-plus' || platform === 'app') {
+				//----------------------------------------------------------------
+				const osName = plus.os.name;
+
+				if (osName === 'iOS') {
+					// iOS 平台打开蓝牙设置
+					plus.runtime.openURL('App-Prefs:root=Bluetooth', function() {
+						console.log('成功打开蓝牙设置');
+					}, function(err) {
+						console.error('打开蓝牙设置失败：' + err.message);
+						uni.showModal({
+							title: '提示',
+							content: '无法自动打开蓝牙设置，请手动前往设置 > 蓝牙 进行操作。',
+							showCancel: false
+						});
+					});
+				} else if (osName === 'Android') {
+					// Android 平台打开蓝牙设置
+					try {
+						const Intent = plus.android.importClass('android.content.Intent');
+						const Settings = plus.android.importClass('android.provider.Settings');
+						const main = plus.android.runtimeMainActivity();
+						const intent = new Intent(Settings.ACTION_BLUETOOTH_SETTINGS);
+						main.startActivity(intent);
+					} catch (e) {
+						console.error('打开蓝牙设置失败：' + e.message);
+						// 尝试使用通用设置页面作为备选方案
+						plus.runtime.openURL('settings://', function() {
+							console.log('打开系统设置成功，请手动找到蓝牙选项');
+						}, function() {
+							uni.showModal({
+								title: '提示',
+								content: '无法自动打开蓝牙设置，请手动前往设置页面开启蓝牙。',
+								showCancel: false
+							});
+						});
+					}
+				} else {
+					uni.showModal({
+						title: '提示',
+						content: '当前系统不支持自动打开蓝牙设置，请手动操作。',
+						showCancel: false
+					});
+				}
+
+
+				//--------------------------------------------------------------------
+			} else if (platform === 'mp-alipay') {
+				uni.openSetting();
+			}
+
+		}
+
+		if (showTip !== undefined) {
+			openBlueSetting();
+			return;
+		}
+		if (platform === 'mp-weixin' || platform === 'app-plus' || platform === 'mp-alipay' || platform === 'app') {
+			uni.showModal({
+				title: '蓝牙未开启',
+				content: '请在系统设置中打开蓝牙以使用此功能',
+				success: (res) => {
+					if (res.confirm) {
+						openBlueSetting();
+					}
+				}
+			});
+		} else {
+			console.log("当前平台不支持打开系统设置" + platform);
+		}
+
+
+	},
+	//获取蓝牙适配器状态
+	CheckBlue: function(callback) {
+
+		uni.getBluetoothAdapterState({
+			success(res1) {
+
+				console.log("当前蓝牙适配器状态:" + JSON.stringify(res1))
+				if (callback) {
+					callback(res1);
+				}
+
+			},
+			fail(ex1) {
+				console.log("检查蓝牙状态异常：" + JSON.stringify(ex1));
+				if (callback) {
+					if (ex1.code == 10000) {
+						console.log("未初始化蓝牙适配器");
+					}
+					let res1 = {
+						available: false,
+						discovering: false
+					}
+					callback(res1);
+				}
+			},
+			complete() {
+
+			}
+		});
+	},
+	//初始化蓝牙模块 
+	OpenBlue: function(isCheckState, callback, availCallback) {
+
+		var these = this;
+
+		var init = function() {
+			uni.openBluetoothAdapter({
+				success: (res) => {
+					console.log("蓝牙初始化成功:" + JSON.stringify(res));
+					if (callback) {
+						callback();
+					}
+					uni.onBluetoothAdapterStateChange(function(state) {
+						console.log('蓝牙状态发生变化:' + JSON.stringify(state));
+						if(this.BleChangeCallback){
+							this.BleChangeCallback()
+						}
+					})
+				},
+				fail: function(ex2) {
+					console.log("蓝牙初始化失败:" + JSON.stringify(ex2))
+					if (ex2.code == '10001') {
+						console.log("手机蓝牙未打开或设备不支持蓝牙");
+
+
+						if (availCallback) {
+							availCallback();
+						} else {
+							these.showBluetoothGuide();
+						}
+					}
+				}
+			});
+		}
+		if (isCheckState) {
+			this.CheckBlue(function(res1) {
+				if (res1.available) {
+					if (callback) {
+						callback();
+					}
+					return;
+				}
+				init();
+			})
+		} else {
+			init();
+		}
+
+
+
+	},
+	//关闭蓝牙模块,停止搜索、断开所有连接
+	CloseBlue: function(callback) {
+
+		this.StopSearch();
+
+		this.disconnectDevice();
+
+		uni.closeBluetoothAdapter({
+			success: () => {
+				console.log("蓝牙模块已关闭");
+				if (callback) {
+					callback();
+				}
+			}
+		});
+	},
+	//开始搜索新设备
+	StartSearch: function(callback) {
+
+		var these = this;
+
+		//发现新设备
+		var onDeviceFound = function() {
+			uni.onBluetoothDeviceFound(function(res) {
+				console.log("发现新设备:" + JSON.stringify(res));
+				if (callback) {
+					callback(res);
+				}
+			})
+		}
+		//开始搜索
+		var Search = function() {
+			uni.startBluetoothDevicesDiscovery({
+				services: ["0xFFE0"],
+				allowDuplicatesKey: false,
+				success: (res) => {
+					console.log('开始搜索蓝牙设备成功');
+					onDeviceFound();
+				},
+				fail: (err) => {
+					console.log(`搜索蓝牙设备失败: ${err.errMsg}`);
+				}
+			});
+
+		}
+		//先检查蓝牙状态是可用
+		this.CheckBlue(function(res1) {
+			if (res1.available) {
+				if (!res1.discovering) {
+					Search();
+				} else {
+					console.log("当前蓝牙正在搜索设备")
+				}
+
+			} else {
+				these.OpenBlue(false, Search, () => {
+					these.showBluetoothGuide();
+				});
+			}
+		});
+
+
+
+	},
+	//停止搜索
+	StopSearch: function() {
+		uni.stopBluetoothDevicesDiscovery({
+			success: (res) => {
+				console.log("停止搜索蓝牙设备成功")
+			},
+			fail() {
+				console.log("无法停止蓝牙搜索")
+			}
+		});
+	},
+	//获取已连接的设备
+	getLinkBlue: function(callback) {
+		uni.getConnectedBluetoothDevices({
+			services: ["0xFFE0"],
+			success: (res) => {
+				if (callback) {
+					callback(res);
+
+				}
+			},
+			fail: function(ex) {
+				console.log("获取已连接设备异常");
+				if (callback) {
+					callback({
+						devices: []
+					});
+				}
+			}
+		})
+	},
+	//连接某个设备
+	LinkBlue: function(deviceId, callback, error) {
+		
+		this.StopSearch();
+		var these = this;
+		let key = "linkedDevices";
+		var store = uni.getStorageInfoSync();
+		var f = store.keys.find(function(v) {
+			return v == key;
+		});
+		var linkedDevices = [];
+		if (f) {
+			var str = uni.getStorageSync(key);
+			if (str) {
+				linkedDevices = JSON.parse(str);
+			}else{
+				linkedDevices=[];
+			}
+
+		}
+		//连接成功的回调
+		var lindedCallback = function () {
+
+			let c = linkedDevices.find(function (v) {
+				return v.deviceId == deviceId;
+			});
+
+			if (c) {
+				console.log("连接成功开始监听特征变化")
+				//监听设备的特征变化
+				uni.notifyBLECharacteristicValueChange({
+					deviceId: deviceId,
+					serviceId: c.notifyServiceid,
+					characteristicId: c.notifyCharactId,
+					state: true,
+					success: function (res) {
+						console.log("开始监听成功。。。。")
+						if(res.errCode=='0'){
+							//订阅特征值
+							uni.onBLECharacteristicValueChange(function(data){
+								// data.characteristicId
+								// data.deviceId
+								// data.serviceId
+								// data.value
+								console.log("监听到特征值:"+JSON.stringify(data));
+								
+								if(these.featrueValueCallback){
+									these.featrueValueCallback(data);
+								}
+							});
+							
+						}
+					}
+				});
+			}
+
+			if (callback) {
+				callback(deviceId);
+			}
+		}
+
+		var linkState = function(res) {
+			console.log("获取已连接的设备回调" + JSON.stringify(res))
+			let flag = res.devices.find(function(v) {
+				if (v.deviceId == deviceId) {
+					return true;
+				}
+				return false;
+			});
+			if (flag) {
+				console.log("设备状态已连接");
+				
+				lindedCallback(deviceId);
+				
+				return;
+			} else {
+				console.log("设备未连接");
+				linkDevice(deviceId);
+			}
+		}
+
+		var linkDevice = function(id) {
+			console.log("正在连接"+id);
+			uni.createBLEConnection({
+				deviceId: id,
+				timeout: 30000,
+				success: function(info) {
+
+					console.log("连接成功");
+
+					uni.setBLEMTU({
+						deviceId: id,
+						mtu: 512,
+						success: () => {
+							console.log("mtu设置成功");
+							if(linkedDevices){
+								console.log("11111"+JSON.stringify(linkedDevices));
+								f = linkedDevices.find(function (v) {
+									return v.deviceId == id;
+								});
+							}else{
+								console.log("22222")
+								f=null;
+							}
+							
+
+
+							if (!f) {
+								console.log("缓存中没有找到该设备")
+
+								these.getLinkBlue(function (res) {
+									if (res.devices && res.devices.length) {
+										let f = res.devices.find(function (v) {
+											return v.deviceId == id;
+										});
+										linkedDevices.push(f);
+										uni.setStorageSync(key, JSON.stringify(linkedDevices));
+
+										getService(id);
+
+									}
+
+								});
+
+
+							} else {
+								console.log("缓存中已连接过");
+								if (!f.services) {
+									getService(id);
+								} else {
+									
+									lindedCallback(id);
+									
+								}
+							}
+						},
+						fail: function() {
+							console.log("mtu设置失败")
+						}
+					});
+
+				},
+				fail: function(ex) {
+					if (error) {
+						console.log("蓝牙连接失败" + JSON.stringify(error));
+						error(ex);
+					}
+				}
+			});
+		}
+		//获取服务
+		var getService = function(id) {
+
+			var repeatCnt = 0;
+			var startgetService = function() {
+				uni.getBLEDeviceServices({
+					deviceId: id,
+					success: function(res) {
+						if (res.services && res.services.length > 0) {
+							console.log("获取到服务：" + JSON.stringify(res));
+
+							linkedDevices.find(function(v) {
+								if (v.deviceId == id) {
+									v.services = res.services;
+								}
+							});
+							uni.setStorageSync(key, JSON.stringify(linkedDevices));
+							var promises = [];
+							for (var i = 0; i < res.services.length; i++) {
+								let service = res.services[i];
+								promises.push(getFeatrus(id, service.uuid));
+							}
+
+							Promise.all(promises)
+								.then(results => {
+									console.log('所有操作成功完成', results);
+									
+									lindedCallback(id);
+									
+								})
+								.catch(error => {
+									console.error('至少一个操作失败', error);
+								});
+
+
+						} else {
+							repeatCnt++;
+							if (repeatCnt > 5) {
+							
+									lindedCallback(id);
+								
+								return;
+							}
+							setTimeout(function() {
+								startgetService(id);
+							}, 500);
+						}
+					}
+				})
+			}
+
+			setTimeout(function() {
+				startgetService(id);
+			}, 1000);
+		}
+		//获取特性
+		var getFeatrus = function(id, serviceId) {
+			var promise = new Promise((resolve, reject) => {
+				uni.getBLEDeviceCharacteristics({
+					deviceId: id,
+					serviceId: serviceId,
+					success: (res) => {
+						console.log("获取到特征:" + JSON.stringify(res));
+
+						//写特征
+						let writeChar = res.characteristics.find(char =>
+							char.uuid.indexOf("FFE1") > -1
+						);
+						//通知特征
+						let notiChar = res.characteristics.find(char =>
+							char.uuid.indexOf("FFE2") > -1
+						);
+
+						linkedDevices.find(function(v) {
+							if (v.deviceId == id) {
+								if (!v.Characteristics) {
+									v.Characteristics = [];
+								}
+								v.Characteristics = v.Characteristics.concat(res
+									.characteristics);
+
+								if (writeChar) {
+									v.writeServiceId = serviceId;
+									v.wirteCharactId = writeChar.uuid;
+								}
+
+								if (notiChar) {
+									v.notifyServiceid = serviceId;
+									v.notifyCharactId = notiChar.uuid;
+								}
+							}
+						});
+
+						uni.setStorageSync(key, JSON.stringify(linkedDevices));
+						resolve(res);
+					},
+					fail: (ex) => {
+						console.log("获取特征出现异常:" + JSON.stringify(ex));
+						resolve(ex);
+					}
+				});
+			});
+			return promise;
+		}
+
+		//监测蓝牙状态变化
+		uni.onBLEConnectionStateChange(function(res) {
+			if (!res.connected) {
+				console.log("蓝牙断开连接" + res.deviceId + "");
+				// lindDevice(res.deviceId);
+			}
+		});
+
+		console.log("正在获取蓝牙适配器状态")
+		this.CheckBlue((res) => {
+			console.log("蓝牙状态：" + JSON.stringify(res));
+			if (res.available) {
+				this.getLinkBlue(linkState);
+			} else {
+				console.log("蓝牙适配器不可用,正在初始化");
+				this.OpenBlue(false, () => {
+					this.getLinkBlue(linkState);
+				}, () => {
+					console.log("请引导用户打开蓝牙");
+					these.showBluetoothGuide();
+				})
+			}
+
+		});
+
+
+	},
+	//断开连接
+	disconnectDevice: function(deviceId) {
+
+		var disconnect = function(id) {
+			uni.closeBLEConnection({
+				deviceId: id,
+				success: (res) => {
+					console.log("蓝牙连接已断开");
+
+				}
+			});
+		}
+		if (deviceId) {
+			disconnect(deviceId);
+			return;
+		}
+		//断开所有已连接的设备
+		this.getLinkBlue(function(res) {
+			if (res.devices && res.devices.length > 0) {
+				for (var i = 0; i < res.devices.length; i++) {
+					let item = res.devices[i];
+					disconnect(item.deviceId);
+				}
+
+			} else {
+				console.log("无连接设备");
+			}
+		});
+
+	},
+	//发送二进制数据
+	sendData: function(deviceid, buffer) {
+
+		console.log("准备向设备发送数据，deviceid=" + deviceid);
+		return new Promise((resolve, reject) => {
+			if (!deviceid) {
+				reject(`deviceid为空，请输入要发送的设备`);
+				return;
+			}
+			 console.log("准备发送数据包");
+			let key = "linkedDevices";
+			var store = uni.getStorageInfoSync();
+			var f = store.keys.find(function(v) {
+				return v == key;
+			});
+			 console.log("倒计时：5");
+			var linkedDevices = [];
+			if (f) {
+				var str = uni.getStorageSync(key);
+				if (str) {
+					linkedDevices = JSON.parse(str);
+				}
+
+			}
+			 console.log("倒计时：4");
+			if (linkedDevices && linkedDevices.length && linkedDevices.length > 0) {
+				 console.log("倒计时：3");
+				f = linkedDevices.find(function(v) {
+					return v.deviceId == deviceid;
+
+				});
+				console.log("f=" + JSON.stringify(f));
+				// console.log("deviceid=" + deviceid);
+				 console.log("倒计时：2");
+				if (f) {
+					 console.log("倒计时：1");
+					uni.writeBLECharacteristicValue({
+						deviceId: f.deviceId,
+						serviceId: f.writeServiceId,
+						characteristicId: f.wirteCharactId,
+						value: buffer,
+						success: () => {
+							console.log("发送数据成功");
+							resolve();
+						},
+						fail: (err) => {
+							console.log("发送数据失败" + JSON.stringify(err));
+							reject(`发送数据失败: ${err.errMsg}`);
+						},
+						complete: function() {
+							console.log("发送数据complete");
+						}
+					});
+				} else {
+					reject(`已连接设备中无法找到此设备`);
+					// console.log("警报：已连接设备中无法找到此设备")
+				}
+
+			} else {
+				console.log("检测到未与设备建立连接");
+				reject(`检测到未与设备建立连接`);
+			}
+
+
+		});
+	},
+	sendDataNew: function(deviceid, serviceId, characteristicId, buffer) {
+
+		console.log("准备向设备发送数据，deviceid=" + deviceid);
+		return new Promise((resolve, reject) => {
+			uni.writeBLECharacteristicValue({
+				deviceId: deviceid,
+				serviceId: serviceId,
+				characteristicId: characteristicId,
+				value: buffer,
+				success: () => {
+					console.log("发送数据成功");
+					resolve();
+				},
+				fail: (err) => {
+					console.log("发送数据失败" + JSON.stringify(err));
+					reject(`发送数据失败: ${err.errMsg}`);
+				},
+				complete: function() {
+					console.log("发送数据complete");
+				}
+			});
+
+
+
+
+
+		});
+	}
+
+}
+
+

api/6170/deviceControl.js

@@ -0,0 +1,31 @@
+// 获取设备详细信息
+import request from '@/utils/request'
+export function deviceDetail(id) {
+  return request({
+    url: `/app/device/${id}`,
+    method: 'get',
+  })
+}
+// 获取设备分享详细信息
+export function deviceShareId(id) {
+  return request({
+    url: `/app/deviceShare/${id}`,
+    method: 'get',
+  })
+}
+// 人员信息登记
+export function registerPersonInfo(data) {
+  return request({
+    url: `/app/device/registerPersonInfo`,
+    method: 'post',
+	data: data
+  })
+}
+// 发送信息
+export function deviceSendMessage(data) {
+  return request({
+    url: `/app/device/sendMessage`,
+    method: 'post',
+	data: data
+  })
+}

api/6170/share.js

@@ -0,0 +1,42 @@
+import request from '@/utils/request'
+// 新增设备分享
+export function deviceShareAdd(data) {
+  return request({
+    url: '/app/deviceShare/deviceShare',
+    method: 'post',
+    data: data
+  })
+}
+
+// 分享短信验证码
+export function deviceShareCode(params) {
+  return request({
+    url: '/app/deviceShare/sms/code',
+    method: 'get',
+	data:params
+  })
+}
+
+//设备管理列表 我的分享
+export function deviceShareList(params) {
+  return request({
+    url: '/app/deviceShare/deviceShareList',
+    method: 'get',
+    data: params
+  })
+}
+// 他人分享
+export function otherDeviceShareList(params) {
+  return request({
+    url: '/app/deviceShare/otherDeviceShareList',
+    method: 'get',
+    data: params
+  })
+}
+// 移除设备管理
+export function deviceShareDelete(ids) {
+  return request({
+    url: `/app/deviceShare/${ids}`,
+    method: 'DELETE',
+  })
+}

api/common/index.js

@@ -0,0 +1,34 @@
+import request from '@/utils/request'
+import qs from 'qs'
+// 设备列表
+export function deviceInfo(params) {
+	return request({
+		url: '/app/device/list',
+		method: 'GET',
+		data: params 
+	})
+}
+// APP用户设备类型列表
+export function deviceTypeList(params) {
+	return request({
+		url: '/app/device/typeList',
+		method: 'get',
+		data: params 
+	})
+}
+
+// 删除设备列表接口
+export function deviceUnbind(id) {
+	return request({
+		url: `/app/device/unBind?id=${id}`,
+		method: 'DELETE',
+	})
+}
+// 重命名设备
+export function deviceReName(data) {
+	return request({
+		url: '/app/device/reName',
+		method: 'POST',
+		data: data,
+	})
+}

api/common/login.js

@@ -0,0 +1,30 @@
+import request from '@/utils/request'
+// 登录方法
+export function login(data) {
+  return request({
+    url: '/app/auth/login',
+    method: 'POST',
+    data: data
+  })
+}
+// 注册发送验证码
+export function resourceSmsCode(params) {
+  return request({
+    url: '/resource/sms/code', //发送验证码注册
+    method: 'GET',
+    data: params
+  })
+}
+// 退出登录
+export function Logout(data) {
+  return request({
+    url: '/app/auth/logout',
+    method: 'POST',
+    data: data
+  })
+}
+
+
+
+
+

api/common/operatingInstruct/index.js

@@ -0,0 +1,19 @@
+import request from '@/utils/request'
+import qs from 'qs'
+// 查询列表
+export function fileInfo(params) {
+  return request({
+    url: '/app/file/list',
+    method: 'GET',
+    data: params
+  })
+}
+
+
+// 删除
+export function fileDelete(ids) {
+  return request({
+    url: `/app/file/delete/${ids}`,
+    method: 'delete',
+	})
+}

api/common/operationVideo/index.js

@@ -0,0 +1,32 @@
+import request from '@/utils/request'
+// 视频列表
+export function listOperationVideos(params) {
+  return request({
+    url: '/app/operationVideo/listOperationVideos',
+    method: 'GET',
+    data: params
+  })
+}
+// 添加
+export function addOperationVideo(data) {
+  return request({
+    url: '/app/operationVideo/addOperationVideo',
+    method: 'post',
+    data
+  })
+}
+// 编辑
+export function editOperationVideo(data) {
+  return request({
+    url: '/app/operationVideo/editOperationVideo',
+    method: 'post',
+    data
+  })
+}
+// 删除视频列表
+export function deleteOperationVideo(ids) {
+  return request({
+    url: `/app/operationVideo/deleteOperationVideo/${ids}`,
+    method: 'delete',
+	})
+}

api/common/qrcode.js

@@ -0,0 +1,9 @@
+import request from '@/utils/request'
+// APP设备入库绑定
+export function deviceBind(data) {
+  return request({
+    url: '/app/device/bind',
+    method: 'POST',
+    data: data
+  })
+}

components/BottomSlideMenuPlus/BottomSlideMenuPlus.vue

@@ -0,0 +1,258 @@
+<template>
+	<view class="message-popup" :class="{ 'show': config.show }">
+
+		<view class="mask" @click="closeMenu" :class="{ 'show': config.show }"
+		:style="{backgroundColor:config.maskBgColor,display:(config.showMask?'':'none')}"
+		>
+
+		</view>
+		<view class="bottom-slide-menu" :style="{ backgroundColor: config.bgColor }" :class="{ 'show': config.show }"
+			@touchmove.stop.prevent>
+			<view class="menu-header" :class="config.showHeader?'':'displayNone'">
+				<view class="title" :style="{ color: config.textColor}">{{ config.title }}</view>
+				<view  class="close-icon" @click="closeMenu"
+				:style="{display:(config.showClose?'':'none')}"
+				>
+					<image src="/static/Images/public/close.png" mode="aspectFit"></image>
+				</view>
+			</view>
+			<view class="menu-items" v-if="config.menuItems && config.menuItems.length>0">
+				<view class="menu-item" v-for="(item, index) in config.menuItems" :key="index" :style="{ 
+					color: config.textColor, 
+				textAlign: config.textAlign,
+				height:config.itemHeight,
+				lineHeight:config.itemHeight,				
+				paddingLeft: config.dividerMargin,
+				paddingRight: config.dividerMargin
+				}" @click="handleItemClick(item, index)">
+
+					<view class="p100" :style="{backgroundColor:config.activeIndex==index?config.itemBgColor:'',
+				justifyContent:config.textAlign
+				}">
+						<image v-if="item.icon" :src="item.icon" mode="aspectFit"></image>
+						<text>{{ item.text }}</text>
+					</view>
+
+
+					<view v-if="index<config.menuItems.length-1" class="menu-line"
+						:style="{paddingLeft: config.dividerMargin,paddingRight: config.dividerMargin}">
+						<view class="menu-divider"
+							:style="{borderTopWidth: config.dividerThickness,borderTopColor: config.dividerColor}">
+						</view>
+					</view>
+
+
+				</view>
+			</view>
+			<slot v-else></slot>
+			<view @click="btnClick" class="bottom-btn" :class="config.showBtn?'':'displayNone'"
+				:style="{ backgroundColor: config.btnBgColor ,color:config.btnTextColor}">
+				{{config.btnText}}
+			</view>
+		</view>
+
+	</view>
+</template>
+
+<script>
+	export default {
+		name: 'BottomSlideMenuPlus',
+		props: {
+			config: {
+				type: Object,
+				default: () => ({
+					show: false,//是否显示
+					showHeader: false,//是否显示标头
+					showMask:true,//是否显示mask
+					showDivider: false,//是否在两个项之间显示分隔线
+					showBtn: false,//是否显示底部按钮
+					showClose:false,//是否显示右上角关闭按钮
+					maskBgColor:'',//mask的颜色
+					menuItems: [],//菜单项 包含icon text
+					activeIndex: -1,//当前已选中的项编号
+					bgColor: '#2a2a2a',//主体背景
+					itemBgColor: '#3a3a3a',//各项被选中后的背景
+					textColor: '#ffffffde',//各项的文字颜色
+					textAlign: 'flex-start',//各项的文字居中方式
+					title: '',//header的文字					
+					dividerColor: '#00000000',//分隔线颜色
+					dividerThickness: '0rpx',//分隔线宽度
+					dividerMargin: '10rpx',//分隔线距离两边的宽度
+					itemHeight: '80rpx',//各项的调试					
+					btnBgColor: "#bbe600",//按钮颜色
+					btnText: "确定",//按钮文字
+					btnTextColor: "#000000",//按钮文字颜色
+					
+				})
+			},
+
+
+		},
+		
+		methods: {
+			closeMenu() {
+
+				this.$emit('close');
+			},
+			handleItemClick(item, index) {
+
+
+				this.$emit('itemClick', item, index);
+			},
+			btnClick() {
+				
+				let item = null;
+				let index = null;
+				if (this.config.activeIndex > -1) {
+					item = this.config.menuItems[this.config.activeIndex];
+				}
+				index = this.config.activeIndex;
+				this.$emit('btnClick', item, index); 
+			}
+			
+		}
+	}
+	
+</script>
+
+<style>
+	.message-popup {
+		position: relative;
+		display: none;
+	}
+
+	.message-popup.show {
+		display: block;
+	}
+
+	.p100 {
+		width: 100%;
+		height: 100%;
+		border-radius: 8rpx;
+		display: flex;
+		flex-direction: row;
+		flex-wrap: nowrap;
+		align-content: center;
+		justify-content: flex-start;
+		align-items: center;
+		box-sizing: border-box;
+		padding: 0rpx 20rpx;
+	}
+
+	.displayNone {
+		display: none !important;
+	}
+
+	.bottom-slide-menu {
+		position: fixed;
+		bottom: 0;
+		left: 0;
+		right: 0;
+		z-index: 9999;
+		transition: transform 0.3s ease-out;
+		transform: translateY(100%);
+		border-radius: 16rpx 16rpx 0 0;
+		box-shadow: 0 -2rpx 10rpx rgba(0, 0, 0, 0.1);
+	}
+
+	.mask {
+		position: fixed;
+		bottom: 0;
+		left: 0;
+		right: 0;
+		z-index: 9998;
+		width: 100%;
+		height: 100%;
+	}
+
+
+	.bottom-slide-menu.show {
+		transform: translateY(0);
+	}
+
+	.menu-header {
+		display: flex;
+		justify-content: center;
+		align-items: center;
+		padding-top: 30rpx;
+		/* border-bottom: 0.03125rem solid #eeeeee; */
+		flex-direction: row;
+		flex-wrap: nowrap;
+		width: 100%;
+		height: auto;
+		position: relative;
+	}
+
+	.title {
+		font-size: 32rpx;
+		font-weight: 600;
+	}
+
+	.close-icon {
+		width: 28rpx;
+		height: 28rpx;
+		position: absolute;
+		top: 30rpx;
+		right: 30rpx;
+
+	}
+
+	.close-icon image {
+		width: 100%;
+		height: 100%;
+	}
+
+	.menu-items {
+		padding: 20rpx 0;
+	}
+
+	.menu-item {
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		flex-direction: column;
+		flex-wrap: nowrap;
+		box-sizing: border-box;
+		font-size: 28rpx;
+		width: 100%;
+		box-sizing: border-box;
+		position: relative;
+	}
+
+	.menu-item image {
+		width: 40rpx;
+		height: 40rpx;
+		margin-right: 20rpx;
+	}
+
+	/* 分隔线样式 */
+
+	.menu-line {
+		width: 100%;
+		box-sizing: border-box;
+		position: absolute;
+		bottom: 0px;
+		height: auto;
+	}
+
+	.menu-divider {
+		border-top-style: solid;
+		width: 100%;
+		height: 0px;
+
+
+	}
+
+	.bottom-btn {
+		width: 100%;
+		height: 90rpx;
+		text-align: center;
+		color: rgba(35, 35, 35, 0.87);
+		font-family: PingFang SC;
+		font-size: 30rpx;
+		font-weight: 600;
+		line-height: 90rpx;
+		letter-spacing: 12rpx;
+		text-align: center;
+	}
+</style>

components/CustomPopup/CustomPopup.vue

@@ -0,0 +1,182 @@
+<template>
+  <view class="agreement-mask" v-if="show" @click="closePopup">
+    <view class="agreement-popup" @click.stop>
+      <view class="popup-content">
+        <!-- 动态图标 -->
+        <image v-if="showIcon && icon" :src="icon" mode="aspectFit" class="svg"></image>
+        <view class="text-content">
+          <!-- 动态标题 -->
+          <view class="popup-Title" v-if="title">{{ title }}</view>
+          <!-- 动态消息内容 -->
+          <view class="popup-Message" v-if="message">{{ message }}</view>
+        </view>
+      </view>
+      <!-- 按钮组 -->
+      <view class="popup-buttons">
+        <button v-if="showCancel" class="btn cancelBtn" @click="handleCancel">{{ cancelText }}</button>
+        <button class="btn agreeBtn" @click="handleConfirm">{{ confirmText }}</button>
+      </view>
+    </view>
+  </view>
+</template>
+
+<script>
+export default {
+  props: {
+    // 控制显示
+    show: {
+      type: Boolean,
+      default: false
+    },
+    // 标题内容（可选）
+    title: {
+      type: String,
+      default: ''
+    },
+    // 消息内容
+    message: {
+      type: String,
+      default: ''
+    },
+    // 确认按钮文本
+    confirmText: {
+      type: String,
+      default: '确定'
+    },
+    // 取消按钮文本
+    cancelText: {
+      type: String,
+      default: '取消'
+    },
+    // 是否显示取消按钮
+    showCancel: {
+      type: Boolean,
+      default: false
+    },
+    // 是否显示图标
+    showIcon: {
+      type: Boolean,
+      default: true
+    },
+    // 图标路径（支持网络和本地路径）
+    icon: {
+      type: String,
+      default: ''
+    },
+    // 图标样式
+    iconStyle: {
+      type: Object,
+      default: () => ({
+        width: '58rpx',
+        height: '62rpx',
+        marginBottom: '20rpx'
+      })
+    }
+  },
+  methods: {
+    handleConfirm() {
+      this.$emit('confirm')
+      this.$emit('update:show', false)
+    },
+    handleCancel() {
+      this.$emit('cancel')
+      this.$emit('update:show', false)
+    },
+    closePopup() {
+      this.$emit('close')
+      this.$emit('update:show', false)
+    }
+  }
+}
+</script>
+
+<style scoped>
+/* 遮罩层 */
+.agreement-mask {
+  position: fixed;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  background-color: rgba(0, 0, 0, 0.5);
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  z-index: 9999;
+}
+
+/* 弹窗主体 */
+.agreement-popup {
+  width: 60%;
+  background-color: rgb(42, 42, 42);
+  border-radius: 40rpx;
+  padding: 30rpx;
+  text-align: center;
+  border: 1px solid rgba(255, 200, 78, 0.3);
+}
+
+.popup-content {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+}
+
+.text-content {
+  width: 100%;
+}
+
+.popup-Title {
+  color: rgba(255, 255, 255, 0.86);
+  text-align: center;
+  padding: 30rpx 0 10rpx;
+  font-size: 32rpx;
+  font-weight: bold;
+}
+
+.popup-Message {
+  color: rgba(255, 255, 255, 0.7);
+  text-align: center;
+  padding: 10rpx 20rpx 30rpx;
+  font-size: 28rpx;
+  line-height: 1.5;
+}
+
+/* 图标样式 */
+.svg {
+  width: 72rpx;
+  height: 60rpx;
+  margin-bottom: v-bind('iconStyle.marginBottom');
+}
+
+/* 按钮组 */
+.popup-buttons {
+  display: flex;
+  justify-content: center;
+  margin-top: 20rpx;
+}
+
+/* 按钮基础样式 */
+.btn {
+  height: 60rpx;
+  line-height: 60rpx;
+  border-radius: 40rpx;
+  font-size: 24rpx;
+  margin: 0 10rpx;
+  padding: 0 30rpx;
+  min-width: 170rpx;
+}
+
+/* 确认按钮 */
+.agreeBtn {
+  background: rgba(187, 230, 0, 1);
+  color: #232323;
+  border: none;
+}
+
+/* 取消按钮 */
+.cancelBtn {
+  background: transparent;
+  color: rgba(255, 255, 255, 0.7);
+  border: 1px solid rgba(255, 255, 255, 0.3);
+}
+</style>

components/MessagePopup/MessagePopup.vue

@@ -0,0 +1,381 @@
+<template>
+  <view class="message-popup" v-if="visible">
+    <view class="popup-mask" @click="handleMaskClick"></view>
+    <view 
+      class="popup-content" 
+      :style="{ 
+        backgroundColor: bgColor || getTypeStyle('bgColor'),
+        borderColor: borderColor || getTypeStyle('borderColor'),
+        color: textColor || getTypeStyle('textColor')
+      }"
+    >
+	<view v-if="showHeader&&headerTxt" class="header"
+	
+	>{{headerTxt}}</view>
+	
+     <view v-if="visibleClose" class="rightClose" 
+	 :style="{color:textColor || getTypeStyle('textColor')}"
+	 @click="closeClick"
+	 >x</view>
+      <view v-if="!visiblePrompt">
+        <image 
+          v-if="iconUrl" 
+          :src="iconUrl" 
+          mode="aspectFit" 
+          class="popup-icon"
+          :style="{ tintColor: textColor || getTypeStyle('textColor') }"
+        ></image>
+        <view class="popup-message">{{ message }}</view>
+      </view>
+      
+     
+      <view v-else class="popup-prompt">
+        <text class="popup-prompt-title">{{ promptTitle || '请输入信息' }}</text>
+        <input 
+          class="popup-prompt-input"  
+          :placeholder="promptPlaceholder" 
+          :value="modelValue"
+          @input="handleInput"
+          @confirm="handleButtonClick"
+        />
+      </view>
+      
+	  <view class="popBtnContent">
+		  
+		  <view
+		    class="popup-button-cancel" 
+		   :style="{display:showCancel?'block':'none'}"
+		    @click="handleCancelClick"
+		  >{{ buttonCancelText?buttonCancelText:'取消' }}</view>
+		  
+		  <view
+		    class="popup-button" 
+		    :style="{ 
+		      backgroundColor: buttonBgColor || getTypeStyle('buttonBgColor'),
+		      color: buttonTextColor || getTypeStyle('buttonTextColor')
+		    }"
+		    @click="handleButtonClick"
+		  >{{ buttonText }}</view>
+		  
+		  
+	  </view>
+     
+	  
+	  
+    </view>
+  </view>
+</template>
+
+<script>
+export default {
+  name: 'MessagePopup',
+  props: {
+    visible: {
+      type: Boolean,
+      default: false
+    },
+	visibleClose:{
+		type:Boolean,
+		default:true
+	},
+    visiblePrompt: {
+      type: Boolean,
+      default: false
+    },
+    promptTitle: String,
+    promptPlaceholder: {
+      type: String,
+      default: "请输入"
+    },
+    modelValue: {
+      type: String,
+      default: ''
+    },
+    type: {
+      type: String,
+      default: 'info',
+      validator: value => ['success', 'error', 'info','custom'].includes(value)
+    },
+    bgColor: String,
+    borderColor: String,
+    textColor: String,
+    buttonBgColor: String,
+    buttonTextColor: String,
+    iconUrl: String,
+    message: {
+      type: String,
+      default: ''
+    },
+    buttonText: {
+      type: String,
+      default: '确定'
+    },
+	buttonCancelText:{
+		type:String,
+		default:'取消'
+	},
+	showCancel:{
+		type:Boolean,
+		default:false
+	},
+	showHeader:{
+		type:Boolean,
+		default:false
+	},
+	headerTxt:{
+		type:String,
+		default:""
+	}
+  },
+  data() {
+    return {
+      inputValue: this.modelValue
+    }
+  },
+  watch: {
+    // 监听外部值变化
+    modelValue(newVal) {
+      this.inputValue = newVal
+    },
+    // 监听模式切换
+    visiblePrompt(newVal) {
+      console.log('[MessagePopup] visiblePrompt changed to:', newVal)
+      // 重置输入值
+      if (newVal) {
+        this.inputValue = this.modelValue
+      }
+    }
+  },
+  mounted() {
+    
+  },
+  methods: {
+    getTypeStyle(styleType) {
+      const styles = {
+        success: {
+          bgColor: '#f0fff0',
+          borderColor: '#52c41a',
+          textColor: '#389e0d',
+          buttonBgColor: '#52c41a',
+          buttonTextColor: '#FFFFFF'
+        },
+        error: {
+          bgColor: '#fff0f0',
+          borderColor: '#ff4d4f',
+          textColor: '#cf1322',
+          buttonBgColor: '#ff4d4f',
+          buttonTextColor: '#FFFFFF'
+        },
+        info: {
+          bgColor: '#e6f7ff',
+          borderColor: '#1890ff',
+          textColor: '#0050b3',
+          buttonBgColor: '#1890ff',
+          buttonTextColor: '#FFFFFF'
+        }
+      }
+      return styles[this.type][styleType]
+    },
+    handleButtonClick() {
+      console.log('[MessagePopup] Button clicked with value:', this.inputValue)
+      this.$emit('buttonClick', this.inputValue)
+    },
+    handleMaskClick() {
+      console.log('[MessagePopup] Mask clicked')
+      this.$emit('maskClick')
+    },
+	closeClick(){
+		 this.$emit('closePop')
+	},
+	handleCancelClick(){
+		this.$emit('cancelPop');
+	},
+    handleInput(e) {
+		
+      this.inputValue = e.detail.value
+      this.$emit('update:modelValue', this.inputValue)
+    }
+  }
+}
+</script>
+
+<style>
+.message-popup {
+  position: fixed;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+  z-index: 9999;
+  display: flex;
+  justify-content: center;
+  align-items: center;
+}
+
+.popup-mask {
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+  background-color: rgba(0, 0, 0, 0.5);
+}
+
+.popup-content {
+  position: relative;
+  width: 80%;
+  max-width: 400px;
+  border-radius: 12px;
+  padding: 30rpx;
+  background-color: white;
+  box-shadow: 0 4px 16px rgba(0, 0, 0, 0.1);
+  border-width: 2rpx;
+  border-style: solid;
+  box-sizing: border-box;
+  z-index: 10;
+}
+.header{
+	width:100%;
+	color: rgba(255, 255, 255, 0.87);
+	font-family: PingFang SC;
+	font-size: 32rpx;
+	font-weight: 600;
+	height: 80rpx;
+	line-height: 80rpx;
+	letter-spacing: 0.07px;
+	text-align: center;
+}
+.rightClose{
+	position: absolute;
+	right: 20rpx;
+	top: 20rpx;
+	color: #FFFFFF;
+	font-size: 36rpx;
+	width: 24rpx;
+	height: 24rpx;
+	line-height: 24rpx;
+}
+.popup-icon {
+  width: 60rpx;
+  height: 60rpx;
+  margin: 20rpx auto;
+  display: block;
+}
+
+.popup-message {
+  font-size: 28rpx;
+  text-align: center;
+  padding: 20rpx 0rpx 30rpx 0rpx;
+
+  
+  font-weight: 400;
+
+  letter-spacing: 0.07px;
+}
+
+.popup-prompt {
+  width: 100%;
+}
+
+.popup-prompt-title {
+  display: block;
+  font-size: 32rpx;
+  text-align: center;
+  margin-bottom: 20rpx;
+  font-weight: 500;
+}
+
+.popup-prompt-input {
+  width: 100%;
+  height: 80rpx;
+  line-height: 80rpx;
+  border: 1rpx solid #ddd;
+  border-radius: 8rpx;
+  padding: 0 20rpx;
+  margin-bottom: 30rpx;
+  font-size: 28rpx;
+  box-sizing: border-box;
+}
+
+.popBtnContent{
+	width:100%;
+	height: 60rpx;
+	 margin-top: 20rpx;
+	     display: flex
+	 ;
+	     flex-direction: row;
+	     flex-wrap: nowrap;
+	     align-content: center;
+	     justify-content: space-evenly;
+	     align-items: center;
+}
+.popup-button {
+  width: 30%;
+  height: 60rpx;
+  line-height: 60rpx;
+  border-radius: 44rpx;
+  
+  text-align: center;
+  font-size: 24rpx;
+  font-weight: 500;
+  letter-spacing: 4rpx;
+  border: none;
+  outline: none;
+  cursor: pointer;
+ 
+}
+
+.popup-button-cancel{
+	width: 30%;
+	height: 60rpx;
+	line-height: 60rpx;
+	border-radius: 44rpx;
+	
+	text-align: center;
+	font-size: 24rpx;
+	font-weight: 500;
+	letter-spacing: 4rpx;
+	border: none;
+	outline: none;
+	cursor: pointer;
+	 
+	 box-sizing: border-box;
+	 border: 1px solid rgba(255, 255, 255, 0.5);
+
+	 background-color: #00000000;
+	
+color: #FFFFFFde;
+}
+
+.popup-prompt{
+	width: 100%;
+	height: 60rpx;
+	line-height: 60rpx;
+padding-top: 40rpx;	
+}
+
+
+.popup-prompt-title{
+	color: rgba(255, 255, 255, 0.6);
+	text-align: right;
+	width: 30%;
+	float: left;
+	box-sizing: border-box;
+	white-space:nowrap;
+	padding-right: 10rpx;
+}
+.popup-prompt-input{
+	float: left;
+	width: 70%;
+	height: 60rpx;
+	line-height: 60rpx;
+	color: rgba(255, 255, 255, 0.87) ;
+	
+	box-sizing: border-box;
+	border: 2rpx solid rgba(255, 255, 255, 0.4);
+	border-radius: 8rpx;
+
+}
+
+
+</style>

components/Progress/Progress.vue

@@ -0,0 +1,129 @@
+<template>
+	<view class="message-popup" :class="{ 'show': config.show }">
+		<view class="mask" @click="closeProgress" :class="{ 'show': config.show }"
+			:style="{backgroundColor:config.maskBgColor,display:(config.showMask?'':'none')}">
+		</view>
+
+		<view class="progress-content" :style="{backgroundColor:config.contentBgColor}">
+			<text
+				:style="{color:config.txtColor,display:(config.showText?'':'none')}">{{config.curr}}/{{config.total}}</text>
+			<view class="jdWai"
+				:style="{borderRadius:config.borderRadius, backgroundColor:config.proBgColor,border:config.proBorder,height:config.height}">
+				<view class="jdNei"
+					:style="{borderRadius:config.borderRadius,height:config.height,backgroundColor:config.currBgColor,border:config.currBorder,width:(config.curr/config.total*100)+'%'}">
+				</view>
+			</view>
+		</view>
+	</view>
+</template>
+
+<script>
+	export default {
+		name: "Progress",
+		data() {
+			return {
+
+			};
+		},
+		props: {
+			config: {
+				type: Object,
+				default: () => ({
+					show: false, //是否显示
+					showMask: true, //是否显示mask
+					height:'20px',
+					maskBgColor: '#00000000', //mask背景颜色
+					contentBgColor: '#121212', //总背景颜色
+					showText: true, //是否显示当前进度的文字
+					txtColor: '#ffffffde', //文字的颜色
+					curr: 0, //当前进度
+					total: 100, //总进度
+					proBgColor: '#2a2a2a', //进度条底色,
+					proBorder: '', //进度条border
+					currBgColor: '#bbe600', //当前进度底色
+					currBorder: '', //当前进度border
+					borderRadius:'10px'
+				})
+			}
+		},methods: {
+			closeProgress() {
+
+				this.$emit('closeProgress');
+			}
+			}
+	}
+</script>
+
+<style>
+	.message-popup {
+		position: fixed;
+		top: 0;
+		left: 0;
+		width: 100%;
+		height: 100%;
+		z-index: 9999;
+		display: none;
+		justify-content: center;
+		align-items: center;
+	}
+
+	.message-popup.show {
+		display: block;
+	}
+
+	.p100 {
+		width: 100%;
+		height: 100%;
+		border-radius: 8rpx;
+		display: flex;
+		flex-direction: row;
+		flex-wrap: nowrap;
+		align-content: center;
+		justify-content: flex-start;
+		align-items: center;
+		box-sizing: border-box;
+		padding: 0rpx 20rpx;
+	}
+
+	.displayNone {
+		display: none !important;
+	}
+
+
+
+	.mask {
+		position: fixed;
+		bottom: 0;
+		left: 0;
+		right: 0;
+		z-index: 9;
+		width: 100%;
+		height: 100%;
+	}
+
+
+	.progress-content {
+		position: relative;
+		width: 100%;
+		padding: 30rpx;
+		box-sizing: border-box;
+		z-index: 10;
+
+		display: flex;
+		flex-direction: column;
+		flex-wrap: nowrap;
+		align-content: center;
+		align-items: center;
+		height: 100%;
+		justify-content: center;
+	}
+
+	.jdWai {
+		width: 100%;
+	}
+
+	.jdNei {
+		height: 100%;
+
+	}
+</style>

components/custom-navbar/custom-navbar.vue

@@ -23,7 +23,8 @@
 					{{ rightText }}
 				</text>
 				<!-- 或显示图标 -->
-				<image v-if="rightIcon" @click="handleRightClick" src="/static/images/path.png" mode="" class="pathIMG">
+				<image v-if="rightIcon" :src="rightIcon" @click="handleRightClick"  mode=""
+					class="pathIMG">
 				</image>
 			</slot>
 		</view>
@@ -49,8 +50,8 @@
 			},
 			rightText: String, // 右侧文字
 			rightIcon: {
-				type: Boolean,
-				default: false
+				type: String, // 改为 String 类型，接收图片路径
+				default: '' // 默认空字符串
 			},
 			rightColor: { // 右侧内容颜色
 				type: String,

config/index.js

@@ -0,0 +1,25 @@
+// 全局配置文件
+const config = {
+	// 开发环境
+	development: {
+		BASE_URL: 'http://192.168.2.34:8000',
+		API_PREFIX: '',
+		// MQTT 配置
+		MQTT_HOST: '47.120.79.150',
+		MQTT_PORT: 8083,
+		MQTT_USERNAME: 'admin',
+		MQTT_PASSWORD: '#YtvpSfCNG'
+	},
+	// 生产环境
+	production: {
+		BASE_URL: 'http://47.120.79.150/backend', // https://fuyuanshen.com/backend
+		API_PREFIX: '',
+		// MQTT 配置
+		MQTT_HOST: '47.120.79.150',
+		MQTT_PORT: 8083,
+		MQTT_USERNAME: 'admin',
+		MQTT_PASSWORD: '#YtvpSfCNG'
+	}
+};
+
+export default config; 

manifest.json

@@ -22,7 +22,8 @@
             "Barcode" : {},
             "Camera" : {},
             "Maps" : {},
-            "OAuth" : {}
+            "OAuth" : {},
+            "Geolocation" : {}
         },
         /* 应用发布信息 */
         "distribute" : {
@@ -58,6 +59,7 @@
             },
             /* ios打包配置 */
             "ios" : {
+                "appid" : "uni.app.UNIA21EF43",
                 "privacyDescription" : {
                     "NSBluetoothPeripheralUsageDescription" : "需要蓝牙访问权限，用于设备通信",
                     "NSBluetoothAlwaysUsageDescription" : "需要蓝牙访问权限，用于设备通信"
@@ -66,8 +68,21 @@
             },
             /* SDK配置 */
             "sdkConfigs" : {
-                "geolocation" : {},
-                "maps" : {},
+                "geolocation" : {
+                    "amap" : {
+                        "name" : "amapHG8nIFW5",
+                        "__platform__" : [ "ios", "android" ],
+                        "appkey_ios" : "065c43f02c7b627a74ad7dd23b16bb4f",
+                        "appkey_android" : "d7d852dbda2b95f6f796fb9a711a9fee"
+                    }
+                },
+                "maps" : {
+                    "amap" : {
+                        "name" : "amapHG8nIFW5",
+                        "appkey_ios" : "065c43f02c7b627a74ad7dd23b16bb4f",
+                        "appkey_android" : "d7d852dbda2b95f6f796fb9a711a9fee"
+                    }
+                },
                 "oauth" : {},
                 "push" : {}
             },

node_modules/.bin/mqtt

@@ -1,15 +0,0 @@
-#!/bin/sh
-basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
-
-case `uname` in
-    *CYGWIN*|*MINGW*|*MSYS*) basedir=`cygpath -w "$basedir"`;;
-esac
-
-if [ -x "$basedir/node" ]; then
-  "$basedir/node"  "$basedir/../mqtt/mqtt.js" "$@"
-  ret=$?
-else 
-  node  "$basedir/../mqtt/mqtt.js" "$@"
-  ret=$?
-fi
-exit $ret

node_modules/.bin/mqtt.cmd

@@ -1,17 +0,0 @@
-@ECHO off
-SETLOCAL
-CALL :find_dp0
-
-IF EXIST "%dp0%\node.exe" (
-  SET "_prog=%dp0%\node.exe"
-) ELSE (
-  SET "_prog=node"
-  SET PATHEXT=%PATHEXT:;.JS;=;%
-)
-
-"%_prog%"  "%dp0%\..\mqtt\mqtt.js" %*
-ENDLOCAL
-EXIT /b %errorlevel%
-:find_dp0
-SET dp0=%~dp0
-EXIT /b

node_modules/.bin/mqtt.ps1

@@ -1,18 +0,0 @@
-#!/usr/bin/env pwsh
-$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
-
-$exe=""
-if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
-  # Fix case when both the Windows and Linux builds of Node
-  # are installed in the same directory
-  $exe=".exe"
-}
-$ret=0
-if (Test-Path "$basedir/node$exe") {
-  & "$basedir/node$exe"  "$basedir/../mqtt/mqtt.js" $args
-  $ret=$LASTEXITCODE
-} else {
-  & "node$exe"  "$basedir/../mqtt/mqtt.js" $args
-  $ret=$LASTEXITCODE
-}
-exit $ret

node_modules/.bin/mqtt_pub

@@ -1,15 +0,0 @@
-#!/bin/sh
-basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
-
-case `uname` in
-    *CYGWIN*|*MINGW*|*MSYS*) basedir=`cygpath -w "$basedir"`;;
-esac
-
-if [ -x "$basedir/node" ]; then
-  "$basedir/node"  "$basedir/../mqtt/bin/pub.js" "$@"
-  ret=$?
-else 
-  node  "$basedir/../mqtt/bin/pub.js" "$@"
-  ret=$?
-fi
-exit $ret

node_modules/.bin/mqtt_pub.cmd

@@ -1,17 +0,0 @@
-@ECHO off
-SETLOCAL
-CALL :find_dp0
-
-IF EXIST "%dp0%\node.exe" (
-  SET "_prog=%dp0%\node.exe"
-) ELSE (
-  SET "_prog=node"
-  SET PATHEXT=%PATHEXT:;.JS;=;%
-)
-
-"%_prog%"  "%dp0%\..\mqtt\bin\pub.js" %*
-ENDLOCAL
-EXIT /b %errorlevel%
-:find_dp0
-SET dp0=%~dp0
-EXIT /b

node_modules/.bin/mqtt_pub.ps1

@@ -1,18 +0,0 @@
-#!/usr/bin/env pwsh
-$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
-
-$exe=""
-if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
-  # Fix case when both the Windows and Linux builds of Node
-  # are installed in the same directory
-  $exe=".exe"
-}
-$ret=0
-if (Test-Path "$basedir/node$exe") {
-  & "$basedir/node$exe"  "$basedir/../mqtt/bin/pub.js" $args
-  $ret=$LASTEXITCODE
-} else {
-  & "node$exe"  "$basedir/../mqtt/bin/pub.js" $args
-  $ret=$LASTEXITCODE
-}
-exit $ret

node_modules/.bin/mqtt_sub

@@ -1,15 +0,0 @@
-#!/bin/sh
-basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
-
-case `uname` in
-    *CYGWIN*|*MINGW*|*MSYS*) basedir=`cygpath -w "$basedir"`;;
-esac
-
-if [ -x "$basedir/node" ]; then
-  "$basedir/node"  "$basedir/../mqtt/bin/sub.js" "$@"
-  ret=$?
-else 
-  node  "$basedir/../mqtt/bin/sub.js" "$@"
-  ret=$?
-fi
-exit $ret

node_modules/.bin/mqtt_sub.cmd

@@ -1,17 +0,0 @@
-@ECHO off
-SETLOCAL
-CALL :find_dp0
-
-IF EXIST "%dp0%\node.exe" (
-  SET "_prog=%dp0%\node.exe"
-) ELSE (
-  SET "_prog=node"
-  SET PATHEXT=%PATHEXT:;.JS;=;%
-)
-
-"%_prog%"  "%dp0%\..\mqtt\bin\sub.js" %*
-ENDLOCAL
-EXIT /b %errorlevel%
-:find_dp0
-SET dp0=%~dp0
-EXIT /b

node_modules/.bin/mqtt_sub.ps1

@@ -1,18 +0,0 @@
-#!/usr/bin/env pwsh
-$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
-
-$exe=""
-if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
-  # Fix case when both the Windows and Linux builds of Node
-  # are installed in the same directory
-  $exe=".exe"
-}
-$ret=0
-if (Test-Path "$basedir/node$exe") {
-  & "$basedir/node$exe"  "$basedir/../mqtt/bin/sub.js" $args
-  $ret=$LASTEXITCODE
-} else {
-  & "node$exe"  "$basedir/../mqtt/bin/sub.js" $args
-  $ret=$LASTEXITCODE
-}
-exit $ret

node_modules/async-limiter/.eslintignore

@@ -1,2 +0,0 @@
-coverage
-.nyc_output

node_modules/async-limiter/.nycrc

@@ -1,10 +0,0 @@
-{
-  "check-coverage": false,
-  "lines": 99,
-  "statements": 99,
-  "functions": 99,
-  "branches": 99,
-  "include": [
-     "index.js"
-  ]
-}

node_modules/async-limiter/.travis.yml

@@ -1,9 +0,0 @@
-language: node_js
-node_js:
-  - "6"
-  - "8"
-  - "10"
-  - "node"
-script: npm run travis
-cache:
-  yarn: true

node_modules/async-limiter/LICENSE

@@ -1,8 +0,0 @@
-The MIT License (MIT)
-Copyright (c) 2017 Samuel Reed <samuel.trace.reed@gmail.com>
-
-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.

node_modules/async-limiter/index.js

@@ -1,67 +0,0 @@
-'use strict';
-
-function Queue(options) {
-  if (!(this instanceof Queue)) {
-    return new Queue(options);
-  }
-
-  options = options || {};
-  this.concurrency = options.concurrency || Infinity;
-  this.pending = 0;
-  this.jobs = [];
-  this.cbs = [];
-  this._done = done.bind(this);
-}
-
-var arrayAddMethods = [
-  'push',
-  'unshift',
-  'splice'
-];
-
-arrayAddMethods.forEach(function(method) {
-  Queue.prototype[method] = function() {
-    var methodResult = Array.prototype[method].apply(this.jobs, arguments);
-    this._run();
-    return methodResult;
-  };
-});
-
-Object.defineProperty(Queue.prototype, 'length', {
-  get: function() {
-    return this.pending + this.jobs.length;
-  }
-});
-
-Queue.prototype._run = function() {
-  if (this.pending === this.concurrency) {
-    return;
-  }
-  if (this.jobs.length) {
-    var job = this.jobs.shift();
-    this.pending++;
-    job(this._done);
-    this._run();
-  }
-
-  if (this.pending === 0) {
-    while (this.cbs.length !== 0) {
-      var cb = this.cbs.pop();
-      process.nextTick(cb);
-    }
-  }
-};
-
-Queue.prototype.onDone = function(cb) {
-  if (typeof cb === 'function') {
-    this.cbs.push(cb);
-    this._run();
-  }
-};
-
-function done() {
-  this.pending--;
-  this._run();
-}
-
-module.exports = Queue;

node_modules/async-limiter/package.json

@@ -1,69 +0,0 @@
-{
-  "_from": "async-limiter@~1.0.0",
-  "_id": "async-limiter@1.0.1",
-  "_inBundle": false,
-  "_integrity": "sha512-csOlWGAcRFJaI6m+F2WKdnMKr4HhdhFVBk0H/QbJFMCr+uO2kwohwXQPxw/9OCxp05r5ghVBFSyioixx3gfkNQ==",
-  "_location": "/async-limiter",
-  "_phantomChildren": {},
-  "_requested": {
-    "type": "range",
-    "registry": true,
-    "raw": "async-limiter@~1.0.0",
-    "name": "async-limiter",
-    "escapedName": "async-limiter",
-    "rawSpec": "~1.0.0",
-    "saveSpec": null,
-    "fetchSpec": "~1.0.0"
-  },
-  "_requiredBy": [
-    "/ws"
-  ],
-  "_resolved": "https://registry.npmjs.org/async-limiter/-/async-limiter-1.0.1.tgz",
-  "_shasum": "dd379e94f0db8310b08291f9d64c3209766617fd",
-  "_spec": "async-limiter@~1.0.0",
-  "_where": "E:\\gitee\\fys\\fys\\app\\JingQuan\\node_modules\\ws",
-  "author": {
-    "name": "Samuel Reed"
-  },
-  "bugs": {
-    "url": "https://github.com/strml/async-limiter/issues"
-  },
-  "bundleDependencies": false,
-  "dependencies": {},
-  "deprecated": false,
-  "description": "asynchronous function queue with adjustable concurrency",
-  "devDependencies": {
-    "coveralls": "^3.0.3",
-    "eslint": "^5.16.0",
-    "eslint-plugin-mocha": "^5.3.0",
-    "intelli-espower-loader": "^1.0.1",
-    "mocha": "^6.1.4",
-    "nyc": "^14.1.1",
-    "power-assert": "^1.6.1"
-  },
-  "homepage": "https://github.com/strml/async-limiter#readme",
-  "keywords": [
-    "throttle",
-    "async",
-    "limiter",
-    "asynchronous",
-    "job",
-    "task",
-    "concurrency",
-    "concurrent"
-  ],
-  "license": "MIT",
-  "name": "async-limiter",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/strml/async-limiter.git"
-  },
-  "scripts": {
-    "coverage": "nyc npm test && nyc report --reporter=text-lcov | coveralls",
-    "example": "node example",
-    "lint": "eslint .",
-    "test": "mocha --require intelli-espower-loader test/",
-    "travis": "npm run lint && npm run test"
-  },
-  "version": "1.0.1"
-}

node_modules/async-limiter/readme.md

@@ -1,132 +0,0 @@
-# Async-Limiter
-
-A module for limiting concurrent asynchronous actions in flight. Forked from [queue](https://github.com/jessetane/queue).
-
-[![npm](http://img.shields.io/npm/v/async-limiter.svg?style=flat-square)](http://www.npmjs.org/async-limiter)
-[![tests](https://img.shields.io/travis/STRML/async-limiter.svg?style=flat-square&branch=master)](https://travis-ci.org/STRML/async-limiter)
-[![coverage](https://img.shields.io/coveralls/STRML/async-limiter.svg?style=flat-square&branch=master)](https://coveralls.io/r/STRML/async-limiter)
-
-This module exports a class `Limiter` that implements some of the `Array` API.
-Pass async functions (ones that accept a callback or return a promise) to an instance's additive array methods.
-
-## Motivation
-
-Certain functions, like `zlib`, have [undesirable behavior](https://github.com/nodejs/node/issues/8871#issuecomment-250915913) when
-run at infinite concurrency.
-
-In this case, it is actually faster, and takes far less memory, to limit concurrency.
-
-This module should do the absolute minimum work necessary to queue up functions. PRs are welcome that would
-make this module faster or lighter, but new functionality is not desired.
-
-Style should confirm to nodejs/node style.
-
-## Example
-
-``` javascript
-var Limiter = require('async-limiter')
-
-var t = new Limiter({concurrency: 2});
-var results = []
-
-// add jobs using the familiar Array API
-t.push(function (cb) {
-  results.push('two')
-  cb()
-})
-
-t.push(
-  function (cb) {
-    results.push('four')
-    cb()
-  },
-  function (cb) {
-    results.push('five')
-    cb()
-  }
-)
-
-t.unshift(function (cb) {
-  results.push('one')
-  cb()
-})
-
-t.splice(2, 0, function (cb) {
-  results.push('three')
-  cb()
-})
-
-// Jobs run automatically. If you want a callback when all are done,
-// call 'onDone()'.
-t.onDone(function () {
-  console.log('all done:', results)
-})
-```
-
-## Zlib Example
-
-```js
-const zlib = require('zlib');
-const Limiter = require('async-limiter');
-
-const message = {some: "data"};
-const payload = new Buffer(JSON.stringify(message));
-
-// Try with different concurrency values to see how this actually
-// slows significantly with higher concurrency!
-//
-// 5:        1398.607ms
-// 10:       1375.668ms
-// Infinity: 4423.300ms
-//
-const t = new Limiter({concurrency: 5});
-function deflate(payload, cb) {
-  t.push(function(done) {
-    zlib.deflate(payload, function(err, buffer) {
-      done();
-      cb(err, buffer);
-    });
-  });
-}
-
-console.time('deflate');
-for(let i = 0; i < 30000; ++i) {
-  deflate(payload, function (err, buffer) {});
-}
-t.onDone(function() {
-  console.timeEnd('deflate');
-});
-```
-
-## Install
-
-`npm install async-limiter`
-
-## Test
-
-`npm test`
-
-## API
-
-### `var t = new Limiter([opts])`
-Constructor. `opts` may contain inital values for:
-* `t.concurrency`
-
-## Instance methods
-
-### `t.onDone(fn)`
-`fn` will be called once and only once, when the queue is empty.
-
-## Instance methods mixed in from `Array`
-Mozilla has docs on how these methods work [here](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array).
-### `t.push(element1, ..., elementN)`
-### `t.unshift(element1, ..., elementN)`
-### `t.splice(index , howMany[, element1[, ...[, elementN]]])`
-
-## Properties
-### `t.concurrency`
-Max number of jobs the queue should process concurrently, defaults to `Infinity`.
-
-### `t.length`
-Jobs pending + jobs to process (readonly).
-

node_modules/asynckit/package.json

@@ -1,38 +1,49 @@
 {
-  "_from": "asynckit@^0.4.0",
-  "_id": "asynckit@0.4.0",
-  "_inBundle": false,
-  "_integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==",
-  "_location": "/asynckit",
-  "_phantomChildren": {},
-  "_requested": {
-    "type": "range",
-    "registry": true,
-    "raw": "asynckit@^0.4.0",
-    "name": "asynckit",
-    "escapedName": "asynckit",
-    "rawSpec": "^0.4.0",
-    "saveSpec": null,
-    "fetchSpec": "^0.4.0"
+  "name": "asynckit",
+  "version": "0.4.0",
+  "description": "Minimal async jobs utility library, with streams support",
+  "main": "index.js",
+  "scripts": {
+    "clean": "rimraf coverage",
+    "lint": "eslint *.js lib/*.js test/*.js",
+    "test": "istanbul cover --reporter=json tape -- 'test/test-*.js' | tap-spec",
+    "win-test": "tape test/test-*.js",
+    "browser": "browserify -t browserify-istanbul test/lib/browserify_adjustment.js test/test-*.js | obake --coverage | tap-spec",
+    "report": "istanbul report",
+    "size": "browserify index.js | size-table asynckit",
+    "debug": "tape test/test-*.js"
   },
-  "_requiredBy": [
-    "/form-data"
+  "pre-commit": [
+    "clean",
+    "lint",
+    "test",
+    "browser",
+    "report",
+    "size"
   ],
-  "_resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
-  "_shasum": "c79ed97f7f34cb8f2ba1bc9790bcc366474b4b79",
-  "_spec": "asynckit@^0.4.0",
-  "_where": "E:\\gitee\\fys\\fys\\app\\Fuyuan\\node_modules\\form-data",
-  "author": {
-    "name": "Alex Indigo",
-    "email": "iam@alexindigo.com"
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/alexindigo/asynckit.git"
   },
+  "keywords": [
+    "async",
+    "jobs",
+    "parallel",
+    "serial",
+    "iterator",
+    "array",
+    "object",
+    "stream",
+    "destroy",
+    "terminate",
+    "abort"
+  ],
+  "author": "Alex Indigo <iam@alexindigo.com>",
+  "license": "MIT",
   "bugs": {
     "url": "https://github.com/alexindigo/asynckit/issues"
   },
-  "bundleDependencies": false,
-  "dependencies": {},
-  "deprecated": false,
-  "description": "Minimal async jobs utility library, with streams support",
+  "homepage": "https://github.com/alexindigo/asynckit#readme",
   "devDependencies": {
     "browserify": "^13.0.0",
     "browserify-istanbul": "^2.0.0",
@@ -48,44 +59,5 @@
     "tap-spec": "^4.1.1",
     "tape": "^4.5.1"
   },
-  "homepage": "https://github.com/alexindigo/asynckit#readme",
-  "keywords": [
-    "async",
-    "jobs",
-    "parallel",
-    "serial",
-    "iterator",
-    "array",
-    "object",
-    "stream",
-    "destroy",
-    "terminate",
-    "abort"
-  ],
-  "license": "MIT",
-  "main": "index.js",
-  "name": "asynckit",
-  "pre-commit": [
-    "clean",
-    "lint",
-    "test",
-    "browser",
-    "report",
-    "size"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/alexindigo/asynckit.git"
-  },
-  "scripts": {
-    "browser": "browserify -t browserify-istanbul test/lib/browserify_adjustment.js test/test-*.js | obake --coverage | tap-spec",
-    "clean": "rimraf coverage",
-    "debug": "tape test/test-*.js",
-    "lint": "eslint *.js lib/*.js test/*.js",
-    "report": "istanbul report",
-    "size": "browserify index.js | size-table asynckit",
-    "test": "istanbul cover --reporter=json tape -- 'test/test-*.js' | tap-spec",
-    "win-test": "tape test/test-*.js"
-  },
-  "version": "0.4.0"
+  "dependencies": {}
 }

node_modules/axios/package.json

@@ -1,126 +1,90 @@
 {
-  "_from": "axios",
-  "_id": "axios@1.9.0",
-  "_inBundle": false,
-  "_integrity": "sha512-re4CqKTJaURpzbLHtIi6XpDv20/CnpXOtjRY5/CU32L8gU8ek9UIivcfvSWvmKEngmVbrUtPpdDwWDWL7DNHvg==",
-  "_location": "/axios",
-  "_phantomChildren": {},
-  "_requested": {
-    "type": "tag",
-    "registry": true,
-    "raw": "axios",
-    "name": "axios",
-    "escapedName": "axios",
-    "rawSpec": "",
-    "saveSpec": null,
-    "fetchSpec": "latest"
+  "name": "axios",
+  "version": "1.9.0",
+  "description": "Promise based HTTP client for the browser and node.js",
+  "main": "index.js",
+  "exports": {
+    ".": {
+      "types": {
+        "require": "./index.d.cts",
+        "default": "./index.d.ts"
+      },
+      "browser": {
+        "require": "./dist/browser/axios.cjs",
+        "default": "./index.js"
+      },
+      "default": {
+        "require": "./dist/node/axios.cjs",
+        "default": "./index.js"
+      }
+    },
+    "./lib/adapters/http.js": "./lib/adapters/http.js",
+    "./lib/adapters/xhr.js": "./lib/adapters/xhr.js",
+    "./unsafe/*": "./lib/*",
+    "./unsafe/core/settle.js": "./lib/core/settle.js",
+    "./unsafe/core/buildFullPath.js": "./lib/core/buildFullPath.js",
+    "./unsafe/helpers/isAbsoluteURL.js": "./lib/helpers/isAbsoluteURL.js",
+    "./unsafe/helpers/buildURL.js": "./lib/helpers/buildURL.js",
+    "./unsafe/helpers/combineURLs.js": "./lib/helpers/combineURLs.js",
+    "./unsafe/adapters/http.js": "./lib/adapters/http.js",
+    "./unsafe/adapters/xhr.js": "./lib/adapters/xhr.js",
+    "./unsafe/utils.js": "./lib/utils.js",
+    "./package.json": "./package.json"
   },
-  "_requiredBy": [
-    "#USER",
-    "/"
+  "type": "module",
+  "types": "index.d.ts",
+  "scripts": {
+    "test": "npm run test:eslint && npm run test:mocha && npm run test:karma && npm run test:dtslint && npm run test:exports",
+    "test:eslint": "node bin/ssl_hotfix.js eslint lib/**/*.js",
+    "test:dtslint": "dtslint --localTs node_modules/typescript/lib",
+    "test:mocha": "node bin/ssl_hotfix.js mocha test/unit/**/*.js --timeout 30000 --exit",
+    "test:exports": "node bin/ssl_hotfix.js mocha test/module/test.js --timeout 30000 --exit",
+    "test:karma": "node bin/ssl_hotfix.js cross-env LISTEN_ADDR=:: karma start karma.conf.cjs --single-run",
+    "test:karma:firefox": "node bin/ssl_hotfix.js cross-env LISTEN_ADDR=:: Browsers=Firefox karma start karma.conf.cjs --single-run",
+    "test:karma:server": "node bin/ssl_hotfix.js cross-env karma start karma.conf.cjs",
+    "test:build:version": "node ./bin/check-build-version.js",
+    "start": "node ./sandbox/server.js",
+    "preversion": "gulp version",
+    "version": "npm run build && git add dist && git add package.json",
+    "prepublishOnly": "npm run test:build:version",
+    "postpublish": "git push && git push --tags",
+    "build": "gulp clear && cross-env NODE_ENV=production rollup -c -m",
+    "examples": "node ./examples/server.js",
+    "coveralls": "cat coverage/lcov.info | ./node_modules/coveralls/bin/coveralls.js",
+    "fix": "eslint --fix lib/**/*.js",
+    "prepare": "husky install && npm run prepare:hooks",
+    "prepare:hooks": "npx husky set .husky/commit-msg \"npx commitlint --edit $1\"",
+    "release:dry": "release-it --dry-run --no-npm",
+    "release:info": "release-it --release-version",
+    "release:beta:no-npm": "release-it --preRelease=beta --no-npm",
+    "release:beta": "release-it --preRelease=beta",
+    "release:no-npm": "release-it --no-npm",
+    "release:changelog:fix": "node ./bin/injectContributorsList.js && git add CHANGELOG.md",
+    "release": "release-it"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/axios/axios.git"
+  },
+  "keywords": [
+    "xhr",
+    "http",
+    "ajax",
+    "promise",
+    "node"
   ],
-  "_resolved": "https://registry.npmjs.org/axios/-/axios-1.9.0.tgz",
-  "_shasum": "25534e3b72b54540077d33046f77e3b8d7081901",
-  "_spec": "axios",
-  "_where": "E:\\gitee\\fys\\fys\\app\\Fuyuan",
-  "author": {
-    "name": "Matt Zabriskie"
-  },
-  "browser": {
-    "./lib/adapters/http.js": "./lib/helpers/null.js",
-    "./lib/platform/node/index.js": "./lib/platform/browser/index.js",
-    "./lib/platform/node/classes/FormData.js": "./lib/helpers/null.js"
-  },
+  "author": "Matt Zabriskie",
+  "license": "MIT",
   "bugs": {
     "url": "https://github.com/axios/axios/issues"
   },
-  "bundleDependencies": false,
-  "bundlesize": [
-    {
-      "path": "./dist/axios.min.js",
-      "threshold": "5kB"
-    }
-  ],
-  "commitlint": {
-    "rules": {
-      "header-max-length": [
-        2,
-        "always",
-        130
-      ]
-    },
-    "extends": [
-      "@commitlint/config-conventional"
-    ]
-  },
-  "contributors": [
-    {
-      "name": "Matt Zabriskie",
-      "url": "https://github.com/mzabriskie"
-    },
-    {
-      "name": "Nick Uraltsev",
-      "url": "https://github.com/nickuraltsev"
-    },
-    {
-      "name": "Dmitriy Mozgovoy",
-      "url": "https://github.com/DigitalBrainJS"
-    },
-    {
-      "name": "Jay",
-      "url": "https://github.com/jasonsaayman"
-    },
-    {
-      "name": "Emily Morehouse",
-      "url": "https://github.com/emilyemorehouse"
-    },
-    {
-      "name": "Rubén Norte",
-      "url": "https://github.com/rubennorte"
-    },
-    {
-      "name": "Justin Beckwith",
-      "url": "https://github.com/JustinBeckwith"
-    },
-    {
-      "name": "Martti Laine",
-      "url": "https://github.com/codeclown"
-    },
-    {
-      "name": "Xianming Zhong",
-      "url": "https://github.com/chinesedfan"
-    },
-    {
-      "name": "Rikki Gibson",
-      "url": "https://github.com/RikkiGibson"
-    },
-    {
-      "name": "Remco Haszing",
-      "url": "https://github.com/remcohaszing"
-    },
-    {
-      "name": "Yasu Flores",
-      "url": "https://github.com/yasuf"
-    },
-    {
-      "name": "Ben Carp",
-      "url": "https://github.com/carpben"
-    }
-  ],
-  "dependencies": {
-    "follow-redirects": "^1.15.6",
-    "form-data": "^4.0.0",
-    "proxy-from-env": "^1.1.0"
-  },
-  "deprecated": false,
-  "description": "Promise based HTTP client for the browser and node.js",
+  "homepage": "https://axios-http.com",
   "devDependencies": {
     "@babel/core": "^7.23.9",
     "@babel/preset-env": "^7.23.9",
     "@commitlint/cli": "^17.8.1",
     "@commitlint/config-conventional": "^17.8.1",
     "@release-it/conventional-changelog": "^5.1.1",
-    "@rollup/plugin-alias": "^5.1.0",
     "@rollup/plugin-babel": "^5.3.1",
     "@rollup/plugin-commonjs": "^15.1.0",
     "@rollup/plugin-json": "^4.1.0",
@@ -171,48 +135,44 @@
     "stream-throttle": "^0.1.3",
     "string-replace-async": "^3.0.2",
     "terser-webpack-plugin": "^4.2.3",
-    "typescript": "^4.9.5"
+    "typescript": "^4.9.5",
+    "@rollup/plugin-alias": "^5.1.0"
   },
-  "exports": {
-    ".": {
-      "types": {
-        "require": "./index.d.cts",
-        "default": "./index.d.ts"
-      },
-      "browser": {
-        "require": "./dist/browser/axios.cjs",
-        "default": "./index.js"
-      },
-      "default": {
-        "require": "./dist/node/axios.cjs",
-        "default": "./index.js"
-      }
-    },
-    "./lib/adapters/http.js": "./lib/adapters/http.js",
-    "./lib/adapters/xhr.js": "./lib/adapters/xhr.js",
-    "./unsafe/*": "./lib/*",
-    "./unsafe/core/settle.js": "./lib/core/settle.js",
-    "./unsafe/core/buildFullPath.js": "./lib/core/buildFullPath.js",
-    "./unsafe/helpers/isAbsoluteURL.js": "./lib/helpers/isAbsoluteURL.js",
-    "./unsafe/helpers/buildURL.js": "./lib/helpers/buildURL.js",
-    "./unsafe/helpers/combineURLs.js": "./lib/helpers/combineURLs.js",
-    "./unsafe/adapters/http.js": "./lib/adapters/http.js",
-    "./unsafe/adapters/xhr.js": "./lib/adapters/xhr.js",
-    "./unsafe/utils.js": "./lib/utils.js",
-    "./package.json": "./package.json"
+  "browser": {
+    "./lib/adapters/http.js": "./lib/helpers/null.js",
+    "./lib/platform/node/index.js": "./lib/platform/browser/index.js",
+    "./lib/platform/node/classes/FormData.js": "./lib/helpers/null.js"
   },
-  "homepage": "https://axios-http.com",
   "jsdelivr": "dist/axios.min.js",
-  "keywords": [
-    "xhr",
-    "http",
-    "ajax",
-    "promise",
-    "node"
+  "unpkg": "dist/axios.min.js",
+  "typings": "./index.d.ts",
+  "dependencies": {
+    "follow-redirects": "^1.15.6",
+    "form-data": "^4.0.0",
+    "proxy-from-env": "^1.1.0"
+  },
+  "bundlesize": [
+    {
+      "path": "./dist/axios.min.js",
+      "threshold": "5kB"
+    }
   ],
-  "license": "MIT",
-  "main": "index.js",
-  "name": "axios",
+  "contributors": [
+    "Matt Zabriskie (https://github.com/mzabriskie)",
+    "Nick Uraltsev (https://github.com/nickuraltsev)",
+    "Dmitriy Mozgovoy (https://github.com/DigitalBrainJS)",
+    "Jay (https://github.com/jasonsaayman)",
+    "Emily Morehouse (https://github.com/emilyemorehouse)",
+    "Rubén Norte (https://github.com/rubennorte)",
+    "Justin Beckwith (https://github.com/JustinBeckwith)",
+    "Martti Laine (https://github.com/codeclown)",
+    "Xianming Zhong (https://github.com/chinesedfan)",
+    "Rikki Gibson (https://github.com/RikkiGibson)",
+    "Remco Haszing (https://github.com/remcohaszing)",
+    "Yasu Flores (https://github.com/yasuf)",
+    "Ben Carp (https://github.com/carpben)"
+  ],
+  "sideEffects": false,
   "release-it": {
     "git": {
       "commitMessage": "chore(release): v${version}",
@@ -244,43 +204,16 @@
       "after:release": "echo Successfully released ${name} v${version} to ${repo.repository}."
     }
   },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/axios/axios.git"
-  },
-  "scripts": {
-    "build": "gulp clear && cross-env NODE_ENV=production rollup -c -m",
-    "coveralls": "cat coverage/lcov.info | ./node_modules/coveralls/bin/coveralls.js",
-    "examples": "node ./examples/server.js",
-    "fix": "eslint --fix lib/**/*.js",
-    "postpublish": "git push && git push --tags",
-    "prepare": "husky install && npm run prepare:hooks",
-    "prepare:hooks": "npx husky set .husky/commit-msg \"npx commitlint --edit $1\"",
-    "prepublishOnly": "npm run test:build:version",
-    "preversion": "gulp version",
-    "release": "release-it",
-    "release:beta": "release-it --preRelease=beta",
-    "release:beta:no-npm": "release-it --preRelease=beta --no-npm",
-    "release:changelog:fix": "node ./bin/injectContributorsList.js && git add CHANGELOG.md",
-    "release:dry": "release-it --dry-run --no-npm",
-    "release:info": "release-it --release-version",
-    "release:no-npm": "release-it --no-npm",
-    "start": "node ./sandbox/server.js",
-    "test": "npm run test:eslint && npm run test:mocha && npm run test:karma && npm run test:dtslint && npm run test:exports",
-    "test:build:version": "node ./bin/check-build-version.js",
-    "test:dtslint": "dtslint --localTs node_modules/typescript/lib",
-    "test:eslint": "node bin/ssl_hotfix.js eslint lib/**/*.js",
-    "test:exports": "node bin/ssl_hotfix.js mocha test/module/test.js --timeout 30000 --exit",
-    "test:karma": "node bin/ssl_hotfix.js cross-env LISTEN_ADDR=:: karma start karma.conf.cjs --single-run",
-    "test:karma:firefox": "node bin/ssl_hotfix.js cross-env LISTEN_ADDR=:: Browsers=Firefox karma start karma.conf.cjs --single-run",
-    "test:karma:server": "node bin/ssl_hotfix.js cross-env karma start karma.conf.cjs",
-    "test:mocha": "node bin/ssl_hotfix.js mocha test/unit/**/*.js --timeout 30000 --exit",
-    "version": "npm run build && git add dist && git add package.json"
-  },
-  "sideEffects": false,
-  "type": "module",
-  "types": "index.d.ts",
-  "typings": "./index.d.ts",
-  "unpkg": "dist/axios.min.js",
-  "version": "1.9.0"
-}
+  "commitlint": {
+    "rules": {
+      "header-max-length": [
+        2,
+        "always",
+        130
+      ]
+    },
+    "extends": [
+      "@commitlint/config-conventional"
+    ]
+  }
+}

node_modules/balanced-match/.github/FUNDING.yml

@@ -1,2 +0,0 @@
-tidelift: "npm/balanced-match"
-patreon: juliangruber

node_modules/balanced-match/LICENSE.md

@@ -1,21 +0,0 @@
-(MIT)
-
-Copyright (c) 2013 Julian Gruber <julian@juliangruber.com>
-
-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.

node_modules/balanced-match/README.md

@@ -1,97 +0,0 @@
-# balanced-match
-
-Match balanced string pairs, like `{` and `}` or `<b>` and `</b>`. Supports regular expressions as well!
-
-[![build status](https://secure.travis-ci.org/juliangruber/balanced-match.svg)](http://travis-ci.org/juliangruber/balanced-match)
-[![downloads](https://img.shields.io/npm/dm/balanced-match.svg)](https://www.npmjs.org/package/balanced-match)
-
-[![testling badge](https://ci.testling.com/juliangruber/balanced-match.png)](https://ci.testling.com/juliangruber/balanced-match)
-
-## Example
-
-Get the first matching pair of braces:
-
-```js
-var balanced = require('balanced-match');
-
-console.log(balanced('{', '}', 'pre{in{nested}}post'));
-console.log(balanced('{', '}', 'pre{first}between{second}post'));
-console.log(balanced(/\s+\{\s+/, /\s+\}\s+/, 'pre  {   in{nest}   }  post'));
-```
-
-The matches are:
-
-```bash
-$ node example.js
-{ start: 3, end: 14, pre: 'pre', body: 'in{nested}', post: 'post' }
-{ start: 3,
-  end: 9,
-  pre: 'pre',
-  body: 'first',
-  post: 'between{second}post' }
-{ start: 3, end: 17, pre: 'pre', body: 'in{nest}', post: 'post' }
-```
-
-## API
-
-### var m = balanced(a, b, str)
-
-For the first non-nested matching pair of `a` and `b` in `str`, return an
-object with those keys:
-
-* **start** the index of the first match of `a`
-* **end** the index of the matching `b`
-* **pre** the preamble, `a` and `b` not included
-* **body** the match, `a` and `b` not included
-* **post** the postscript, `a` and `b` not included
-
-If there's no match, `undefined` will be returned.
-
-If the `str` contains more `a` than `b` / there are unmatched pairs, the first match that was closed will be used. For example, `{{a}` will match `['{', 'a', '']` and `{a}}` will match `['', 'a', '}']`.
-
-### var r = balanced.range(a, b, str)
-
-For the first non-nested matching pair of `a` and `b` in `str`, return an
-array with indexes: `[ <a index>, <b index> ]`.
-
-If there's no match, `undefined` will be returned.
-
-If the `str` contains more `a` than `b` / there are unmatched pairs, the first match that was closed will be used. For example, `{{a}` will match `[ 1, 3 ]` and `{a}}` will match `[0, 2]`.
-
-## Installation
-
-With [npm](https://npmjs.org) do:
-
-```bash
-npm install balanced-match
-```
-
-## Security contact information
-
-To report a security vulnerability, please use the
-[Tidelift security contact](https://tidelift.com/security).
-Tidelift will coordinate the fix and disclosure.
-
-## License
-
-(MIT)
-
-Copyright (c) 2013 Julian Gruber &lt;julian@juliangruber.com&gt;
-
-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.

node_modules/balanced-match/index.js

@@ -1,62 +0,0 @@
-'use strict';
-module.exports = balanced;
-function balanced(a, b, str) {
-  if (a instanceof RegExp) a = maybeMatch(a, str);
-  if (b instanceof RegExp) b = maybeMatch(b, str);
-
-  var r = range(a, b, str);
-
-  return r && {
-    start: r[0],
-    end: r[1],
-    pre: str.slice(0, r[0]),
-    body: str.slice(r[0] + a.length, r[1]),
-    post: str.slice(r[1] + b.length)
-  };
-}
-
-function maybeMatch(reg, str) {
-  var m = str.match(reg);
-  return m ? m[0] : null;
-}
-
-balanced.range = range;
-function range(a, b, str) {
-  var begs, beg, left, right, result;
-  var ai = str.indexOf(a);
-  var bi = str.indexOf(b, ai + 1);
-  var i = ai;
-
-  if (ai >= 0 && bi > 0) {
-    if(a===b) {
-      return [ai, bi];
-    }
-    begs = [];
-    left = str.length;
-
-    while (i >= 0 && !result) {
-      if (i == ai) {
-        begs.push(i);
-        ai = str.indexOf(a, i + 1);
-      } else if (begs.length == 1) {
-        result = [ begs.pop(), bi ];
-      } else {
-        beg = begs.pop();
-        if (beg < left) {
-          left = beg;
-          right = bi;
-        }
-
-        bi = str.indexOf(b, i + 1);
-      }
-
-      i = ai < bi && ai >= 0 ? ai : bi;
-    }
-
-    if (begs.length) {
-      result = [ left, right ];
-    }
-  }
-
-  return result;
-}

node_modules/balanced-match/package.json

@@ -1,76 +0,0 @@
-{
-  "_from": "balanced-match@^1.0.0",
-  "_id": "balanced-match@1.0.2",
-  "_inBundle": false,
-  "_integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
-  "_location": "/balanced-match",
-  "_phantomChildren": {},
-  "_requested": {
-    "type": "range",
-    "registry": true,
-    "raw": "balanced-match@^1.0.0",
-    "name": "balanced-match",
-    "escapedName": "balanced-match",
-    "rawSpec": "^1.0.0",
-    "saveSpec": null,
-    "fetchSpec": "^1.0.0"
-  },
-  "_requiredBy": [
-    "/brace-expansion"
-  ],
-  "_resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
-  "_shasum": "e83e3a7e3f300b34cb9d87f615fa0cbf357690ee",
-  "_spec": "balanced-match@^1.0.0",
-  "_where": "E:\\gitee\\fys\\fys\\app\\JingQuan\\node_modules\\brace-expansion",
-  "author": {
-    "name": "Julian Gruber",
-    "email": "mail@juliangruber.com",
-    "url": "http://juliangruber.com"
-  },
-  "bugs": {
-    "url": "https://github.com/juliangruber/balanced-match/issues"
-  },
-  "bundleDependencies": false,
-  "deprecated": false,
-  "description": "Match balanced character pairs, like \"{\" and \"}\"",
-  "devDependencies": {
-    "matcha": "^0.7.0",
-    "tape": "^4.6.0"
-  },
-  "homepage": "https://github.com/juliangruber/balanced-match",
-  "keywords": [
-    "match",
-    "regexp",
-    "test",
-    "balanced",
-    "parse"
-  ],
-  "license": "MIT",
-  "main": "index.js",
-  "name": "balanced-match",
-  "repository": {
-    "type": "git",
-    "url": "git://github.com/juliangruber/balanced-match.git"
-  },
-  "scripts": {
-    "bench": "matcha test/bench.js",
-    "test": "tape test/test.js"
-  },
-  "testling": {
-    "files": "test/*.js",
-    "browsers": [
-      "ie/8..latest",
-      "firefox/20..latest",
-      "firefox/nightly",
-      "chrome/25..latest",
-      "chrome/canary",
-      "opera/12..latest",
-      "opera/next",
-      "safari/5.1..latest",
-      "ipad/6.0..latest",
-      "iphone/6.0..latest",
-      "android-browser/4.2..latest"
-    ]
-  },
-  "version": "1.0.2"
-}

node_modules/base64-js/LICENSE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2014 Jameson Little
-
-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.

node_modules/base64-js/README.md

@@ -1,34 +0,0 @@
-base64-js
-=========
-
-`base64-js` does basic base64 encoding/decoding in pure JS.
-
-[![build status](https://secure.travis-ci.org/beatgammit/base64-js.png)](http://travis-ci.org/beatgammit/base64-js)
-
-Many browsers already have base64 encoding/decoding functionality, but it is for text data, not all-purpose binary data.
-
-Sometimes encoding/decoding binary data in the browser is useful, and that is what this module does.
-
-## install
-
-With [npm](https://npmjs.org) do:
-
-`npm install base64-js` and `var base64js = require('base64-js')`
-
-For use in web browsers do:
-
-`<script src="base64js.min.js"></script>`
-
-[Get supported base64-js with the Tidelift Subscription](https://tidelift.com/subscription/pkg/npm-base64-js?utm_source=npm-base64-js&utm_medium=referral&utm_campaign=readme)
-
-## methods
-
-`base64js` has three exposed functions, `byteLength`, `toByteArray` and `fromByteArray`, which both take a single argument.
-
-* `byteLength` - Takes a base64 string and returns length of byte array
-* `toByteArray` - Takes a base64 string and returns a byte array
-* `fromByteArray` - Takes a byte array and returns a base64 string
-
-## license
-
-MIT

node_modules/base64-js/base64js.min.js

@@ -1 +0,0 @@
-(function(a){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=a();else if("function"==typeof define&&define.amd)define([],a);else{var b;b="undefined"==typeof window?"undefined"==typeof global?"undefined"==typeof self?this:self:global:window,b.base64js=a()}})(function(){return function(){function b(d,e,g){function a(j,i){if(!e[j]){if(!d[j]){var f="function"==typeof require&&require;if(!i&&f)return f(j,!0);if(h)return h(j,!0);var c=new Error("Cannot find module '"+j+"'");throw c.code="MODULE_NOT_FOUND",c}var k=e[j]={exports:{}};d[j][0].call(k.exports,function(b){var c=d[j][1][b];return a(c||b)},k,k.exports,b,d,e,g)}return e[j].exports}for(var h="function"==typeof require&&require,c=0;c<g.length;c++)a(g[c]);return a}return b}()({"/":[function(a,b,c){'use strict';function d(a){var b=a.length;if(0<b%4)throw new Error("Invalid string. Length must be a multiple of 4");var c=a.indexOf("=");-1===c&&(c=b);var d=c===b?0:4-c%4;return[c,d]}function e(a,b,c){return 3*(b+c)/4-c}function f(a){var b,c,f=d(a),g=f[0],h=f[1],j=new m(e(a,g,h)),k=0,n=0<h?g-4:g;for(c=0;c<n;c+=4)b=l[a.charCodeAt(c)]<<18|l[a.charCodeAt(c+1)]<<12|l[a.charCodeAt(c+2)]<<6|l[a.charCodeAt(c+3)],j[k++]=255&b>>16,j[k++]=255&b>>8,j[k++]=255&b;return 2===h&&(b=l[a.charCodeAt(c)]<<2|l[a.charCodeAt(c+1)]>>4,j[k++]=255&b),1===h&&(b=l[a.charCodeAt(c)]<<10|l[a.charCodeAt(c+1)]<<4|l[a.charCodeAt(c+2)]>>2,j[k++]=255&b>>8,j[k++]=255&b),j}function g(a){return k[63&a>>18]+k[63&a>>12]+k[63&a>>6]+k[63&a]}function h(a,b,c){for(var d,e=[],f=b;f<c;f+=3)d=(16711680&a[f]<<16)+(65280&a[f+1]<<8)+(255&a[f+2]),e.push(g(d));return e.join("")}function j(a){for(var b,c=a.length,d=c%3,e=[],f=16383,g=0,j=c-d;g<j;g+=f)e.push(h(a,g,g+f>j?j:g+f));return 1===d?(b=a[c-1],e.push(k[b>>2]+k[63&b<<4]+"==")):2===d&&(b=(a[c-2]<<8)+a[c-1],e.push(k[b>>10]+k[63&b>>4]+k[63&b<<2]+"=")),e.join("")}c.byteLength=function(a){var b=d(a),c=b[0],e=b[1];return 3*(c+e)/4-e},c.toByteArray=f,c.fromByteArray=j;for(var k=[],l=[],m="undefined"==typeof Uint8Array?Array:Uint8Array,n="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",o=0,p=n.length;o<p;++o)k[o]=n[o],l[n.charCodeAt(o)]=o;l[45]=62,l[95]=63},{}]},{},[])("/")});

node_modules/base64-js/index.d.ts

@@ -1,3 +0,0 @@
-export function byteLength(b64: string): number;
-export function toByteArray(b64: string): Uint8Array;
-export function fromByteArray(uint8: Uint8Array): string;

node_modules/base64-js/index.js

@@ -1,150 +0,0 @@
-'use strict'
-
-exports.byteLength = byteLength
-exports.toByteArray = toByteArray
-exports.fromByteArray = fromByteArray
-
-var lookup = []
-var revLookup = []
-var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array
-
-var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
-for (var i = 0, len = code.length; i < len; ++i) {
-  lookup[i] = code[i]
-  revLookup[code.charCodeAt(i)] = i
-}
-
-// Support decoding URL-safe base64 strings, as Node.js does.
-// See: https://en.wikipedia.org/wiki/Base64#URL_applications
-revLookup['-'.charCodeAt(0)] = 62
-revLookup['_'.charCodeAt(0)] = 63
-
-function getLens (b64) {
-  var len = b64.length
-
-  if (len % 4 > 0) {
-    throw new Error('Invalid string. Length must be a multiple of 4')
-  }
-
-  // Trim off extra bytes after placeholder bytes are found
-  // See: https://github.com/beatgammit/base64-js/issues/42
-  var validLen = b64.indexOf('=')
-  if (validLen === -1) validLen = len
-
-  var placeHoldersLen = validLen === len
-    ? 0
-    : 4 - (validLen % 4)
-
-  return [validLen, placeHoldersLen]
-}
-
-// base64 is 4/3 + up to two characters of the original data
-function byteLength (b64) {
-  var lens = getLens(b64)
-  var validLen = lens[0]
-  var placeHoldersLen = lens[1]
-  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
-}
-
-function _byteLength (b64, validLen, placeHoldersLen) {
-  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
-}
-
-function toByteArray (b64) {
-  var tmp
-  var lens = getLens(b64)
-  var validLen = lens[0]
-  var placeHoldersLen = lens[1]
-
-  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))
-
-  var curByte = 0
-
-  // if there are placeholders, only get up to the last complete 4 chars
-  var len = placeHoldersLen > 0
-    ? validLen - 4
-    : validLen
-
-  var i
-  for (i = 0; i < len; i += 4) {
-    tmp =
-      (revLookup[b64.charCodeAt(i)] << 18) |
-      (revLookup[b64.charCodeAt(i + 1)] << 12) |
-      (revLookup[b64.charCodeAt(i + 2)] << 6) |
-      revLookup[b64.charCodeAt(i + 3)]
-    arr[curByte++] = (tmp >> 16) & 0xFF
-    arr[curByte++] = (tmp >> 8) & 0xFF
-    arr[curByte++] = tmp & 0xFF
-  }
-
-  if (placeHoldersLen === 2) {
-    tmp =
-      (revLookup[b64.charCodeAt(i)] << 2) |
-      (revLookup[b64.charCodeAt(i + 1)] >> 4)
-    arr[curByte++] = tmp & 0xFF
-  }
-
-  if (placeHoldersLen === 1) {
-    tmp =
-      (revLookup[b64.charCodeAt(i)] << 10) |
-      (revLookup[b64.charCodeAt(i + 1)] << 4) |
-      (revLookup[b64.charCodeAt(i + 2)] >> 2)
-    arr[curByte++] = (tmp >> 8) & 0xFF
-    arr[curByte++] = tmp & 0xFF
-  }
-
-  return arr
-}
-
-function tripletToBase64 (num) {
-  return lookup[num >> 18 & 0x3F] +
-    lookup[num >> 12 & 0x3F] +
-    lookup[num >> 6 & 0x3F] +
-    lookup[num & 0x3F]
-}
-
-function encodeChunk (uint8, start, end) {
-  var tmp
-  var output = []
-  for (var i = start; i < end; i += 3) {
-    tmp =
-      ((uint8[i] << 16) & 0xFF0000) +
-      ((uint8[i + 1] << 8) & 0xFF00) +
-      (uint8[i + 2] & 0xFF)
-    output.push(tripletToBase64(tmp))
-  }
-  return output.join('')
-}
-
-function fromByteArray (uint8) {
-  var tmp
-  var len = uint8.length
-  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes
-  var parts = []
-  var maxChunkLength = 16383 // must be multiple of 3
-
-  // go through the array every three bytes, we'll deal with trailing stuff later
-  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
-    parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))
-  }
-
-  // pad the end with zeros, but make sure to not forget the extra bytes
-  if (extraBytes === 1) {
-    tmp = uint8[len - 1]
-    parts.push(
-      lookup[tmp >> 2] +
-      lookup[(tmp << 4) & 0x3F] +
-      '=='
-    )
-  } else if (extraBytes === 2) {
-    tmp = (uint8[len - 2] << 8) + uint8[len - 1]
-    parts.push(
-      lookup[tmp >> 10] +
-      lookup[(tmp >> 4) & 0x3F] +
-      lookup[(tmp << 2) & 0x3F] +
-      '='
-    )
-  }
-
-  return parts.join('')
-}

node_modules/base64-js/package.json

@@ -1,76 +0,0 @@
-{
-  "_from": "base64-js@^1.3.0",
-  "_id": "base64-js@1.5.1",
-  "_inBundle": false,
-  "_integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==",
-  "_location": "/base64-js",
-  "_phantomChildren": {},
-  "_requested": {
-    "type": "range",
-    "registry": true,
-    "raw": "base64-js@^1.3.0",
-    "name": "base64-js",
-    "escapedName": "base64-js",
-    "rawSpec": "^1.3.0",
-    "saveSpec": null,
-    "fetchSpec": "^1.3.0"
-  },
-  "_requiredBy": [
-    "/buffer",
-    "/mqtt"
-  ],
-  "_resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz",
-  "_shasum": "1b1b440160a5bf7ad40b650f095963481903930a",
-  "_spec": "base64-js@^1.3.0",
-  "_where": "E:\\gitee\\fys\\fys\\app\\JingQuan\\node_modules\\mqtt",
-  "author": {
-    "name": "T. Jameson Little",
-    "email": "t.jameson.little@gmail.com"
-  },
-  "bugs": {
-    "url": "https://github.com/beatgammit/base64-js/issues"
-  },
-  "bundleDependencies": false,
-  "deprecated": false,
-  "description": "Base64 encoding/decoding in pure JS",
-  "devDependencies": {
-    "babel-minify": "^0.5.1",
-    "benchmark": "^2.1.4",
-    "browserify": "^16.3.0",
-    "standard": "*",
-    "tape": "4.x"
-  },
-  "funding": [
-    {
-      "type": "github",
-      "url": "https://github.com/sponsors/feross"
-    },
-    {
-      "type": "patreon",
-      "url": "https://www.patreon.com/feross"
-    },
-    {
-      "type": "consulting",
-      "url": "https://feross.org/support"
-    }
-  ],
-  "homepage": "https://github.com/beatgammit/base64-js",
-  "keywords": [
-    "base64"
-  ],
-  "license": "MIT",
-  "main": "index.js",
-  "name": "base64-js",
-  "repository": {
-    "type": "git",
-    "url": "git://github.com/beatgammit/base64-js.git"
-  },
-  "scripts": {
-    "build": "browserify -s base64js -r ./ | minify > base64js.min.js",
-    "lint": "standard",
-    "test": "npm run lint && npm run unit",
-    "unit": "tape test/*.js"
-  },
-  "typings": "index.d.ts",
-  "version": "1.5.1"
-}

node_modules/bl/.travis.yml

@@ -1,17 +0,0 @@
-sudo: false
-arch:
- - amd64
- - ppc64le
-language: node_js
-node_js:
-  - '6'
-  - '8'
-  - '10'
-  - '12'
-  - '14'
-  - '15'
-  - lts/*
-notifications:
-  email:
-    - rod@vagg.org
-    - matteo.collina@gmail.com

node_modules/bl/BufferList.js

@@ -1,396 +0,0 @@
-'use strict'
-
-const { Buffer } = require('buffer')
-const symbol = Symbol.for('BufferList')
-
-function BufferList (buf) {
-  if (!(this instanceof BufferList)) {
-    return new BufferList(buf)
-  }
-
-  BufferList._init.call(this, buf)
-}
-
-BufferList._init = function _init (buf) {
-  Object.defineProperty(this, symbol, { value: true })
-
-  this._bufs = []
-  this.length = 0
-
-  if (buf) {
-    this.append(buf)
-  }
-}
-
-BufferList.prototype._new = function _new (buf) {
-  return new BufferList(buf)
-}
-
-BufferList.prototype._offset = function _offset (offset) {
-  if (offset === 0) {
-    return [0, 0]
-  }
-
-  let tot = 0
-
-  for (let i = 0; i < this._bufs.length; i++) {
-    const _t = tot + this._bufs[i].length
-    if (offset < _t || i === this._bufs.length - 1) {
-      return [i, offset - tot]
-    }
-    tot = _t
-  }
-}
-
-BufferList.prototype._reverseOffset = function (blOffset) {
-  const bufferId = blOffset[0]
-  let offset = blOffset[1]
-
-  for (let i = 0; i < bufferId; i++) {
-    offset += this._bufs[i].length
-  }
-
-  return offset
-}
-
-BufferList.prototype.get = function get (index) {
-  if (index > this.length || index < 0) {
-    return undefined
-  }
-
-  const offset = this._offset(index)
-
-  return this._bufs[offset[0]][offset[1]]
-}
-
-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)
-  }
-
-  const copy = !!dst
-  const off = this._offset(srcStart)
-  const len = srcEnd - srcStart
-  let bytes = len
-  let bufoff = (copy && dstStart) || 0
-  let start = off[1]
-
-  // 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 (let 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 (let i = off[0]; i < this._bufs.length; i++) {
-    const l = this._bufs[i].length - start
-
-    if (bytes > l) {
-      this._bufs[i].copy(dst, bufoff, start)
-      bufoff += l
-    } else {
-      this._bufs[i].copy(dst, bufoff, start, start + bytes)
-      bufoff += l
-      break
-    }
-
-    bytes -= l
-
-    if (start) {
-      start = 0
-    }
-  }
-
-  // safeguard so that we don't return uninitialized memory
-  if (dst.length > bufoff) return dst.slice(0, bufoff)
-
-  return dst
-}
-
-BufferList.prototype.shallowSlice = function shallowSlice (start, end) {
-  start = start || 0
-  end = typeof end !== 'number' ? this.length : end
-
-  if (start < 0) {
-    start += this.length
-  }
-
-  if (end < 0) {
-    end += this.length
-  }
-
-  if (start === end) {
-    return this._new()
-  }
-
-  const startOffset = this._offset(start)
-  const endOffset = this._offset(end)
-  const 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 this._new(buffers)
-}
-
-BufferList.prototype.toString = function toString (encoding, start, end) {
-  return this.slice(start, end).toString(encoding)
-}
-
-BufferList.prototype.consume = function consume (bytes) {
-  // first, normalize the argument, in accordance with how Buffer does it
-  bytes = Math.trunc(bytes)
-  // do nothing if not a positive number
-  if (Number.isNaN(bytes) || bytes <= 0) return this
-
-  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 () {
-  const copy = this._new()
-
-  for (let i = 0; i < this._bufs.length; i++) {
-    copy.append(this._bufs[i])
-  }
-
-  return copy
-}
-
-BufferList.prototype.append = function append (buf) {
-  if (buf == null) {
-    return this
-  }
-
-  if (buf.buffer) {
-    // append a view of the underlying ArrayBuffer
-    this._appendBuffer(Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength))
-  } else if (Array.isArray(buf)) {
-    for (let i = 0; i < buf.length; i++) {
-      this.append(buf[i])
-    }
-  } else if (this._isBufferList(buf)) {
-    // unwrap argument into individual BufferLists
-    for (let i = 0; i < buf._bufs.length; i++) {
-      this.append(buf._bufs[i])
-    }
-  } else {
-    // 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.indexOf = function (search, offset, encoding) {
-  if (encoding === undefined && typeof offset === 'string') {
-    encoding = offset
-    offset = undefined
-  }
-
-  if (typeof search === 'function' || Array.isArray(search)) {
-    throw new TypeError('The "value" argument must be one of type string, Buffer, BufferList, or Uint8Array.')
-  } else if (typeof search === 'number') {
-    search = Buffer.from([search])
-  } else if (typeof search === 'string') {
-    search = Buffer.from(search, encoding)
-  } else if (this._isBufferList(search)) {
-    search = search.slice()
-  } else if (Array.isArray(search.buffer)) {
-    search = Buffer.from(search.buffer, search.byteOffset, search.byteLength)
-  } else if (!Buffer.isBuffer(search)) {
-    search = Buffer.from(search)
-  }
-
-  offset = Number(offset || 0)
-
-  if (isNaN(offset)) {
-    offset = 0
-  }
-
-  if (offset < 0) {
-    offset = this.length + offset
-  }
-
-  if (offset < 0) {
-    offset = 0
-  }
-
-  if (search.length === 0) {
-    return offset > this.length ? this.length : offset
-  }
-
-  const blOffset = this._offset(offset)
-  let blIndex = blOffset[0] // index of which internal buffer we're working on
-  let buffOffset = blOffset[1] // offset of the internal buffer we're working on
-
-  // scan over each buffer
-  for (; blIndex < this._bufs.length; blIndex++) {
-    const buff = this._bufs[blIndex]
-
-    while (buffOffset < buff.length) {
-      const availableWindow = buff.length - buffOffset
-
-      if (availableWindow >= search.length) {
-        const nativeSearchResult = buff.indexOf(search, buffOffset)
-
-        if (nativeSearchResult !== -1) {
-          return this._reverseOffset([blIndex, nativeSearchResult])
-        }
-
-        buffOffset = buff.length - search.length + 1 // end of native search window
-      } else {
-        const revOffset = this._reverseOffset([blIndex, buffOffset])
-
-        if (this._match(revOffset, search)) {
-          return revOffset
-        }
-
-        buffOffset++
-      }
-    }
-
-    buffOffset = 0
-  }
-
-  return -1
-}
-
-BufferList.prototype._match = function (offset, search) {
-  if (this.length - offset < search.length) {
-    return false
-  }
-
-  for (let searchOffset = 0; searchOffset < search.length; searchOffset++) {
-    if (this.get(offset + searchOffset) !== search[searchOffset]) {
-      return false
-    }
-  }
-  return true
-}
-
-;(function () {
-  const 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,
-    readIntBE: null,
-    readIntLE: null,
-    readUIntBE: null,
-    readUIntLE: null
-  }
-
-  for (const m in methods) {
-    (function (m) {
-      if (methods[m] === null) {
-        BufferList.prototype[m] = function (offset, byteLength) {
-          return this.slice(offset, offset + byteLength)[m](0, byteLength)
-        }
-      } else {
-        BufferList.prototype[m] = function (offset = 0) {
-          return this.slice(offset, offset + methods[m])[m](0)
-        }
-      }
-    }(m))
-  }
-}())
-
-// Used internally by the class and also as an indicator of this object being
-// a `BufferList`. It's not possible to use `instanceof BufferList` in a browser
-// environment because there could be multiple different copies of the
-// BufferList class and some `BufferList`s might be `BufferList`s.
-BufferList.prototype._isBufferList = function _isBufferList (b) {
-  return b instanceof BufferList || BufferList.isBufferList(b)
-}
-
-BufferList.isBufferList = function isBufferList (b) {
-  return b != null && b[symbol]
-}
-
-module.exports = BufferList

node_modules/bl/LICENSE.md

@@ -1,13 +0,0 @@
-The MIT License (MIT)
-=====================
-
-Copyright (c) 2013-2019 bl contributors
-----------------------------------
-
-*bl contributors listed at <https://github.com/rvagg/bl#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.

node_modules/bl/README.md

@@ -1,247 +0,0 @@
-# bl *(BufferList)*
-
-[![Build Status](https://api.travis-ci.com/rvagg/bl.svg?branch=master)](https://travis-ci.com/rvagg/bl/)
-
-**A Node.js Buffer list collector, reader and streamer thingy.**
-
-[![NPM](https://nodei.co/npm/bl.svg)](https://nodei.co/npm/bl/)
-
-**bl** is a storage object for collections of Node Buffers, exposing them with the main Buffer readable API. Also works as a duplex stream so you can collect buffers from a stream that emits them and emit buffers to a stream that consumes them!
-
-The original buffers are kept intact and copies are only done as necessary. Any reads that require the use of a single original buffer will return a slice of that buffer only (which references the same memory as the original buffer). Reads that span buffers perform concatenation as required and return the results transparently.
-
-```js
-const { BufferList } = require('bl')
-
-const bl = new BufferList()
-bl.append(Buffer.from('abcd'))
-bl.append(Buffer.from('efg'))
-bl.append('hi')                     // bl will also accept & convert Strings
-bl.append(Buffer.from('j'))
-bl.append(Buffer.from([ 0x3, 0x4 ]))
-
-console.log(bl.length) // 12
-
-console.log(bl.slice(0, 10).toString('ascii')) // 'abcdefghij'
-console.log(bl.slice(3, 10).toString('ascii')) // 'defghij'
-console.log(bl.slice(3, 6).toString('ascii'))  // 'def'
-console.log(bl.slice(3, 8).toString('ascii'))  // 'defgh'
-console.log(bl.slice(5, 10).toString('ascii')) // 'fghij'
-
-console.log(bl.indexOf('def')) // 3
-console.log(bl.indexOf('asdf')) // -1
-
-// or just use toString!
-console.log(bl.toString())               // 'abcdefghij\u0003\u0004'
-console.log(bl.toString('ascii', 3, 8))  // 'defgh'
-console.log(bl.toString('ascii', 5, 10)) // 'fghij'
-
-// other standard Buffer readables
-console.log(bl.readUInt16BE(10)) // 0x0304
-console.log(bl.readUInt16LE(10)) // 0x0403
-```
-
-Give it a callback in the constructor and use it just like **[concat-stream](https://github.com/maxogden/node-concat-stream)**:
-
-```js
-const { BufferListStream } = require('bl')
-const fs = require('fs')
-
-fs.createReadStream('README.md')
-  .pipe(BufferListStream((err, data) => { // note 'new' isn't strictly required
-    // `data` is a complete Buffer object containing the full data
-    console.log(data.toString())
-  }))
-```
-
-Note that when you use the *callback* method like this, the resulting `data` parameter is a concatenation of all `Buffer` objects in the list. If you want to avoid the overhead of this concatenation (in cases of extreme performance consciousness), then avoid the *callback* method and just listen to `'end'` instead, like a standard Stream.
-
-Or to fetch a URL using [hyperquest](https://github.com/substack/hyperquest) (should work with [request](http://github.com/mikeal/request) and even plain Node http too!):
-
-```js
-const hyperquest = require('hyperquest')
-const { BufferListStream } = require('bl')
-
-const url = 'https://raw.github.com/rvagg/bl/master/README.md'
-
-hyperquest(url).pipe(BufferListStream((err, data) => {
-  console.log(data.toString())
-}))
-```
-
-Or, use it as a readable stream to recompose a list of Buffers to an output source:
-
-```js
-const { BufferListStream } = require('bl')
-const fs = require('fs')
-
-var bl = new BufferListStream()
-bl.append(Buffer.from('abcd'))
-bl.append(Buffer.from('efg'))
-bl.append(Buffer.from('hi'))
-bl.append(Buffer.from('j'))
-
-bl.pipe(fs.createWriteStream('gibberish.txt'))
-```
-
-## API
-
-  * <a href="#ctor"><code><b>new BufferList([ buf ])</b></code></a>
-  * <a href="#isBufferList"><code><b>BufferList.isBufferList(obj)</b></code></a>
-  * <a href="#length"><code>bl.<b>length</b></code></a>
-  * <a href="#append"><code>bl.<b>append(buffer)</b></code></a>
-  * <a href="#get"><code>bl.<b>get(index)</b></code></a>
-  * <a href="#indexOf"><code>bl.<b>indexOf(value[, byteOffset][, encoding])</b></code></a>
-  * <a href="#slice"><code>bl.<b>slice([ start[, end ] ])</b></code></a>
-  * <a href="#shallowSlice"><code>bl.<b>shallowSlice([ start[, end ] ])</b></code></a>
-  * <a href="#copy"><code>bl.<b>copy(dest, [ destStart, [ srcStart [, srcEnd ] ] ])</b></code></a>
-  * <a href="#duplicate"><code>bl.<b>duplicate()</b></code></a>
-  * <a href="#consume"><code>bl.<b>consume(bytes)</b></code></a>
-  * <a href="#toString"><code>bl.<b>toString([encoding, [ start, [ end ]]])</b></code></a>
-  * <a href="#readXX"><code>bl.<b>readDoubleBE()</b></code>, <code>bl.<b>readDoubleLE()</b></code>, <code>bl.<b>readFloatBE()</b></code>, <code>bl.<b>readFloatLE()</b></code>, <code>bl.<b>readInt32BE()</b></code>, <code>bl.<b>readInt32LE()</b></code>, <code>bl.<b>readUInt32BE()</b></code>, <code>bl.<b>readUInt32LE()</b></code>, <code>bl.<b>readInt16BE()</b></code>, <code>bl.<b>readInt16LE()</b></code>, <code>bl.<b>readUInt16BE()</b></code>, <code>bl.<b>readUInt16LE()</b></code>, <code>bl.<b>readInt8()</b></code>, <code>bl.<b>readUInt8()</b></code></a>
-  * <a href="#ctorStream"><code><b>new BufferListStream([ callback ])</b></code></a>
-
---------------------------------------------------------
-<a name="ctor"></a>
-### new BufferList([ Buffer | Buffer array | BufferList | BufferList array | String ])
-No arguments are _required_ for the constructor, but you can initialise the list by passing in a single `Buffer` object or an array of `Buffer` objects.
-
-`new` is not strictly required, if you don't instantiate a new object, it will be done automatically for you so you can create a new instance simply with:
-
-```js
-const { BufferList } = require('bl')
-const bl = BufferList()
-
-// equivalent to:
-
-const { BufferList } = require('bl')
-const bl = new BufferList()
-```
-
---------------------------------------------------------
-<a name="isBufferList"></a>
-### BufferList.isBufferList(obj)
-Determines if the passed object is a `BufferList`. It will return `true` if the passed object is an instance of `BufferList` **or** `BufferListStream` and `false` otherwise.
-
-N.B. this won't return `true` for `BufferList` or `BufferListStream` instances created by versions of this library before this static method was added.
-
---------------------------------------------------------
-<a name="length"></a>
-### bl.length
-Get the length of the list in bytes. This is the sum of the lengths of all of the buffers contained in the list, minus any initial offset for a semi-consumed buffer at the beginning. Should accurately represent the total number of bytes that can be read from the list.
-
---------------------------------------------------------
-<a name="append"></a>
-### bl.append(Buffer | Buffer array | BufferList | BufferList array | String)
-`append(buffer)` adds an additional buffer or BufferList to the internal list. `this` is returned so it can be chained.
-
---------------------------------------------------------
-<a name="get"></a>
-### bl.get(index)
-`get()` will return the byte at the specified index.
-
---------------------------------------------------------
-<a name="indexOf"></a>
-### bl.indexOf(value[, byteOffset][, encoding])
-`get()` will return the byte at the specified index.
-`indexOf()` method returns the first index at which a given element can be found in the BufferList, or -1 if it is not present.
-
---------------------------------------------------------
-<a name="slice"></a>
-### bl.slice([ start, [ end ] ])
-`slice()` returns a new `Buffer` object containing the bytes within the range specified. Both `start` and `end` are optional and will default to the beginning and end of the list respectively.
-
-If the requested range spans a single internal buffer then a slice of that buffer will be returned which shares the original memory range of that Buffer. If the range spans multiple buffers then copy operations will likely occur to give you a uniform Buffer.
-
---------------------------------------------------------
-<a name="shallowSlice"></a>
-### bl.shallowSlice([ start, [ end ] ])
-`shallowSlice()` returns a new `BufferList` object containing the bytes within the range specified. Both `start` and `end` are optional and will default to the beginning and end of the list respectively.
-
-No copies will be performed. All buffers in the result share memory with the original list.
-
---------------------------------------------------------
-<a name="copy"></a>
-### bl.copy(dest, [ destStart, [ srcStart [, srcEnd ] ] ])
-`copy()` copies the content of the list in the `dest` buffer, starting from `destStart` and containing the bytes within the range specified with `srcStart` to `srcEnd`. `destStart`, `start` and `end` are optional and will default to the beginning of the `dest` buffer, and the beginning and end of the list respectively.
-
---------------------------------------------------------
-<a name="duplicate"></a>
-### bl.duplicate()
-`duplicate()` performs a **shallow-copy** of the list. The internal Buffers remains the same, so if you change the underlying Buffers, the change will be reflected in both the original and the duplicate. This method is needed if you want to call `consume()` or `pipe()` and still keep the original list.Example:
-
-```js
-var bl = new BufferListStream()
-
-bl.append('hello')
-bl.append(' world')
-bl.append('\n')
-
-bl.duplicate().pipe(process.stdout, { end: false })
-
-console.log(bl.toString())
-```
-
---------------------------------------------------------
-<a name="consume"></a>
-### bl.consume(bytes)
-`consume()` will shift bytes *off the start of the list*. The number of bytes consumed don't need to line up with the sizes of the internal Buffers&mdash;initial offsets will be calculated accordingly in order to give you a consistent view of the data.
-
---------------------------------------------------------
-<a name="toString"></a>
-### bl.toString([encoding, [ start, [ end ]]])
-`toString()` will return a string representation of the buffer. The optional `start` and `end` arguments are passed on to `slice()`, while the `encoding` is passed on to `toString()` of the resulting Buffer. See the [Buffer#toString()](http://nodejs.org/docs/latest/api/buffer.html#buffer_buf_tostring_encoding_start_end) documentation for more information.
-
---------------------------------------------------------
-<a name="readXX"></a>
-### bl.readDoubleBE(), bl.readDoubleLE(), bl.readFloatBE(), bl.readFloatLE(), bl.readInt32BE(), bl.readInt32LE(), bl.readUInt32BE(), bl.readUInt32LE(), bl.readInt16BE(), bl.readInt16LE(), bl.readUInt16BE(), bl.readUInt16LE(), bl.readInt8(), bl.readUInt8()
-
-All of the standard byte-reading methods of the `Buffer` interface are implemented and will operate across internal Buffer boundaries transparently.
-
-See the <b><code>[Buffer](http://nodejs.org/docs/latest/api/buffer.html)</code></b> documentation for how these work.
-
---------------------------------------------------------
-<a name="ctorStream"></a>
-### new BufferListStream([ callback | Buffer | Buffer array | BufferList | BufferList array | String ])
-**BufferListStream** is a Node **[Duplex Stream](http://nodejs.org/docs/latest/api/stream.html#stream_class_stream_duplex)**, so it can be read from and written to like a standard Node stream. You can also `pipe()` to and from a **BufferListStream** instance.
-
-The constructor takes an optional callback, if supplied, the callback will be called with an error argument followed by a reference to the **bl** instance, when `bl.end()` is called (i.e. from a piped stream). This is a convenient method of collecting the entire contents of a stream, particularly when the stream is *chunky*, such as a network stream.
-
-Normally, no arguments are required for the constructor, but you can initialise the list by passing in a single `Buffer` object or an array of `Buffer` object.
-
-`new` is not strictly required, if you don't instantiate a new object, it will be done automatically for you so you can create a new instance simply with:
-
-```js
-const { BufferListStream } = require('bl')
-const bl = BufferListStream()
-
-// equivalent to:
-
-const { BufferListStream } = require('bl')
-const bl = new BufferListStream()
-```
-
-N.B. For backwards compatibility reasons, `BufferListStream` is the **default** export when you `require('bl')`:
-
-```js
-const { BufferListStream } = require('bl')
-// equivalent to:
-const BufferListStream = require('bl')
-```
-
---------------------------------------------------------
-
-## Contributors
-
-**bl** is brought to you by the following hackers:
-
- * [Rod Vagg](https://github.com/rvagg)
- * [Matteo Collina](https://github.com/mcollina)
- * [Jarett Cruger](https://github.com/jcrugzz)
-
-<a name="license"></a>
-## License &amp; copyright
-
-Copyright (c) 2013-2019 bl contributors (listed above).
-
-bl is licensed under the MIT license. All rights not explicitly granted in the MIT license are reserved. See the included LICENSE.md file for more details.

node_modules/bl/bl.js

@@ -1,84 +0,0 @@
-'use strict'
-
-const DuplexStream = require('readable-stream').Duplex
-const inherits = require('inherits')
-const BufferList = require('./BufferList')
-
-function BufferListStream (callback) {
-  if (!(this instanceof BufferListStream)) {
-    return new BufferListStream(callback)
-  }
-
-  if (typeof callback === 'function') {
-    this._callback = callback
-
-    const 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)
-    })
-
-    callback = null
-  }
-
-  BufferList._init.call(this, callback)
-  DuplexStream.call(this)
-}
-
-inherits(BufferListStream, DuplexStream)
-Object.assign(BufferListStream.prototype, BufferList.prototype)
-
-BufferListStream.prototype._new = function _new (callback) {
-  return new BufferListStream(callback)
-}
-
-BufferListStream.prototype._write = function _write (buf, encoding, callback) {
-  this._appendBuffer(buf)
-
-  if (typeof callback === 'function') {
-    callback()
-  }
-}
-
-BufferListStream.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)
-}
-
-BufferListStream.prototype.end = function end (chunk) {
-  DuplexStream.prototype.end.call(this, chunk)
-
-  if (this._callback) {
-    this._callback(null, this.slice())
-    this._callback = null
-  }
-}
-
-BufferListStream.prototype._destroy = function _destroy (err, cb) {
-  this._bufs.length = 0
-  this.length = 0
-  cb(err)
-}
-
-BufferListStream.prototype._isBufferList = function _isBufferList (b) {
-  return b instanceof BufferListStream || b instanceof BufferList || BufferListStream.isBufferList(b)
-}
-
-BufferListStream.isBufferList = BufferList.isBufferList
-
-module.exports = BufferListStream
-module.exports.BufferListStream = BufferListStream
-module.exports.BufferList = BufferList

node_modules/bl/node_modules/readable-stream/CONTRIBUTING.md

@@ -1,38 +0,0 @@
-# Developer's Certificate of Origin 1.1
-
-By making a contribution to this project, I certify that:
-
-* (a) The contribution was created in whole or in part by me and I
-  have the right to submit it under the open source license
-  indicated in the file; or
-
-* (b) The contribution is based upon previous work that, to the best
-  of my knowledge, is covered under an appropriate open source
-  license and I have the right under that license to submit that
-  work with modifications, whether created in whole or in part
-  by me, under the same open source license (unless I am
-  permitted to submit under a different license), as indicated
-  in the file; or
-
-* (c) The contribution was provided directly to me by some other
-  person who certified (a), (b) or (c) and I have not modified
-  it.
-
-* (d) I understand and agree that this project and the contribution
-  are public and that a record of the contribution (including all
-  personal information I submit with it, including my sign-off) is
-  maintained indefinitely and may be redistributed consistent with
-  this project or the open source license(s) involved.
-
-## Moderation Policy
-
-The [Node.js Moderation Policy] applies to this WG.
-
-## Code of Conduct
-
-The [Node.js Code of Conduct][] applies to this WG.
-
-[Node.js Code of Conduct]:
-https://github.com/nodejs/node/blob/master/CODE_OF_CONDUCT.md
-[Node.js Moderation Policy]:
-https://github.com/nodejs/TSC/blob/master/Moderation-Policy.md

node_modules/bl/node_modules/readable-stream/GOVERNANCE.md

@@ -1,136 +0,0 @@
-### Streams Working Group
-
-The Node.js Streams is jointly governed by a Working Group
-(WG)
-that is responsible for high-level guidance of the project.
-
-The WG has final authority over this project including:
-
-* Technical direction
-* Project governance and process (including this policy)
-* Contribution policy
-* GitHub repository hosting
-* Conduct guidelines
-* Maintaining the list of additional Collaborators
-
-For the current list of WG members, see the project
-[README.md](./README.md#current-project-team-members).
-
-### Collaborators
-
-The readable-stream GitHub repository is
-maintained by the WG and additional Collaborators who are added by the
-WG on an ongoing basis.
-
-Individuals making significant and valuable contributions are made
-Collaborators and given commit-access to the project. These
-individuals are identified by the WG and their addition as
-Collaborators is discussed during the WG meeting.
-
-_Note:_ If you make a significant contribution and are not considered
-for commit-access log an issue or contact a WG member directly and it
-will be brought up in the next WG meeting.
-
-Modifications of the contents of the readable-stream repository are
-made on
-a collaborative basis. Anybody with a GitHub account may propose a
-modification via pull request and it will be considered by the project
-Collaborators. All pull requests must be reviewed and accepted by a
-Collaborator with sufficient expertise who is able to take full
-responsibility for the change. In the case of pull requests proposed
-by an existing Collaborator, an additional Collaborator is required
-for sign-off. Consensus should be sought if additional Collaborators
-participate and there is disagreement around a particular
-modification. See _Consensus Seeking Process_ below for further detail
-on the consensus model used for governance.
-
-Collaborators may opt to elevate significant or controversial
-modifications, or modifications that have not found consensus to the
-WG for discussion by assigning the ***WG-agenda*** tag to a pull
-request or issue. The WG should serve as the final arbiter where
-required.
-
-For the current list of Collaborators, see the project
-[README.md](./README.md#members).
-
-### WG Membership
-
-WG seats are not time-limited.  There is no fixed size of the WG.
-However, the expected target is between 6 and 12, to ensure adequate
-coverage of important areas of expertise, balanced with the ability to
-make decisions efficiently.
-
-There is no specific set of requirements or qualifications for WG
-membership beyond these rules.
-
-The WG may add additional members to the WG by unanimous consensus.
-
-A WG member may be removed from the WG by voluntary resignation, or by
-unanimous consensus of all other WG members.
-
-Changes to WG membership should be posted in the agenda, and may be
-suggested as any other agenda item (see "WG Meetings" below).
-
-If an addition or removal is proposed during a meeting, and the full
-WG is not in attendance to participate, then the addition or removal
-is added to the agenda for the subsequent meeting.  This is to ensure
-that all members are given the opportunity to participate in all
-membership decisions.  If a WG member is unable to attend a meeting
-where a planned membership decision is being made, then their consent
-is assumed.
-
-No more than 1/3 of the WG members may be affiliated with the same
-employer.  If removal or resignation of a WG member, or a change of
-employment by a WG member, creates a situation where more than 1/3 of
-the WG membership shares an employer, then the situation must be
-immediately remedied by the resignation or removal of one or more WG
-members affiliated with the over-represented employer(s).
-
-### WG Meetings
-
-The WG meets occasionally on a Google Hangout On Air. A designated moderator
-approved by the WG runs the meeting. Each meeting should be
-published to YouTube.
-
-Items are added to the WG agenda that are considered contentious or
-are modifications of governance, contribution policy, WG membership,
-or release process.
-
-The intention of the agenda is not to approve or review all patches;
-that should happen continuously on GitHub and be handled by the larger
-group of Collaborators.
-
-Any community member or contributor can ask that something be added to
-the next meeting's agenda by logging a GitHub Issue. Any Collaborator,
-WG member or the moderator can add the item to the agenda by adding
-the ***WG-agenda*** tag to the issue.
-
-Prior to each WG meeting the moderator will share the Agenda with
-members of the WG. WG members can add any items they like to the
-agenda at the beginning of each meeting. The moderator and the WG
-cannot veto or remove items.
-
-The WG may invite persons or representatives from certain projects to
-participate in a non-voting capacity.
-
-The moderator is responsible for summarizing the discussion of each
-agenda item and sends it as a pull request after the meeting.
-
-### Consensus Seeking Process
-
-The WG follows a
-[Consensus
-Seeking](http://en.wikipedia.org/wiki/Consensus-seeking_decision-making)
-decision-making model.
-
-When an agenda item has appeared to reach a consensus the moderator
-will ask "Does anyone object?" as a final call for dissent from the
-consensus.
-
-If an agenda item cannot reach a consensus a WG member can call for
-either a closing vote or a vote to table the issue to the next
-meeting. The call for a vote must be seconded by a majority of the WG
-or else the discussion will continue. Simple majority wins.
-
-Note that changes to WG membership require a majority consensus.  See
-"WG Membership" above.

node_modules/bl/node_modules/readable-stream/LICENSE

@@ -1,47 +0,0 @@
-Node.js is licensed for use as follows:
-
-"""
-Copyright Node.js contributors. All rights reserved.
-
-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.
-"""
-
-This license applies to parts of Node.js originating from the
-https://github.com/joyent/node repository:
-
-"""
-Copyright Joyent, Inc. and other Node contributors. All rights reserved.
-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.
-"""

node_modules/bl/node_modules/readable-stream/README.md

@@ -1,106 +0,0 @@
-# readable-stream
-
-***Node.js core streams for userland*** [![Build Status](https://travis-ci.com/nodejs/readable-stream.svg?branch=master)](https://travis-ci.com/nodejs/readable-stream)
-
-
-[![NPM](https://nodei.co/npm/readable-stream.png?downloads=true&downloadRank=true)](https://nodei.co/npm/readable-stream/)
-[![NPM](https://nodei.co/npm-dl/readable-stream.png?&months=6&height=3)](https://nodei.co/npm/readable-stream/)
-
-
-[![Sauce Test Status](https://saucelabs.com/browser-matrix/readabe-stream.svg)](https://saucelabs.com/u/readabe-stream)
-
-```bash
-npm install --save readable-stream
-```
-
-This package is a mirror of the streams implementations in Node.js.
-
-Full documentation may be found on the [Node.js website](https://nodejs.org/dist/v10.18.1/docs/api/stream.html).
-
-If you want to guarantee a stable streams base, regardless of what version of
-Node you, or the users of your libraries are using, use **readable-stream** *only* and avoid the *"stream"* module in Node-core, for background see [this blogpost](http://r.va.gg/2014/06/why-i-dont-use-nodes-core-stream-module.html).
-
-As of version 2.0.0 **readable-stream** uses semantic versioning.
-
-## Version 3.x.x
-
-v3.x.x of `readable-stream` is a cut from Node 10. This version supports Node 6, 8, and 10, as well as evergreen browsers, IE 11 and latest Safari. The breaking changes introduced by v3 are composed by the combined breaking changes in [Node v9](https://nodejs.org/en/blog/release/v9.0.0/) and [Node v10](https://nodejs.org/en/blog/release/v10.0.0/), as follows:
-
-1. Error codes: https://github.com/nodejs/node/pull/13310,
-   https://github.com/nodejs/node/pull/13291,
-   https://github.com/nodejs/node/pull/16589,
-   https://github.com/nodejs/node/pull/15042,
-   https://github.com/nodejs/node/pull/15665,
-   https://github.com/nodejs/readable-stream/pull/344
-2. 'readable' have precedence over flowing
-   https://github.com/nodejs/node/pull/18994
-3. make virtual methods errors consistent
-   https://github.com/nodejs/node/pull/18813
-4. updated streams error handling
-   https://github.com/nodejs/node/pull/18438
-5. writable.end should return this.
-   https://github.com/nodejs/node/pull/18780
-6. readable continues to read when push('')
-   https://github.com/nodejs/node/pull/18211
-7. add custom inspect to BufferList
-   https://github.com/nodejs/node/pull/17907
-8. always defer 'readable' with nextTick
-   https://github.com/nodejs/node/pull/17979
-
-## Version 2.x.x
-v2.x.x of `readable-stream` is a cut of the stream module from Node 8 (there have been no semver-major changes from Node 4 to 8). This version supports all Node.js versions from 0.8, as well as evergreen browsers and IE 10 & 11.
-
-### Big Thanks
-
-Cross-browser Testing Platform and Open Source <3 Provided by [Sauce Labs][sauce]
-
-# Usage
-
-You can swap your `require('stream')` with `require('readable-stream')`
-without any changes, if you are just using one of the main classes and
-functions.
-
-```js
-const {
-  Readable,
-  Writable,
-  Transform,
-  Duplex,
-  pipeline,
-  finished
-} = require('readable-stream')
-````
-
-Note that `require('stream')` will return `Stream`, while
-`require('readable-stream')` will return `Readable`. We discourage using
-whatever is exported directly, but rather use one of the properties as
-shown in the example above.
-
-# Streams Working Group
-
-`readable-stream` is maintained by the Streams Working Group, which
-oversees the development and maintenance of the Streams API within
-Node.js. The responsibilities of the Streams Working Group include:
-
-* Addressing stream issues on the Node.js issue tracker.
-* Authoring and editing stream documentation within the Node.js project.
-* Reviewing changes to stream subclasses within the Node.js project.
-* Redirecting changes to streams from the Node.js project to this
-  project.
-* Assisting in the implementation of stream providers within Node.js.
-* Recommending versions of `readable-stream` to be included in Node.js.
-* Messaging about the future of streams to give the community advance
-  notice of changes.
-
-<a name="members"></a>
-## Team Members
-
-* **Calvin Metcalf** ([@calvinmetcalf](https://github.com/calvinmetcalf)) &lt;calvin.metcalf@gmail.com&gt;
-  - Release GPG key: F3EF5F62A87FC27A22E643F714CE4FF5015AA242
-* **Mathias Buus** ([@mafintosh](https://github.com/mafintosh)) &lt;mathiasbuus@gmail.com&gt;
-* **Matteo Collina** ([@mcollina](https://github.com/mcollina)) &lt;matteo.collina@gmail.com&gt;
-  - Release GPG key: 3ABC01543F22DD2239285CDD818674489FBC127E
-* **Irina Shestak** ([@lrlna](https://github.com/lrlna)) &lt;shestak.irina@gmail.com&gt;
-* **Yoshua Wyuts** ([@yoshuawuyts](https://github.com/yoshuawuyts)) &lt;yoshuawuyts@gmail.com&gt;
-
-[sauce]: https://saucelabs.com

node_modules/bl/node_modules/readable-stream/errors-browser.js

@@ -1,127 +0,0 @@
-'use strict';
-
-function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }
-
-var codes = {};
-
-function createErrorType(code, message, Base) {
-  if (!Base) {
-    Base = Error;
-  }
-
-  function getMessage(arg1, arg2, arg3) {
-    if (typeof message === 'string') {
-      return message;
-    } else {
-      return message(arg1, arg2, arg3);
-    }
-  }
-
-  var NodeError =
-  /*#__PURE__*/
-  function (_Base) {
-    _inheritsLoose(NodeError, _Base);
-
-    function NodeError(arg1, arg2, arg3) {
-      return _Base.call(this, getMessage(arg1, arg2, arg3)) || this;
-    }
-
-    return NodeError;
-  }(Base);
-
-  NodeError.prototype.name = Base.name;
-  NodeError.prototype.code = code;
-  codes[code] = NodeError;
-} // https://github.com/nodejs/node/blob/v10.8.0/lib/internal/errors.js
-
-
-function oneOf(expected, thing) {
-  if (Array.isArray(expected)) {
-    var len = expected.length;
-    expected = expected.map(function (i) {
-      return String(i);
-    });
-
-    if (len > 2) {
-      return "one of ".concat(thing, " ").concat(expected.slice(0, len - 1).join(', '), ", or ") + expected[len - 1];
-    } else if (len === 2) {
-      return "one of ".concat(thing, " ").concat(expected[0], " or ").concat(expected[1]);
-    } else {
-      return "of ".concat(thing, " ").concat(expected[0]);
-    }
-  } else {
-    return "of ".concat(thing, " ").concat(String(expected));
-  }
-} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith
-
-
-function startsWith(str, search, pos) {
-  return str.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search;
-} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith
-
-
-function endsWith(str, search, this_len) {
-  if (this_len === undefined || this_len > str.length) {
-    this_len = str.length;
-  }
-
-  return str.substring(this_len - search.length, this_len) === search;
-} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes
-
-
-function includes(str, search, start) {
-  if (typeof start !== 'number') {
-    start = 0;
-  }
-
-  if (start + search.length > str.length) {
-    return false;
-  } else {
-    return str.indexOf(search, start) !== -1;
-  }
-}
-
-createErrorType('ERR_INVALID_OPT_VALUE', function (name, value) {
-  return 'The value "' + value + '" is invalid for option "' + name + '"';
-}, TypeError);
-createErrorType('ERR_INVALID_ARG_TYPE', function (name, expected, actual) {
-  // determiner: 'must be' or 'must not be'
-  var determiner;
-
-  if (typeof expected === 'string' && startsWith(expected, 'not ')) {
-    determiner = 'must not be';
-    expected = expected.replace(/^not /, '');
-  } else {
-    determiner = 'must be';
-  }
-
-  var msg;
-
-  if (endsWith(name, ' argument')) {
-    // For cases like 'first argument'
-    msg = "The ".concat(name, " ").concat(determiner, " ").concat(oneOf(expected, 'type'));
-  } else {
-    var type = includes(name, '.') ? 'property' : 'argument';
-    msg = "The \"".concat(name, "\" ").concat(type, " ").concat(determiner, " ").concat(oneOf(expected, 'type'));
-  }
-
-  msg += ". Received type ".concat(typeof actual);
-  return msg;
-}, TypeError);
-createErrorType('ERR_STREAM_PUSH_AFTER_EOF', 'stream.push() after EOF');
-createErrorType('ERR_METHOD_NOT_IMPLEMENTED', function (name) {
-  return 'The ' + name + ' method is not implemented';
-});
-createErrorType('ERR_STREAM_PREMATURE_CLOSE', 'Premature close');
-createErrorType('ERR_STREAM_DESTROYED', function (name) {
-  return 'Cannot call ' + name + ' after a stream was destroyed';
-});
-createErrorType('ERR_MULTIPLE_CALLBACK', 'Callback called multiple times');
-createErrorType('ERR_STREAM_CANNOT_PIPE', 'Cannot pipe, not readable');
-createErrorType('ERR_STREAM_WRITE_AFTER_END', 'write after end');
-createErrorType('ERR_STREAM_NULL_VALUES', 'May not write null values to stream', TypeError);
-createErrorType('ERR_UNKNOWN_ENCODING', function (arg) {
-  return 'Unknown encoding: ' + arg;
-}, TypeError);
-createErrorType('ERR_STREAM_UNSHIFT_AFTER_END_EVENT', 'stream.unshift() after end event');
-module.exports.codes = codes;

node_modules/bl/node_modules/readable-stream/errors.js

@@ -1,116 +0,0 @@
-'use strict';
-
-const codes = {};
-
-function createErrorType(code, message, Base) {
-  if (!Base) {
-    Base = Error
-  }
-
-  function getMessage (arg1, arg2, arg3) {
-    if (typeof message === 'string') {
-      return message
-    } else {
-      return message(arg1, arg2, arg3)
-    }
-  }
-
-  class NodeError extends Base {
-    constructor (arg1, arg2, arg3) {
-      super(getMessage(arg1, arg2, arg3));
-    }
-  }
-
-  NodeError.prototype.name = Base.name;
-  NodeError.prototype.code = code;
-
-  codes[code] = NodeError;
-}
-
-// https://github.com/nodejs/node/blob/v10.8.0/lib/internal/errors.js
-function oneOf(expected, thing) {
-  if (Array.isArray(expected)) {
-    const len = expected.length;
-    expected = expected.map((i) => String(i));
-    if (len > 2) {
-      return `one of ${thing} ${expected.slice(0, len - 1).join(', ')}, or ` +
-             expected[len - 1];
-    } else if (len === 2) {
-      return `one of ${thing} ${expected[0]} or ${expected[1]}`;
-    } else {
-      return `of ${thing} ${expected[0]}`;
-    }
-  } else {
-    return `of ${thing} ${String(expected)}`;
-  }
-}
-
-// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith
-function startsWith(str, search, pos) {
-	return str.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search;
-}
-
-// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith
-function endsWith(str, search, this_len) {
-	if (this_len === undefined || this_len > str.length) {
-		this_len = str.length;
-	}
-	return str.substring(this_len - search.length, this_len) === search;
-}
-
-// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes
-function includes(str, search, start) {
-  if (typeof start !== 'number') {
-    start = 0;
-  }
-
-  if (start + search.length > str.length) {
-    return false;
-  } else {
-    return str.indexOf(search, start) !== -1;
-  }
-}
-
-createErrorType('ERR_INVALID_OPT_VALUE', function (name, value) {
-  return 'The value "' + value + '" is invalid for option "' + name + '"'
-}, TypeError);
-createErrorType('ERR_INVALID_ARG_TYPE', function (name, expected, actual) {
-  // determiner: 'must be' or 'must not be'
-  let determiner;
-  if (typeof expected === 'string' && startsWith(expected, 'not ')) {
-    determiner = 'must not be';
-    expected = expected.replace(/^not /, '');
-  } else {
-    determiner = 'must be';
-  }
-
-  let msg;
-  if (endsWith(name, ' argument')) {
-    // For cases like 'first argument'
-    msg = `The ${name} ${determiner} ${oneOf(expected, 'type')}`;
-  } else {
-    const type = includes(name, '.') ? 'property' : 'argument';
-    msg = `The "${name}" ${type} ${determiner} ${oneOf(expected, 'type')}`;
-  }
-
-  msg += `. Received type ${typeof actual}`;
-  return msg;
-}, TypeError);
-createErrorType('ERR_STREAM_PUSH_AFTER_EOF', 'stream.push() after EOF');
-createErrorType('ERR_METHOD_NOT_IMPLEMENTED', function (name) {
-  return 'The ' + name + ' method is not implemented'
-});
-createErrorType('ERR_STREAM_PREMATURE_CLOSE', 'Premature close');
-createErrorType('ERR_STREAM_DESTROYED', function (name) {
-  return 'Cannot call ' + name + ' after a stream was destroyed';
-});
-createErrorType('ERR_MULTIPLE_CALLBACK', 'Callback called multiple times');
-createErrorType('ERR_STREAM_CANNOT_PIPE', 'Cannot pipe, not readable');
-createErrorType('ERR_STREAM_WRITE_AFTER_END', 'write after end');
-createErrorType('ERR_STREAM_NULL_VALUES', 'May not write null values to stream', TypeError);
-createErrorType('ERR_UNKNOWN_ENCODING', function (arg) {
-  return 'Unknown encoding: ' + arg
-}, TypeError);
-createErrorType('ERR_STREAM_UNSHIFT_AFTER_END_EVENT', 'stream.unshift() after end event');
-
-module.exports.codes = codes;

node_modules/bl/node_modules/readable-stream/experimentalWarning.js

@@ -1,17 +0,0 @@
-'use strict'
-
-var experimentalWarnings = new Set();
-
-function emitExperimentalWarning(feature) {
-  if (experimentalWarnings.has(feature)) return;
-  var msg = feature + ' is an experimental feature. This feature could ' +
-       'change at any time';
-  experimentalWarnings.add(feature);
-  process.emitWarning(msg, 'ExperimentalWarning');
-}
-
-function noop() {}
-
-module.exports.emitExperimentalWarning = process.emitWarning
-  ? emitExperimentalWarning
-  : noop;

node_modules/bl/node_modules/readable-stream/lib/_stream_duplex.js

@@ -1,126 +0,0 @@
-// 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';
-
-/*<replacement>*/
-var objectKeys = Object.keys || function (obj) {
-  var keys = [];
-  for (var key in obj) keys.push(key);
-  return keys;
-};
-/*</replacement>*/
-
-module.exports = Duplex;
-var Readable = require('./_stream_readable');
-var Writable = require('./_stream_writable');
-require('inherits')(Duplex, Readable);
-{
-  // Allow the keys array to be GC'ed.
-  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);
-  this.allowHalfOpen = true;
-  if (options) {
-    if (options.readable === false) this.readable = false;
-    if (options.writable === false) this.writable = false;
-    if (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 get() {
-    return this._writableState.highWaterMark;
-  }
-});
-Object.defineProperty(Duplex.prototype, 'writableBuffer', {
-  // making it explicit this property is not enumerable
-  // because otherwise some prototype manipulation in
-  // userland will fail
-  enumerable: false,
-  get: function get() {
-    return this._writableState && this._writableState.getBuffer();
-  }
-});
-Object.defineProperty(Duplex.prototype, 'writableLength', {
-  // making it explicit this property is not enumerable
-  // because otherwise some prototype manipulation in
-  // userland will fail
-  enumerable: false,
-  get: function get() {
-    return this._writableState.length;
-  }
-});
-
-// the no-half-open enforcer
-function onend() {
-  // If the writable side ended, then we're ok.
-  if (this._writableState.ended) return;
-
-  // no more data can be written.
-  // But allow more writes to happen in this tick.
-  process.nextTick(onEndNT, this);
-}
-function onEndNT(self) {
-  self.end();
-}
-Object.defineProperty(Duplex.prototype, 'destroyed', {
-  // making it explicit this property is not enumerable
-  // because otherwise some prototype manipulation in
-  // userland will fail
-  enumerable: false,
-  get: function get() {
-    if (this._readableState === undefined || this._writableState === undefined) {
-      return false;
-    }
-    return this._readableState.destroyed && this._writableState.destroyed;
-  },
-  set: function set(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;
-  }
-});

node_modules/bl/node_modules/readable-stream/lib/_stream_passthrough.js

@@ -1,37 +0,0 @@
-// 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');
-require('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);
-};

node_modules/bl/node_modules/readable-stream/lib/_stream_transform.js

@@ -1,190 +0,0 @@
-// 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 _require$codes = require('../errors').codes,
-  ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,
-  ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,
-  ERR_TRANSFORM_ALREADY_TRANSFORMING = _require$codes.ERR_TRANSFORM_ALREADY_TRANSFORMING,
-  ERR_TRANSFORM_WITH_LENGTH_0 = _require$codes.ERR_TRANSFORM_WITH_LENGTH_0;
-var Duplex = require('./_stream_duplex');
-require('inherits')(Transform, Duplex);
-function afterTransform(er, data) {
-  var ts = this._transformState;
-  ts.transforming = false;
-  var cb = ts.writecb;
-  if (cb === null) {
-    return this.emit('error', new ERR_MULTIPLE_CALLBACK());
-  }
-  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._readableState.destroyed) {
-    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) {
-  cb(new ERR_METHOD_NOT_IMPLEMENTED('_transform()'));
-};
-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.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) {
-  Duplex.prototype._destroy.call(this, err, function (err2) {
-    cb(err2);
-  });
-};
-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);
-
-  // TODO(BridgeAR): Write a test for these two error cases
-  // if there's nothing in the write buffer, then that means
-  // that nothing more will ever be provided
-  if (stream._writableState.length) throw new ERR_TRANSFORM_WITH_LENGTH_0();
-  if (stream._transformState.transforming) throw new ERR_TRANSFORM_ALREADY_TRANSFORMING();
-  return stream.push(null);
-}

node_modules/bl/node_modules/readable-stream/lib/_stream_writable.js

@@ -1,641 +0,0 @@
-// 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';
-
-module.exports = Writable;
-
-/* <replacement> */
-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);
-  };
-}
-/* </replacement> */
-
-/*<replacement>*/
-var Duplex;
-/*</replacement>*/
-
-Writable.WritableState = WritableState;
-
-/*<replacement>*/
-var internalUtil = {
-  deprecate: require('util-deprecate')
-};
-/*</replacement>*/
-
-/*<replacement>*/
-var Stream = require('./internal/streams/stream');
-/*</replacement>*/
-
-var Buffer = require('buffer').Buffer;
-var OurUint8Array = (typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : typeof self !== 'undefined' ? self : {}).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');
-var _require = require('./internal/streams/state'),
-  getHighWaterMark = _require.getHighWaterMark;
-var _require$codes = require('../errors').codes,
-  ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,
-  ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,
-  ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,
-  ERR_STREAM_CANNOT_PIPE = _require$codes.ERR_STREAM_CANNOT_PIPE,
-  ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED,
-  ERR_STREAM_NULL_VALUES = _require$codes.ERR_STREAM_NULL_VALUES,
-  ERR_STREAM_WRITE_AFTER_END = _require$codes.ERR_STREAM_WRITE_AFTER_END,
-  ERR_UNKNOWN_ENCODING = _require$codes.ERR_UNKNOWN_ENCODING;
-var errorOrDestroy = destroyImpl.errorOrDestroy;
-require('inherits')(Writable, Stream);
-function nop() {}
-function WritableState(options, stream, isDuplex) {
-  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,
-  // e.g. options.readableObjectMode vs. options.writableObjectMode, etc.
-  if (typeof isDuplex !== 'boolean') 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()
-  this.highWaterMark = getHighWaterMark(this, options, 'writableHighWaterMark', isDuplex);
-
-  // 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;
-
-  // Should close be emitted on destroy. Defaults to true.
-  this.emitClose = options.emitClose !== false;
-
-  // Should .destroy() be called after 'finish' (and potentially 'end')
-  this.autoDestroy = !!options.autoDestroy;
-
-  // 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 writableStateBufferGetter() {
-        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 value(object) {
-      if (realHasInstance.call(this, object)) return true;
-      if (this !== Writable) return false;
-      return object && object._writableState instanceof WritableState;
-    }
-  });
-} else {
-  realHasInstance = function realHasInstance(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.
-
-  // Checking for a Stream.Duplex instance is faster here instead of inside
-  // the WritableState constructor, at least with V8 6.5
-  var isDuplex = this instanceof Duplex;
-  if (!isDuplex && !realHasInstance.call(Writable, this)) return new Writable(options);
-  this._writableState = new WritableState(options, this, isDuplex);
-
-  // 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 () {
-  errorOrDestroy(this, new ERR_STREAM_CANNOT_PIPE());
-};
-function writeAfterEnd(stream, cb) {
-  var er = new ERR_STREAM_WRITE_AFTER_END();
-  // TODO: defer error events consistently everywhere, not just the cb
-  errorOrDestroy(stream, er);
-  process.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 er;
-  if (chunk === null) {
-    er = new ERR_STREAM_NULL_VALUES();
-  } else if (typeof chunk !== 'string' && !state.objectMode) {
-    er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer'], chunk);
-  }
-  if (er) {
-    errorOrDestroy(stream, er);
-    process.nextTick(cb, er);
-    return false;
-  }
-  return true;
-}
-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.ending) 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 () {
-  this._writableState.corked++;
-};
-Writable.prototype.uncork = function () {
-  var state = this._writableState;
-  if (state.corked) {
-    state.corked--;
-    if (!state.writing && !state.corked && !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 ERR_UNKNOWN_ENCODING(encoding);
-  this._writableState.defaultEncoding = encoding;
-  return this;
-};
-Object.defineProperty(Writable.prototype, 'writableBuffer', {
-  // making it explicit this property is not enumerable
-  // because otherwise some prototype manipulation in
-  // userland will fail
-  enumerable: false,
-  get: function get() {
-    return this._writableState && this._writableState.getBuffer();
-  }
-});
-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 get() {
-    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 (state.destroyed) state.onwrite(new ERR_STREAM_DESTROYED('write'));else 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
-    process.nextTick(cb, er);
-    // this can emit finish, and it will always happen
-    // after error
-    process.nextTick(finishMaybe, stream, state);
-    stream._writableState.errorEmitted = true;
-    errorOrDestroy(stream, er);
-  } else {
-    // the caller expect this to happen before if
-    // it is async
-    cb(er);
-    stream._writableState.errorEmitted = true;
-    errorOrDestroy(stream, 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;
-  if (typeof cb !== 'function') throw new ERR_MULTIPLE_CALLBACK();
-  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) || stream.destroyed;
-    if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {
-      clearBuffer(stream, state);
-    }
-    if (sync) {
-      process.nextTick(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 ERR_METHOD_NOT_IMPLEMENTED('_write()'));
-};
-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) endWritable(this, state, cb);
-  return this;
-};
-Object.defineProperty(Writable.prototype, 'writableLength', {
-  // making it explicit this property is not enumerable
-  // because otherwise some prototype manipulation in
-  // userland will fail
-  enumerable: false,
-  get: function get() {
-    return this._writableState.length;
-  }
-});
-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) {
-      errorOrDestroy(stream, 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.destroyed) {
-      state.pendingcb++;
-      state.finalCalled = true;
-      process.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');
-      if (state.autoDestroy) {
-        // In case of duplex streams we need a way to detect
-        // if the readable side is ready for autoDestroy as well
-        var rState = stream._readableState;
-        if (!rState || rState.autoDestroy && rState.endEmitted) {
-          stream.destroy();
-        }
-      }
-    }
-  }
-  return need;
-}
-function endWritable(stream, state, cb) {
-  state.ending = true;
-  finishMaybe(stream, state);
-  if (cb) {
-    if (state.finished) process.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;
-  }
-
-  // reuse the free corkReq.
-  state.corkedRequestsFree.next = corkReq;
-}
-Object.defineProperty(Writable.prototype, 'destroyed', {
-  // making it explicit this property is not enumerable
-  // because otherwise some prototype manipulation in
-  // userland will fail
-  enumerable: false,
-  get: function get() {
-    if (this._writableState === undefined) {
-      return false;
-    }
-    return this._writableState.destroyed;
-  },
-  set: function set(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) {
-  cb(err);
-};

node_modules/bl/node_modules/readable-stream/lib/internal/streams/async_iterator.js

@@ -1,180 +0,0 @@
-'use strict';
-
-var _Object$setPrototypeO;
-function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
-function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-var finished = require('./end-of-stream');
-var kLastResolve = Symbol('lastResolve');
-var kLastReject = Symbol('lastReject');
-var kError = Symbol('error');
-var kEnded = Symbol('ended');
-var kLastPromise = Symbol('lastPromise');
-var kHandlePromise = Symbol('handlePromise');
-var kStream = Symbol('stream');
-function createIterResult(value, done) {
-  return {
-    value: value,
-    done: done
-  };
-}
-function readAndResolve(iter) {
-  var resolve = iter[kLastResolve];
-  if (resolve !== null) {
-    var data = iter[kStream].read();
-    // we defer if data is null
-    // we can be expecting either 'end' or
-    // 'error'
-    if (data !== null) {
-      iter[kLastPromise] = null;
-      iter[kLastResolve] = null;
-      iter[kLastReject] = null;
-      resolve(createIterResult(data, false));
-    }
-  }
-}
-function onReadable(iter) {
-  // we wait for the next tick, because it might
-  // emit an error with process.nextTick
-  process.nextTick(readAndResolve, iter);
-}
-function wrapForNext(lastPromise, iter) {
-  return function (resolve, reject) {
-    lastPromise.then(function () {
-      if (iter[kEnded]) {
-        resolve(createIterResult(undefined, true));
-        return;
-      }
-      iter[kHandlePromise](resolve, reject);
-    }, reject);
-  };
-}
-var AsyncIteratorPrototype = Object.getPrototypeOf(function () {});
-var ReadableStreamAsyncIteratorPrototype = Object.setPrototypeOf((_Object$setPrototypeO = {
-  get stream() {
-    return this[kStream];
-  },
-  next: function next() {
-    var _this = this;
-    // if we have detected an error in the meanwhile
-    // reject straight away
-    var error = this[kError];
-    if (error !== null) {
-      return Promise.reject(error);
-    }
-    if (this[kEnded]) {
-      return Promise.resolve(createIterResult(undefined, true));
-    }
-    if (this[kStream].destroyed) {
-      // We need to defer via nextTick because if .destroy(err) is
-      // called, the error will be emitted via nextTick, and
-      // we cannot guarantee that there is no error lingering around
-      // waiting to be emitted.
-      return new Promise(function (resolve, reject) {
-        process.nextTick(function () {
-          if (_this[kError]) {
-            reject(_this[kError]);
-          } else {
-            resolve(createIterResult(undefined, true));
-          }
-        });
-      });
-    }
-
-    // if we have multiple next() calls
-    // we will wait for the previous Promise to finish
-    // this logic is optimized to support for await loops,
-    // where next() is only called once at a time
-    var lastPromise = this[kLastPromise];
-    var promise;
-    if (lastPromise) {
-      promise = new Promise(wrapForNext(lastPromise, this));
-    } else {
-      // fast path needed to support multiple this.push()
-      // without triggering the next() queue
-      var data = this[kStream].read();
-      if (data !== null) {
-        return Promise.resolve(createIterResult(data, false));
-      }
-      promise = new Promise(this[kHandlePromise]);
-    }
-    this[kLastPromise] = promise;
-    return promise;
-  }
-}, _defineProperty(_Object$setPrototypeO, Symbol.asyncIterator, function () {
-  return this;
-}), _defineProperty(_Object$setPrototypeO, "return", function _return() {
-  var _this2 = this;
-  // destroy(err, cb) is a private API
-  // we can guarantee we have that here, because we control the
-  // Readable class this is attached to
-  return new Promise(function (resolve, reject) {
-    _this2[kStream].destroy(null, function (err) {
-      if (err) {
-        reject(err);
-        return;
-      }
-      resolve(createIterResult(undefined, true));
-    });
-  });
-}), _Object$setPrototypeO), AsyncIteratorPrototype);
-var createReadableStreamAsyncIterator = function createReadableStreamAsyncIterator(stream) {
-  var _Object$create;
-  var iterator = Object.create(ReadableStreamAsyncIteratorPrototype, (_Object$create = {}, _defineProperty(_Object$create, kStream, {
-    value: stream,
-    writable: true
-  }), _defineProperty(_Object$create, kLastResolve, {
-    value: null,
-    writable: true
-  }), _defineProperty(_Object$create, kLastReject, {
-    value: null,
-    writable: true
-  }), _defineProperty(_Object$create, kError, {
-    value: null,
-    writable: true
-  }), _defineProperty(_Object$create, kEnded, {
-    value: stream._readableState.endEmitted,
-    writable: true
-  }), _defineProperty(_Object$create, kHandlePromise, {
-    value: function value(resolve, reject) {
-      var data = iterator[kStream].read();
-      if (data) {
-        iterator[kLastPromise] = null;
-        iterator[kLastResolve] = null;
-        iterator[kLastReject] = null;
-        resolve(createIterResult(data, false));
-      } else {
-        iterator[kLastResolve] = resolve;
-        iterator[kLastReject] = reject;
-      }
-    },
-    writable: true
-  }), _Object$create));
-  iterator[kLastPromise] = null;
-  finished(stream, function (err) {
-    if (err && err.code !== 'ERR_STREAM_PREMATURE_CLOSE') {
-      var reject = iterator[kLastReject];
-      // reject if we are waiting for data in the Promise
-      // returned by next() and store the error
-      if (reject !== null) {
-        iterator[kLastPromise] = null;
-        iterator[kLastResolve] = null;
-        iterator[kLastReject] = null;
-        reject(err);
-      }
-      iterator[kError] = err;
-      return;
-    }
-    var resolve = iterator[kLastResolve];
-    if (resolve !== null) {
-      iterator[kLastPromise] = null;
-      iterator[kLastResolve] = null;
-      iterator[kLastReject] = null;
-      resolve(createIterResult(undefined, true));
-    }
-    iterator[kEnded] = true;
-  });
-  stream.on('readable', onReadable.bind(null, iterator));
-  return iterator;
-};
-module.exports = createReadableStreamAsyncIterator;

node_modules/bl/node_modules/readable-stream/lib/internal/streams/buffer_list.js

@@ -1,183 +0,0 @@
-'use strict';
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
-function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-var _require = require('buffer'),
-  Buffer = _require.Buffer;
-var _require2 = require('util'),
-  inspect = _require2.inspect;
-var custom = inspect && inspect.custom || 'inspect';
-function copyBuffer(src, target, offset) {
-  Buffer.prototype.copy.call(src, target, offset);
-}
-module.exports = /*#__PURE__*/function () {
-  function BufferList() {
-    _classCallCheck(this, BufferList);
-    this.head = null;
-    this.tail = null;
-    this.length = 0;
-  }
-  _createClass(BufferList, [{
-    key: "push",
-    value: 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;
-    }
-  }, {
-    key: "unshift",
-    value: function unshift(v) {
-      var entry = {
-        data: v,
-        next: this.head
-      };
-      if (this.length === 0) this.tail = entry;
-      this.head = entry;
-      ++this.length;
-    }
-  }, {
-    key: "shift",
-    value: 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;
-    }
-  }, {
-    key: "clear",
-    value: function clear() {
-      this.head = this.tail = null;
-      this.length = 0;
-    }
-  }, {
-    key: "join",
-    value: 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;
-    }
-  }, {
-    key: "concat",
-    value: function concat(n) {
-      if (this.length === 0) return Buffer.alloc(0);
-      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;
-    }
-
-    // Consumes a specified amount of bytes or characters from the buffered data.
-  }, {
-    key: "consume",
-    value: function consume(n, hasStrings) {
-      var ret;
-      if (n < this.head.data.length) {
-        // `slice` is the same for buffers and strings.
-        ret = this.head.data.slice(0, n);
-        this.head.data = this.head.data.slice(n);
-      } else if (n === this.head.data.length) {
-        // First chunk is a perfect match.
-        ret = this.shift();
-      } else {
-        // Result spans more than one buffer.
-        ret = hasStrings ? this._getString(n) : this._getBuffer(n);
-      }
-      return ret;
-    }
-  }, {
-    key: "first",
-    value: function first() {
-      return this.head.data;
-    }
-
-    // Consumes a specified amount of characters from the buffered data.
-  }, {
-    key: "_getString",
-    value: function _getString(n) {
-      var p = this.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) this.head = p.next;else this.head = this.tail = null;
-          } else {
-            this.head = p;
-            p.data = str.slice(nb);
-          }
-          break;
-        }
-        ++c;
-      }
-      this.length -= c;
-      return ret;
-    }
-
-    // Consumes a specified amount of bytes from the buffered data.
-  }, {
-    key: "_getBuffer",
-    value: function _getBuffer(n) {
-      var ret = Buffer.allocUnsafe(n);
-      var p = this.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) this.head = p.next;else this.head = this.tail = null;
-          } else {
-            this.head = p;
-            p.data = buf.slice(nb);
-          }
-          break;
-        }
-        ++c;
-      }
-      this.length -= c;
-      return ret;
-    }
-
-    // Make sure the linked list only shows the minimal necessary information.
-  }, {
-    key: custom,
-    value: function value(_, options) {
-      return inspect(this, _objectSpread(_objectSpread({}, options), {}, {
-        // Only inspect one level.
-        depth: 0,
-        // It should not recurse.
-        customInspect: false
-      }));
-    }
-  }]);
-  return BufferList;
-}();

node_modules/bl/node_modules/readable-stream/lib/internal/streams/destroy.js

@@ -1,96 +0,0 @@
-'use strict';
-
-// 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) {
-      if (!this._writableState) {
-        process.nextTick(emitErrorNT, this, err);
-      } else if (!this._writableState.errorEmitted) {
-        this._writableState.errorEmitted = true;
-        process.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) {
-      if (!_this._writableState) {
-        process.nextTick(emitErrorAndCloseNT, _this, err);
-      } else if (!_this._writableState.errorEmitted) {
-        _this._writableState.errorEmitted = true;
-        process.nextTick(emitErrorAndCloseNT, _this, err);
-      } else {
-        process.nextTick(emitCloseNT, _this);
-      }
-    } else if (cb) {
-      process.nextTick(emitCloseNT, _this);
-      cb(err);
-    } else {
-      process.nextTick(emitCloseNT, _this);
-    }
-  });
-  return this;
-}
-function emitErrorAndCloseNT(self, err) {
-  emitErrorNT(self, err);
-  emitCloseNT(self);
-}
-function emitCloseNT(self) {
-  if (self._writableState && !self._writableState.emitClose) return;
-  if (self._readableState && !self._readableState.emitClose) return;
-  self.emit('close');
-}
-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.finalCalled = false;
-    this._writableState.prefinished = false;
-    this._writableState.finished = false;
-    this._writableState.errorEmitted = false;
-  }
-}
-function emitErrorNT(self, err) {
-  self.emit('error', err);
-}
-function errorOrDestroy(stream, err) {
-  // We have tests that rely on errors being emitted
-  // in the same tick, so changing this is semver major.
-  // For now when you opt-in to autoDestroy we allow
-  // the error to be emitted nextTick. In a future
-  // semver major update we should change the default to this.
-
-  var rState = stream._readableState;
-  var wState = stream._writableState;
-  if (rState && rState.autoDestroy || wState && wState.autoDestroy) stream.destroy(err);else stream.emit('error', err);
-}
-module.exports = {
-  destroy: destroy,
-  undestroy: undestroy,
-  errorOrDestroy: errorOrDestroy
-};

node_modules/bl/node_modules/readable-stream/lib/internal/streams/end-of-stream.js

@@ -1,86 +0,0 @@
-// Ported from https://github.com/mafintosh/end-of-stream with
-// permission from the author, Mathias Buus (@mafintosh).
-
-'use strict';
-
-var ERR_STREAM_PREMATURE_CLOSE = require('../../../errors').codes.ERR_STREAM_PREMATURE_CLOSE;
-function once(callback) {
-  var called = false;
-  return function () {
-    if (called) return;
-    called = true;
-    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-      args[_key] = arguments[_key];
-    }
-    callback.apply(this, args);
-  };
-}
-function noop() {}
-function isRequest(stream) {
-  return stream.setHeader && typeof stream.abort === 'function';
-}
-function eos(stream, opts, callback) {
-  if (typeof opts === 'function') return eos(stream, null, opts);
-  if (!opts) opts = {};
-  callback = once(callback || noop);
-  var readable = opts.readable || opts.readable !== false && stream.readable;
-  var writable = opts.writable || opts.writable !== false && stream.writable;
-  var onlegacyfinish = function onlegacyfinish() {
-    if (!stream.writable) onfinish();
-  };
-  var writableEnded = stream._writableState && stream._writableState.finished;
-  var onfinish = function onfinish() {
-    writable = false;
-    writableEnded = true;
-    if (!readable) callback.call(stream);
-  };
-  var readableEnded = stream._readableState && stream._readableState.endEmitted;
-  var onend = function onend() {
-    readable = false;
-    readableEnded = true;
-    if (!writable) callback.call(stream);
-  };
-  var onerror = function onerror(err) {
-    callback.call(stream, err);
-  };
-  var onclose = function onclose() {
-    var err;
-    if (readable && !readableEnded) {
-      if (!stream._readableState || !stream._readableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();
-      return callback.call(stream, err);
-    }
-    if (writable && !writableEnded) {
-      if (!stream._writableState || !stream._writableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();
-      return callback.call(stream, err);
-    }
-  };
-  var onrequest = function onrequest() {
-    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 && !stream._writableState) {
-    // legacy streams
-    stream.on('end', onlegacyfinish);
-    stream.on('close', onlegacyfinish);
-  }
-  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('end', onend);
-    stream.removeListener('error', onerror);
-    stream.removeListener('close', onclose);
-  };
-}
-module.exports = eos;

node_modules/bl/node_modules/readable-stream/lib/internal/streams/from-browser.js

@@ -1,3 +0,0 @@
-module.exports = function () {
-  throw new Error('Readable.from is not available in the browser')
-};

node_modules/bl/node_modules/readable-stream/lib/internal/streams/from.js

@@ -1,52 +0,0 @@
-'use strict';
-
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
-function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
-function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-var ERR_INVALID_ARG_TYPE = require('../../../errors').codes.ERR_INVALID_ARG_TYPE;
-function from(Readable, iterable, opts) {
-  var iterator;
-  if (iterable && typeof iterable.next === 'function') {
-    iterator = iterable;
-  } else if (iterable && iterable[Symbol.asyncIterator]) iterator = iterable[Symbol.asyncIterator]();else if (iterable && iterable[Symbol.iterator]) iterator = iterable[Symbol.iterator]();else throw new ERR_INVALID_ARG_TYPE('iterable', ['Iterable'], iterable);
-  var readable = new Readable(_objectSpread({
-    objectMode: true
-  }, opts));
-  // Reading boolean to protect against _read
-  // being called before last iteration completion.
-  var reading = false;
-  readable._read = function () {
-    if (!reading) {
-      reading = true;
-      next();
-    }
-  };
-  function next() {
-    return _next2.apply(this, arguments);
-  }
-  function _next2() {
-    _next2 = _asyncToGenerator(function* () {
-      try {
-        var _yield$iterator$next = yield iterator.next(),
-          value = _yield$iterator$next.value,
-          done = _yield$iterator$next.done;
-        if (done) {
-          readable.push(null);
-        } else if (readable.push(yield value)) {
-          next();
-        } else {
-          reading = false;
-        }
-      } catch (err) {
-        readable.destroy(err);
-      }
-    });
-    return _next2.apply(this, arguments);
-  }
-  return readable;
-}
-module.exports = from;

node_modules/bl/node_modules/readable-stream/lib/internal/streams/pipeline.js

@@ -1,86 +0,0 @@
-// Ported from https://github.com/mafintosh/pump with
-// permission from the author, Mathias Buus (@mafintosh).
-
-'use strict';
-
-var eos;
-function once(callback) {
-  var called = false;
-  return function () {
-    if (called) return;
-    called = true;
-    callback.apply(void 0, arguments);
-  };
-}
-var _require$codes = require('../../../errors').codes,
-  ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS,
-  ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED;
-function noop(err) {
-  // Rethrow the error if it exists to avoid swallowing it
-  if (err) throw err;
-}
-function isRequest(stream) {
-  return stream.setHeader && typeof stream.abort === 'function';
-}
-function destroyer(stream, reading, writing, callback) {
-  callback = once(callback);
-  var closed = false;
-  stream.on('close', function () {
-    closed = true;
-  });
-  if (eos === undefined) eos = require('./end-of-stream');
-  eos(stream, {
-    readable: reading,
-    writable: writing
-  }, function (err) {
-    if (err) return callback(err);
-    closed = true;
-    callback();
-  });
-  var destroyed = false;
-  return function (err) {
-    if (closed) return;
-    if (destroyed) return;
-    destroyed = true;
-
-    // request.destroy just do .end - .abort is what we want
-    if (isRequest(stream)) return stream.abort();
-    if (typeof stream.destroy === 'function') return stream.destroy();
-    callback(err || new ERR_STREAM_DESTROYED('pipe'));
-  };
-}
-function call(fn) {
-  fn();
-}
-function pipe(from, to) {
-  return from.pipe(to);
-}
-function popCallback(streams) {
-  if (!streams.length) return noop;
-  if (typeof streams[streams.length - 1] !== 'function') return noop;
-  return streams.pop();
-}
-function pipeline() {
-  for (var _len = arguments.length, streams = new Array(_len), _key = 0; _key < _len; _key++) {
-    streams[_key] = arguments[_key];
-  }
-  var callback = popCallback(streams);
-  if (Array.isArray(streams[0])) streams = streams[0];
-  if (streams.length < 2) {
-    throw new ERR_MISSING_ARGS('streams');
-  }
-  var error;
-  var destroys = streams.map(function (stream, i) {
-    var reading = i < streams.length - 1;
-    var writing = i > 0;
-    return destroyer(stream, reading, writing, function (err) {
-      if (!error) error = err;
-      if (err) destroys.forEach(call);
-      if (reading) return;
-      destroys.forEach(call);
-      callback(error);
-    });
-  });
-  return streams.reduce(pipe);
-}
-module.exports = pipeline;

node_modules/bl/node_modules/readable-stream/lib/internal/streams/state.js

@@ -1,22 +0,0 @@
-'use strict';
-
-var ERR_INVALID_OPT_VALUE = require('../../../errors').codes.ERR_INVALID_OPT_VALUE;
-function highWaterMarkFrom(options, isDuplex, duplexKey) {
-  return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null;
-}
-function getHighWaterMark(state, options, duplexKey, isDuplex) {
-  var hwm = highWaterMarkFrom(options, isDuplex, duplexKey);
-  if (hwm != null) {
-    if (!(isFinite(hwm) && Math.floor(hwm) === hwm) || hwm < 0) {
-      var name = isDuplex ? duplexKey : 'highWaterMark';
-      throw new ERR_INVALID_OPT_VALUE(name, hwm);
-    }
-    return Math.floor(hwm);
-  }
-
-  // Default value
-  return state.objectMode ? 16 : 16 * 1024;
-}
-module.exports = {
-  getHighWaterMark: getHighWaterMark
-};

node_modules/bl/node_modules/readable-stream/lib/internal/streams/stream-browser.js

@@ -1 +0,0 @@
-module.exports = require('events').EventEmitter;

node_modules/bl/node_modules/readable-stream/lib/internal/streams/stream.js

@@ -1 +0,0 @@
-module.exports = require('stream');

node_modules/bl/node_modules/readable-stream/package.json

@@ -1,97 +0,0 @@
-{
-  "_from": "readable-stream@^3.4.0",
-  "_id": "readable-stream@3.6.2",
-  "_inBundle": false,
-  "_integrity": "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==",
-  "_location": "/bl/readable-stream",
-  "_phantomChildren": {},
-  "_requested": {
-    "type": "range",
-    "registry": true,
-    "raw": "readable-stream@^3.4.0",
-    "name": "readable-stream",
-    "escapedName": "readable-stream",
-    "rawSpec": "^3.4.0",
-    "saveSpec": null,
-    "fetchSpec": "^3.4.0"
-  },
-  "_requiredBy": [
-    "/bl"
-  ],
-  "_resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz",
-  "_shasum": "56a9b36ea965c00c5a93ef31eb111a0f11056967",
-  "_spec": "readable-stream@^3.4.0",
-  "_where": "E:\\gitee\\fys\\fys\\app\\JingQuan\\node_modules\\bl",
-  "browser": {
-    "util": false,
-    "worker_threads": false,
-    "./errors": "./errors-browser.js",
-    "./readable.js": "./readable-browser.js",
-    "./lib/internal/streams/from.js": "./lib/internal/streams/from-browser.js",
-    "./lib/internal/streams/stream.js": "./lib/internal/streams/stream-browser.js"
-  },
-  "bugs": {
-    "url": "https://github.com/nodejs/readable-stream/issues"
-  },
-  "bundleDependencies": false,
-  "dependencies": {
-    "inherits": "^2.0.3",
-    "string_decoder": "^1.1.1",
-    "util-deprecate": "^1.0.1"
-  },
-  "deprecated": false,
-  "description": "Streams3, a user-land copy of the stream library from Node.js",
-  "devDependencies": {
-    "@babel/cli": "^7.2.0",
-    "@babel/core": "^7.2.0",
-    "@babel/polyfill": "^7.0.0",
-    "@babel/preset-env": "^7.2.0",
-    "airtap": "0.0.9",
-    "assert": "^1.4.0",
-    "bl": "^2.0.0",
-    "deep-strict-equal": "^0.2.0",
-    "events.once": "^2.0.2",
-    "glob": "^7.1.2",
-    "gunzip-maybe": "^1.4.1",
-    "hyperquest": "^2.1.3",
-    "lolex": "^2.6.0",
-    "nyc": "^11.0.0",
-    "pump": "^3.0.0",
-    "rimraf": "^2.6.2",
-    "tap": "^12.0.0",
-    "tape": "^4.9.0",
-    "tar-fs": "^1.16.2",
-    "util-promisify": "^2.1.0"
-  },
-  "engines": {
-    "node": ">= 6"
-  },
-  "homepage": "https://github.com/nodejs/readable-stream#readme",
-  "keywords": [
-    "readable",
-    "stream",
-    "pipe"
-  ],
-  "license": "MIT",
-  "main": "readable.js",
-  "name": "readable-stream",
-  "nyc": {
-    "include": [
-      "lib/**.js"
-    ]
-  },
-  "repository": {
-    "type": "git",
-    "url": "git://github.com/nodejs/readable-stream.git"
-  },
-  "scripts": {
-    "ci": "TAP=1 tap --no-esm test/parallel/*.js test/ours/*.js | tee test.tap",
-    "cover": "nyc npm test",
-    "report": "nyc report --reporter=lcov",
-    "test": "tap -J --no-esm test/parallel/*.js test/ours/*.js",
-    "test-browser-local": "airtap --open --local -- test/browser.js",
-    "test-browsers": "airtap --sauce-connect --loopback airtap.local -- test/browser.js",
-    "update-browser-errors": "babel -o errors-browser.js errors.js"
-  },
-  "version": "3.6.2"
-}

node_modules/bl/node_modules/readable-stream/readable-browser.js

@@ -1,9 +0,0 @@
-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');
-exports.finished = require('./lib/internal/streams/end-of-stream.js');
-exports.pipeline = require('./lib/internal/streams/pipeline.js');

node_modules/bl/node_modules/readable-stream/readable.js

@@ -1,16 +0,0 @@
-var Stream = require('stream');
-if (process.env.READABLE_STREAM === 'disable' && Stream) {
-  module.exports = Stream.Readable;
-  Object.assign(module.exports, Stream);
-  module.exports.Stream = Stream;
-} else {
-  exports = module.exports = require('./lib/_stream_readable.js');
-  exports.Stream = Stream || exports;
-  exports.Readable = exports;
-  exports.Writable = require('./lib/_stream_writable.js');
-  exports.Duplex = require('./lib/_stream_duplex.js');
-  exports.Transform = require('./lib/_stream_transform.js');
-  exports.PassThrough = require('./lib/_stream_passthrough.js');
-  exports.finished = require('./lib/internal/streams/end-of-stream.js');
-  exports.pipeline = require('./lib/internal/streams/pipeline.js');
-}

node_modules/bl/package.json

@@ -1,69 +0,0 @@
-{
-  "_from": "bl@^4.0.2",
-  "_id": "bl@4.1.0",
-  "_inBundle": false,
-  "_integrity": "sha512-1W07cM9gS6DcLperZfFSj+bWLtaPGSOHWhPiGzXmvVJbRLdG82sH/Kn8EtW1VqWVA54AKf2h5k5BbnIbwF3h6w==",
-  "_location": "/bl",
-  "_phantomChildren": {
-    "inherits": "2.0.4",
-    "string_decoder": "1.1.1",
-    "util-deprecate": "1.0.2"
-  },
-  "_requested": {
-    "type": "range",
-    "registry": true,
-    "raw": "bl@^4.0.2",
-    "name": "bl",
-    "escapedName": "bl",
-    "rawSpec": "^4.0.2",
-    "saveSpec": null,
-    "fetchSpec": "^4.0.2"
-  },
-  "_requiredBy": [
-    "/mqtt-packet"
-  ],
-  "_resolved": "https://registry.npmjs.org/bl/-/bl-4.1.0.tgz",
-  "_shasum": "451535264182bec2fbbc83a62ab98cf11d9f7b3a",
-  "_spec": "bl@^4.0.2",
-  "_where": "E:\\gitee\\fys\\fys\\app\\JingQuan\\node_modules\\mqtt-packet",
-  "authors": [
-    "Rod Vagg <rod@vagg.org> (https://github.com/rvagg)",
-    "Matteo Collina <matteo.collina@gmail.com> (https://github.com/mcollina)",
-    "Jarett Cruger <jcrugzz@gmail.com> (https://github.com/jcrugzz)"
-  ],
-  "bugs": {
-    "url": "https://github.com/rvagg/bl/issues"
-  },
-  "bundleDependencies": false,
-  "dependencies": {
-    "buffer": "^5.5.0",
-    "inherits": "^2.0.4",
-    "readable-stream": "^3.4.0"
-  },
-  "deprecated": false,
-  "description": "Buffer List: collect buffers and access with a standard readable Buffer interface, streamable too!",
-  "devDependencies": {
-    "faucet": "~0.0.1",
-    "standard": "^14.3.0",
-    "tape": "^4.11.0"
-  },
-  "homepage": "https://github.com/rvagg/bl",
-  "keywords": [
-    "buffer",
-    "buffers",
-    "stream",
-    "awesomesauce"
-  ],
-  "license": "MIT",
-  "main": "bl.js",
-  "name": "bl",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/rvagg/bl.git"
-  },
-  "scripts": {
-    "lint": "standard *.js test/*.js",
-    "test": "npm run lint && node test/test.js | faucet"
-  },
-  "version": "4.1.0"
-}

node_modules/bl/test/convert.js

@@ -1,21 +0,0 @@
-'use strict'
-
-const tape = require('tape')
-const { BufferList, BufferListStream } = require('../')
-const { Buffer } = require('buffer')
-
-tape('convert from BufferList to BufferListStream', (t) => {
-  const data = Buffer.from(`TEST-${Date.now()}`)
-  const bl = new BufferList(data)
-  const bls = new BufferListStream(bl)
-  t.ok(bl.slice().equals(bls.slice()))
-  t.end()
-})
-
-tape('convert from BufferListStream to BufferList', (t) => {
-  const data = Buffer.from(`TEST-${Date.now()}`)
-  const bls = new BufferListStream(data)
-  const bl = new BufferList(bls)
-  t.ok(bl.slice().equals(bls.slice()))
-  t.end()
-})

node_modules/bl/test/indexOf.js

@@ -1,492 +0,0 @@
-'use strict'
-
-const tape = require('tape')
-const BufferList = require('../')
-const { Buffer } = require('buffer')
-
-tape('indexOf single byte needle', (t) => {
-  const bl = new BufferList(['abcdefg', 'abcdefg', '12345'])
-
-  t.equal(bl.indexOf('e'), 4)
-  t.equal(bl.indexOf('e', 5), 11)
-  t.equal(bl.indexOf('e', 12), -1)
-  t.equal(bl.indexOf('5'), 18)
-
-  t.end()
-})
-
-tape('indexOf multiple byte needle', (t) => {
-  const bl = new BufferList(['abcdefg', 'abcdefg'])
-
-  t.equal(bl.indexOf('ef'), 4)
-  t.equal(bl.indexOf('ef', 5), 11)
-
-  t.end()
-})
-
-tape('indexOf multiple byte needles across buffer boundaries', (t) => {
-  const bl = new BufferList(['abcdefg', 'abcdefg'])
-
-  t.equal(bl.indexOf('fgabc'), 5)
-
-  t.end()
-})
-
-tape('indexOf takes a Uint8Array search', (t) => {
-  const bl = new BufferList(['abcdefg', 'abcdefg'])
-  const search = new Uint8Array([102, 103, 97, 98, 99]) // fgabc
-
-  t.equal(bl.indexOf(search), 5)
-
-  t.end()
-})
-
-tape('indexOf takes a buffer list search', (t) => {
-  const bl = new BufferList(['abcdefg', 'abcdefg'])
-  const search = new BufferList('fgabc')
-
-  t.equal(bl.indexOf(search), 5)
-
-  t.end()
-})
-
-tape('indexOf a zero byte needle', (t) => {
-  const b = new BufferList('abcdef')
-  const bufEmpty = Buffer.from('')
-
-  t.equal(b.indexOf(''), 0)
-  t.equal(b.indexOf('', 1), 1)
-  t.equal(b.indexOf('', b.length + 1), b.length)
-  t.equal(b.indexOf('', Infinity), b.length)
-  t.equal(b.indexOf(bufEmpty), 0)
-  t.equal(b.indexOf(bufEmpty, 1), 1)
-  t.equal(b.indexOf(bufEmpty, b.length + 1), b.length)
-  t.equal(b.indexOf(bufEmpty, Infinity), b.length)
-
-  t.end()
-})
-
-tape('indexOf buffers smaller and larger than the needle', (t) => {
-  const bl = new BufferList(['abcdefg', 'a', 'bcdefg', 'a', 'bcfgab'])
-
-  t.equal(bl.indexOf('fgabc'), 5)
-  t.equal(bl.indexOf('fgabc', 6), 12)
-  t.equal(bl.indexOf('fgabc', 13), -1)
-
-  t.end()
-})
-
-// only present in node 6+
-;(process.version.substr(1).split('.')[0] >= 6) && tape('indexOf latin1 and binary encoding', (t) => {
-  const b = new BufferList('abcdef')
-
-  // test latin1 encoding
-  t.equal(
-    new BufferList(Buffer.from(b.toString('latin1'), 'latin1'))
-      .indexOf('d', 0, 'latin1'),
-    3
-  )
-  t.equal(
-    new BufferList(Buffer.from(b.toString('latin1'), 'latin1'))
-      .indexOf(Buffer.from('d', 'latin1'), 0, 'latin1'),
-    3
-  )
-  t.equal(
-    new BufferList(Buffer.from('aa\u00e8aa', 'latin1'))
-      .indexOf('\u00e8', 'latin1'),
-    2
-  )
-  t.equal(
-    new BufferList(Buffer.from('\u00e8', 'latin1'))
-      .indexOf('\u00e8', 'latin1'),
-    0
-  )
-  t.equal(
-    new BufferList(Buffer.from('\u00e8', 'latin1'))
-      .indexOf(Buffer.from('\u00e8', 'latin1'), 'latin1'),
-    0
-  )
-
-  // test binary encoding
-  t.equal(
-    new BufferList(Buffer.from(b.toString('binary'), 'binary'))
-      .indexOf('d', 0, 'binary'),
-    3
-  )
-  t.equal(
-    new BufferList(Buffer.from(b.toString('binary'), 'binary'))
-      .indexOf(Buffer.from('d', 'binary'), 0, 'binary'),
-    3
-  )
-  t.equal(
-    new BufferList(Buffer.from('aa\u00e8aa', 'binary'))
-      .indexOf('\u00e8', 'binary'),
-    2
-  )
-  t.equal(
-    new BufferList(Buffer.from('\u00e8', 'binary'))
-      .indexOf('\u00e8', 'binary'),
-    0
-  )
-  t.equal(
-    new BufferList(Buffer.from('\u00e8', 'binary'))
-      .indexOf(Buffer.from('\u00e8', 'binary'), 'binary'),
-    0
-  )
-
-  t.end()
-})
-
-tape('indexOf the entire nodejs10 buffer test suite', (t) => {
-  const b = new BufferList('abcdef')
-  const bufA = Buffer.from('a')
-  const bufBc = Buffer.from('bc')
-  const bufF = Buffer.from('f')
-  const bufZ = Buffer.from('z')
-
-  const stringComparison = 'abcdef'
-
-  t.equal(b.indexOf('a'), 0)
-  t.equal(b.indexOf('a', 1), -1)
-  t.equal(b.indexOf('a', -1), -1)
-  t.equal(b.indexOf('a', -4), -1)
-  t.equal(b.indexOf('a', -b.length), 0)
-  t.equal(b.indexOf('a', NaN), 0)
-  t.equal(b.indexOf('a', -Infinity), 0)
-  t.equal(b.indexOf('a', Infinity), -1)
-  t.equal(b.indexOf('bc'), 1)
-  t.equal(b.indexOf('bc', 2), -1)
-  t.equal(b.indexOf('bc', -1), -1)
-  t.equal(b.indexOf('bc', -3), -1)
-  t.equal(b.indexOf('bc', -5), 1)
-  t.equal(b.indexOf('bc', NaN), 1)
-  t.equal(b.indexOf('bc', -Infinity), 1)
-  t.equal(b.indexOf('bc', Infinity), -1)
-  t.equal(b.indexOf('f'), b.length - 1)
-  t.equal(b.indexOf('z'), -1)
-
-  // empty search tests
-  t.equal(b.indexOf(bufA), 0)
-  t.equal(b.indexOf(bufA, 1), -1)
-  t.equal(b.indexOf(bufA, -1), -1)
-  t.equal(b.indexOf(bufA, -4), -1)
-  t.equal(b.indexOf(bufA, -b.length), 0)
-  t.equal(b.indexOf(bufA, NaN), 0)
-  t.equal(b.indexOf(bufA, -Infinity), 0)
-  t.equal(b.indexOf(bufA, Infinity), -1)
-  t.equal(b.indexOf(bufBc), 1)
-  t.equal(b.indexOf(bufBc, 2), -1)
-  t.equal(b.indexOf(bufBc, -1), -1)
-  t.equal(b.indexOf(bufBc, -3), -1)
-  t.equal(b.indexOf(bufBc, -5), 1)
-  t.equal(b.indexOf(bufBc, NaN), 1)
-  t.equal(b.indexOf(bufBc, -Infinity), 1)
-  t.equal(b.indexOf(bufBc, Infinity), -1)
-  t.equal(b.indexOf(bufF), b.length - 1)
-  t.equal(b.indexOf(bufZ), -1)
-  t.equal(b.indexOf(0x61), 0)
-  t.equal(b.indexOf(0x61, 1), -1)
-  t.equal(b.indexOf(0x61, -1), -1)
-  t.equal(b.indexOf(0x61, -4), -1)
-  t.equal(b.indexOf(0x61, -b.length), 0)
-  t.equal(b.indexOf(0x61, NaN), 0)
-  t.equal(b.indexOf(0x61, -Infinity), 0)
-  t.equal(b.indexOf(0x61, Infinity), -1)
-  t.equal(b.indexOf(0x0), -1)
-
-  // test offsets
-  t.equal(b.indexOf('d', 2), 3)
-  t.equal(b.indexOf('f', 5), 5)
-  t.equal(b.indexOf('f', -1), 5)
-  t.equal(b.indexOf('f', 6), -1)
-
-  t.equal(b.indexOf(Buffer.from('d'), 2), 3)
-  t.equal(b.indexOf(Buffer.from('f'), 5), 5)
-  t.equal(b.indexOf(Buffer.from('f'), -1), 5)
-  t.equal(b.indexOf(Buffer.from('f'), 6), -1)
-
-  t.equal(Buffer.from('ff').indexOf(Buffer.from('f'), 1, 'ucs2'), -1)
-
-  // test invalid and uppercase encoding
-  t.equal(b.indexOf('b', 'utf8'), 1)
-  t.equal(b.indexOf('b', 'UTF8'), 1)
-  t.equal(b.indexOf('62', 'HEX'), 1)
-  t.throws(() => b.indexOf('bad', 'enc'), TypeError)
-
-  // test hex encoding
-  t.equal(
-    Buffer.from(b.toString('hex'), 'hex')
-      .indexOf('64', 0, 'hex'),
-    3
-  )
-  t.equal(
-    Buffer.from(b.toString('hex'), 'hex')
-      .indexOf(Buffer.from('64', 'hex'), 0, 'hex'),
-    3
-  )
-
-  // test base64 encoding
-  t.equal(
-    Buffer.from(b.toString('base64'), 'base64')
-      .indexOf('ZA==', 0, 'base64'),
-    3
-  )
-  t.equal(
-    Buffer.from(b.toString('base64'), 'base64')
-      .indexOf(Buffer.from('ZA==', 'base64'), 0, 'base64'),
-    3
-  )
-
-  // test ascii encoding
-  t.equal(
-    Buffer.from(b.toString('ascii'), 'ascii')
-      .indexOf('d', 0, 'ascii'),
-    3
-  )
-  t.equal(
-    Buffer.from(b.toString('ascii'), 'ascii')
-      .indexOf(Buffer.from('d', 'ascii'), 0, 'ascii'),
-    3
-  )
-
-  // test optional offset with passed encoding
-  t.equal(Buffer.from('aaaa0').indexOf('30', 'hex'), 4)
-  t.equal(Buffer.from('aaaa00a').indexOf('3030', 'hex'), 4)
-
-  {
-    // test usc2 encoding
-    const twoByteString = Buffer.from('\u039a\u0391\u03a3\u03a3\u0395', 'ucs2')
-
-    t.equal(8, twoByteString.indexOf('\u0395', 4, 'ucs2'))
-    t.equal(6, twoByteString.indexOf('\u03a3', -4, 'ucs2'))
-    t.equal(4, twoByteString.indexOf('\u03a3', -6, 'ucs2'))
-    t.equal(4, twoByteString.indexOf(
-      Buffer.from('\u03a3', 'ucs2'), -6, 'ucs2'))
-    t.equal(-1, twoByteString.indexOf('\u03a3', -2, 'ucs2'))
-  }
-
-  const mixedByteStringUcs2 =
-      Buffer.from('\u039a\u0391abc\u03a3\u03a3\u0395', 'ucs2')
-
-  t.equal(6, mixedByteStringUcs2.indexOf('bc', 0, 'ucs2'))
-  t.equal(10, mixedByteStringUcs2.indexOf('\u03a3', 0, 'ucs2'))
-  t.equal(-1, mixedByteStringUcs2.indexOf('\u0396', 0, 'ucs2'))
-
-  t.equal(
-    6, mixedByteStringUcs2.indexOf(Buffer.from('bc', 'ucs2'), 0, 'ucs2'))
-  t.equal(
-    10, mixedByteStringUcs2.indexOf(Buffer.from('\u03a3', 'ucs2'), 0, 'ucs2'))
-  t.equal(
-    -1, mixedByteStringUcs2.indexOf(Buffer.from('\u0396', 'ucs2'), 0, 'ucs2'))
-
-  {
-    const twoByteString = Buffer.from('\u039a\u0391\u03a3\u03a3\u0395', 'ucs2')
-
-    // Test single char pattern
-    t.equal(0, twoByteString.indexOf('\u039a', 0, 'ucs2'))
-    let index = twoByteString.indexOf('\u0391', 0, 'ucs2')
-    t.equal(2, index, `Alpha - at index ${index}`)
-    index = twoByteString.indexOf('\u03a3', 0, 'ucs2')
-    t.equal(4, index, `First Sigma - at index ${index}`)
-    index = twoByteString.indexOf('\u03a3', 6, 'ucs2')
-    t.equal(6, index, `Second Sigma - at index ${index}`)
-    index = twoByteString.indexOf('\u0395', 0, 'ucs2')
-    t.equal(8, index, `Epsilon - at index ${index}`)
-    index = twoByteString.indexOf('\u0392', 0, 'ucs2')
-    t.equal(-1, index, `Not beta - at index ${index}`)
-
-    // Test multi-char pattern
-    index = twoByteString.indexOf('\u039a\u0391', 0, 'ucs2')
-    t.equal(0, index, `Lambda Alpha - at index ${index}`)
-    index = twoByteString.indexOf('\u0391\u03a3', 0, 'ucs2')
-    t.equal(2, index, `Alpha Sigma - at index ${index}`)
-    index = twoByteString.indexOf('\u03a3\u03a3', 0, 'ucs2')
-    t.equal(4, index, `Sigma Sigma - at index ${index}`)
-    index = twoByteString.indexOf('\u03a3\u0395', 0, 'ucs2')
-    t.equal(6, index, `Sigma Epsilon - at index ${index}`)
-  }
-
-  const mixedByteStringUtf8 = Buffer.from('\u039a\u0391abc\u03a3\u03a3\u0395')
-
-  t.equal(5, mixedByteStringUtf8.indexOf('bc'))
-  t.equal(5, mixedByteStringUtf8.indexOf('bc', 5))
-  t.equal(5, mixedByteStringUtf8.indexOf('bc', -8))
-  t.equal(7, mixedByteStringUtf8.indexOf('\u03a3'))
-  t.equal(-1, mixedByteStringUtf8.indexOf('\u0396'))
-
-  // Test complex string indexOf algorithms. Only trigger for long strings.
-  // Long string that isn't a simple repeat of a shorter string.
-  let longString = 'A'
-  for (let i = 66; i < 76; i++) { // from 'B' to 'K'
-    longString = longString + String.fromCharCode(i) + longString
-  }
-
-  const longBufferString = Buffer.from(longString)
-
-  // pattern of 15 chars, repeated every 16 chars in long
-  let pattern = 'ABACABADABACABA'
-  for (let i = 0; i < longBufferString.length - pattern.length; i += 7) {
-    const index = longBufferString.indexOf(pattern, i)
-    t.equal((i + 15) & ~0xf, index,
-      `Long ABACABA...-string at index ${i}`)
-  }
-
-  let index = longBufferString.indexOf('AJABACA')
-  t.equal(510, index, `Long AJABACA, First J - at index ${index}`)
-  index = longBufferString.indexOf('AJABACA', 511)
-  t.equal(1534, index, `Long AJABACA, Second J - at index ${index}`)
-
-  pattern = 'JABACABADABACABA'
-  index = longBufferString.indexOf(pattern)
-  t.equal(511, index, `Long JABACABA..., First J - at index ${index}`)
-  index = longBufferString.indexOf(pattern, 512)
-  t.equal(
-    1535, index, `Long JABACABA..., Second J - at index ${index}`)
-
-  // Search for a non-ASCII string in a pure ASCII string.
-  const asciiString = Buffer.from(
-    'somethingnotatallsinisterwhichalsoworks')
-  t.equal(-1, asciiString.indexOf('\x2061'))
-  t.equal(3, asciiString.indexOf('eth', 0))
-
-  // Search in string containing many non-ASCII chars.
-  const allCodePoints = []
-  for (let i = 0; i < 65536; i++) {
-    allCodePoints[i] = i
-  }
-
-  const allCharsString = String.fromCharCode.apply(String, allCodePoints)
-  const allCharsBufferUtf8 = Buffer.from(allCharsString)
-  const allCharsBufferUcs2 = Buffer.from(allCharsString, 'ucs2')
-
-  // Search for string long enough to trigger complex search with ASCII pattern
-  // and UC16 subject.
-  t.equal(-1, allCharsBufferUtf8.indexOf('notfound'))
-  t.equal(-1, allCharsBufferUcs2.indexOf('notfound'))
-
-  // Needle is longer than haystack, but only because it's encoded as UTF-16
-  t.equal(Buffer.from('aaaa').indexOf('a'.repeat(4), 'ucs2'), -1)
-
-  t.equal(Buffer.from('aaaa').indexOf('a'.repeat(4), 'utf8'), 0)
-  t.equal(Buffer.from('aaaa').indexOf('你好', 'ucs2'), -1)
-
-  // Haystack has odd length, but the needle is UCS2.
-  t.equal(Buffer.from('aaaaa').indexOf('b', 'ucs2'), -1)
-
-  {
-    // Find substrings in Utf8.
-    const lengths = [1, 3, 15] // Single char, simple and complex.
-    const indices = [0x5, 0x60, 0x400, 0x680, 0x7ee, 0xFF02, 0x16610, 0x2f77b]
-    for (let lengthIndex = 0; lengthIndex < lengths.length; lengthIndex++) {
-      for (let i = 0; i < indices.length; i++) {
-        const index = indices[i]
-        let length = lengths[lengthIndex]
-
-        if (index + length > 0x7F) {
-          length = 2 * length
-        }
-
-        if (index + length > 0x7FF) {
-          length = 3 * length
-        }
-
-        if (index + length > 0xFFFF) {
-          length = 4 * length
-        }
-
-        const patternBufferUtf8 = allCharsBufferUtf8.slice(index, index + length)
-        t.equal(index, allCharsBufferUtf8.indexOf(patternBufferUtf8))
-
-        const patternStringUtf8 = patternBufferUtf8.toString()
-        t.equal(index, allCharsBufferUtf8.indexOf(patternStringUtf8))
-      }
-    }
-  }
-
-  {
-    // Find substrings in Usc2.
-    const lengths = [2, 4, 16] // Single char, simple and complex.
-    const indices = [0x5, 0x65, 0x105, 0x205, 0x285, 0x2005, 0x2085, 0xfff0]
-
-    for (let lengthIndex = 0; lengthIndex < lengths.length; lengthIndex++) {
-      for (let i = 0; i < indices.length; i++) {
-        const index = indices[i] * 2
-        const length = lengths[lengthIndex]
-
-        const patternBufferUcs2 =
-            allCharsBufferUcs2.slice(index, index + length)
-        t.equal(
-          index, allCharsBufferUcs2.indexOf(patternBufferUcs2, 0, 'ucs2'))
-
-        const patternStringUcs2 = patternBufferUcs2.toString('ucs2')
-        t.equal(
-          index, allCharsBufferUcs2.indexOf(patternStringUcs2, 0, 'ucs2'))
-      }
-    }
-  }
-
-  [
-    () => {},
-    {},
-    []
-  ].forEach((val) => {
-    t.throws(() => b.indexOf(val), TypeError, `"${JSON.stringify(val)}" should throw`)
-  })
-
-  // Test weird offset arguments.
-  // The following offsets coerce to NaN or 0, searching the whole Buffer
-  t.equal(b.indexOf('b', undefined), 1)
-  t.equal(b.indexOf('b', {}), 1)
-  t.equal(b.indexOf('b', 0), 1)
-  t.equal(b.indexOf('b', null), 1)
-  t.equal(b.indexOf('b', []), 1)
-
-  // The following offset coerces to 2, in other words +[2] === 2
-  t.equal(b.indexOf('b', [2]), -1)
-
-  // Behavior should match String.indexOf()
-  t.equal(
-    b.indexOf('b', undefined),
-    stringComparison.indexOf('b', undefined))
-  t.equal(
-    b.indexOf('b', {}),
-    stringComparison.indexOf('b', {}))
-  t.equal(
-    b.indexOf('b', 0),
-    stringComparison.indexOf('b', 0))
-  t.equal(
-    b.indexOf('b', null),
-    stringComparison.indexOf('b', null))
-  t.equal(
-    b.indexOf('b', []),
-    stringComparison.indexOf('b', []))
-  t.equal(
-    b.indexOf('b', [2]),
-    stringComparison.indexOf('b', [2]))
-
-  // test truncation of Number arguments to uint8
-  {
-    const buf = Buffer.from('this is a test')
-
-    t.equal(buf.indexOf(0x6973), 3)
-    t.equal(buf.indexOf(0x697320), 4)
-    t.equal(buf.indexOf(0x69732069), 2)
-    t.equal(buf.indexOf(0x697374657374), 0)
-    t.equal(buf.indexOf(0x69737374), 0)
-    t.equal(buf.indexOf(0x69737465), 11)
-    t.equal(buf.indexOf(0x69737465), 11)
-    t.equal(buf.indexOf(-140), 0)
-    t.equal(buf.indexOf(-152), 1)
-    t.equal(buf.indexOf(0xff), -1)
-    t.equal(buf.indexOf(0xffff), -1)
-  }
-
-  // Test that Uint8Array arguments are okay.
-  {
-    const needle = new Uint8Array([0x66, 0x6f, 0x6f])
-    const haystack = new BufferList(Buffer.from('a foo b foo'))
-    t.equal(haystack.indexOf(needle), 2)
-  }
-
-  t.end()
-})

node_modules/bl/test/isBufferList.js

@@ -1,32 +0,0 @@
-'use strict'
-
-const tape = require('tape')
-const { BufferList, BufferListStream } = require('../')
-const { Buffer } = require('buffer')
-
-tape('isBufferList positives', (t) => {
-  t.ok(BufferList.isBufferList(new BufferList()))
-  t.ok(BufferList.isBufferList(new BufferListStream()))
-
-  t.end()
-})
-
-tape('isBufferList negatives', (t) => {
-  const types = [
-    null,
-    undefined,
-    NaN,
-    true,
-    false,
-    {},
-    [],
-    Buffer.alloc(0),
-    [Buffer.alloc(0)]
-  ]
-
-  for (const obj of types) {
-    t.notOk(BufferList.isBufferList(obj))
-  }
-
-  t.end()
-})

node_modules/bl/test/test.js

@@ -1,869 +0,0 @@
-'use strict'
-
-const tape = require('tape')
-const crypto = require('crypto')
-const fs = require('fs')
-const path = require('path')
-const BufferList = require('../')
-const { Buffer } = require('buffer')
-
-const encodings =
-      ('hex utf8 utf-8 ascii binary base64' +
-          (process.browser ? '' : ' ucs2 ucs-2 utf16le utf-16le')).split(' ')
-
-require('./indexOf')
-require('./isBufferList')
-require('./convert')
-
-tape('single bytes from single buffer', function (t) {
-  const bl = new BufferList()
-
-  bl.append(Buffer.from('abcd'))
-
-  t.equal(bl.length, 4)
-  t.equal(bl.get(-1), undefined)
-  t.equal(bl.get(0), 97)
-  t.equal(bl.get(1), 98)
-  t.equal(bl.get(2), 99)
-  t.equal(bl.get(3), 100)
-  t.equal(bl.get(4), undefined)
-
-  t.end()
-})
-
-tape('single bytes from multiple buffers', function (t) {
-  const bl = new BufferList()
-
-  bl.append(Buffer.from('abcd'))
-  bl.append(Buffer.from('efg'))
-  bl.append(Buffer.from('hi'))
-  bl.append(Buffer.from('j'))
-
-  t.equal(bl.length, 10)
-
-  t.equal(bl.get(0), 97)
-  t.equal(bl.get(1), 98)
-  t.equal(bl.get(2), 99)
-  t.equal(bl.get(3), 100)
-  t.equal(bl.get(4), 101)
-  t.equal(bl.get(5), 102)
-  t.equal(bl.get(6), 103)
-  t.equal(bl.get(7), 104)
-  t.equal(bl.get(8), 105)
-  t.equal(bl.get(9), 106)
-
-  t.end()
-})
-
-tape('multi bytes from single buffer', function (t) {
-  const bl = new BufferList()
-
-  bl.append(Buffer.from('abcd'))
-
-  t.equal(bl.length, 4)
-
-  t.equal(bl.slice(0, 4).toString('ascii'), 'abcd')
-  t.equal(bl.slice(0, 3).toString('ascii'), 'abc')
-  t.equal(bl.slice(1, 4).toString('ascii'), 'bcd')
-  t.equal(bl.slice(-4, -1).toString('ascii'), 'abc')
-
-  t.end()
-})
-
-tape('multi bytes from single buffer (negative indexes)', function (t) {
-  const bl = new BufferList()
-
-  bl.append(Buffer.from('buffer'))
-
-  t.equal(bl.length, 6)
-
-  t.equal(bl.slice(-6, -1).toString('ascii'), 'buffe')
-  t.equal(bl.slice(-6, -2).toString('ascii'), 'buff')
-  t.equal(bl.slice(-5, -2).toString('ascii'), 'uff')
-
-  t.end()
-})
-
-tape('multiple bytes from multiple buffers', function (t) {
-  const bl = new BufferList()
-
-  bl.append(Buffer.from('abcd'))
-  bl.append(Buffer.from('efg'))
-  bl.append(Buffer.from('hi'))
-  bl.append(Buffer.from('j'))
-
-  t.equal(bl.length, 10)
-
-  t.equal(bl.slice(0, 10).toString('ascii'), 'abcdefghij')
-  t.equal(bl.slice(3, 10).toString('ascii'), 'defghij')
-  t.equal(bl.slice(3, 6).toString('ascii'), 'def')
-  t.equal(bl.slice(3, 8).toString('ascii'), 'defgh')
-  t.equal(bl.slice(5, 10).toString('ascii'), 'fghij')
-  t.equal(bl.slice(-7, -4).toString('ascii'), 'def')
-
-  t.end()
-})
-
-tape('multiple bytes from multiple buffer lists', function (t) {
-  const bl = new BufferList()
-
-  bl.append(new BufferList([Buffer.from('abcd'), Buffer.from('efg')]))
-  bl.append(new BufferList([Buffer.from('hi'), Buffer.from('j')]))
-
-  t.equal(bl.length, 10)
-
-  t.equal(bl.slice(0, 10).toString('ascii'), 'abcdefghij')
-
-  t.equal(bl.slice(3, 10).toString('ascii'), 'defghij')
-  t.equal(bl.slice(3, 6).toString('ascii'), 'def')
-  t.equal(bl.slice(3, 8).toString('ascii'), 'defgh')
-  t.equal(bl.slice(5, 10).toString('ascii'), 'fghij')
-
-  t.end()
-})
-
-// same data as previous test, just using nested constructors
-tape('multiple bytes from crazy nested buffer lists', function (t) {
-  const bl = new BufferList()
-
-  bl.append(new BufferList([
-    new BufferList([
-      new BufferList(Buffer.from('abc')),
-      Buffer.from('d'),
-      new BufferList(Buffer.from('efg'))
-    ]),
-    new BufferList([Buffer.from('hi')]),
-    new BufferList(Buffer.from('j'))
-  ]))
-
-  t.equal(bl.length, 10)
-
-  t.equal(bl.slice(0, 10).toString('ascii'), 'abcdefghij')
-
-  t.equal(bl.slice(3, 10).toString('ascii'), 'defghij')
-  t.equal(bl.slice(3, 6).toString('ascii'), 'def')
-  t.equal(bl.slice(3, 8).toString('ascii'), 'defgh')
-  t.equal(bl.slice(5, 10).toString('ascii'), 'fghij')
-
-  t.end()
-})
-
-tape('append accepts arrays of Buffers', function (t) {
-  const bl = new BufferList()
-
-  bl.append(Buffer.from('abc'))
-  bl.append([Buffer.from('def')])
-  bl.append([Buffer.from('ghi'), Buffer.from('jkl')])
-  bl.append([Buffer.from('mnop'), Buffer.from('qrstu'), Buffer.from('vwxyz')])
-  t.equal(bl.length, 26)
-  t.equal(bl.slice().toString('ascii'), 'abcdefghijklmnopqrstuvwxyz')
-
-  t.end()
-})
-
-tape('append accepts arrays of Uint8Arrays', function (t) {
-  const bl = new BufferList()
-
-  bl.append(new Uint8Array([97, 98, 99]))
-  bl.append([Uint8Array.from([100, 101, 102])])
-  bl.append([new Uint8Array([103, 104, 105]), new Uint8Array([106, 107, 108])])
-  bl.append([new Uint8Array([109, 110, 111, 112]), new Uint8Array([113, 114, 115, 116, 117]), new Uint8Array([118, 119, 120, 121, 122])])
-  t.equal(bl.length, 26)
-  t.equal(bl.slice().toString('ascii'), 'abcdefghijklmnopqrstuvwxyz')
-
-  t.end()
-})
-
-tape('append accepts arrays of BufferLists', function (t) {
-  const bl = new BufferList()
-
-  bl.append(Buffer.from('abc'))
-  bl.append([new BufferList('def')])
-  bl.append(new BufferList([Buffer.from('ghi'), new BufferList('jkl')]))
-  bl.append([Buffer.from('mnop'), new BufferList([Buffer.from('qrstu'), Buffer.from('vwxyz')])])
-  t.equal(bl.length, 26)
-  t.equal(bl.slice().toString('ascii'), 'abcdefghijklmnopqrstuvwxyz')
-
-  t.end()
-})
-
-tape('append chainable', function (t) {
-  const bl = new BufferList()
-
-  t.ok(bl.append(Buffer.from('abcd')) === bl)
-  t.ok(bl.append([Buffer.from('abcd')]) === bl)
-  t.ok(bl.append(new BufferList(Buffer.from('abcd'))) === bl)
-  t.ok(bl.append([new BufferList(Buffer.from('abcd'))]) === bl)
-
-  t.end()
-})
-
-tape('append chainable (test results)', function (t) {
-  const bl = new BufferList('abc')
-    .append([new BufferList('def')])
-    .append(new BufferList([Buffer.from('ghi'), new BufferList('jkl')]))
-    .append([Buffer.from('mnop'), new BufferList([Buffer.from('qrstu'), Buffer.from('vwxyz')])])
-
-  t.equal(bl.length, 26)
-  t.equal(bl.slice().toString('ascii'), 'abcdefghijklmnopqrstuvwxyz')
-
-  t.end()
-})
-
-tape('consuming from multiple buffers', function (t) {
-  const bl = new BufferList()
-
-  bl.append(Buffer.from('abcd'))
-  bl.append(Buffer.from('efg'))
-  bl.append(Buffer.from('hi'))
-  bl.append(Buffer.from('j'))
-
-  t.equal(bl.length, 10)
-
-  t.equal(bl.slice(0, 10).toString('ascii'), 'abcdefghij')
-
-  bl.consume(3)
-  t.equal(bl.length, 7)
-  t.equal(bl.slice(0, 7).toString('ascii'), 'defghij')
-
-  bl.consume(2)
-  t.equal(bl.length, 5)
-  t.equal(bl.slice(0, 5).toString('ascii'), 'fghij')
-
-  bl.consume(1)
-  t.equal(bl.length, 4)
-  t.equal(bl.slice(0, 4).toString('ascii'), 'ghij')
-
-  bl.consume(1)
-  t.equal(bl.length, 3)
-  t.equal(bl.slice(0, 3).toString('ascii'), 'hij')
-
-  bl.consume(2)
-  t.equal(bl.length, 1)
-  t.equal(bl.slice(0, 1).toString('ascii'), 'j')
-
-  t.end()
-})
-
-tape('complete consumption', function (t) {
-  const bl = new BufferList()
-
-  bl.append(Buffer.from('a'))
-  bl.append(Buffer.from('b'))
-
-  bl.consume(2)
-
-  t.equal(bl.length, 0)
-  t.equal(bl._bufs.length, 0)
-
-  t.end()
-})
-
-tape('test readUInt8 / readInt8', function (t) {
-  const buf1 = Buffer.alloc(1)
-  const buf2 = Buffer.alloc(3)
-  const buf3 = Buffer.alloc(3)
-  const bl = new BufferList()
-
-  buf1[0] = 0x1
-  buf2[1] = 0x3
-  buf2[2] = 0x4
-  buf3[0] = 0x23
-  buf3[1] = 0x42
-
-  bl.append(buf1)
-  bl.append(buf2)
-  bl.append(buf3)
-
-  t.equal(bl.readUInt8(), 0x1)
-  t.equal(bl.readUInt8(2), 0x3)
-  t.equal(bl.readInt8(2), 0x3)
-  t.equal(bl.readUInt8(3), 0x4)
-  t.equal(bl.readInt8(3), 0x4)
-  t.equal(bl.readUInt8(4), 0x23)
-  t.equal(bl.readInt8(4), 0x23)
-  t.equal(bl.readUInt8(5), 0x42)
-  t.equal(bl.readInt8(5), 0x42)
-
-  t.end()
-})
-
-tape('test readUInt16LE / readUInt16BE / readInt16LE / readInt16BE', function (t) {
-  const buf1 = Buffer.alloc(1)
-  const buf2 = Buffer.alloc(3)
-  const buf3 = Buffer.alloc(3)
-  const bl = new BufferList()
-
-  buf1[0] = 0x1
-  buf2[1] = 0x3
-  buf2[2] = 0x4
-  buf3[0] = 0x23
-  buf3[1] = 0x42
-
-  bl.append(buf1)
-  bl.append(buf2)
-  bl.append(buf3)
-
-  t.equal(bl.readUInt16BE(), 0x0100)
-  t.equal(bl.readUInt16LE(), 0x0001)
-  t.equal(bl.readUInt16BE(2), 0x0304)
-  t.equal(bl.readUInt16LE(2), 0x0403)
-  t.equal(bl.readInt16BE(2), 0x0304)
-  t.equal(bl.readInt16LE(2), 0x0403)
-  t.equal(bl.readUInt16BE(3), 0x0423)
-  t.equal(bl.readUInt16LE(3), 0x2304)
-  t.equal(bl.readInt16BE(3), 0x0423)
-  t.equal(bl.readInt16LE(3), 0x2304)
-  t.equal(bl.readUInt16BE(4), 0x2342)
-  t.equal(bl.readUInt16LE(4), 0x4223)
-  t.equal(bl.readInt16BE(4), 0x2342)
-  t.equal(bl.readInt16LE(4), 0x4223)
-
-  t.end()
-})
-
-tape('test readUInt32LE / readUInt32BE / readInt32LE / readInt32BE', function (t) {
-  const buf1 = Buffer.alloc(1)
-  const buf2 = Buffer.alloc(3)
-  const buf3 = Buffer.alloc(3)
-  const bl = new BufferList()
-
-  buf1[0] = 0x1
-  buf2[1] = 0x3
-  buf2[2] = 0x4
-  buf3[0] = 0x23
-  buf3[1] = 0x42
-
-  bl.append(buf1)
-  bl.append(buf2)
-  bl.append(buf3)
-
-  t.equal(bl.readUInt32BE(), 0x01000304)
-  t.equal(bl.readUInt32LE(), 0x04030001)
-  t.equal(bl.readUInt32BE(2), 0x03042342)
-  t.equal(bl.readUInt32LE(2), 0x42230403)
-  t.equal(bl.readInt32BE(2), 0x03042342)
-  t.equal(bl.readInt32LE(2), 0x42230403)
-
-  t.end()
-})
-
-tape('test readUIntLE / readUIntBE / readIntLE / readIntBE', function (t) {
-  const buf1 = Buffer.alloc(1)
-  const buf2 = Buffer.alloc(3)
-  const buf3 = Buffer.alloc(3)
-  const bl = new BufferList()
-
-  buf2[0] = 0x2
-  buf2[1] = 0x3
-  buf2[2] = 0x4
-  buf3[0] = 0x23
-  buf3[1] = 0x42
-  buf3[2] = 0x61
-
-  bl.append(buf1)
-  bl.append(buf2)
-  bl.append(buf3)
-
-  t.equal(bl.readUIntBE(1, 1), 0x02)
-  t.equal(bl.readUIntBE(1, 2), 0x0203)
-  t.equal(bl.readUIntBE(1, 3), 0x020304)
-  t.equal(bl.readUIntBE(1, 4), 0x02030423)
-  t.equal(bl.readUIntBE(1, 5), 0x0203042342)
-  t.equal(bl.readUIntBE(1, 6), 0x020304234261)
-  t.equal(bl.readUIntLE(1, 1), 0x02)
-  t.equal(bl.readUIntLE(1, 2), 0x0302)
-  t.equal(bl.readUIntLE(1, 3), 0x040302)
-  t.equal(bl.readUIntLE(1, 4), 0x23040302)
-  t.equal(bl.readUIntLE(1, 5), 0x4223040302)
-  t.equal(bl.readUIntLE(1, 6), 0x614223040302)
-  t.equal(bl.readIntBE(1, 1), 0x02)
-  t.equal(bl.readIntBE(1, 2), 0x0203)
-  t.equal(bl.readIntBE(1, 3), 0x020304)
-  t.equal(bl.readIntBE(1, 4), 0x02030423)
-  t.equal(bl.readIntBE(1, 5), 0x0203042342)
-  t.equal(bl.readIntBE(1, 6), 0x020304234261)
-  t.equal(bl.readIntLE(1, 1), 0x02)
-  t.equal(bl.readIntLE(1, 2), 0x0302)
-  t.equal(bl.readIntLE(1, 3), 0x040302)
-  t.equal(bl.readIntLE(1, 4), 0x23040302)
-  t.equal(bl.readIntLE(1, 5), 0x4223040302)
-  t.equal(bl.readIntLE(1, 6), 0x614223040302)
-
-  t.end()
-})
-
-tape('test readFloatLE / readFloatBE', function (t) {
-  const buf1 = Buffer.alloc(1)
-  const buf2 = Buffer.alloc(3)
-  const buf3 = Buffer.alloc(3)
-  const bl = new BufferList()
-
-  buf1[0] = 0x01
-  buf2[1] = 0x00
-  buf2[2] = 0x00
-  buf3[0] = 0x80
-  buf3[1] = 0x3f
-
-  bl.append(buf1)
-  bl.append(buf2)
-  bl.append(buf3)
-
-  const canonical = Buffer.concat([buf1, buf2, buf3])
-  t.equal(bl.readFloatLE(), canonical.readFloatLE())
-  t.equal(bl.readFloatBE(), canonical.readFloatBE())
-  t.equal(bl.readFloatLE(2), canonical.readFloatLE(2))
-  t.equal(bl.readFloatBE(2), canonical.readFloatBE(2))
-
-  t.end()
-})
-
-tape('test readDoubleLE / readDoubleBE', function (t) {
-  const buf1 = Buffer.alloc(1)
-  const buf2 = Buffer.alloc(3)
-  const buf3 = Buffer.alloc(10)
-  const bl = new BufferList()
-
-  buf1[0] = 0x01
-  buf2[1] = 0x55
-  buf2[2] = 0x55
-  buf3[0] = 0x55
-  buf3[1] = 0x55
-  buf3[2] = 0x55
-  buf3[3] = 0x55
-  buf3[4] = 0xd5
-  buf3[5] = 0x3f
-
-  bl.append(buf1)
-  bl.append(buf2)
-  bl.append(buf3)
-
-  const canonical = Buffer.concat([buf1, buf2, buf3])
-  t.equal(bl.readDoubleBE(), canonical.readDoubleBE())
-  t.equal(bl.readDoubleLE(), canonical.readDoubleLE())
-  t.equal(bl.readDoubleBE(2), canonical.readDoubleBE(2))
-  t.equal(bl.readDoubleLE(2), canonical.readDoubleLE(2))
-
-  t.end()
-})
-
-tape('test toString', function (t) {
-  const bl = new BufferList()
-
-  bl.append(Buffer.from('abcd'))
-  bl.append(Buffer.from('efg'))
-  bl.append(Buffer.from('hi'))
-  bl.append(Buffer.from('j'))
-
-  t.equal(bl.toString('ascii', 0, 10), 'abcdefghij')
-  t.equal(bl.toString('ascii', 3, 10), 'defghij')
-  t.equal(bl.toString('ascii', 3, 6), 'def')
-  t.equal(bl.toString('ascii', 3, 8), 'defgh')
-  t.equal(bl.toString('ascii', 5, 10), 'fghij')
-
-  t.end()
-})
-
-tape('test toString encoding', function (t) {
-  const bl = new BufferList()
-  const b = Buffer.from('abcdefghij\xff\x00')
-
-  bl.append(Buffer.from('abcd'))
-  bl.append(Buffer.from('efg'))
-  bl.append(Buffer.from('hi'))
-  bl.append(Buffer.from('j'))
-  bl.append(Buffer.from('\xff\x00'))
-
-  encodings.forEach(function (enc) {
-    t.equal(bl.toString(enc), b.toString(enc), enc)
-  })
-
-  t.end()
-})
-
-tape('uninitialized memory', function (t) {
-  const secret = crypto.randomBytes(256)
-  for (let i = 0; i < 1e6; i++) {
-    const clone = Buffer.from(secret)
-    const bl = new BufferList()
-    bl.append(Buffer.from('a'))
-    bl.consume(-1024)
-    const buf = bl.slice(1)
-    if (buf.indexOf(clone) !== -1) {
-      t.fail(`Match (at ${i})`)
-      break
-    }
-  }
-  t.end()
-})
-
-!process.browser && tape('test stream', function (t) {
-  const random = crypto.randomBytes(65534)
-
-  const bl = new BufferList((err, buf) => {
-    t.ok(Buffer.isBuffer(buf))
-    t.ok(err === null)
-    t.ok(random.equals(bl.slice()))
-    t.ok(random.equals(buf.slice()))
-
-    bl.pipe(fs.createWriteStream('/tmp/bl_test_rnd_out.dat'))
-      .on('close', function () {
-        const rndhash = crypto.createHash('md5').update(random).digest('hex')
-        const md5sum = crypto.createHash('md5')
-        const s = fs.createReadStream('/tmp/bl_test_rnd_out.dat')
-
-        s.on('data', md5sum.update.bind(md5sum))
-        s.on('end', function () {
-          t.equal(rndhash, md5sum.digest('hex'), 'woohoo! correct hash!')
-          t.end()
-        })
-      })
-  })
-
-  fs.writeFileSync('/tmp/bl_test_rnd.dat', random)
-  fs.createReadStream('/tmp/bl_test_rnd.dat').pipe(bl)
-})
-
-tape('instantiation with Buffer', function (t) {
-  const buf = crypto.randomBytes(1024)
-  const buf2 = crypto.randomBytes(1024)
-  let b = BufferList(buf)
-
-  t.equal(buf.toString('hex'), b.slice().toString('hex'), 'same buffer')
-  b = BufferList([buf, buf2])
-  t.equal(b.slice().toString('hex'), Buffer.concat([buf, buf2]).toString('hex'), 'same buffer')
-
-  t.end()
-})
-
-tape('test String appendage', function (t) {
-  const bl = new BufferList()
-  const b = Buffer.from('abcdefghij\xff\x00')
-
-  bl.append('abcd')
-  bl.append('efg')
-  bl.append('hi')
-  bl.append('j')
-  bl.append('\xff\x00')
-
-  encodings.forEach(function (enc) {
-    t.equal(bl.toString(enc), b.toString(enc))
-  })
-
-  t.end()
-})
-
-tape('test Number appendage', function (t) {
-  const bl = new BufferList()
-  const b = Buffer.from('1234567890')
-
-  bl.append(1234)
-  bl.append(567)
-  bl.append(89)
-  bl.append(0)
-
-  encodings.forEach(function (enc) {
-    t.equal(bl.toString(enc), b.toString(enc))
-  })
-
-  t.end()
-})
-
-tape('write nothing, should get empty buffer', function (t) {
-  t.plan(3)
-  BufferList(function (err, data) {
-    t.notOk(err, 'no error')
-    t.ok(Buffer.isBuffer(data), 'got a buffer')
-    t.equal(0, data.length, 'got a zero-length buffer')
-    t.end()
-  }).end()
-})
-
-tape('unicode string', function (t) {
-  t.plan(2)
-
-  const inp1 = '\u2600'
-  const inp2 = '\u2603'
-  const exp = inp1 + ' and ' + inp2
-  const bl = BufferList()
-
-  bl.write(inp1)
-  bl.write(' and ')
-  bl.write(inp2)
-  t.equal(exp, bl.toString())
-  t.equal(Buffer.from(exp).toString('hex'), bl.toString('hex'))
-})
-
-tape('should emit finish', function (t) {
-  const source = BufferList()
-  const dest = BufferList()
-
-  source.write('hello')
-  source.pipe(dest)
-
-  dest.on('finish', function () {
-    t.equal(dest.toString('utf8'), 'hello')
-    t.end()
-  })
-})
-
-tape('basic copy', function (t) {
-  const buf = crypto.randomBytes(1024)
-  const buf2 = Buffer.alloc(1024)
-  const b = BufferList(buf)
-
-  b.copy(buf2)
-  t.equal(b.slice().toString('hex'), buf2.toString('hex'), 'same buffer')
-
-  t.end()
-})
-
-tape('copy after many appends', function (t) {
-  const buf = crypto.randomBytes(512)
-  const buf2 = Buffer.alloc(1024)
-  const b = BufferList(buf)
-
-  b.append(buf)
-  b.copy(buf2)
-  t.equal(b.slice().toString('hex'), buf2.toString('hex'), 'same buffer')
-
-  t.end()
-})
-
-tape('copy at a precise position', function (t) {
-  const buf = crypto.randomBytes(1004)
-  const buf2 = Buffer.alloc(1024)
-  const b = BufferList(buf)
-
-  b.copy(buf2, 20)
-  t.equal(b.slice().toString('hex'), buf2.slice(20).toString('hex'), 'same buffer')
-
-  t.end()
-})
-
-tape('copy starting from a precise location', function (t) {
-  const buf = crypto.randomBytes(10)
-  const buf2 = Buffer.alloc(5)
-  const b = BufferList(buf)
-
-  b.copy(buf2, 0, 5)
-  t.equal(b.slice(5).toString('hex'), buf2.toString('hex'), 'same buffer')
-
-  t.end()
-})
-
-tape('copy in an interval', function (t) {
-  const rnd = crypto.randomBytes(10)
-  const b = BufferList(rnd) // put the random bytes there
-  const actual = Buffer.alloc(3)
-  const expected = Buffer.alloc(3)
-
-  rnd.copy(expected, 0, 5, 8)
-  b.copy(actual, 0, 5, 8)
-
-  t.equal(actual.toString('hex'), expected.toString('hex'), 'same buffer')
-
-  t.end()
-})
-
-tape('copy an interval between two buffers', function (t) {
-  const buf = crypto.randomBytes(10)
-  const buf2 = Buffer.alloc(10)
-  const b = BufferList(buf)
-
-  b.append(buf)
-  b.copy(buf2, 0, 5, 15)
-
-  t.equal(b.slice(5, 15).toString('hex'), buf2.toString('hex'), 'same buffer')
-
-  t.end()
-})
-
-tape('shallow slice across buffer boundaries', function (t) {
-  const bl = new BufferList(['First', 'Second', 'Third'])
-
-  t.equal(bl.shallowSlice(3, 13).toString(), 'stSecondTh')
-
-  t.end()
-})
-
-tape('shallow slice within single buffer', function (t) {
-  t.plan(2)
-
-  const bl = new BufferList(['First', 'Second', 'Third'])
-
-  t.equal(bl.shallowSlice(5, 10).toString(), 'Secon')
-  t.equal(bl.shallowSlice(7, 10).toString(), 'con')
-
-  t.end()
-})
-
-tape('shallow slice single buffer', function (t) {
-  t.plan(3)
-
-  const bl = new BufferList(['First', 'Second', 'Third'])
-
-  t.equal(bl.shallowSlice(0, 5).toString(), 'First')
-  t.equal(bl.shallowSlice(5, 11).toString(), 'Second')
-  t.equal(bl.shallowSlice(11, 16).toString(), 'Third')
-})
-
-tape('shallow slice with negative or omitted indices', function (t) {
-  t.plan(4)
-
-  const bl = new BufferList(['First', 'Second', 'Third'])
-
-  t.equal(bl.shallowSlice().toString(), 'FirstSecondThird')
-  t.equal(bl.shallowSlice(5).toString(), 'SecondThird')
-  t.equal(bl.shallowSlice(5, -3).toString(), 'SecondTh')
-  t.equal(bl.shallowSlice(-8).toString(), 'ondThird')
-})
-
-tape('shallow slice does not make a copy', function (t) {
-  t.plan(1)
-
-  const buffers = [Buffer.from('First'), Buffer.from('Second'), Buffer.from('Third')]
-  const bl = (new BufferList(buffers)).shallowSlice(5, -3)
-
-  buffers[1].fill('h')
-  buffers[2].fill('h')
-
-  t.equal(bl.toString(), 'hhhhhhhh')
-})
-
-tape('shallow slice with 0 length', function (t) {
-  t.plan(1)
-
-  const buffers = [Buffer.from('First'), Buffer.from('Second'), Buffer.from('Third')]
-  const bl = (new BufferList(buffers)).shallowSlice(0, 0)
-
-  t.equal(bl.length, 0)
-})
-
-tape('shallow slice with 0 length from middle', function (t) {
-  t.plan(1)
-
-  const buffers = [Buffer.from('First'), Buffer.from('Second'), Buffer.from('Third')]
-  const bl = (new BufferList(buffers)).shallowSlice(10, 10)
-
-  t.equal(bl.length, 0)
-})
-
-tape('duplicate', function (t) {
-  t.plan(2)
-
-  const bl = new BufferList('abcdefghij\xff\x00')
-  const dup = bl.duplicate()
-
-  t.equal(bl.prototype, dup.prototype)
-  t.equal(bl.toString('hex'), dup.toString('hex'))
-})
-
-tape('destroy no pipe', function (t) {
-  t.plan(2)
-
-  const bl = new BufferList('alsdkfja;lsdkfja;lsdk')
-
-  bl.destroy()
-
-  t.equal(bl._bufs.length, 0)
-  t.equal(bl.length, 0)
-})
-
-tape('destroy with error', function (t) {
-  t.plan(3)
-
-  const bl = new BufferList('alsdkfja;lsdkfja;lsdk')
-  const err = new Error('kaboom')
-
-  bl.destroy(err)
-  bl.on('error', function (_err) {
-    t.equal(_err, err)
-  })
-
-  t.equal(bl._bufs.length, 0)
-  t.equal(bl.length, 0)
-})
-
-!process.browser && tape('destroy with pipe before read end', function (t) {
-  t.plan(2)
-
-  const bl = new BufferList()
-  fs.createReadStream(path.join(__dirname, '/test.js'))
-    .pipe(bl)
-
-  bl.destroy()
-
-  t.equal(bl._bufs.length, 0)
-  t.equal(bl.length, 0)
-})
-
-!process.browser && tape('destroy with pipe before read end with race', function (t) {
-  t.plan(2)
-
-  const bl = new BufferList()
-
-  fs.createReadStream(path.join(__dirname, '/test.js'))
-    .pipe(bl)
-
-  setTimeout(function () {
-    bl.destroy()
-    setTimeout(function () {
-      t.equal(bl._bufs.length, 0)
-      t.equal(bl.length, 0)
-    }, 500)
-  }, 500)
-})
-
-!process.browser && tape('destroy with pipe after read end', function (t) {
-  t.plan(2)
-
-  const bl = new BufferList()
-
-  fs.createReadStream(path.join(__dirname, '/test.js'))
-    .on('end', onEnd)
-    .pipe(bl)
-
-  function onEnd () {
-    bl.destroy()
-
-    t.equal(bl._bufs.length, 0)
-    t.equal(bl.length, 0)
-  }
-})
-
-!process.browser && tape('destroy with pipe while writing to a destination', function (t) {
-  t.plan(4)
-
-  const bl = new BufferList()
-  const ds = new BufferList()
-
-  fs.createReadStream(path.join(__dirname, '/test.js'))
-    .on('end', onEnd)
-    .pipe(bl)
-
-  function onEnd () {
-    bl.pipe(ds)
-
-    setTimeout(function () {
-      bl.destroy()
-
-      t.equals(bl._bufs.length, 0)
-      t.equals(bl.length, 0)
-
-      ds.destroy()
-
-      t.equals(bl._bufs.length, 0)
-      t.equals(bl.length, 0)
-    }, 100)
-  }
-})
-
-!process.browser && tape('handle error', function (t) {
-  t.plan(2)
-
-  fs.createReadStream('/does/not/exist').pipe(BufferList(function (err, data) {
-    t.ok(err instanceof Error, 'has error')
-    t.notOk(data, 'no data')
-  }))
-})

node_modules/brace-expansion/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2013 Julian Gruber <julian@juliangruber.com>
-
-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.

node_modules/brace-expansion/README.md

@@ -1,129 +0,0 @@
-# brace-expansion
-
-[Brace expansion](https://www.gnu.org/software/bash/manual/html_node/Brace-Expansion.html), 
-as known from sh/bash, in JavaScript.
-
-[![build status](https://secure.travis-ci.org/juliangruber/brace-expansion.svg)](http://travis-ci.org/juliangruber/brace-expansion)
-[![downloads](https://img.shields.io/npm/dm/brace-expansion.svg)](https://www.npmjs.org/package/brace-expansion)
-[![Greenkeeper badge](https://badges.greenkeeper.io/juliangruber/brace-expansion.svg)](https://greenkeeper.io/)
-
-[![testling badge](https://ci.testling.com/juliangruber/brace-expansion.png)](https://ci.testling.com/juliangruber/brace-expansion)
-
-## Example
-
-```js
-var expand = require('brace-expansion');
-
-expand('file-{a,b,c}.jpg')
-// => ['file-a.jpg', 'file-b.jpg', 'file-c.jpg']
-
-expand('-v{,,}')
-// => ['-v', '-v', '-v']
-
-expand('file{0..2}.jpg')
-// => ['file0.jpg', 'file1.jpg', 'file2.jpg']
-
-expand('file-{a..c}.jpg')
-// => ['file-a.jpg', 'file-b.jpg', 'file-c.jpg']
-
-expand('file{2..0}.jpg')
-// => ['file2.jpg', 'file1.jpg', 'file0.jpg']
-
-expand('file{0..4..2}.jpg')
-// => ['file0.jpg', 'file2.jpg', 'file4.jpg']
-
-expand('file-{a..e..2}.jpg')
-// => ['file-a.jpg', 'file-c.jpg', 'file-e.jpg']
-
-expand('file{00..10..5}.jpg')
-// => ['file00.jpg', 'file05.jpg', 'file10.jpg']
-
-expand('{{A..C},{a..c}}')
-// => ['A', 'B', 'C', 'a', 'b', 'c']
-
-expand('ppp{,config,oe{,conf}}')
-// => ['ppp', 'pppconfig', 'pppoe', 'pppoeconf']
-```
-
-## API
-
-```js
-var expand = require('brace-expansion');
-```
-
-### var expanded = expand(str)
-
-Return an array of all possible and valid expansions of `str`. If none are
-found, `[str]` is returned.
-
-Valid expansions are:
-
-```js
-/^(.*,)+(.+)?$/
-// {a,b,...}
-```
-
-A comma separated list of options, like `{a,b}` or `{a,{b,c}}` or `{,a,}`.
-
-```js
-/^-?\d+\.\.-?\d+(\.\.-?\d+)?$/
-// {x..y[..incr]}
-```
-
-A numeric sequence from `x` to `y` inclusive, with optional increment.
-If `x` or `y` start with a leading `0`, all the numbers will be padded
-to have equal length. Negative numbers and backwards iteration work too.
-
-```js
-/^-?\d+\.\.-?\d+(\.\.-?\d+)?$/
-// {x..y[..incr]}
-```
-
-An alphabetic sequence from `x` to `y` inclusive, with optional increment.
-`x` and `y` must be exactly one character, and if given, `incr` must be a
-number.
-
-For compatibility reasons, the string `${` is not eligible for brace expansion.
-
-## Installation
-
-With [npm](https://npmjs.org) do:
-
-```bash
-npm install brace-expansion
-```
-
-## Contributors
-
-- [Julian Gruber](https://github.com/juliangruber)
-- [Isaac Z. Schlueter](https://github.com/isaacs)
-
-## Sponsors
-
-This module is proudly supported by my [Sponsors](https://github.com/juliangruber/sponsors)!
-
-Do you want to support modules like this to improve their quality, stability and weigh in on new features? Then please consider donating to my [Patreon](https://www.patreon.com/juliangruber). Not sure how much of my modules you're using? Try [feross/thanks](https://github.com/feross/thanks)!
-
-## License
-
-(MIT)
-
-Copyright (c) 2013 Julian Gruber <julian@juliangruber.com>
-
-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.

node_modules/brace-expansion/index.js

@@ -1,201 +0,0 @@
-var concatMap = require('concat-map');
-var balanced = require('balanced-match');
-
-module.exports = expandTop;
-
-var escSlash = '\0SLASH'+Math.random()+'\0';
-var escOpen = '\0OPEN'+Math.random()+'\0';
-var escClose = '\0CLOSE'+Math.random()+'\0';
-var escComma = '\0COMMA'+Math.random()+'\0';
-var escPeriod = '\0PERIOD'+Math.random()+'\0';
-
-function numeric(str) {
-  return parseInt(str, 10) == str
-    ? parseInt(str, 10)
-    : str.charCodeAt(0);
-}
-
-function escapeBraces(str) {
-  return str.split('\\\\').join(escSlash)
-            .split('\\{').join(escOpen)
-            .split('\\}').join(escClose)
-            .split('\\,').join(escComma)
-            .split('\\.').join(escPeriod);
-}
-
-function unescapeBraces(str) {
-  return str.split(escSlash).join('\\')
-            .split(escOpen).join('{')
-            .split(escClose).join('}')
-            .split(escComma).join(',')
-            .split(escPeriod).join('.');
-}
-
-
-// Basically just str.split(","), but handling cases
-// where we have nested braced sections, which should be
-// treated as individual members, like {a,{b,c},d}
-function parseCommaParts(str) {
-  if (!str)
-    return [''];
-
-  var parts = [];
-  var m = balanced('{', '}', str);
-
-  if (!m)
-    return str.split(',');
-
-  var pre = m.pre;
-  var body = m.body;
-  var post = m.post;
-  var p = pre.split(',');
-
-  p[p.length-1] += '{' + body + '}';
-  var postParts = parseCommaParts(post);
-  if (post.length) {
-    p[p.length-1] += postParts.shift();
-    p.push.apply(p, postParts);
-  }
-
-  parts.push.apply(parts, p);
-
-  return parts;
-}
-
-function expandTop(str) {
-  if (!str)
-    return [];
-
-  // I don't know why Bash 4.3 does this, but it does.
-  // Anything starting with {} will have the first two bytes preserved
-  // but *only* at the top level, so {},a}b will not expand to anything,
-  // but a{},b}c will be expanded to [a}c,abc].
-  // One could argue that this is a bug in Bash, but since the goal of
-  // this module is to match Bash's rules, we escape a leading {}
-  if (str.substr(0, 2) === '{}') {
-    str = '\\{\\}' + str.substr(2);
-  }
-
-  return expand(escapeBraces(str), true).map(unescapeBraces);
-}
-
-function identity(e) {
-  return e;
-}
-
-function embrace(str) {
-  return '{' + str + '}';
-}
-function isPadded(el) {
-  return /^-?0\d/.test(el);
-}
-
-function lte(i, y) {
-  return i <= y;
-}
-function gte(i, y) {
-  return i >= y;
-}
-
-function expand(str, isTop) {
-  var expansions = [];
-
-  var m = balanced('{', '}', str);
-  if (!m || /\$$/.test(m.pre)) return [str];
-
-  var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
-  var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
-  var isSequence = isNumericSequence || isAlphaSequence;
-  var isOptions = m.body.indexOf(',') >= 0;
-  if (!isSequence && !isOptions) {
-    // {a},b}
-    if (m.post.match(/,.*\}/)) {
-      str = m.pre + '{' + m.body + escClose + m.post;
-      return expand(str);
-    }
-    return [str];
-  }
-
-  var n;
-  if (isSequence) {
-    n = m.body.split(/\.\./);
-  } else {
-    n = parseCommaParts(m.body);
-    if (n.length === 1) {
-      // x{{a,b}}y ==> x{a}y x{b}y
-      n = expand(n[0], false).map(embrace);
-      if (n.length === 1) {
-        var post = m.post.length
-          ? expand(m.post, false)
-          : [''];
-        return post.map(function(p) {
-          return m.pre + n[0] + p;
-        });
-      }
-    }
-  }
-
-  // at this point, n is the parts, and we know it's not a comma set
-  // with a single entry.
-
-  // no need to expand pre, since it is guaranteed to be free of brace-sets
-  var pre = m.pre;
-  var post = m.post.length
-    ? expand(m.post, false)
-    : [''];
-
-  var N;
-
-  if (isSequence) {
-    var x = numeric(n[0]);
-    var y = numeric(n[1]);
-    var width = Math.max(n[0].length, n[1].length)
-    var incr = n.length == 3
-      ? Math.abs(numeric(n[2]))
-      : 1;
-    var test = lte;
-    var reverse = y < x;
-    if (reverse) {
-      incr *= -1;
-      test = gte;
-    }
-    var pad = n.some(isPadded);
-
-    N = [];
-
-    for (var i = x; test(i, y); i += incr) {
-      var c;
-      if (isAlphaSequence) {
-        c = String.fromCharCode(i);
-        if (c === '\\')
-          c = '';
-      } else {
-        c = String(i);
-        if (pad) {
-          var need = width - c.length;
-          if (need > 0) {
-            var z = new Array(need + 1).join('0');
-            if (i < 0)
-              c = '-' + z + c.slice(1);
-            else
-              c = z + c;
-          }
-        }
-      }
-      N.push(c);
-    }
-  } else {
-    N = concatMap(n, function(el) { return expand(el, false) });
-  }
-
-  for (var j = 0; j < N.length; j++) {
-    for (var k = 0; k < post.length; k++) {
-      var expansion = pre + N[j] + post[k];
-      if (!isTop || isSequence || expansion)
-        expansions.push(expansion);
-    }
-  }
-
-  return expansions;
-}
-

node_modules/brace-expansion/package.json

@@ -1,75 +0,0 @@
-{
-  "_from": "brace-expansion@^1.1.7",
-  "_id": "brace-expansion@1.1.11",
-  "_inBundle": false,
-  "_integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
-  "_location": "/brace-expansion",
-  "_phantomChildren": {},
-  "_requested": {
-    "type": "range",
-    "registry": true,
-    "raw": "brace-expansion@^1.1.7",
-    "name": "brace-expansion",
-    "escapedName": "brace-expansion",
-    "rawSpec": "^1.1.7",
-    "saveSpec": null,
-    "fetchSpec": "^1.1.7"
-  },
-  "_requiredBy": [
-    "/minimatch"
-  ],
-  "_resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
-  "_shasum": "3c7fcbf529d87226f3d2f52b966ff5271eb441dd",
-  "_spec": "brace-expansion@^1.1.7",
-  "_where": "E:\\gitee\\fys\\fys\\app\\JingQuan\\node_modules\\minimatch",
-  "author": {
-    "name": "Julian Gruber",
-    "email": "mail@juliangruber.com",
-    "url": "http://juliangruber.com"
-  },
-  "bugs": {
-    "url": "https://github.com/juliangruber/brace-expansion/issues"
-  },
-  "bundleDependencies": false,
-  "dependencies": {
-    "balanced-match": "^1.0.0",
-    "concat-map": "0.0.1"
-  },
-  "deprecated": false,
-  "description": "Brace expansion as known from sh/bash",
-  "devDependencies": {
-    "matcha": "^0.7.0",
-    "tape": "^4.6.0"
-  },
-  "homepage": "https://github.com/juliangruber/brace-expansion",
-  "keywords": [],
-  "license": "MIT",
-  "main": "index.js",
-  "name": "brace-expansion",
-  "repository": {
-    "type": "git",
-    "url": "git://github.com/juliangruber/brace-expansion.git"
-  },
-  "scripts": {
-    "bench": "matcha test/perf/bench.js",
-    "gentest": "bash test/generate.sh",
-    "test": "tape test/*.js"
-  },
-  "testling": {
-    "files": "test/*.js",
-    "browsers": [
-      "ie/8..latest",
-      "firefox/20..latest",
-      "firefox/nightly",
-      "chrome/25..latest",
-      "chrome/canary",
-      "opera/12..latest",
-      "opera/next",
-      "safari/5.1..latest",
-      "ipad/6.0..latest",
-      "iphone/6.0..latest",
-      "android-browser/4.2..latest"
-    ]
-  },
-  "version": "1.1.11"
-}

node_modules/buffer-from/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2016, 2018 Linus Unnebäck
-
-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.

node_modules/buffer-from/index.js

@@ -1,72 +0,0 @@
-/* eslint-disable node/no-deprecated-api */
-
-var toString = Object.prototype.toString
-
-var isModern = (
-  typeof Buffer !== 'undefined' &&
-  typeof Buffer.alloc === 'function' &&
-  typeof Buffer.allocUnsafe === 'function' &&
-  typeof Buffer.from === 'function'
-)
-
-function isArrayBuffer (input) {
-  return toString.call(input).slice(8, -1) === 'ArrayBuffer'
-}
-
-function fromArrayBuffer (obj, byteOffset, length) {
-  byteOffset >>>= 0
-
-  var maxLength = obj.byteLength - byteOffset
-
-  if (maxLength < 0) {
-    throw new RangeError("'offset' is out of bounds")
-  }
-
-  if (length === undefined) {
-    length = maxLength
-  } else {
-    length >>>= 0
-
-    if (length > maxLength) {
-      throw new RangeError("'length' is out of bounds")
-    }
-  }
-
-  return isModern
-    ? Buffer.from(obj.slice(byteOffset, byteOffset + length))
-    : new Buffer(new Uint8Array(obj.slice(byteOffset, byteOffset + length)))
-}
-
-function fromString (string, encoding) {
-  if (typeof encoding !== 'string' || encoding === '') {
-    encoding = 'utf8'
-  }
-
-  if (!Buffer.isEncoding(encoding)) {
-    throw new TypeError('"encoding" must be a valid string encoding')
-  }
-
-  return isModern
-    ? Buffer.from(string, encoding)
-    : new Buffer(string, encoding)
-}
-
-function bufferFrom (value, encodingOrOffset, length) {
-  if (typeof value === 'number') {
-    throw new TypeError('"value" argument must not be a number')
-  }
-
-  if (isArrayBuffer(value)) {
-    return fromArrayBuffer(value, encodingOrOffset, length)
-  }
-
-  if (typeof value === 'string') {
-    return fromString(value, encodingOrOffset)
-  }
-
-  return isModern
-    ? Buffer.from(value)
-    : new Buffer(value)
-}
-
-module.exports = bufferFrom

node_modules/buffer-from/package.json

@@ -1,52 +0,0 @@
-{
-  "_from": "buffer-from@^1.0.0",
-  "_id": "buffer-from@1.1.2",
-  "_inBundle": false,
-  "_integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==",
-  "_location": "/buffer-from",
-  "_phantomChildren": {},
-  "_requested": {
-    "type": "range",
-    "registry": true,
-    "raw": "buffer-from@^1.0.0",
-    "name": "buffer-from",
-    "escapedName": "buffer-from",
-    "rawSpec": "^1.0.0",
-    "saveSpec": null,
-    "fetchSpec": "^1.0.0"
-  },
-  "_requiredBy": [
-    "/concat-stream"
-  ],
-  "_resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz",
-  "_shasum": "2b146a6fd72e80b4f55d255f35ed59a3a9a41bd5",
-  "_spec": "buffer-from@^1.0.0",
-  "_where": "E:\\gitee\\fys\\fys\\app\\JingQuan\\node_modules\\concat-stream",
-  "bugs": {
-    "url": "https://github.com/LinusU/buffer-from/issues"
-  },
-  "bundleDependencies": false,
-  "deprecated": false,
-  "description": "A [ponyfill](https://ponyfill.com) for `Buffer.from`, uses native implementation if available.",
-  "devDependencies": {
-    "standard": "^12.0.1"
-  },
-  "files": [
-    "index.js"
-  ],
-  "homepage": "https://github.com/LinusU/buffer-from#readme",
-  "keywords": [
-    "buffer",
-    "buffer from"
-  ],
-  "license": "MIT",
-  "name": "buffer-from",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/LinusU/buffer-from.git"
-  },
-  "scripts": {
-    "test": "standard && node test"
-  },
-  "version": "1.1.2"
-}

node_modules/buffer-from/readme.md

@@ -1,69 +0,0 @@
-# Buffer From
-
-A [ponyfill](https://ponyfill.com) for `Buffer.from`, uses native implementation if available.
-
-## Installation
-
-```sh
-npm install --save buffer-from
-```
-
-## Usage
-
-```js
-const bufferFrom = require('buffer-from')
-
-console.log(bufferFrom([1, 2, 3, 4]))
-//=> <Buffer 01 02 03 04>
-
-const arr = new Uint8Array([1, 2, 3, 4])
-console.log(bufferFrom(arr.buffer, 1, 2))
-//=> <Buffer 02 03>
-
-console.log(bufferFrom('test', 'utf8'))
-//=> <Buffer 74 65 73 74>
-
-const buf = bufferFrom('test')
-console.log(bufferFrom(buf))
-//=> <Buffer 74 65 73 74>
-```
-
-## API
-
-### bufferFrom(array)
-
-- `array` &lt;Array&gt;
-
-Allocates a new `Buffer` using an `array` of octets.
-
-### bufferFrom(arrayBuffer[, byteOffset[, length]])
-
-- `arrayBuffer` &lt;ArrayBuffer&gt; The `.buffer` property of a TypedArray or ArrayBuffer
-- `byteOffset` &lt;Integer&gt; Where to start copying from `arrayBuffer`. **Default:** `0`
-- `length` &lt;Integer&gt; How many bytes to copy from `arrayBuffer`. **Default:** `arrayBuffer.length - byteOffset`
-
-When passed a reference to the `.buffer` property of a TypedArray instance, the
-newly created `Buffer` will share the same allocated memory as the TypedArray.
-
-The optional `byteOffset` and `length` arguments specify a memory range within
-the `arrayBuffer` that will be shared by the `Buffer`.
-
-### bufferFrom(buffer)
-
-- `buffer` &lt;Buffer&gt; An existing `Buffer` to copy data from
-
-Copies the passed `buffer` data onto a new `Buffer` instance.
-
-### bufferFrom(string[, encoding])
-
-- `string` &lt;String&gt; A string to encode.
-- `encoding` &lt;String&gt; The encoding of `string`. **Default:** `'utf8'`
-
-Creates a new `Buffer` containing the given JavaScript string `string`. If
-provided, the `encoding` parameter identifies the character encoding of
-`string`.
-
-## See also
-
-- [buffer-alloc](https://github.com/LinusU/buffer-alloc) A ponyfill for `Buffer.alloc`
-- [buffer-alloc-unsafe](https://github.com/LinusU/buffer-alloc-unsafe) A ponyfill for `Buffer.allocUnsafe`

node_modules/buffer/AUTHORS.md

@@ -1,70 +0,0 @@
-# Authors
-
-#### Ordered by first contribution.
-
-- Romain Beauxis (toots@rastageeks.org)
-- Tobias Koppers (tobias.koppers@googlemail.com)
-- Janus (ysangkok@gmail.com)
-- Rainer Dreyer (rdrey1@gmail.com)
-- Tõnis Tiigi (tonistiigi@gmail.com)
-- James Halliday (mail@substack.net)
-- Michael Williamson (mike@zwobble.org)
-- elliottcable (github@elliottcable.name)
-- rafael (rvalle@livelens.net)
-- Andrew Kelley (superjoe30@gmail.com)
-- Andreas Madsen (amwebdk@gmail.com)
-- Mike Brevoort (mike.brevoort@pearson.com)
-- Brian White (mscdex@mscdex.net)
-- Feross Aboukhadijeh (feross@feross.org)
-- Ruben Verborgh (ruben@verborgh.org)
-- eliang (eliang.cs@gmail.com)
-- Jesse Tane (jesse.tane@gmail.com)
-- Alfonso Boza (alfonso@cloud.com)
-- Mathias Buus (mathiasbuus@gmail.com)
-- Devon Govett (devongovett@gmail.com)
-- Daniel Cousens (github@dcousens.com)
-- Joseph Dykstra (josephdykstra@gmail.com)
-- Parsha Pourkhomami (parshap+git@gmail.com)
-- Damjan Košir (damjan.kosir@gmail.com)
-- daverayment (dave.rayment@gmail.com)
-- kawanet (u-suke@kawa.net)
-- Linus Unnebäck (linus@folkdatorn.se)
-- Nolan Lawson (nolan.lawson@gmail.com)
-- Calvin Metcalf (calvin.metcalf@gmail.com)
-- Koki Takahashi (hakatasiloving@gmail.com)
-- Guy Bedford (guybedford@gmail.com)
-- Jan Schär (jscissr@gmail.com)
-- RaulTsc (tomescu.raul@gmail.com)
-- Matthieu Monsch (monsch@alum.mit.edu)
-- Dan Ehrenberg (littledan@chromium.org)
-- Kirill Fomichev (fanatid@ya.ru)
-- Yusuke Kawasaki (u-suke@kawa.net)
-- DC (dcposch@dcpos.ch)
-- John-David Dalton (john.david.dalton@gmail.com)
-- adventure-yunfei (adventure030@gmail.com)
-- Emil Bay (github@tixz.dk)
-- Sam Sudar (sudar.sam@gmail.com)
-- Volker Mische (volker.mische@gmail.com)
-- David Walton (support@geekstocks.com)
-- Сковорода Никита Андреевич (chalkerx@gmail.com)
-- greenkeeper[bot] (greenkeeper[bot]@users.noreply.github.com)
-- ukstv (sergey.ukustov@machinomy.com)
-- Renée Kooi (renee@kooi.me)
-- ranbochen (ranbochen@qq.com)
-- Vladimir Borovik (bobahbdb@gmail.com)
-- greenkeeper[bot] (23040076+greenkeeper[bot]@users.noreply.github.com)
-- kumavis (aaron@kumavis.me)
-- Sergey Ukustov (sergey.ukustov@machinomy.com)
-- Fei Liu (liu.feiwood@gmail.com)
-- Blaine Bublitz (blaine.bublitz@gmail.com)
-- clement (clement@seald.io)
-- Koushik Dutta (koushd@gmail.com)
-- Jordan Harband (ljharb@gmail.com)
-- Niklas Mischkulnig (mischnic@users.noreply.github.com)
-- Nikolai Vavilov (vvnicholas@gmail.com)
-- Fedor Nezhivoi (gyzerok@users.noreply.github.com)
-- Peter Newman (peternewman@users.noreply.github.com)
-- mathmakgakpak (44949126+mathmakgakpak@users.noreply.github.com)
-- jkkang (jkkang@smartauth.kr)
-
-#### Generated by bin/update-authors.sh.

node_modules/buffer/LICENSE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) Feross Aboukhadijeh, and other 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.

node_modules/buffer/README.md

@@ -1,410 +0,0 @@
-# buffer [![travis][travis-image]][travis-url] [![npm][npm-image]][npm-url] [![downloads][downloads-image]][downloads-url] [![javascript style guide][standard-image]][standard-url]
-
-[travis-image]: https://img.shields.io/travis/feross/buffer/master.svg
-[travis-url]: https://travis-ci.org/feross/buffer
-[npm-image]: https://img.shields.io/npm/v/buffer.svg
-[npm-url]: https://npmjs.org/package/buffer
-[downloads-image]: https://img.shields.io/npm/dm/buffer.svg
-[downloads-url]: https://npmjs.org/package/buffer
-[standard-image]: https://img.shields.io/badge/code_style-standard-brightgreen.svg
-[standard-url]: https://standardjs.com
-
-#### The buffer module from [node.js](https://nodejs.org/), for the browser.
-
-[![saucelabs][saucelabs-image]][saucelabs-url]
-
-[saucelabs-image]: https://saucelabs.com/browser-matrix/buffer.svg
-[saucelabs-url]: https://saucelabs.com/u/buffer
-
-With [browserify](http://browserify.org), simply `require('buffer')` or use the `Buffer` global and you will get this module.
-
-The goal is to provide an API that is 100% identical to
-[node's Buffer API](https://nodejs.org/api/buffer.html). Read the
-[official docs](https://nodejs.org/api/buffer.html) for the full list of properties,
-instance methods, and class methods that are supported.
-
-## features
-
-- Manipulate binary data like a boss, in all browsers!
-- Super fast. Backed by Typed Arrays (`Uint8Array`/`ArrayBuffer`, not `Object`)
-- Extremely small bundle size (**6.75KB minified + gzipped**, 51.9KB with comments)
-- Excellent browser support (Chrome, Firefox, Edge, Safari 9+, IE 11, iOS 9+, Android, etc.)
-- Preserves Node API exactly, with one minor difference (see below)
-- Square-bracket `buf[4]` notation works!
-- Does not modify any browser prototypes or put anything on `window`
-- Comprehensive test suite (including all buffer tests from node.js core)
-
-## install
-
-To use this module directly (without browserify), install it:
-
-```bash
-npm install buffer
-```
-
-This module was previously called **native-buffer-browserify**, but please use **buffer**
-from now on.
-
-If you do not use a bundler, you can use the [standalone script](https://bundle.run/buffer).
-
-## usage
-
-The module's API is identical to node's `Buffer` API. Read the
-[official docs](https://nodejs.org/api/buffer.html) for the full list of properties,
-instance methods, and class methods that are supported.
-
-As mentioned above, `require('buffer')` or use the `Buffer` global with
-[browserify](http://browserify.org) and this module will automatically be included
-in your bundle. Almost any npm module will work in the browser, even if it assumes that
-the node `Buffer` API will be available.
-
-To depend on this module explicitly (without browserify), require it like this:
-
-```js
-var Buffer = require('buffer/').Buffer  // note: the trailing slash is important!
-```
-
-To require this module explicitly, use `require('buffer/')` which tells the node.js module
-lookup algorithm (also used by browserify) to use the **npm module** named `buffer`
-instead of the **node.js core** module named `buffer`!
-
-
-## how does it work?
-
-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.
-
-
-## tracking the latest node api
-
-This module tracks the Buffer API in the latest (unstable) version of node.js. The Buffer
-API is considered **stable** in the
-[node stability index](https://nodejs.org/docs/latest/api/documentation.html#documentation_stability_index),
-so it is unlikely that there will ever be breaking changes.
-Nonetheless, when/if the Buffer API changes in node, this module's API will change
-accordingly.
-
-## related packages
-
-- [`buffer-reverse`](https://www.npmjs.com/package/buffer-reverse) - Reverse a buffer
-- [`buffer-xor`](https://www.npmjs.com/package/buffer-xor) - Bitwise xor a buffer
-- [`is-buffer`](https://www.npmjs.com/package/is-buffer) - Determine if an object is a Buffer without including the whole `Buffer` package
-
-## conversion packages
-
-### convert typed array to buffer
-
-Use [`typedarray-to-buffer`](https://www.npmjs.com/package/typedarray-to-buffer) to convert any kind of typed array to a `Buffer`. Does not perform a copy, so it's super fast.
-
-### convert buffer to typed array
-
-`Buffer` is a subclass of `Uint8Array` (which is a typed array). So there is no need to explicitly convert to typed array. Just use the buffer as a `Uint8Array`.
-
-### convert blob to buffer
-
-Use [`blob-to-buffer`](https://www.npmjs.com/package/blob-to-buffer) to convert a `Blob` to a `Buffer`.
-
-### convert buffer to blob
-
-To convert a `Buffer` to a `Blob`, use the `Blob` constructor:
-
-```js
-var blob = new Blob([ buffer ])
-```
-
-Optionally, specify a mimetype:
-
-```js
-var blob = new Blob([ buffer ], { type: 'text/html' })
-```
-
-### convert arraybuffer to buffer
-
-To convert an `ArrayBuffer` to a `Buffer`, use the `Buffer.from` function. Does not perform a copy, so it's super fast.
-
-```js
-var buffer = Buffer.from(arrayBuffer)
-```
-
-### convert buffer to arraybuffer
-
-To convert a `Buffer` to an `ArrayBuffer`, use the `.buffer` property (which is present on all `Uint8Array` objects):
-
-```js
-var arrayBuffer = buffer.buffer.slice(
-  buffer.byteOffset, buffer.byteOffset + buffer.byteLength
-)
-```
-
-Alternatively, use the [`to-arraybuffer`](https://www.npmjs.com/package/to-arraybuffer) module.
-
-## performance
-
-See perf tests in `/perf`.
-
-`BrowserBuffer` is the browser `buffer` module (this repo). `Uint8Array` is included as a
-sanity check (since `BrowserBuffer` uses `Uint8Array` under the hood, `Uint8Array` will
-always be at least a bit faster). Finally, `NodeBuffer` is the node.js buffer module,
-which is included to compare against.
-
-NOTE: Performance has improved since these benchmarks were taken. PR welcome to update the README.
-
-### Chrome 38
-
-| Method | Operations | Accuracy | Sampled | Fastest |
-|:-------|:-----------|:---------|:--------|:-------:|
-| BrowserBuffer#bracket-notation | 11,457,464 ops/sec | ±0.86% | 66 | ✓ |
-| Uint8Array#bracket-notation | 10,824,332 ops/sec | ±0.74% | 65 | |
-| | | | |
-| BrowserBuffer#concat | 450,532 ops/sec | ±0.76% | 68 | |
-| Uint8Array#concat | 1,368,911 ops/sec | ±1.50% | 62 | ✓ |
-| | | | |
-| BrowserBuffer#copy(16000) | 903,001 ops/sec | ±0.96% | 67 | |
-| Uint8Array#copy(16000) | 1,422,441 ops/sec | ±1.04% | 66 | ✓ |
-| | | | |
-| BrowserBuffer#copy(16) | 11,431,358 ops/sec | ±0.46% | 69 | |
-| Uint8Array#copy(16) | 13,944,163 ops/sec | ±1.12% | 68 | ✓ |
-| | | | |
-| BrowserBuffer#new(16000) | 106,329 ops/sec | ±6.70% | 44 | |
-| Uint8Array#new(16000) | 131,001 ops/sec | ±2.85% | 31 | ✓ |
-| | | | |
-| BrowserBuffer#new(16) | 1,554,491 ops/sec | ±1.60% | 65 | |
-| Uint8Array#new(16) | 6,623,930 ops/sec | ±1.66% | 65 | ✓ |
-| | | | |
-| BrowserBuffer#readDoubleBE | 112,830 ops/sec | ±0.51% | 69 | ✓ |
-| DataView#getFloat64 | 93,500 ops/sec | ±0.57% | 68 | |
-| | | | |
-| BrowserBuffer#readFloatBE | 146,678 ops/sec | ±0.95% | 68 | ✓ |
-| DataView#getFloat32 | 99,311 ops/sec | ±0.41% | 67 | |
-| | | | |
-| BrowserBuffer#readUInt32LE | 843,214 ops/sec | ±0.70% | 69 | ✓ |
-| DataView#getUint32 | 103,024 ops/sec | ±0.64% | 67 | |
-| | | | |
-| BrowserBuffer#slice | 1,013,941 ops/sec | ±0.75% | 67 | |
-| Uint8Array#subarray | 1,903,928 ops/sec | ±0.53% | 67 | ✓ |
-| | | | |
-| BrowserBuffer#writeFloatBE | 61,387 ops/sec | ±0.90% | 67 | |
-| DataView#setFloat32 | 141,249 ops/sec | ±0.40% | 66 | ✓ |
-
-
-### Firefox 33
-
-| Method | Operations | Accuracy | Sampled | Fastest |
-|:-------|:-----------|:---------|:--------|:-------:|
-| BrowserBuffer#bracket-notation | 20,800,421 ops/sec | ±1.84% | 60 | |
-| Uint8Array#bracket-notation | 20,826,235 ops/sec | ±2.02% | 61 | ✓ |
-| | | | |
-| BrowserBuffer#concat | 153,076 ops/sec | ±2.32% | 61 | |
-| Uint8Array#concat | 1,255,674 ops/sec | ±8.65% | 52 | ✓ |
-| | | | |
-| BrowserBuffer#copy(16000) | 1,105,312 ops/sec | ±1.16% | 63 | |
-| Uint8Array#copy(16000) | 1,615,911 ops/sec | ±0.55% | 66 | ✓ |
-| | | | |
-| BrowserBuffer#copy(16) | 16,357,599 ops/sec | ±0.73% | 68 | |
-| Uint8Array#copy(16) | 31,436,281 ops/sec | ±1.05% | 68 | ✓ |
-| | | | |
-| BrowserBuffer#new(16000) | 52,995 ops/sec | ±6.01% | 35 | |
-| Uint8Array#new(16000) | 87,686 ops/sec | ±5.68% | 45 | ✓ |
-| | | | |
-| BrowserBuffer#new(16) | 252,031 ops/sec | ±1.61% | 66 | |
-| Uint8Array#new(16) | 8,477,026 ops/sec | ±0.49% | 68 | ✓ |
-| | | | |
-| BrowserBuffer#readDoubleBE | 99,871 ops/sec | ±0.41% | 69 | |
-| DataView#getFloat64 | 285,663 ops/sec | ±0.70% | 68 | ✓ |
-| | | | |
-| BrowserBuffer#readFloatBE | 115,540 ops/sec | ±0.42% | 69 | |
-| DataView#getFloat32 | 288,722 ops/sec | ±0.82% | 68 | ✓ |
-| | | | |
-| BrowserBuffer#readUInt32LE | 633,926 ops/sec | ±1.08% | 67 | ✓ |
-| DataView#getUint32 | 294,808 ops/sec | ±0.79% | 64 | |
-| | | | |
-| BrowserBuffer#slice | 349,425 ops/sec | ±0.46% | 69 | |
-| Uint8Array#subarray | 5,965,819 ops/sec | ±0.60% | 65 | ✓ |
-| | | | |
-| BrowserBuffer#writeFloatBE | 59,980 ops/sec | ±0.41% | 67 | |
-| DataView#setFloat32 | 317,634 ops/sec | ±0.63% | 68 | ✓ |
-
-### Safari 8
-
-| Method | Operations | Accuracy | Sampled | Fastest |
-|:-------|:-----------|:---------|:--------|:-------:|
-| BrowserBuffer#bracket-notation | 10,279,729 ops/sec | ±2.25% | 56 | ✓ |
-| Uint8Array#bracket-notation | 10,030,767 ops/sec | ±2.23% | 59 | |
-| | | | |
-| BrowserBuffer#concat | 144,138 ops/sec | ±1.38% | 65 | |
-| Uint8Array#concat | 4,950,764 ops/sec | ±1.70% | 63 | ✓ |
-| | | | |
-| BrowserBuffer#copy(16000) | 1,058,548 ops/sec | ±1.51% | 64 | |
-| Uint8Array#copy(16000) | 1,409,666 ops/sec | ±1.17% | 65 | ✓ |
-| | | | |
-| BrowserBuffer#copy(16) | 6,282,529 ops/sec | ±1.88% | 58 | |
-| Uint8Array#copy(16) | 11,907,128 ops/sec | ±2.87% | 58 | ✓ |
-| | | | |
-| BrowserBuffer#new(16000) | 101,663 ops/sec | ±3.89% | 57 | |
-| Uint8Array#new(16000) | 22,050,818 ops/sec | ±6.51% | 46 | ✓ |
-| | | | |
-| BrowserBuffer#new(16) | 176,072 ops/sec | ±2.13% | 64 | |
-| Uint8Array#new(16) | 24,385,731 ops/sec | ±5.01% | 51 | ✓ |
-| | | | |
-| BrowserBuffer#readDoubleBE | 41,341 ops/sec | ±1.06% | 67 | |
-| DataView#getFloat64 | 322,280 ops/sec | ±0.84% | 68 | ✓ |
-| | | | |
-| BrowserBuffer#readFloatBE | 46,141 ops/sec | ±1.06% | 65 | |
-| DataView#getFloat32 | 337,025 ops/sec | ±0.43% | 69 | ✓ |
-| | | | |
-| BrowserBuffer#readUInt32LE | 151,551 ops/sec | ±1.02% | 66 | |
-| DataView#getUint32 | 308,278 ops/sec | ±0.94% | 67 | ✓ |
-| | | | |
-| BrowserBuffer#slice | 197,365 ops/sec | ±0.95% | 66 | |
-| Uint8Array#subarray | 9,558,024 ops/sec | ±3.08% | 58 | ✓ |
-| | | | |
-| BrowserBuffer#writeFloatBE | 17,518 ops/sec | ±1.03% | 63 | |
-| DataView#setFloat32 | 319,751 ops/sec | ±0.48% | 68 | ✓ |
-
-
-### Node 0.11.14
-
-| Method | Operations | Accuracy | Sampled | Fastest |
-|:-------|:-----------|:---------|:--------|:-------:|
-| BrowserBuffer#bracket-notation | 10,489,828 ops/sec | ±3.25% | 90 | |
-| Uint8Array#bracket-notation | 10,534,884 ops/sec | ±0.81% | 92 | ✓ |
-| NodeBuffer#bracket-notation | 10,389,910 ops/sec | ±0.97% | 87 | |
-| | | | |
-| BrowserBuffer#concat | 487,830 ops/sec | ±2.58% | 88 | |
-| Uint8Array#concat | 1,814,327 ops/sec | ±1.28% | 88 | ✓ |
-| NodeBuffer#concat | 1,636,523 ops/sec | ±1.88% | 73 | |
-| | | | |
-| BrowserBuffer#copy(16000) | 1,073,665 ops/sec | ±0.77% | 90 | |
-| Uint8Array#copy(16000) | 1,348,517 ops/sec | ±0.84% | 89 | ✓ |
-| NodeBuffer#copy(16000) | 1,289,533 ops/sec | ±0.82% | 93 | |
-| | | | |
-| BrowserBuffer#copy(16) | 12,782,706 ops/sec | ±0.74% | 85 | |
-| Uint8Array#copy(16) | 14,180,427 ops/sec | ±0.93% | 92 | ✓ |
-| NodeBuffer#copy(16) | 11,083,134 ops/sec | ±1.06% | 89 | |
-| | | | |
-| BrowserBuffer#new(16000) | 141,678 ops/sec | ±3.30% | 67 | |
-| Uint8Array#new(16000) | 161,491 ops/sec | ±2.96% | 60 | |
-| NodeBuffer#new(16000) | 292,699 ops/sec | ±3.20% | 55 | ✓ |
-| | | | |
-| BrowserBuffer#new(16) | 1,655,466 ops/sec | ±2.41% | 82 | |
-| Uint8Array#new(16) | 14,399,926 ops/sec | ±0.91% | 94 | ✓ |
-| NodeBuffer#new(16) | 3,894,696 ops/sec | ±0.88% | 92 | |
-| | | | |
-| BrowserBuffer#readDoubleBE | 109,582 ops/sec | ±0.75% | 93 | ✓ |
-| DataView#getFloat64 | 91,235 ops/sec | ±0.81% | 90 | |
-| NodeBuffer#readDoubleBE | 88,593 ops/sec | ±0.96% | 81 | |
-| | | | |
-| BrowserBuffer#readFloatBE | 139,854 ops/sec | ±1.03% | 85 | ✓ |
-| DataView#getFloat32 | 98,744 ops/sec | ±0.80% | 89 | |
-| NodeBuffer#readFloatBE | 92,769 ops/sec | ±0.94% | 93 | |
-| | | | |
-| BrowserBuffer#readUInt32LE | 710,861 ops/sec | ±0.82% | 92 | |
-| DataView#getUint32 | 117,893 ops/sec | ±0.84% | 91 | |
-| NodeBuffer#readUInt32LE | 851,412 ops/sec | ±0.72% | 93 | ✓ |
-| | | | |
-| BrowserBuffer#slice | 1,673,877 ops/sec | ±0.73% | 94 | |
-| Uint8Array#subarray | 6,919,243 ops/sec | ±0.67% | 90 | ✓ |
-| NodeBuffer#slice | 4,617,604 ops/sec | ±0.79% | 93 | |
-| | | | |
-| BrowserBuffer#writeFloatBE | 66,011 ops/sec | ±0.75% | 93 | |
-| DataView#setFloat32 | 127,760 ops/sec | ±0.72% | 93 | ✓ |
-| NodeBuffer#writeFloatBE | 103,352 ops/sec | ±0.83% | 93 | |
-
-### iojs 1.8.1
-
-| Method | Operations | Accuracy | Sampled | Fastest |
-|:-------|:-----------|:---------|:--------|:-------:|
-| BrowserBuffer#bracket-notation | 10,990,488 ops/sec | ±1.11% | 91 | |
-| Uint8Array#bracket-notation | 11,268,757 ops/sec | ±0.65% | 97 | |
-| NodeBuffer#bracket-notation | 11,353,260 ops/sec | ±0.83% | 94 | ✓ |
-| | | | |
-| BrowserBuffer#concat | 378,954 ops/sec | ±0.74% | 94 | |
-| Uint8Array#concat | 1,358,288 ops/sec | ±0.97% | 87 | |
-| NodeBuffer#concat | 1,934,050 ops/sec | ±1.11% | 78 | ✓ |
-| | | | |
-| BrowserBuffer#copy(16000) | 894,538 ops/sec | ±0.56% | 84 | |
-| Uint8Array#copy(16000) | 1,442,656 ops/sec | ±0.71% | 96 | |
-| NodeBuffer#copy(16000) | 1,457,898 ops/sec | ±0.53% | 92 | ✓ |
-| | | | |
-| BrowserBuffer#copy(16) | 12,870,457 ops/sec | ±0.67% | 95 | |
-| Uint8Array#copy(16) | 16,643,989 ops/sec | ±0.61% | 93 | ✓ |
-| NodeBuffer#copy(16) | 14,885,848 ops/sec | ±0.74% | 94 | |
-| | | | |
-| BrowserBuffer#new(16000) | 109,264 ops/sec | ±4.21% | 63 | |
-| Uint8Array#new(16000) | 138,916 ops/sec | ±1.87% | 61 | |
-| NodeBuffer#new(16000) | 281,449 ops/sec | ±3.58% | 51 | ✓ |
-| | | | |
-| BrowserBuffer#new(16) | 1,362,935 ops/sec | ±0.56% | 99 | |
-| Uint8Array#new(16) | 6,193,090 ops/sec | ±0.64% | 95 | ✓ |
-| NodeBuffer#new(16) | 4,745,425 ops/sec | ±1.56% | 90 | |
-| | | | |
-| BrowserBuffer#readDoubleBE | 118,127 ops/sec | ±0.59% | 93 | ✓ |
-| DataView#getFloat64 | 107,332 ops/sec | ±0.65% | 91 | |
-| NodeBuffer#readDoubleBE | 116,274 ops/sec | ±0.94% | 95 | |
-| | | | |
-| BrowserBuffer#readFloatBE | 150,326 ops/sec | ±0.58% | 95 | ✓ |
-| DataView#getFloat32 | 110,541 ops/sec | ±0.57% | 98 | |
-| NodeBuffer#readFloatBE | 121,599 ops/sec | ±0.60% | 87 | |
-| | | | |
-| BrowserBuffer#readUInt32LE | 814,147 ops/sec | ±0.62% | 93 | |
-| DataView#getUint32 | 137,592 ops/sec | ±0.64% | 90 | |
-| NodeBuffer#readUInt32LE | 931,650 ops/sec | ±0.71% | 96 | ✓ |
-| | | | |
-| BrowserBuffer#slice | 878,590 ops/sec | ±0.68% | 93 | |
-| Uint8Array#subarray | 2,843,308 ops/sec | ±1.02% | 90 | |
-| NodeBuffer#slice | 4,998,316 ops/sec | ±0.68% | 90 | ✓ |
-| | | | |
-| BrowserBuffer#writeFloatBE | 65,927 ops/sec | ±0.74% | 93 | |
-| DataView#setFloat32 | 139,823 ops/sec | ±0.97% | 89 | ✓ |
-| NodeBuffer#writeFloatBE | 135,763 ops/sec | ±0.65% | 96 | |
-| | | | |
-
-## Testing the project
-
-First, install the project:
-
-    npm install
-
-Then, to run tests in Node.js, run:
-
-    npm run test-node
-
-To test locally in a browser, you can run:
-
-    npm run test-browser-es5-local # For ES5 browsers that don't support ES6
-    npm run test-browser-es6-local # For ES6 compliant browsers
-
-This will print out a URL that you can then open in a browser to run the tests, using [airtap](https://www.npmjs.com/package/airtap).
-
-To run automated browser tests using Saucelabs, ensure that your `SAUCE_USERNAME` and `SAUCE_ACCESS_KEY` environment variables are set, then run:
-
-    npm test
-
-This is what's run in Travis, to check against various browsers. The list of browsers is kept in the `bin/airtap-es5.yml` and `bin/airtap-es6.yml` files.
-
-## JavaScript Standard Style
-
-This module uses [JavaScript Standard Style](https://github.com/feross/standard).
-
-[![JavaScript Style Guide](https://cdn.rawgit.com/feross/standard/master/badge.svg)](https://github.com/feross/standard)
-
-To test that the code conforms to the style, `npm install` and run:
-
-    ./node_modules/.bin/standard
-
-## credit
-
-This was originally forked from [buffer-browserify](https://github.com/toots/buffer-browserify).
-
-## Security Policies and Procedures
-
-The `buffer` team and community take all security bugs in `buffer` seriously. Please see our [security policies and procedures](https://github.com/feross/security) document to learn how to report issues.
-
-## license
-
-MIT. Copyright (C) [Feross Aboukhadijeh](http://feross.org), and other contributors. Originally forked from an MIT-licensed module by Romain Beauxis.

node_modules/buffer/index.d.ts

@@ -1,186 +0,0 @@
-export class Buffer extends Uint8Array {
-    length: number
-    write(string: string, offset?: number, length?: number, encoding?: string): number;
-    toString(encoding?: string, start?: number, end?: number): string;
-    toJSON(): { type: 'Buffer', data: any[] };
-    equals(otherBuffer: Buffer): boolean;
-    compare(otherBuffer: Buffer, targetStart?: number, targetEnd?: number, sourceStart?: number, sourceEnd?: number): number;
-    copy(targetBuffer: Buffer, targetStart?: number, sourceStart?: number, sourceEnd?: number): number;
-    slice(start?: number, end?: number): Buffer;
-    writeUIntLE(value: number, offset: number, byteLength: number, noAssert?: boolean): number;
-    writeUIntBE(value: number, offset: number, byteLength: number, noAssert?: boolean): number;
-    writeIntLE(value: number, offset: number, byteLength: number, noAssert?: boolean): number;
-    writeIntBE(value: number, offset: number, byteLength: number, noAssert?: boolean): number;
-    readUIntLE(offset: number, byteLength: number, noAssert?: boolean): number;
-    readUIntBE(offset: number, byteLength: number, noAssert?: boolean): number;
-    readIntLE(offset: number, byteLength: number, noAssert?: boolean): number;
-    readIntBE(offset: number, byteLength: number, noAssert?: boolean): number;
-    readUInt8(offset: number, noAssert?: boolean): number;
-    readUInt16LE(offset: number, noAssert?: boolean): number;
-    readUInt16BE(offset: number, noAssert?: boolean): number;
-    readUInt32LE(offset: number, noAssert?: boolean): number;
-    readUInt32BE(offset: number, noAssert?: boolean): number;
-    readInt8(offset: number, noAssert?: boolean): number;
-    readInt16LE(offset: number, noAssert?: boolean): number;
-    readInt16BE(offset: number, noAssert?: boolean): number;
-    readInt32LE(offset: number, noAssert?: boolean): number;
-    readInt32BE(offset: number, noAssert?: boolean): number;
-    readFloatLE(offset: number, noAssert?: boolean): number;
-    readFloatBE(offset: number, noAssert?: boolean): number;
-    readDoubleLE(offset: number, noAssert?: boolean): number;
-    readDoubleBE(offset: number, noAssert?: boolean): number;
-    reverse(): this;
-    swap16(): Buffer;
-    swap32(): Buffer;
-    swap64(): Buffer;
-    writeUInt8(value: number, offset: number, noAssert?: boolean): number;
-    writeUInt16LE(value: number, offset: number, noAssert?: boolean): number;
-    writeUInt16BE(value: number, offset: number, noAssert?: boolean): number;
-    writeUInt32LE(value: number, offset: number, noAssert?: boolean): number;
-    writeUInt32BE(value: number, offset: number, noAssert?: boolean): number;
-    writeInt8(value: number, offset: number, noAssert?: boolean): number;
-    writeInt16LE(value: number, offset: number, noAssert?: boolean): number;
-    writeInt16BE(value: number, offset: number, noAssert?: boolean): number;
-    writeInt32LE(value: number, offset: number, noAssert?: boolean): number;
-    writeInt32BE(value: number, offset: number, noAssert?: boolean): number;
-    writeFloatLE(value: number, offset: number, noAssert?: boolean): number;
-    writeFloatBE(value: number, offset: number, noAssert?: boolean): number;
-    writeDoubleLE(value: number, offset: number, noAssert?: boolean): number;
-    writeDoubleBE(value: number, offset: number, noAssert?: boolean): number;
-    fill(value: any, offset?: number, end?: number): this;
-    indexOf(value: string | number | Buffer, byteOffset?: number, encoding?: string): number;
-    lastIndexOf(value: string | number | Buffer, byteOffset?: number, encoding?: string): number;
-    includes(value: string | number | Buffer, byteOffset?: number, encoding?: string): boolean;
-
-    /**
-     * Allocates a new buffer containing the given {str}.
-     *
-     * @param str String to store in buffer.
-     * @param encoding encoding to use, optional.  Default is 'utf8'
-     */
-    constructor (str: string, encoding?: string);
-    /**
-     * Allocates a new buffer of {size} octets.
-     *
-     * @param size count of octets to allocate.
-     */
-    constructor (size: number);
-    /**
-     * Allocates a new buffer containing the given {array} of octets.
-     *
-     * @param array The octets to store.
-     */
-    constructor (array: Uint8Array);
-    /**
-     * Produces a Buffer backed by the same allocated memory as
-     * the given {ArrayBuffer}.
-     *
-     *
-     * @param arrayBuffer The ArrayBuffer with which to share memory.
-     */
-    constructor (arrayBuffer: ArrayBuffer);
-    /**
-     * Allocates a new buffer containing the given {array} of octets.
-     *
-     * @param array The octets to store.
-     */
-    constructor (array: any[]);
-    /**
-     * Copies the passed {buffer} data onto a new {Buffer} instance.
-     *
-     * @param buffer The buffer to copy.
-     */
-    constructor (buffer: Buffer);
-    prototype: Buffer;
-    /**
-     * Allocates a new Buffer using an {array} of octets.
-     *
-     * @param array
-     */
-    static from(array: any[]): Buffer;
-    /**
-     * When passed a reference to the .buffer property of a TypedArray instance,
-     * the newly created Buffer will share the same allocated memory as the TypedArray.
-     * The optional {byteOffset} and {length} arguments specify a memory range
-     * within the {arrayBuffer} that will be shared by the Buffer.
-     *
-     * @param arrayBuffer The .buffer property of a TypedArray or a new ArrayBuffer()
-     * @param byteOffset
-     * @param length
-     */
-    static from(arrayBuffer: ArrayBuffer, byteOffset?: number, length?: number): Buffer;
-    /**
-     * Copies the passed {buffer} data onto a new Buffer instance.
-     *
-     * @param buffer
-     */
-    static from(buffer: Buffer | Uint8Array): Buffer;
-    /**
-     * Creates a new Buffer containing the given JavaScript string {str}.
-     * If provided, the {encoding} parameter identifies the character encoding.
-     * If not provided, {encoding} defaults to 'utf8'.
-     *
-     * @param str
-     */
-    static from(str: string, encoding?: string): Buffer;
-    /**
-     * Returns true if {obj} is a Buffer
-     *
-     * @param obj object to test.
-     */
-    static isBuffer(obj: any): obj is Buffer;
-    /**
-     * Returns true if {encoding} is a valid encoding argument.
-     * Valid string encodings in Node 0.12: 'ascii'|'utf8'|'utf16le'|'ucs2'(alias of 'utf16le')|'base64'|'binary'(deprecated)|'hex'
-     *
-     * @param encoding string to test.
-     */
-    static isEncoding(encoding: string): boolean;
-    /**
-     * Gives the actual byte length of a string. encoding defaults to 'utf8'.
-     * This is not the same as String.prototype.length since that returns the number of characters in a string.
-     *
-     * @param string string to test.
-     * @param encoding encoding used to evaluate (defaults to 'utf8')
-     */
-    static byteLength(string: string, encoding?: string): number;
-    /**
-     * Returns a buffer which is the result of concatenating all the buffers in the list together.
-     *
-     * If the list has no items, or if the totalLength is 0, then it returns a zero-length buffer.
-     * If the list has exactly one item, then the first item of the list is returned.
-     * If the list has more than one item, then a new Buffer is created.
-     *
-     * @param list An array of Buffer objects to concatenate
-     * @param totalLength Total length of the buffers when concatenated.
-     *   If totalLength is not provided, it is read from the buffers in the list. However, this adds an additional loop to the function, so it is faster to provide the length explicitly.
-     */
-    static concat(list: Buffer[], totalLength?: number): Buffer;
-    /**
-     * The same as buf1.compare(buf2).
-     */
-    static compare(buf1: Buffer, buf2: Buffer): number;
-    /**
-     * Allocates a new buffer of {size} octets.
-     *
-     * @param size count of octets to allocate.
-     * @param fill if specified, buffer will be initialized by calling buf.fill(fill).
-     *    If parameter is omitted, buffer will be filled with zeros.
-     * @param encoding encoding used for call to buf.fill while initializing
-     */
-    static alloc(size: number, fill?: string | Buffer | number, encoding?: string): Buffer;
-    /**
-     * Allocates a new buffer of {size} octets, leaving memory not initialized, so the contents
-     * of the newly created Buffer are unknown and may contain sensitive data.
-     *
-     * @param size count of octets to allocate
-     */
-    static allocUnsafe(size: number): Buffer;
-    /**
-     * Allocates a new non-pooled buffer of {size} octets, leaving memory not initialized, so the contents
-     * of the newly created Buffer are unknown and may contain sensitive data.
-     *
-     * @param size count of octets to allocate
-     */
-    static allocUnsafeSlow(size: number): Buffer;
-}

node_modules/buffer/package.json

@@ -1,127 +0,0 @@
-{
-  "_from": "buffer@^5.5.0",
-  "_id": "buffer@5.7.1",
-  "_inBundle": false,
-  "_integrity": "sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==",
-  "_location": "/buffer",
-  "_phantomChildren": {},
-  "_requested": {
-    "type": "range",
-    "registry": true,
-    "raw": "buffer@^5.5.0",
-    "name": "buffer",
-    "escapedName": "buffer",
-    "rawSpec": "^5.5.0",
-    "saveSpec": null,
-    "fetchSpec": "^5.5.0"
-  },
-  "_requiredBy": [
-    "/bl"
-  ],
-  "_resolved": "https://registry.npmjs.org/buffer/-/buffer-5.7.1.tgz",
-  "_shasum": "ba62e7c13133053582197160851a8f648e99eed0",
-  "_spec": "buffer@^5.5.0",
-  "_where": "E:\\gitee\\fys\\fys\\app\\JingQuan\\node_modules\\bl",
-  "author": {
-    "name": "Feross Aboukhadijeh",
-    "email": "feross@feross.org",
-    "url": "https://feross.org"
-  },
-  "bugs": {
-    "url": "https://github.com/feross/buffer/issues"
-  },
-  "bundleDependencies": false,
-  "contributors": [
-    {
-      "name": "Romain Beauxis",
-      "email": "toots@rastageeks.org"
-    },
-    {
-      "name": "James Halliday",
-      "email": "mail@substack.net"
-    }
-  ],
-  "dependencies": {
-    "base64-js": "^1.3.1",
-    "ieee754": "^1.1.13"
-  },
-  "deprecated": false,
-  "description": "Node.js Buffer API, for the browser",
-  "devDependencies": {
-    "airtap": "^3.0.0",
-    "benchmark": "^2.1.4",
-    "browserify": "^17.0.0",
-    "concat-stream": "^2.0.0",
-    "hyperquest": "^2.1.3",
-    "is-buffer": "^2.0.4",
-    "is-nan": "^1.3.0",
-    "split": "^1.0.1",
-    "standard": "*",
-    "tape": "^5.0.1",
-    "through2": "^4.0.2",
-    "uglify-js": "^3.11.3"
-  },
-  "funding": [
-    {
-      "type": "github",
-      "url": "https://github.com/sponsors/feross"
-    },
-    {
-      "type": "patreon",
-      "url": "https://www.patreon.com/feross"
-    },
-    {
-      "type": "consulting",
-      "url": "https://feross.org/support"
-    }
-  ],
-  "homepage": "https://github.com/feross/buffer",
-  "jspm": {
-    "map": {
-      "./index.js": {
-        "node": "@node/buffer"
-      }
-    }
-  },
-  "keywords": [
-    "arraybuffer",
-    "browser",
-    "browserify",
-    "buffer",
-    "compatible",
-    "dataview",
-    "uint8array"
-  ],
-  "license": "MIT",
-  "main": "index.js",
-  "name": "buffer",
-  "repository": {
-    "type": "git",
-    "url": "git://github.com/feross/buffer.git"
-  },
-  "scripts": {
-    "perf": "browserify --debug perf/bracket-notation.js > perf/bundle.js && open perf/index.html",
-    "perf-node": "node perf/bracket-notation.js && node perf/concat.js && node perf/copy-big.js && node perf/copy.js && node perf/new-big.js && node perf/new.js && node perf/readDoubleBE.js && node perf/readFloatBE.js && node perf/readUInt32LE.js && node perf/slice.js && node perf/writeFloatBE.js",
-    "size": "browserify -r ./ | uglifyjs -c -m | gzip | wc -c",
-    "test": "standard && node ./bin/test.js",
-    "test-browser-es5": "airtap -- test/*.js",
-    "test-browser-es5-local": "airtap --local -- test/*.js",
-    "test-browser-es6": "airtap -- test/*.js test/node/*.js",
-    "test-browser-es6-local": "airtap --local -- test/*.js test/node/*.js",
-    "test-node": "tape test/*.js test/node/*.js",
-    "update-authors": "./bin/update-authors.sh"
-  },
-  "standard": {
-    "ignore": [
-      "test/node/**/*.js",
-      "test/common.js",
-      "test/_polyfill.js",
-      "perf/**/*.js"
-    ],
-    "globals": [
-      "SharedArrayBuffer"
-    ]
-  },
-  "types": "index.d.ts",
-  "version": "5.7.1"
-}

node_modules/call-bind-apply-helpers/package.json

@@ -1,114 +1,85 @@
 {
-  "_from": "call-bind-apply-helpers@^1.0.2",
-  "_id": "call-bind-apply-helpers@1.0.2",
-  "_inBundle": false,
-  "_integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==",
-  "_location": "/call-bind-apply-helpers",
-  "_phantomChildren": {},
-  "_requested": {
-    "type": "range",
-    "registry": true,
-    "raw": "call-bind-apply-helpers@^1.0.2",
-    "name": "call-bind-apply-helpers",
-    "escapedName": "call-bind-apply-helpers",
-    "rawSpec": "^1.0.2",
-    "saveSpec": null,
-    "fetchSpec": "^1.0.2"
-  },
-  "_requiredBy": [
-    "/dunder-proto",
-    "/get-intrinsic"
-  ],
-  "_resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
-  "_shasum": "4b5428c222be985d79c3d82657479dbe0b59b2d6",
-  "_spec": "call-bind-apply-helpers@^1.0.2",
-  "_where": "E:\\gitee\\fys\\fys\\app\\Fuyuan\\node_modules\\get-intrinsic",
-  "author": {
-    "name": "Jordan Harband",
-    "email": "ljharb@gmail.com"
-  },
-  "auto-changelog": {
-    "output": "CHANGELOG.md",
-    "template": "keepachangelog",
-    "unreleased": false,
-    "commitLimit": false,
-    "backfillLimit": false,
-    "hideCredit": true
-  },
-  "bugs": {
-    "url": "https://github.com/ljharb/call-bind-apply-helpers/issues"
-  },
-  "bundleDependencies": false,
-  "dependencies": {
-    "es-errors": "^1.3.0",
-    "function-bind": "^1.1.2"
-  },
-  "deprecated": false,
-  "description": "Helper functions around Function call/apply/bind, for use in `call-bind`",
-  "devDependencies": {
-    "@arethetypeswrong/cli": "^0.17.3",
-    "@ljharb/eslint-config": "^21.1.1",
-    "@ljharb/tsconfig": "^0.2.3",
-    "@types/for-each": "^0.3.3",
-    "@types/function-bind": "^1.1.10",
-    "@types/object-inspect": "^1.13.0",
-    "@types/tape": "^5.8.1",
-    "auto-changelog": "^2.5.0",
-    "encoding": "^0.1.13",
-    "es-value-fixtures": "^1.7.1",
-    "eslint": "=8.8.0",
-    "evalmd": "^0.0.19",
-    "for-each": "^0.3.5",
-    "has-strict-mode": "^1.1.0",
-    "in-publish": "^2.0.1",
-    "npmignore": "^0.3.1",
-    "nyc": "^10.3.2",
-    "object-inspect": "^1.13.4",
-    "safe-publish-latest": "^2.0.0",
-    "tape": "^5.9.0",
-    "typescript": "next"
-  },
-  "engines": {
-    "node": ">= 0.4"
-  },
-  "exports": {
-    ".": "./index.js",
-    "./actualApply": "./actualApply.js",
-    "./applyBind": "./applyBind.js",
-    "./functionApply": "./functionApply.js",
-    "./functionCall": "./functionCall.js",
-    "./reflectApply": "./reflectApply.js",
-    "./package.json": "./package.json"
-  },
-  "homepage": "https://github.com/ljharb/call-bind-apply-helpers#readme",
-  "license": "MIT",
-  "main": "index.js",
-  "name": "call-bind-apply-helpers",
-  "publishConfig": {
-    "ignore": [
-      ".github/workflows"
-    ]
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/ljharb/call-bind-apply-helpers.git"
-  },
-  "scripts": {
-    "lint": "eslint --ext=.js,.mjs .",
-    "postlint": "tsc -p . && attw -P",
-    "posttest": "npx npm@'>=10.2' audit --production",
-    "postversion": "auto-changelog && git add CHANGELOG.md && git commit --no-edit --amend && git tag -f \"v$(node -e \"console.log(require('./package.json').version)\")\"",
-    "prelint": "evalmd README.md",
-    "prepack": "npmignore --auto --commentLines=auto",
-    "prepublish": "not-in-publish || npm run prepublishOnly",
-    "prepublishOnly": "safe-publish-latest",
-    "pretest": "npm run lint",
-    "test": "npm run tests-only",
-    "tests-only": "nyc tape 'test/**/*.js'",
-    "version": "auto-changelog && git add CHANGELOG.md"
-  },
-  "testling": {
-    "files": "test/index.js"
-  },
-  "version": "1.0.2"
+	"name": "call-bind-apply-helpers",
+	"version": "1.0.2",
+	"description": "Helper functions around Function call/apply/bind, for use in `call-bind`",
+	"main": "index.js",
+	"exports": {
+		".": "./index.js",
+		"./actualApply": "./actualApply.js",
+		"./applyBind": "./applyBind.js",
+		"./functionApply": "./functionApply.js",
+		"./functionCall": "./functionCall.js",
+		"./reflectApply": "./reflectApply.js",
+		"./package.json": "./package.json"
+	},
+	"scripts": {
+		"prepack": "npmignore --auto --commentLines=auto",
+		"prepublish": "not-in-publish || npm run prepublishOnly",
+		"prepublishOnly": "safe-publish-latest",
+		"prelint": "evalmd README.md",
+		"lint": "eslint --ext=.js,.mjs .",
+		"postlint": "tsc -p . && attw -P",
+		"pretest": "npm run lint",
+		"tests-only": "nyc tape 'test/**/*.js'",
+		"test": "npm run tests-only",
+		"posttest": "npx npm@'>=10.2' audit --production",
+		"version": "auto-changelog && git add CHANGELOG.md",
+		"postversion": "auto-changelog && git add CHANGELOG.md && git commit --no-edit --amend && git tag -f \"v$(node -e \"console.log(require('./package.json').version)\")\""
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/ljharb/call-bind-apply-helpers.git"
+	},
+	"author": "Jordan Harband <ljharb@gmail.com>",
+	"license": "MIT",
+	"bugs": {
+		"url": "https://github.com/ljharb/call-bind-apply-helpers/issues"
+	},
+	"homepage": "https://github.com/ljharb/call-bind-apply-helpers#readme",
+	"dependencies": {
+		"es-errors": "^1.3.0",
+		"function-bind": "^1.1.2"
+	},
+	"devDependencies": {
+		"@arethetypeswrong/cli": "^0.17.3",
+		"@ljharb/eslint-config": "^21.1.1",
+		"@ljharb/tsconfig": "^0.2.3",
+		"@types/for-each": "^0.3.3",
+		"@types/function-bind": "^1.1.10",
+		"@types/object-inspect": "^1.13.0",
+		"@types/tape": "^5.8.1",
+		"auto-changelog": "^2.5.0",
+		"encoding": "^0.1.13",
+		"es-value-fixtures": "^1.7.1",
+		"eslint": "=8.8.0",
+		"evalmd": "^0.0.19",
+		"for-each": "^0.3.5",
+		"has-strict-mode": "^1.1.0",
+		"in-publish": "^2.0.1",
+		"npmignore": "^0.3.1",
+		"nyc": "^10.3.2",
+		"object-inspect": "^1.13.4",
+		"safe-publish-latest": "^2.0.0",
+		"tape": "^5.9.0",
+		"typescript": "next"
+	},
+	"testling": {
+		"files": "test/index.js"
+	},
+	"auto-changelog": {
+		"output": "CHANGELOG.md",
+		"template": "keepachangelog",
+		"unreleased": false,
+		"commitLimit": false,
+		"backfillLimit": false,
+		"hideCredit": true
+	},
+	"publishConfig": {
+		"ignore": [
+			".github/workflows"
+		]
+	},
+	"engines": {
+		"node": ">= 0.4"
+	}
 }

node_modules/callback-stream/.jshintrc

@@ -1,60 +0,0 @@
-{
-    "predef": [ ]
-  , "bitwise": false
-  , "camelcase": false
-  , "curly": false
-  , "eqeqeq": false
-  , "forin": false
-  , "immed": false
-  , "latedef": false
-  , "noarg": true
-  , "noempty": true
-  , "nonew": true
-  , "plusplus": false
-  , "quotmark": true
-  , "regexp": false
-  , "undef": true
-  , "unused": true
-  , "strict": false
-  , "trailing": true
-  , "maxlen": 120
-  , "asi": true
-  , "boss": true
-  , "debug": true
-  , "eqnull": true
-  , "es5": true
-  , "esnext": true
-  , "evil": true
-  , "expr": true
-  , "funcscope": false
-  , "globalstrict": false
-  , "iterator": false
-  , "lastsemic": true
-  , "laxbreak": true
-  , "laxcomma": true
-  , "loopfunc": true
-  , "multistr": false
-  , "onecase": false
-  , "proto": false
-  , "regexdash": false
-  , "scripturl": true
-  , "smarttabs": false
-  , "shadow": false
-  , "sub": true
-  , "supernew": false
-  , "validthis": true
-  , "browser": true
-  , "couch": false
-  , "devel": false
-  , "dojo": false
-  , "mootools": false
-  , "node": true
-  , "nonstandard": true
-  , "prototypejs": false
-  , "rhino": false
-  , "worker": true
-  , "wsh": false
-  , "nomen": false
-  , "onevar": true
-  , "passfail": false
-}

node_modules/callback-stream/.npmignore

@@ -1,7 +0,0 @@
-node_modules/
-build/
-libleveldb.so
-libleveldb.a
-test-data/
-_benchdb_*
-*.sw*