2 maanden geleden · 16c7719d8b
--- a/css/index.css
+++ b/css/index.css
@@ -148,7 +148,7 @@ a{
 
				 	width: 3.5rem;
			
 
				   }
			
 
				   .monitor .col:nth-child(2) {
			
 
				-	width: 3.2rem;
			
 
				+	width: 4.0rem;
			
 
				   text-align: center;
			
 
				 	/* 不换行  一行省略*/
			
 
				 	white-space: nowrap;
			
@@ -342,6 +342,9 @@ a{
 
				 .order {
			
 
				   height: 6.167rem;
			
 
				 }
			
 
				+.alarms a {
			
 
				+  cursor: pointer;  /* 添加鼠标手型 */
			
 
				+}
			
 
				 .order .filter {
			
 
				   display: flex;
			
 
				 }
			
--- a/index.html
+++ b/index.html
--- a/index2.html
+++ b/index2.html
@@ -0,0 +1,231 @@
 
				+<!DOCTYPE html>
			
 
				+<html lang="en">
			
 
				+
			
 
				+<head>
			
 
				+    <meta charset="UTF-8">
			
 
				+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
			
 
				+    <meta http-equiv="X-UA-Compatible" content="ie=edge">
			
 
				+    <title>维鼎康联养老看板</title>
			
 
				+    <link rel="stylesheet" href="./css/index.css">
			
 
				+    <link rel="stylesheet" href="./css/animsition.css">
			
 
				+    <link rel="stylesheet" href="./fonts/icomoon.css">
			
 
				+    <!-- <link rel="stylesheet" href="./css/flipclock.css"> -->
			
 
				+    // 引入 Vue.js
			
 
				+    <script src="https://cdn.jsdelivr.net/npm/vue@2.6.14"></script>
			
 
				+</head>
			
 
				+
			
 
				+<body>
			
 
				+    <div class="app">
			
 
				+        <div class="header">
			
 
				+            <div class="title" id="title">维鼎康联养老看板</div>
			
 
				+            <div id="muteImg" style="top:20px;right: 20px;position: absolute;">
			
 
				+                <image src="./images/mute.png" style="height: 30px;width: 30px"></image>
			
 
				+            </div>
			
 
				+        </div>
			
 
				+        <div class="clearfix"></div>
			
 
				+        <div class="viewport">
			
 
				+            <div class="column">
			
 
				+                <div class="overview panel">
			
 
				+                    <div class="inner">
			
 
				+                        <div class="item">
			
 
				+                            <h4 id="allCount"></h4>
			
 
				+                            <span>
			
 
				+                                <i class="icon-dot" style="color: #006cff"></i>
			
 
				+                                总用户
			
 
				+                            </span>
			
 
				+                        </div>
			
 
				+                        <div class="item">
			
 
				+                            <h4 id="quarterly-addition"></h4>
			
 
				+                            <span>
			
 
				+                                <i class="icon-dot" style="color: #6acca3"></i>
			
 
				+                                季度新增
			
 
				+                            </span>
			
 
				+                        </div>
			
 
				+                        <div class="item">
			
 
				+                            <h4 id="monthly-addition"></h4>
			
 
				+                            <span>
			
 
				+                                <i class="icon-dot" style="color: #ed3f35"></i>
			
 
				+                                月度新增
			
 
				+                            </span>
			
 
				+                        </div>
			
 
				+                    </div>
			
 
				+                </div>
			
 
				+                <!--监控-->
			
 
				+                <div class="monitor panel">
			
 
				+                    <div class="inner">
			
 
				+                        <div class="tabs">
			
 
				+                            <a href="javascript:;" data-index="0" class="active">最新报警</a>
			
 
				+                        </div>
			
 
				+                        <div class="content" style="display: block;">
			
 
				+                            <div class="head">
			
 
				+                                <span class="col">时间</span>
			
 
				+                                <span class="col">用户</span>
			
 
				+                                <span class="col">项目</span>
			
 
				+                                <!--                            <span class="col">值</span>-->
			
 
				+                            </div>
			
 
				+                            <div class="marquee-view">
			
 
				+                                <div id="vsLogTable" class="marquee">
			
 
				+                                    <div class="vsLogTemplate row">
			
 
				+                                        <span class="col vsLogTime"></span>
			
 
				+                                        <span class="col vsLogUser"></span>
			
 
				+                                        <span class="col vsLogItem"></span>
			
 
				+                                        <!--                                    <span class="col vsLogValue"></span>-->
			
 
				+                                        <span class="icon-dot"></span>
			
 
				+                                    </div>
			
 
				+                                </div>
			
 
				+                            </div>
			
 
				+                        </div>
			
 
				+                    </div>
			
 
				+                </div>
			
 
				+                <!--点位-->
			
 
				+                <div class="point panel">
			
 
				+                    <div class="inner">
			
 
				+                        <h3>用户年龄分布</h3>
			
 
				+                        <div class="chart">
			
 
				+                            <div class="pie"></div>
			
 
				+                            <div class="data">
			
 
				+                                <div class="item">
			
 
				+                                    <h4 id="manCount"></h4>
			
 
				+                                    <span>
			
 
				+                                        <i class="icon-dot" style="color: #ed3f35"></i>
			
 
				+                                        男性
			
 
				+                                    </span>
			
 
				+                                </div>
			
 
				+                                <div class="item">
			
 
				+                                    <h4 id="womanCount">418</h4>
			
 
				+                                    <span>
			
 
				+                                        <i class="icon-dot" style="color: #eacf19"></i>
			
 
				+                                        女性
			
 
				+                                    </span>
			
 
				+                                </div>
			
 
				+                            </div>
			
 
				+                        </div>
			
 
				+                    </div>
			
 
				+                </div>
			
 
				+            </div>
			
 
				+            <div class="column">
			
 
				+                <!-- 地图 -->
			
 
				+                <div class="map">
			
 
				+                    <div class="chart">
			
 
				+                        <div class="geo"></div>
			
 
				+                    </div>
			
 
				+                </div>
			
 
				+                <!-- 用户 -->
			
 
				+                <div class="users panel">
			
 
				+                    <div class="inner">
			
 
				+                        <h3>报警分布</h3>
			
 
				+                        <div class="chart">
			
 
				+                            <div class="bar"></div>
			
 
				+                            <div class="data">
			
 
				+                                <div class="item">
			
 
				+                                    <h4 id="dayCount"></h4>
			
 
				+                                    <span>
			
 
				+                                        <i class="icon-dot" style="color: #ed3f35"></i>
			
 
				+                                        今日测量数
			
 
				+                                    </span>
			
 
				+                                </div>
			
 
				+                                <div class="item">
			
 
				+                                    <h4 id="hourCount"></h4>
			
 
				+                                    <span>
			
 
				+                                        <i class="icon-dot" style="color: #eacf19"></i>
			
 
				+                                        近1小时
			
 
				+                                    </span>
			
 
				+                                </div>
			
 
				+                            </div>
			
 
				+                        </div>
			
 
				+                    </div>
			
 
				+                </div>
			
 
				+            </div>
			
 
				+            <div class="column">
			
 
				+                <div class="order panel">
			
 
				+                    <div class="inner">
			
 
				+                        <!-- 筛选 -->
			
 
				+                        <div class="filter">
			
 
				+                            <a href="javascript:;" data-key="day365" class="active">365天</a>
			
 
				+                            <a href="javascript:;" data-key="day90">90天</a>
			
 
				+                            <a href="javascript:;" data-key="day30">30天</a>
			
 
				+                            <a href="javascript:;" data-key="day7">7天</a>
			
 
				+                        </div>
			
 
				+                        <!-- 数据 -->
			
 
				+                        <div class="data">
			
 
				+                            <div class="item">
			
 
				+                                <h4></h4>
			
 
				+                                <span>
			
 
				+                                    <i class="icon-dot" style="color: #ed3f35;"></i>
			
 
				+                                    测量
			
 
				+                                </span>
			
 
				+                            </div>
			
 
				+                            <div class="item">
			
 
				+                                <h4></h4>
			
 
				+                                <span>
			
 
				+                                    <i class="icon-dot" style="color: #eacf19;"></i>
			
 
				+                                    报警
			
 
				+                                </span>
			
 
				+                            </div>
			
 
				+                        </div>
			
 
				+                    </div>
			
 
				+                </div>
			
 
				+                <!-- 报警统计 -->
			
 
				+                <div class="alarms panel">
			
 
				+                    <div class="inner">
			
 
				+                        <div class="caption">
			
 
				+                            <h3>报警统计</h3>
			
 
				+                            <a href="javascript:;" class="active" data-type="week">周</a>
			
 
				+                            <a href="javascript:;" data-type="month">月</a>
			
 
				+                            <a href="javascript:;" data-type="year">年</a>
			
 
				+
			
 
				+                        </div>
			
 
				+                        <div class="chart">
			
 
				+                            <div class="label"></div>
			
 
				+                            <div class="line"></div>
			
 
				+                        </div>
			
 
				+                    </div>
			
 
				+                </div>
			
 
				+                <!--异常-->
			
 
				+                <div class="monitor panel">
			
 
				+                    <div class="inner">
			
 
				+                        <div class="tabs">
			
 
				+                            <a href="javascript:;" data-index="0" class="active">体征报警</a>
			
 
				+                        </div>
			
 
				+                        <div class="content" style="display: block;">
			
 
				+                            <div class="head">
			
 
				+                                <span class="col">时间</span>
			
 
				+                                <span class="col">用户</span>
			
 
				+                                <span class="col">项目</span>
			
 
				+                                <span class="col">值</span>
			
 
				+                            </div>
			
 
				+                            <div class="marquee-view">
			
 
				+                                <div id="errVsLogTable" class="marquee alarms-list">
			
 
				+                                    <div id="errVsLogTemplate" class="row">
			
 
				+                                        <span class="col errVsLogTime"></span>
			
 
				+                                        <span class="col errVsLogUser"></span>
			
 
				+                                        <span class="col errVsLogItem"></span>
			
 
				+                                        <span class="col errVsLogValue"></span>
			
 
				+                                        <span class="icon-dot"></span>
			
 
				+                                    </div>
			
 
				+                                </div>
			
 
				+                            </div>
			
 
				+                        </div>
			
 
				+                    </div>
			
 
				+                </div>
			
 
				+            </div>
			
 
				+        </div>
			
 
				+        <canvas id="canvas" style="position: absolute;top: 0;left: 0;"></canvas>
			
 
				+    </div>
			
 
				+</body>
			
 
				+
			
 
				+<script src="./js/mapStyleJson.js"></script>
			
 
				+<script src="./js/jquery.min.js"></script>
			
 
				+<script src="./js/echarts.min.js"></script>
			
 
				+<!--<script src="https://fastly.jsdelivr.net/npm/echarts@5.3.3/dist/echarts.min.js"></script>-->
			
 
				+<script src="./js/jquery.animsition.js"></script>
			
 
				+<script src="./js/bg.js"></script>
			
 
				+<!-- <script src="./js/flipclock.min.js"></script> -->
			
 
				+<script src="./js/index.js"></script>
			
 
				+<script type="text/javascript" src="https://api.map.baidu.com/api?v=3.0&ak=4lgYDZ9MWQMbTvjX5R5M5pZG"></script>
			
 
				+<script type="text/javascript" src="https://fastly.jsdelivr.net/npm/echarts@5.3.3/dist/extension/bmap.min.js"></script>
			
 
				+<script src="./js/mymap.js"></script>
			
 
				+
			
 
				+
			
 
				+
			
 
				+</html>
			
--- a/js/api.js
+++ b/js/api.js
@@ -0,0 +1,11 @@
 
				+ const api = {
			
 
				+    // 开发环境
			
 
				+    base: 'http://192.168.1.199:7000', 
			
 
				+    // loginSocket: 'ws://192.168.1.199:7000/microcirculation',
			
 
				+    
			
 
				+    // 生产环境
			
 
				+    // base: 'https://api.base.wdklian.com',
			
 
				+    // loginSocket: 'ws://api.base.wdklian.com/microcirculation',
			
 
				+    // QRSocket: 'ws://api.base.wdklian.com/general'
			
 
				+  };
			
 
				+  window.api = api;
			
--- a/js/i18n.js
+++ b/js/i18n.js
@@ -0,0 +1,251 @@
 
				+const i18n = new VueI18n({
			
 
				+  // 设置默认语言
			
 
				+  // locale: 'zh', // 语言标识
			
 
				+  locale: localStorage.getItem('language') == null ? 'zh' : localStorage.getItem('language'),
			
 
				+  // 添加多语言（每一个语言标示对应一个语言文件）
			
 
				+  messages: {
			
 
				+    'zh': {
			
 
				+      board: {
			
 
				+        wdkl: '维鼎康联养老看板',
			
 
				+        login: '登录',
			
 
				+        username: '用户名',
			
 
				+        password: '密码',
			
 
				+        submit: '确认',
			
 
				+        adminOnly: '仅限管理员登录',
			
 
				+
			
 
				+        title: '养老看板',
			
 
				+        switchOrg: '切换机构',
			
 
				+        selectOrg: '选择机构',
			
 
				+        totalUsers: '总用户数',
			
 
				+        deviceCount: '设备数',
			
 
				+        healthData: '健康数据',
			
 
				+        time: '时间',
			
 
				+        user: '用户',
			
 
				+        project: '项目',
			
 
				+        value: '值',
			
 
				+        ageDistribution: '用户年龄分布',
			
 
				+        male: '男性',
			
 
				+        female: '女性',
			
 
				+        unknown: '未知',
			
 
				+        todayAlerts: '今日紧急报警',
			
 
				+        todayMeasures: '今日测量数',
			
 
				+        lastHour: '近1小时',
			
 
				+        serviceCount: '服务数',
			
 
				+        orderCount: '订单数',
			
 
				+        goodsCount: '商品数',
			
 
				+        warningStats: '预警统计',
			
 
				+        week: '周',
			
 
				+        month: '月',
			
 
				+        year: '年',
			
 
				+        recentAlerts: '近期报警',
			
 
				+        description: '描述',
			
 
				+        time: '时间'
			
 
				+
			
 
				+      },
			
 
				+      wdklScreen: {
			
 
				+        wdkl: '维鼎康联养老看板',
			
 
				+        totalUsers: '总用户',
			
 
				+        quarterlyNew: '季度新增',
			
 
				+        monthlyNew: '月度新增',
			
 
				+        latestAlarms: '最新报警',
			
 
				+        time: '时间',
			
 
				+        user: '用户',
			
 
				+        project: '项目',
			
 
				+        ageDistribution: '用户年龄分布',
			
 
				+        male: '男性',
			
 
				+        female: '女性',
			
 
				+        alarmDistribution: '报警分布',
			
 
				+        todayMeasureCount: '今日测量数',
			
 
				+        lastHour: '近1小时',
			
 
				+        days: '天',
			
 
				+        measurement: '测量',
			
 
				+        alarm: '报警',
			
 
				+        alarmStatistics: '报警统计',
			
 
				+        value: '值',
			
 
				+        week: '周',
			
 
				+        month: '月',
			
 
				+        year: '年',
			
 
				+        latestAlarms: '最新报警',
			
 
				+        vitalSignsAlarm: '体征报警',
			
 
				+        userMapOverview: '用户地图一览',
			
 
				+        ageGroup: '年龄段',
			
 
				+         languageSelector: '语言---中文',
			
 
				+         monday: '周一',
			
 
				+         tuesday: '周二',
			
 
				+         wednesday: '周三',
			
 
				+         thursday: '周四',
			
 
				+         friday: '周五',
			
 
				+         saturday: '周六',
			
 
				+         weekday: '周日'
			
 
				+      }
			
 
				+    },
			
 
				+    'en': {
			
 
				+      board: {
			
 
				+        wdkl: 'Elderly Care Dashboard',
			
 
				+        login: 'Login',
			
 
				+        username: 'Username',
			
 
				+        password: 'Password',
			
 
				+        submit: 'Submit',
			
 
				+        adminOnly: 'Admin Login Only',
			
 
				+
			
 
				+        title: 'Elderly Care Dashboard',
			
 
				+        switchOrg: 'Switch Organization',
			
 
				+        selectOrg: 'Select Organization',
			
 
				+        totalUsers: 'Total Users',
			
 
				+        deviceCount: 'Device Count',
			
 
				+        healthData: 'Health Data',
			
 
				+        time: 'Time',
			
 
				+        user: 'User',
			
 
				+        project: 'Project',
			
 
				+        value: 'Value',
			
 
				+        ageDistribution: 'Age Distribution',
			
 
				+        male: 'Male',
			
 
				+        female: 'Female',
			
 
				+        unknown: 'Unknown',
			
 
				+        todayAlerts: 'Today\'s Emergency Alerts',
			
 
				+        todayMeasures: 'Today\'s Measurements',
			
 
				+        lastHour: 'Last Hour',
			
 
				+        serviceCount: 'Services',
			
 
				+        orderCount: 'Orders',
			
 
				+        goodsCount: 'Products',
			
 
				+        warningStats: 'Warning Statistics',
			
 
				+        week: 'Week',
			
 
				+        month: 'Month',
			
 
				+        year: 'Year',
			
 
				+        recentAlerts: 'Recent Alerts',
			
 
				+        description: 'Description'
			
 
				+      },
			
 
				+      wdklScreen: {
			
 
				+        wdkl: 'Elderly Care Dashboard',
			
 
				+        totalUsers: 'Total Users',
			
 
				+        quarterlyNew: 'Quarterly New',
			
 
				+        monthlyNew: 'Monthly New',
			
 
				+        latestAlarms: 'Latest Alarms',
			
 
				+        time: 'Time',
			
 
				+        user: 'User',
			
 
				+        project: 'Project',
			
 
				+        ageDistribution: 'User Age Distribution',
			
 
				+        male: 'Male',
			
 
				+        female: 'Female',
			
 
				+        alarmDistribution: 'Alarm Distribution',
			
 
				+        todayMeasureCount: 'Today\'s Measure Count',
			
 
				+        lastHour: 'Last Hour',
			
 
				+        days: 'Days',
			
 
				+        measurement: 'Measurement',
			
 
				+        alarm: 'Alarm',
			
 
				+        alarmStatistics: 'Alarm Statistics',
			
 
				+        value: 'Value',
			
 
				+        week: 'Week',
			
 
				+        month: 'Month',
			
 
				+        year: 'Year',
			
 
				+        latestAlarms: 'Latest Alarms',
			
 
				+        vitalSignsAlarm: 'Vital Signs Alarm',
			
 
				+        userMapOverview: 'User Map Overview',
			
 
				+        ageGroup: 'Age Group',
			
 
				+        languageSelector: 'Language---English',
			
 
				+        monday: 'Mon',
			
 
				+        tuesday: 'Tues',
			
 
				+        wednesday: 'Wednes',
			
 
				+        thursday: 'Thurs',
			
 
				+        friday: 'Fri',
			
 
				+        saturday: 'Satur',
			
 
				+        weekday: 'Sun'
			
 
				+      }
			
 
				+    },
			
 
				+    'es': {
			
 
				+      board: {
			
 
				+        wdkl: 'Panel de Cuidado de Ancianos',
			
 
				+        login: 'Iniciar sesión',
			
 
				+        username: 'Nombre de usuario',
			
 
				+        password: 'Contraseña',
			
 
				+        submit: 'Confirmar',
			
 
				+        adminOnly: 'Solo inicio de sesión de administrador'
			
 
				+      },
			
 
				+      wdklScreen: {
			
 
				+        wdkl: 'Panel de Cuidado de Ancianos',
			
 
				+        totalUsers: 'Usuarios Totales',
			
 
				+        quarterlyNew: 'Nuevo Trimestral',
			
 
				+        monthlyNew: 'Nuevo Mensual',
			
 
				+        latestAlarms: 'Últimas Alarmas',
			
 
				+        time: 'Tiempo',
			
 
				+        user: 'Usuario',
			
 
				+        project: 'Proyecto',
			
 
				+        ageDistribution: 'Distribución por Edad',
			
 
				+        male: 'Masculino',
			
 
				+        female: 'Femenino',
			
 
				+        alarmDistribution: 'Distribución de Alarmas',
			
 
				+        todayMeasureCount: 'Mediciones de Hoy',
			
 
				+        lastHour: 'Última Hora',
			
 
				+        days: 'Días',
			
 
				+        measurement: 'Medición',
			
 
				+        alarm: 'Alarma',
			
 
				+        alarmStatistics: 'Estadísticas de Alarmas',
			
 
				+        value: 'Valor',
			
 
				+        week: 'Semana',
			
 
				+        month: 'Mes',
			
 
				+        year: 'Año',
			
 
				+        latestAlarms: 'Últimas Alarmas',
			
 
				+        vitalSignsAlarm: 'Alarma de Signos Vitales',
			
 
				+        userMapOverview: 'Vista General del Mapa de Usuarios',
			
 
				+        ageGroup: 'Grupo de Edad',
			
 
				+         languageSelector: 'Idioma---Español',
			
 
				+         monday: 'Lunes',
			
 
				+         tuesday: 'Martes',
			
 
				+         wednesday: 'Miércoles',
			
 
				+         thursday: 'Jueves',
			
 
				+         friday: 'Viernes',
			
 
				+         saturday: 'Sábado',
			
 
				+         weekday: 'Domingo'
			
 
				+      }
			
 
				+    },
			
 
				+    'ru': {
			
 
				+      board: {
			
 
				+        wdkl: 'Панель Ухода за Пожилыми',
			
 
				+        login: 'Вход',
			
 
				+        username: 'Имя пользователя',
			
 
				+        password: 'Пароль',
			
 
				+        submit: 'Подтвердить',
			
 
				+        adminOnly: 'Только для администраторов'
			
 
				+      },
			
 
				+      wdklScreen: {
			
 
				+        wdkl: 'Канбан для престарелых',
			
 
				+        totalUsers: 'Всего Пользователей',
			
 
				+        quarterlyNew: 'Новые за Квартал',
			
 
				+        monthlyNew: 'Новые за Месяц',
			
 
				+        latestAlarms: 'Последние Тревоги',
			
 
				+        time: 'Время',
			
 
				+        user: 'Пользователь',
			
 
				+        project: 'Проект',
			
 
				+        ageDistribution: 'Распределение по Возрасту',
			
 
				+        male: 'Мужской',
			
 
				+        female: 'Женский',
			
 
				+        alarmDistribution: 'Распределение Тревог',
			
 
				+        todayMeasureCount: 'Измерения за Сегодня',
			
 
				+        lastHour: 'Последний Час',
			
 
				+        days: 'Дней',
			
 
				+        measurement: 'Измерение',
			
 
				+        alarm: 'Тревога',
			
 
				+        alarmStatistics: 'Статистика Тревог',
			
 
				+        value: 'Значение',
			
 
				+        week: 'Неделя',
			
 
				+        month: 'Месяц',
			
 
				+        year: 'Год',
			
 
				+        latestAlarms: 'Последние Тревоги',
			
 
				+        vitalSignsAlarm: 'Тревога Жизненных Показателей',
			
 
				+        userMapOverview: 'Обзор Карты Пользователей',
			
 
				+        ageGroup: 'Возрастная Группа',
			
 
				+        languageSelector: 'Язык---Русский',
			
 
				+        monday: 'Пн',
			
 
				+        tuesday: 'Вт',
			
 
				+        wednesday: 'Ср',
			
 
				+        thursday: 'Чт',
			
 
				+        friday: 'Пт',
			
 
				+        saturday: 'Сб',
			
 
				+        weekday: 'Вс'
			
 
				+      }
			
 
				+    }
			
 
				+  }
			
 
				+})
			
 
				+
			
 
				+// 暴露i18n
			
 
				+window.i18n = i18n
			
--- a/js/index.js
+++ b/js/index.js
@@ -43,6 +43,7 @@ var colorList = ['#00f2f1','#006cff', '#eab408', '#ed8884', '#ff9f7f', '#0096ff'
 
				 (function () {
			
 
				     partId = getQuery("partId");
			
 
				     if (partId) {
			
 
				+        console.log('============',partId);
			
 
				         // 连接webSocket
			
 
				         initWebSocket();
			
 
				         // 打开定时器
			
--- a/js/jquery.animsition.js
+++ b/js/jquery.animsition.js
@@ -1,233 +0,0 @@
 
				-/*!
			
 
				- * animsition v3.4.3
			
 
				- * http://blivesta.github.io/animsition/
			
 
				- * Licensed under MIT
			
 
				- * Author : blivesta
			
 
				- * http://blivesta.com/
			
 
				- */
			
 
				-(function($) {
			
 
				-  "use strict";
			
 
				-  var namespace = "animsition";
			
 
				-  var methods = {
			
 
				-    init: function(options) {
			
 
				-      options = $.extend({
			
 
				-        inClass: "fade-in",
			
 
				-        outClass: "fade-out",
			
 
				-        inDuration: 1500,
			
 
				-        outDuration: 800,
			
 
				-        linkElement: ".animsition-link",
			
 
				-        loading: true,
			
 
				-        loadingParentElement: "body",
			
 
				-        loadingClass: "animsition-loading",
			
 
				-        unSupportCss: [ "animation-duration", "-webkit-animation-duration", "-o-animation-duration" ],
			
 
				-        overlay: false,
			
 
				-        overlayClass: "animsition-overlay-slide",
			
 
				-        overlayParentElement: "body"
			
 
				-      }, options);
			
 
				-      var support = methods.supportCheck.call(this, options);
			
 
				-      if (!support) {
			
 
				-        if (!("console" in window)) {
			
 
				-          window.console = {};
			
 
				-          window.console.log = function(str) {
			
 
				-            return str;
			
 
				-          };
			
 
				-        }
			
 
				-        console.log("Animsition does not support this browser.");
			
 
				-        return methods.destroy.call(this);
			
 
				-      }
			
 
				-      var overlayMode = methods.optionCheck.call(this, options);
			
 
				-      if (overlayMode) {
			
 
				-        methods.addOverlay.call(this, options);
			
 
				-      }
			
 
				-      if (options.loading) {
			
 
				-        methods.addLoading.call(this, options);
			
 
				-      }
			
 
				-      return this.each(function() {
			
 
				-        var _this = this;
			
 
				-        var $this = $(this);
			
 
				-        var $window = $(window);
			
 
				-        var data = $this.data(namespace);
			
 
				-        if (!data) {
			
 
				-          options = $.extend({}, options);
			
 
				-          $this.data(namespace, {
			
 
				-            options: options
			
 
				-          });
			
 
				-          $window.on("load." + namespace + " pageshow." + namespace, function() {
			
 
				-            methods.pageIn.call(_this);
			
 
				-          });
			
 
				-          $window.on("unload." + namespace, function() {});
			
 
				-          $(options.linkElement).on("click." + namespace, function(event) {
			
 
				-            event.preventDefault();
			
 
				-            var $self = $(this);
			
 
				-            methods.pageOut.call(_this, $self);
			
 
				-          });
			
 
				-        }
			
 
				-      });
			
 
				-    },
			
 
				-    addOverlay: function(options) {
			
 
				-      $(options.overlayParentElement).prepend('<div class="' + options.overlayClass + '"></div>');
			
 
				-    },
			
 
				-    addLoading: function(options) {
			
 
				-      $(options.loadingParentElement).append('<div class="' + options.loadingClass + '"></div>');
			
 
				-    },
			
 
				-    removeLoading: function() {
			
 
				-      var $this = $(this);
			
 
				-      var options = $this.data(namespace).options;
			
 
				-      var $loading = $(options.loadingParentElement).children("." + options.loadingClass);
			
 
				-      $loading.fadeOut().remove();
			
 
				-    },
			
 
				-    supportCheck: function(options) {
			
 
				-      var $this = $(this);
			
 
				-      var props = options.unSupportCss;
			
 
				-      var propsNum = props.length;
			
 
				-      var support = false;
			
 
				-      if (propsNum === 0) {
			
 
				-        support = true;
			
 
				-      }
			
 
				-      for (var i = 0; i < propsNum; i++) {
			
 
				-        if (typeof $this.css(props[i]) === "string") {
			
 
				-          support = true;
			
 
				-          break;
			
 
				-        }
			
 
				-      }
			
 
				-      return support;
			
 
				-    },
			
 
				-    optionCheck: function(options) {
			
 
				-      var $this = $(this);
			
 
				-      var overlayMode;
			
 
				-      if (options.overlay || $this.data("animsition-overlay")) {
			
 
				-        overlayMode = true;
			
 
				-      } else {
			
 
				-        overlayMode = false;
			
 
				-      }
			
 
				-      return overlayMode;
			
 
				-    },
			
 
				-    animationCheck: function(data, stateClass, stateIn) {
			
 
				-      var $this = $(this);
			
 
				-      var options = $this.data(namespace).options;
			
 
				-      var dataType = typeof data;
			
 
				-      var dataDuration = !stateClass && dataType === "number";
			
 
				-      var dataClass = stateClass && dataType === "string" && data.length > 0;
			
 
				-      if (dataDuration || dataClass) {
			
 
				-        data = data;
			
 
				-      } else if (stateClass && stateIn) {
			
 
				-        data = options.inClass;
			
 
				-      } else if (!stateClass && stateIn) {
			
 
				-        data = options.inDuration;
			
 
				-      } else if (stateClass && !stateIn) {
			
 
				-        data = options.outClass;
			
 
				-      } else if (!stateClass && !stateIn) {
			
 
				-        data = options.outDuration;
			
 
				-      }
			
 
				-      return data;
			
 
				-    },
			
 
				-    pageIn: function() {
			
 
				-      var _this = this;
			
 
				-      var $this = $(this);
			
 
				-      var options = $this.data(namespace).options;
			
 
				-      var thisInDuration = $this.data("animsition-in-duration");
			
 
				-      var thisInClass = $this.data("animsition-in");
			
 
				-      var inDuration = methods.animationCheck.call(_this, thisInDuration, false, true);
			
 
				-      var inClass = methods.animationCheck.call(_this, thisInClass, true, true);
			
 
				-      var overlayMode = methods.optionCheck.call(_this, options);
			
 
				-      if (options.loading) {
			
 
				-        methods.removeLoading.call(_this);
			
 
				-      }
			
 
				-      if (overlayMode) {
			
 
				-        methods.pageInOverlay.call(_this, inClass, inDuration);
			
 
				-      } else {
			
 
				-        methods.pageInBasic.call(_this, inClass, inDuration);
			
 
				-      }
			
 
				-    },
			
 
				-    pageInBasic: function(inClass, inDuration) {
			
 
				-      var $this = $(this);
			
 
				-      $this.css({
			
 
				-        "animation-duration": inDuration / 1e3 + "s"
			
 
				-      }).addClass(inClass).animateCallback(function() {
			
 
				-        $this.removeClass(inClass).css({
			
 
				-          opacity: 1
			
 
				-        });
			
 
				-      });
			
 
				-    },
			
 
				-    pageInOverlay: function(inClass, inDuration) {
			
 
				-      var $this = $(this);
			
 
				-      var options = $this.data(namespace).options;
			
 
				-      $this.css({
			
 
				-        opacity: 1
			
 
				-      });
			
 
				-      $(options.overlayParentElement).children("." + options.overlayClass).css({
			
 
				-        "animation-duration": inDuration / 1e3 + "s"
			
 
				-      }).addClass(inClass);
			
 
				-    },
			
 
				-    pageOut: function($self) {
			
 
				-      var _this = this;
			
 
				-      var $this = $(this);
			
 
				-      var options = $this.data(namespace).options;
			
 
				-      var selfOutClass = $self.data("animsition-out");
			
 
				-      var thisOutClass = $this.data("animsition-out");
			
 
				-      var selfOutDuration = $self.data("animsition-out-duration");
			
 
				-      var thisOutDuration = $this.data("animsition-out-duration");
			
 
				-      var isOutClass = selfOutClass ? selfOutClass : thisOutClass;
			
 
				-      var isOutDuration = selfOutDuration ? selfOutDuration : thisOutDuration;
			
 
				-      var outClass = methods.animationCheck.call(_this, isOutClass, true, false);
			
 
				-      var outDuration = methods.animationCheck.call(_this, isOutDuration, false, false);
			
 
				-      var overlayMode = methods.optionCheck.call(_this, options);
			
 
				-      var url = $self.attr("href");
			
 
				-      if (overlayMode) {
			
 
				-        methods.pageOutOverlay.call(_this, outClass, outDuration, url);
			
 
				-      } else {
			
 
				-        methods.pageOutBasic.call(_this, outClass, outDuration, url);
			
 
				-      }
			
 
				-    },
			
 
				-    pageOutBasic: function(outClass, outDuration, url) {
			
 
				-      var $this = $(this);
			
 
				-      $this.css({
			
 
				-        "animation-duration": outDuration / 1e3 + "s"
			
 
				-      }).addClass(outClass).animateCallback(function() {
			
 
				-        location.href = url;
			
 
				-      });
			
 
				-    },
			
 
				-    pageOutOverlay: function(outClass, outDuration, url) {
			
 
				-      var _this = this;
			
 
				-      var $this = $(this);
			
 
				-      var options = $this.data(namespace).options;
			
 
				-      var thisInClass = $this.data("animsition-in");
			
 
				-      var inClass = methods.animationCheck.call(_this, thisInClass, true, true);
			
 
				-      $(options.overlayParentElement).children("." + options.overlayClass).css({
			
 
				-        "animation-duration": outDuration / 1e3 + "s"
			
 
				-      }).removeClass(inClass).addClass(outClass).animateCallback(function() {
			
 
				-        $this.css({
			
 
				-          opacity: 0
			
 
				-        });
			
 
				-        location.href = url;
			
 
				-      });
			
 
				-    },
			
 
				-    destroy: function() {
			
 
				-      return this.each(function() {
			
 
				-        var $this = $(this);
			
 
				-        $(window).unbind("." + namespace);
			
 
				-        $this.css({
			
 
				-          opacity: 1
			
 
				-        }).removeData(namespace);
			
 
				-      });
			
 
				-    }
			
 
				-  };
			
 
				-  $.fn.animateCallback = function(callback) {
			
 
				-    var end = "animationend webkitAnimationEnd mozAnimationEnd oAnimationEnd MSAnimationEnd";
			
 
				-    return this.each(function() {
			
 
				-      $(this).bind(end, function() {
			
 
				-        $(this).unbind(end);
			
 
				-        return callback.call(this);
			
 
				-      });
			
 
				-    });
			
 
				-  };
			
 
				-  $.fn.animsition = function(method) {
			
 
				-    if (methods[method]) {
			
 
				-      return methods[method].apply(this, Array.prototype.slice.call(arguments, 1));
			
 
				-    } else if (typeof method === "object" || !method) {
			
 
				-      return methods.init.apply(this, arguments);
			
 
				-    } else {
			
 
				-      $.error("Method " + method + " does not exist on jQuery." + namespace);
			
 
				-    }
			
 
				-  };
			
 
				-})(jQuery);
			
--- a/js/jquery.min.js
+++ b/js/jquery.min.js
--- a/js/mymap.js
+++ b/js/mymap.js
@@ -1,4 +1,4 @@
 
				-var myChart = echarts.init($('.map .geo')[0])
			
 
				+var myChart = echarts.init(document.querySelector('.map .geo'))
			
 
				 var option;
			
 
				 
			
 
				 var data1 = [
			
--- a/js/scoket.js
+++ b/js/scoket.js
@@ -0,0 +1,165 @@
 
				+class socketIO {
			
 
				+  constructor(data, time, url, heartbeat) {
			
 
				+    this.socketTask = null;
			
 
				+    this.is_open_socket = false; //避免重复连接
			
 
				+    this.heartbeat = heartbeat ? heartbeat : 0;
			
 
				+    this.url = url;
			
 
				+    this.data = data ? data : null;
			
 
				+    this.connectNum = 10; // 重连次数
			
 
				+    this.traderDetailIndex = 100; // traderDetailIndex ==2 重连
			
 
				+    this.accountStateIndex = 100; // accountStateIndex ==1 重连
			
 
				+    this.followFlake = true; // followFlake == true 重连
			
 
				+    //心跳检测
			
 
				+    this.timeout = time ? time : 58000; //多少秒执行检测
			
 
				+    this.heartbeatInterval = null; //检测服务器端是否还活着
			
 
				+    this.reconnectTimeOut = null; //重连之后多久再次重连
			
 
				+  }
			
 
				+
			
 
				+  // 进入这个页面的时候创建websocket连接【整个页面随时使用】
			
 
				+  connectSocketInit(data) {
			
 
				+    this.data = data;
			
 
				+    this.socketTask = uni.connectSocket({
			
 
				+      url: this.url,
			
 
				+      success: () => {
			
 
				+        console.log('正准备建立websocket中...');
			
 
				+        // 返回实例
			
 
				+        return this.socketTask;
			
 
				+      }
			
 
				+    });
			
 
				+    this.socketTask.onOpen((res) => {
			
 
				+      this.connectNum = 1;
			
 
				+      console.log('WebSocket连接正常！');
			
 
				+      this.send(data);
			
 
				+      clearInterval(this.reconnectTimeOut);
			
 
				+      clearInterval(this.heartbeatInterval);
			
 
				+      this.is_open_socket = true;
			
 
				+      this.start();
			
 
				+      // 注：只有连接正常打开中 ，才能正常收到消息
			
 
				+      this.socketTask.onMessage((e) => {
			
 
				+        // 字符串转json
			
 
				+        let res = e.data;
			
 
				+        console.log('res---------->', res); // 这里 查看 推送过来的消息
			
 
				+        if (res) {
			
 
				+          uni.$emit('getPositonsOrder', res);
			
 
				+        }
			
 
				+      });
			
 
				+    });
			
 
				+    // 监听连接失败，这里代码我注释掉的原因是因为如果服务器关闭后，和下面的onclose方法一起发起重连操作，这样会导致重复连接
			
 
				+    uni.onSocketError((res) => {
			
 
				+      console.log('WebSocket连接打开失败，请检查！');
			
 
				+      this.socketTask = null;
			
 
				+      this.is_open_socket = false;
			
 
				+      clearInterval(this.heartbeatInterval);
			
 
				+      clearInterval(this.reconnectTimeOut);
			
 
				+      // uni.$off('getPositonsOrder');
			
 
				+      if (this.connectNum < 6) {
			
 
				+        uni.showToast({
			
 
				+          title: `WebSocket连接失败，正尝试第${this.connectNum}次连接`,
			
 
				+          icon: 'none'
			
 
				+        });
			
 
				+        this.reconnect();
			
 
				+        this.connectNum += 1;
			
 
				+      } else {
			
 
				+        uni.$emit('connectError');
			
 
				+        this.connectNum = 1;
			
 
				+      }
			
 
				+    });
			
 
				+    // 这里仅是事件监听【如果socket关闭了会执行】
			
 
				+    this.socketTask.onClose(() => {
			
 
				+      console.log('已经被关闭了-------');
			
 
				+      clearInterval(this.heartbeatInterval);
			
 
				+      clearInterval(this.reconnectTimeOut);
			
 
				+      this.is_open_socket = false;
			
 
				+      this.socketTask = null;
			
 
				+      // uni.$off('getPositonsOrder');
			
 
				+      if (this.connectNum < 6) {
			
 
				+        console.log('执行重连了', this.connectNum);
			
 
				+        this.reconnect();
			
 
				+      } else {
			
 
				+        console.log('没执行重连了', this.connectNum);
			
 
				+        uni.$emit('connectError');
			
 
				+        uni.$off('getPositonsOrder');
			
 
				+        this.connectNum = 1;
			
 
				+      }
			
 
				+    });
			
 
				+  }
			
 
				+  // 主动关闭socket连接
			
 
				+  Close() {
			
 
				+    if (!this.is_open_socket) {
			
 
				+      return;
			
 
				+    }
			
 
				+    this.socketTask.close({
			
 
				+      success() {
			
 
				+        // uni.showToast({
			
 
				+        //   title: 'SocketTask 关闭成功',
			
 
				+        //   icon: 'none'
			
 
				+        // });
			
 
				+      }
			
 
				+    });
			
 
				+  }
			
 
				+  //发送消息
			
 
				+  send(data) {
			
 
				+    console.log('data---------->', data, typeof data);
			
 
				+    // 注：只有连接正常打开中 ，才能正常成功发送消息
			
 
				+    if (this.socketTask) {
			
 
				+      this.socketTask.send({
			
 
				+        data: typeof data === 'object' ? JSON.stringify(data) : data,
			
 
				+        async success() {
			
 
				+          console.log('消息发送成功');
			
 
				+        }
			
 
				+      });
			
 
				+    }
			
 
				+  }
			
 
				+  //开启心跳检测
			
 
				+  start() {
			
 
				+    this.heartbeatInterval = setInterval(() => {
			
 
				+      this.send(this.heartbeat ? this.heartbeat : 0);
			
 
				+    }, this.timeout);
			
 
				+  }
			
 
				+  //重新连接
			
 
				+  reconnect() {
			
 
				+    //停止发送心跳
			
 
				+    clearInterval(this.heartbeatInterval);
			
 
				+    //如果不是人为关闭的话，进行重连
			
 
				+    if (!this.is_open_socket && (this.traderDetailIndex == 2 || this.accountStateIndex == 0 || this.followFlake)) {
			
 
				+      this.reconnectTimeOut = setInterval(() => {
			
 
				+        this.connectSocketInit(this.data);
			
 
				+        console.log('触发重连');
			
 
				+      }, 5000);
			
 
				+    }
			
 
				+  }
			
 
				+  /**
			
 
				+   * @description 将 scoket 数据进行过滤
			
 
				+   * @param {array} array
			
 
				+   * @param {string} type 区分 弹窗 openposition 分为跟随和我的
			
 
				+   */
			
 
				+  arrayFilter(array, type = 'normal', signalId = 0) {
			
 
				+    let arr1 = [];
			
 
				+    let arr2 = [];
			
 
				+    let obj = {
			
 
				+      arr1: [],
			
 
				+      arr2: []
			
 
				+    };
			
 
				+    arr1 = array.filter((v) => v.flwsig == true);
			
 
				+    arr2 = array.filter((v) => v.flwsig == false);
			
 
				+    if (type == 'normal') {
			
 
				+      if (signalId) {
			
 
				+        arr1 = array.filter((v) => v.flwsig == true && v.sigtraderid == signalId);
			
 
				+        return arr1;
			
 
				+      } else {
			
 
				+        return arr1.concat(arr2);
			
 
				+      }
			
 
				+    } else {
			
 
				+      if (signalId > 0) {
			
 
				+        arr1 = array.filter((v) => v.flwsig == true && v.sigtraderid == signalId);
			
 
				+        obj.arr1 = arr1;
			
 
				+      } else {
			
 
				+        obj.arr1 = arr1;
			
 
				+      }
			
 
				+      obj.arr2 = arr2;
			
 
				+
			
 
				+      return obj;
			
 
				+    }
			
 
				+  }
			
 
				+}
			
 
				+module.exports = socketIO;
			
--- a/js/vue.js
+++ b/js/vue.js
--- a/node_modules/asynckit/LICENSE
+++ b/node_modules/asynckit/LICENSE
@@ -0,0 +1,21 @@
 
				+The MIT License (MIT)
			
 
				+
			
 
				+Copyright (c) 2016 Alex Indigo
			
 
				+
			
 
				+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/node_modules/asynckit/README.md
+++ b/node_modules/asynckit/README.md
@@ -0,0 +1,233 @@
 
				+# asynckit [![NPM Module](https://img.shields.io/npm/v/asynckit.svg?style=flat)](https://www.npmjs.com/package/asynckit)
			
 
				+
			
 
				+Minimal async jobs utility library, with streams support.
			
 
				+
			
 
				+[![PhantomJS Build](https://img.shields.io/travis/alexindigo/asynckit/v0.4.0.svg?label=browser&style=flat)](https://travis-ci.org/alexindigo/asynckit)
			
 
				+[![Linux Build](https://img.shields.io/travis/alexindigo/asynckit/v0.4.0.svg?label=linux:0.12-6.x&style=flat)](https://travis-ci.org/alexindigo/asynckit)
			
 
				+[![Windows Build](https://img.shields.io/appveyor/ci/alexindigo/asynckit/v0.4.0.svg?label=windows:0.12-6.x&style=flat)](https://ci.appveyor.com/project/alexindigo/asynckit)
			
 
				+
			
 
				+[![Coverage Status](https://img.shields.io/coveralls/alexindigo/asynckit/v0.4.0.svg?label=code+coverage&style=flat)](https://coveralls.io/github/alexindigo/asynckit?branch=master)
			
 
				+[![Dependency Status](https://img.shields.io/david/alexindigo/asynckit/v0.4.0.svg?style=flat)](https://david-dm.org/alexindigo/asynckit)
			
 
				+[![bitHound Overall Score](https://www.bithound.io/github/alexindigo/asynckit/badges/score.svg)](https://www.bithound.io/github/alexindigo/asynckit)
			
 
				+
			
 
				+<!-- [![Readme](https://img.shields.io/badge/readme-tested-brightgreen.svg?style=flat)](https://www.npmjs.com/package/reamde) -->
			
 
				+
			
 
				+AsyncKit provides harness for `parallel` and `serial` iterators over list of items represented by arrays or objects.
			
 
				+Optionally it accepts abort function (should be synchronously return by iterator for each item), and terminates left over jobs upon an error event. For specific iteration order built-in (`ascending` and `descending`) and custom sort helpers also supported, via `asynckit.serialOrdered` method.
			
 
				+
			
 
				+It ensures async operations to keep behavior more stable and prevent `Maximum call stack size exceeded` errors, from sync iterators.
			
 
				+
			
 
				+| compression        |     size |
			
 
				+| :----------------- | -------: |
			
 
				+| asynckit.js        | 12.34 kB |
			
 
				+| asynckit.min.js    |  4.11 kB |
			
 
				+| asynckit.min.js.gz |  1.47 kB |
			
 
				+
			
 
				+
			
 
				+## Install
			
 
				+
			
 
				+```sh
			
 
				+$ npm install --save asynckit
			
 
				+```
			
 
				+
			
 
				+## Examples
			
 
				+
			
 
				+### Parallel Jobs
			
 
				+
			
 
				+Runs iterator over provided array in parallel. Stores output in the `result` array,
			
 
				+on the matching positions. In unlikely event of an error from one of the jobs,
			
 
				+will terminate rest of the active jobs (if abort function is provided)
			
 
				+and return error along with salvaged data to the main callback function.
			
 
				+
			
 
				+#### Input Array
			
 
				+
			
 
				+```javascript
			
 
				+var parallel = require('asynckit').parallel
			
 
				+  , assert   = require('assert')
			
 
				+  ;
			
 
				+
			
 
				+var source         = [ 1, 1, 4, 16, 64, 32, 8, 2 ]
			
 
				+  , expectedResult = [ 2, 2, 8, 32, 128, 64, 16, 4 ]
			
 
				+  , expectedTarget = [ 1, 1, 2, 4, 8, 16, 32, 64 ]
			
 
				+  , target         = []
			
 
				+  ;
			
 
				+
			
 
				+parallel(source, asyncJob, function(err, result)
			
 
				+{
			
 
				+  assert.deepEqual(result, expectedResult);
			
 
				+  assert.deepEqual(target, expectedTarget);
			
 
				+});
			
 
				+
			
 
				+// async job accepts one element from the array
			
 
				+// and a callback function
			
 
				+function asyncJob(item, cb)
			
 
				+{
			
 
				+  // different delays (in ms) per item
			
 
				+  var delay = item * 25;
			
 
				+
			
 
				+  // pretend different jobs take different time to finish
			
 
				+  // and not in consequential order
			
 
				+  var timeoutId = setTimeout(function() {
			
 
				+    target.push(item);
			
 
				+    cb(null, item * 2);
			
 
				+  }, delay);
			
 
				+
			
 
				+  // allow to cancel "leftover" jobs upon error
			
 
				+  // return function, invoking of which will abort this job
			
 
				+  return clearTimeout.bind(null, timeoutId);
			
 
				+}
			
 
				+```
			
 
				+
			
 
				+More examples could be found in [test/test-parallel-array.js](test/test-parallel-array.js).
			
 
				+
			
 
				+#### Input Object
			
 
				+
			
 
				+Also it supports named jobs, listed via object.
			
 
				+
			
 
				+```javascript
			
 
				+var parallel = require('asynckit/parallel')
			
 
				+  , assert   = require('assert')
			
 
				+  ;
			
 
				+
			
 
				+var source         = { first: 1, one: 1, four: 4, sixteen: 16, sixtyFour: 64, thirtyTwo: 32, eight: 8, two: 2 }
			
 
				+  , expectedResult = { first: 2, one: 2, four: 8, sixteen: 32, sixtyFour: 128, thirtyTwo: 64, eight: 16, two: 4 }
			
 
				+  , expectedTarget = [ 1, 1, 2, 4, 8, 16, 32, 64 ]
			
 
				+  , expectedKeys   = [ 'first', 'one', 'two', 'four', 'eight', 'sixteen', 'thirtyTwo', 'sixtyFour' ]
			
 
				+  , target         = []
			
 
				+  , keys           = []
			
 
				+  ;
			
 
				+
			
 
				+parallel(source, asyncJob, function(err, result)
			
 
				+{
			
 
				+  assert.deepEqual(result, expectedResult);
			
 
				+  assert.deepEqual(target, expectedTarget);
			
 
				+  assert.deepEqual(keys, expectedKeys);
			
 
				+});
			
 
				+
			
 
				+// supports full value, key, callback (shortcut) interface
			
 
				+function asyncJob(item, key, cb)
			
 
				+{
			
 
				+  // different delays (in ms) per item
			
 
				+  var delay = item * 25;
			
 
				+
			
 
				+  // pretend different jobs take different time to finish
			
 
				+  // and not in consequential order
			
 
				+  var timeoutId = setTimeout(function() {
			
 
				+    keys.push(key);
			
 
				+    target.push(item);
			
 
				+    cb(null, item * 2);
			
 
				+  }, delay);
			
 
				+
			
 
				+  // allow to cancel "leftover" jobs upon error
			
 
				+  // return function, invoking of which will abort this job
			
 
				+  return clearTimeout.bind(null, timeoutId);
			
 
				+}
			
 
				+```
			
 
				+
			
 
				+More examples could be found in [test/test-parallel-object.js](test/test-parallel-object.js).
			
 
				+
			
 
				+### Serial Jobs
			
 
				+
			
 
				+Runs iterator over provided array sequentially. Stores output in the `result` array,
			
 
				+on the matching positions. In unlikely event of an error from one of the jobs,
			
 
				+will not proceed to the rest of the items in the list
			
 
				+and return error along with salvaged data to the main callback function.
			
 
				+
			
 
				+#### Input Array
			
 
				+
			
 
				+```javascript
			
 
				+var serial = require('asynckit/serial')
			
 
				+  , assert = require('assert')
			
 
				+  ;
			
 
				+
			
 
				+var source         = [ 1, 1, 4, 16, 64, 32, 8, 2 ]
			
 
				+  , expectedResult = [ 2, 2, 8, 32, 128, 64, 16, 4 ]
			
 
				+  , expectedTarget = [ 0, 1, 2, 3, 4, 5, 6, 7 ]
			
 
				+  , target         = []
			
 
				+  ;
			
 
				+
			
 
				+serial(source, asyncJob, function(err, result)
			
 
				+{
			
 
				+  assert.deepEqual(result, expectedResult);
			
 
				+  assert.deepEqual(target, expectedTarget);
			
 
				+});
			
 
				+
			
 
				+// extended interface (item, key, callback)
			
 
				+// also supported for arrays
			
 
				+function asyncJob(item, key, cb)
			
 
				+{
			
 
				+  target.push(key);
			
 
				+
			
 
				+  // it will be automatically made async
			
 
				+  // even it iterator "returns" in the same event loop
			
 
				+  cb(null, item * 2);
			
 
				+}
			
 
				+```
			
 
				+
			
 
				+More examples could be found in [test/test-serial-array.js](test/test-serial-array.js).
			
 
				+
			
 
				+#### Input Object
			
 
				+
			
 
				+Also it supports named jobs, listed via object.
			
 
				+
			
 
				+```javascript
			
 
				+var serial = require('asynckit').serial
			
 
				+  , assert = require('assert')
			
 
				+  ;
			
 
				+
			
 
				+var source         = [ 1, 1, 4, 16, 64, 32, 8, 2 ]
			
 
				+  , expectedResult = [ 2, 2, 8, 32, 128, 64, 16, 4 ]
			
 
				+  , expectedTarget = [ 0, 1, 2, 3, 4, 5, 6, 7 ]
			
 
				+  , target         = []
			
 
				+  ;
			
 
				+
			
 
				+var source         = { first: 1, one: 1, four: 4, sixteen: 16, sixtyFour: 64, thirtyTwo: 32, eight: 8, two: 2 }
			
 
				+  , expectedResult = { first: 2, one: 2, four: 8, sixteen: 32, sixtyFour: 128, thirtyTwo: 64, eight: 16, two: 4 }
			
 
				+  , expectedTarget = [ 1, 1, 4, 16, 64, 32, 8, 2 ]
			
 
				+  , target         = []
			
 
				+  ;
			
 
				+
			
 
				+
			
 
				+serial(source, asyncJob, function(err, result)
			
 
				+{
			
 
				+  assert.deepEqual(result, expectedResult);
			
 
				+  assert.deepEqual(target, expectedTarget);
			
 
				+});
			
 
				+
			
 
				+// shortcut interface (item, callback)
			
 
				+// works for object as well as for the arrays
			
 
				+function asyncJob(item, cb)
			
 
				+{
			
 
				+  target.push(item);
			
 
				+
			
 
				+  // it will be automatically made async
			
 
				+  // even it iterator "returns" in the same event loop
			
 
				+  cb(null, item * 2);
			
 
				+}
			
 
				+```
			
 
				+
			
 
				+More examples could be found in [test/test-serial-object.js](test/test-serial-object.js).
			
 
				+
			
 
				+_Note: Since _object_ is an _unordered_ collection of properties,
			
 
				+it may produce unexpected results with sequential iterations.
			
 
				+Whenever order of the jobs' execution is important please use `serialOrdered` method._
			
 
				+
			
 
				+### Ordered Serial Iterations
			
 
				+
			
 
				+TBD
			
 
				+
			
 
				+For example [compare-property](compare-property) package.
			
 
				+
			
 
				+### Streaming interface
			
 
				+
			
 
				+TBD
			
 
				+
			
 
				+## Want to Know More?
			
 
				+
			
 
				+More examples can be found in [test folder](test/).
			
 
				+
			
 
				+Or open an [issue](https://github.com/alexindigo/asynckit/issues) with questions and/or suggestions.
			
 
				+
			
 
				+## License
			
 
				+
			
 
				+AsyncKit is licensed under the MIT license.
			
--- a/node_modules/asynckit/bench.js
+++ b/node_modules/asynckit/bench.js
@@ -0,0 +1,76 @@
 
				+/* eslint no-console: "off" */
			
 
				+
			
 
				+var asynckit = require('./')
			
 
				+  , async    = require('async')
			
 
				+  , assert   = require('assert')
			
 
				+  , expected = 0
			
 
				+  ;
			
 
				+
			
 
				+var Benchmark = require('benchmark');
			
 
				+var suite = new Benchmark.Suite;
			
 
				+
			
 
				+var source = [];
			
 
				+for (var z = 1; z < 100; z++)
			
 
				+{
			
 
				+  source.push(z);
			
 
				+  expected += z;
			
 
				+}
			
 
				+
			
 
				+suite
			
 
				+// add tests
			
 
				+
			
 
				+.add('async.map', function(deferred)
			
 
				+{
			
 
				+  var total = 0;
			
 
				+
			
 
				+  async.map(source,
			
 
				+  function(i, cb)
			
 
				+  {
			
 
				+    setImmediate(function()
			
 
				+    {
			
 
				+      total += i;
			
 
				+      cb(null, total);
			
 
				+    });
			
 
				+  },
			
 
				+  function(err, result)
			
 
				+  {
			
 
				+    assert.ifError(err);
			
 
				+    assert.equal(result[result.length - 1], expected);
			
 
				+    deferred.resolve();
			
 
				+  });
			
 
				+}, {'defer': true})
			
 
				+
			
 
				+
			
 
				+.add('asynckit.parallel', function(deferred)
			
 
				+{
			
 
				+  var total = 0;
			
 
				+
			
 
				+  asynckit.parallel(source,
			
 
				+  function(i, cb)
			
 
				+  {
			
 
				+    setImmediate(function()
			
 
				+    {
			
 
				+      total += i;
			
 
				+      cb(null, total);
			
 
				+    });
			
 
				+  },
			
 
				+  function(err, result)
			
 
				+  {
			
 
				+    assert.ifError(err);
			
 
				+    assert.equal(result[result.length - 1], expected);
			
 
				+    deferred.resolve();
			
 
				+  });
			
 
				+}, {'defer': true})
			
 
				+
			
 
				+
			
 
				+// add listeners
			
 
				+.on('cycle', function(ev)
			
 
				+{
			
 
				+  console.log(String(ev.target));
			
 
				+})
			
 
				+.on('complete', function()
			
 
				+{
			
 
				+  console.log('Fastest is ' + this.filter('fastest').map('name'));
			
 
				+})
			
 
				+// run async
			
 
				+.run({ 'async': true });
			
--- a/node_modules/asynckit/index.js
+++ b/node_modules/asynckit/index.js
@@ -0,0 +1,6 @@
 
				+module.exports =
			
 
				+{
			
 
				+  parallel      : require('./parallel.js'),
			
 
				+  serial        : require('./serial.js'),
			
 
				+  serialOrdered : require('./serialOrdered.js')
			
 
				+};
			
--- a/node_modules/asynckit/lib/abort.js
+++ b/node_modules/asynckit/lib/abort.js
@@ -0,0 +1,29 @@
 
				+// API
			
 
				+module.exports = abort;
			
 
				+
			
 
				+/**
			
 
				+ * Aborts leftover active jobs
			
 
				+ *
			
 
				+ * @param {object} state - current state object
			
 
				+ */
			
 
				+function abort(state)
			
 
				+{
			
 
				+  Object.keys(state.jobs).forEach(clean.bind(state));
			
 
				+
			
 
				+  // reset leftover jobs
			
 
				+  state.jobs = {};
			
 
				+}
			
 
				+
			
 
				+/**
			
 
				+ * Cleans up leftover job by invoking abort function for the provided job id
			
 
				+ *
			
 
				+ * @this  state
			
 
				+ * @param {string|number} key - job id to abort
			
 
				+ */
			
 
				+function clean(key)
			
 
				+{
			
 
				+  if (typeof this.jobs[key] == 'function')
			
 
				+  {
			
 
				+    this.jobs[key]();
			
 
				+  }
			
 
				+}
			
--- a/node_modules/asynckit/lib/async.js
+++ b/node_modules/asynckit/lib/async.js
@@ -0,0 +1,34 @@
 
				+var defer = require('./defer.js');
			
 
				+
			
 
				+// API
			
 
				+module.exports = async;
			
 
				+
			
 
				+/**
			
 
				+ * Runs provided callback asynchronously
			
 
				+ * even if callback itself is not
			
 
				+ *
			
 
				+ * @param   {function} callback - callback to invoke
			
 
				+ * @returns {function} - augmented callback
			
 
				+ */
			
 
				+function async(callback)
			
 
				+{
			
 
				+  var isAsync = false;
			
 
				+
			
 
				+  // check if async happened
			
 
				+  defer(function() { isAsync = true; });
			
 
				+
			
 
				+  return function async_callback(err, result)
			
 
				+  {
			
 
				+    if (isAsync)
			
 
				+    {
			
 
				+      callback(err, result);
			
 
				+    }
			
 
				+    else
			
 
				+    {
			
 
				+      defer(function nextTick_callback()
			
 
				+      {
			
 
				+        callback(err, result);
			
 
				+      });
			
 
				+    }
			
 
				+  };
			
 
				+}
			
--- a/node_modules/asynckit/lib/defer.js
+++ b/node_modules/asynckit/lib/defer.js
@@ -0,0 +1,26 @@
 
				+module.exports = defer;
			
 
				+
			
 
				+/**
			
 
				+ * Runs provided function on next iteration of the event loop
			
 
				+ *
			
 
				+ * @param {function} fn - function to run
			
 
				+ */
			
 
				+function defer(fn)
			
 
				+{
			
 
				+  var nextTick = typeof setImmediate == 'function'
			
 
				+    ? setImmediate
			
 
				+    : (
			
 
				+      typeof process == 'object' && typeof process.nextTick == 'function'
			
 
				+      ? process.nextTick
			
 
				+      : null
			
 
				+    );
			
 
				+
			
 
				+  if (nextTick)
			
 
				+  {
			
 
				+    nextTick(fn);
			
 
				+  }
			
 
				+  else
			
 
				+  {
			
 
				+    setTimeout(fn, 0);
			
 
				+  }
			
 
				+}
			
--- a/node_modules/asynckit/lib/iterate.js
+++ b/node_modules/asynckit/lib/iterate.js
@@ -0,0 +1,75 @@
 
				+var async = require('./async.js')
			
 
				+  , abort = require('./abort.js')
			
 
				+  ;
			
 
				+
			
 
				+// API
			
 
				+module.exports = iterate;
			
 
				+
			
 
				+/**
			
 
				+ * Iterates over each job object
			
 
				+ *
			
 
				+ * @param {array|object} list - array or object (named list) to iterate over
			
 
				+ * @param {function} iterator - iterator to run
			
 
				+ * @param {object} state - current job status
			
 
				+ * @param {function} callback - invoked when all elements processed
			
 
				+ */
			
 
				+function iterate(list, iterator, state, callback)
			
 
				+{
			
 
				+  // store current index
			
 
				+  var key = state['keyedList'] ? state['keyedList'][state.index] : state.index;
			
 
				+
			
 
				+  state.jobs[key] = runJob(iterator, key, list[key], function(error, output)
			
 
				+  {
			
 
				+    // don't repeat yourself
			
 
				+    // skip secondary callbacks
			
 
				+    if (!(key in state.jobs))
			
 
				+    {
			
 
				+      return;
			
 
				+    }
			
 
				+
			
 
				+    // clean up jobs
			
 
				+    delete state.jobs[key];
			
 
				+
			
 
				+    if (error)
			
 
				+    {
			
 
				+      // don't process rest of the results
			
 
				+      // stop still active jobs
			
 
				+      // and reset the list
			
 
				+      abort(state);
			
 
				+    }
			
 
				+    else
			
 
				+    {
			
 
				+      state.results[key] = output;
			
 
				+    }
			
 
				+
			
 
				+    // return salvaged results
			
 
				+    callback(error, state.results);
			
 
				+  });
			
 
				+}
			
 
				+
			
 
				+/**
			
 
				+ * Runs iterator over provided job element
			
 
				+ *
			
 
				+ * @param   {function} iterator - iterator to invoke
			
 
				+ * @param   {string|number} key - key/index of the element in the list of jobs
			
 
				+ * @param   {mixed} item - job description
			
 
				+ * @param   {function} callback - invoked after iterator is done with the job
			
 
				+ * @returns {function|mixed} - job abort function or something else
			
 
				+ */
			
 
				+function runJob(iterator, key, item, callback)
			
 
				+{
			
 
				+  var aborter;
			
 
				+
			
 
				+  // allow shortcut if iterator expects only two arguments
			
 
				+  if (iterator.length == 2)
			
 
				+  {
			
 
				+    aborter = iterator(item, async(callback));
			
 
				+  }
			
 
				+  // otherwise go with full three arguments
			
 
				+  else
			
 
				+  {
			
 
				+    aborter = iterator(item, key, async(callback));
			
 
				+  }
			
 
				+
			
 
				+  return aborter;
			
 
				+}
			
--- a/node_modules/asynckit/lib/readable_asynckit.js
+++ b/node_modules/asynckit/lib/readable_asynckit.js
@@ -0,0 +1,91 @@
 
				+var streamify = require('./streamify.js')
			
 
				+  , defer     = require('./defer.js')
			
 
				+  ;
			
 
				+
			
 
				+// API
			
 
				+module.exports = ReadableAsyncKit;
			
 
				+
			
 
				+/**
			
 
				+ * Base constructor for all streams
			
 
				+ * used to hold properties/methods
			
 
				+ */
			
 
				+function ReadableAsyncKit()
			
 
				+{
			
 
				+  ReadableAsyncKit.super_.apply(this, arguments);
			
 
				+
			
 
				+  // list of active jobs
			
 
				+  this.jobs = {};
			
 
				+
			
 
				+  // add stream methods
			
 
				+  this.destroy = destroy;
			
 
				+  this._start  = _start;
			
 
				+  this._read   = _read;
			
 
				+}
			
 
				+
			
 
				+/**
			
 
				+ * Destroys readable stream,
			
 
				+ * by aborting outstanding jobs
			
 
				+ *
			
 
				+ * @returns {void}
			
 
				+ */
			
 
				+function destroy()
			
 
				+{
			
 
				+  if (this.destroyed)
			
 
				+  {
			
 
				+    return;
			
 
				+  }
			
 
				+
			
 
				+  this.destroyed = true;
			
 
				+
			
 
				+  if (typeof this.terminator == 'function')
			
 
				+  {
			
 
				+    this.terminator();
			
 
				+  }
			
 
				+}
			
 
				+
			
 
				+/**
			
 
				+ * Starts provided jobs in async manner
			
 
				+ *
			
 
				+ * @private
			
 
				+ */
			
 
				+function _start()
			
 
				+{
			
 
				+  // first argument – runner function
			
 
				+  var runner = arguments[0]
			
 
				+    // take away first argument
			
 
				+    , args   = Array.prototype.slice.call(arguments, 1)
			
 
				+      // second argument - input data
			
 
				+    , input  = args[0]
			
 
				+      // last argument - result callback
			
 
				+    , endCb  = streamify.callback.call(this, args[args.length - 1])
			
 
				+    ;
			
 
				+
			
 
				+  args[args.length - 1] = endCb;
			
 
				+  // third argument - iterator
			
 
				+  args[1] = streamify.iterator.call(this, args[1]);
			
 
				+
			
 
				+  // allow time for proper setup
			
 
				+  defer(function()
			
 
				+  {
			
 
				+    if (!this.destroyed)
			
 
				+    {
			
 
				+      this.terminator = runner.apply(null, args);
			
 
				+    }
			
 
				+    else
			
 
				+    {
			
 
				+      endCb(null, Array.isArray(input) ? [] : {});
			
 
				+    }
			
 
				+  }.bind(this));
			
 
				+}
			
 
				+
			
 
				+
			
 
				+/**
			
 
				+ * Implement _read to comply with Readable streams
			
 
				+ * Doesn't really make sense for flowing object mode
			
 
				+ *
			
 
				+ * @private
			
 
				+ */
			
 
				+function _read()
			
 
				+{
			
 
				+
			
 
				+}
			
--- a/node_modules/asynckit/lib/readable_parallel.js
+++ b/node_modules/asynckit/lib/readable_parallel.js
@@ -0,0 +1,25 @@
 
				+var parallel = require('../parallel.js');
			
 
				+
			
 
				+// API
			
 
				+module.exports = ReadableParallel;
			
 
				+
			
 
				+/**
			
 
				+ * Streaming wrapper to `asynckit.parallel`
			
 
				+ *
			
 
				+ * @param   {array|object} list - array or object (named list) to iterate over
			
 
				+ * @param   {function} iterator - iterator to run
			
 
				+ * @param   {function} callback - invoked when all elements processed
			
 
				+ * @returns {stream.Readable#}
			
 
				+ */
			
 
				+function ReadableParallel(list, iterator, callback)
			
 
				+{
			
 
				+  if (!(this instanceof ReadableParallel))
			
 
				+  {
			
 
				+    return new ReadableParallel(list, iterator, callback);
			
 
				+  }
			
 
				+
			
 
				+  // turn on object mode
			
 
				+  ReadableParallel.super_.call(this, {objectMode: true});
			
 
				+
			
 
				+  this._start(parallel, list, iterator, callback);
			
 
				+}
			
--- a/node_modules/asynckit/lib/readable_serial.js
+++ b/node_modules/asynckit/lib/readable_serial.js
@@ -0,0 +1,25 @@
 
				+var serial = require('../serial.js');
			
 
				+
			
 
				+// API
			
 
				+module.exports = ReadableSerial;
			
 
				+
			
 
				+/**
			
 
				+ * Streaming wrapper to `asynckit.serial`
			
 
				+ *
			
 
				+ * @param   {array|object} list - array or object (named list) to iterate over
			
 
				+ * @param   {function} iterator - iterator to run
			
 
				+ * @param   {function} callback - invoked when all elements processed
			
 
				+ * @returns {stream.Readable#}
			
 
				+ */
			
 
				+function ReadableSerial(list, iterator, callback)
			
 
				+{
			
 
				+  if (!(this instanceof ReadableSerial))
			
 
				+  {
			
 
				+    return new ReadableSerial(list, iterator, callback);
			
 
				+  }
			
 
				+
			
 
				+  // turn on object mode
			
 
				+  ReadableSerial.super_.call(this, {objectMode: true});
			
 
				+
			
 
				+  this._start(serial, list, iterator, callback);
			
 
				+}
			
--- a/node_modules/asynckit/lib/readable_serial_ordered.js
+++ b/node_modules/asynckit/lib/readable_serial_ordered.js
@@ -0,0 +1,29 @@
 
				+var serialOrdered = require('../serialOrdered.js');
			
 
				+
			
 
				+// API
			
 
				+module.exports = ReadableSerialOrdered;
			
 
				+// expose sort helpers
			
 
				+module.exports.ascending  = serialOrdered.ascending;
			
 
				+module.exports.descending = serialOrdered.descending;
			
 
				+
			
 
				+/**
			
 
				+ * Streaming wrapper to `asynckit.serialOrdered`
			
 
				+ *
			
 
				+ * @param   {array|object} list - array or object (named list) to iterate over
			
 
				+ * @param   {function} iterator - iterator to run
			
 
				+ * @param   {function} sortMethod - custom sort function
			
 
				+ * @param   {function} callback - invoked when all elements processed
			
 
				+ * @returns {stream.Readable#}
			
 
				+ */
			
 
				+function ReadableSerialOrdered(list, iterator, sortMethod, callback)
			
 
				+{
			
 
				+  if (!(this instanceof ReadableSerialOrdered))
			
 
				+  {
			
 
				+    return new ReadableSerialOrdered(list, iterator, sortMethod, callback);
			
 
				+  }
			
 
				+
			
 
				+  // turn on object mode
			
 
				+  ReadableSerialOrdered.super_.call(this, {objectMode: true});
			
 
				+
			
 
				+  this._start(serialOrdered, list, iterator, sortMethod, callback);
			
 
				+}
			
--- a/node_modules/asynckit/lib/state.js
+++ b/node_modules/asynckit/lib/state.js
@@ -0,0 +1,37 @@
 
				+// API
			
 
				+module.exports = state;
			
 
				+
			
 
				+/**
			
 
				+ * Creates initial state object
			
 
				+ * for iteration over list
			
 
				+ *
			
 
				+ * @param   {array|object} list - list to iterate over
			
 
				+ * @param   {function|null} sortMethod - function to use for keys sort,
			
 
				+ *                                     or `null` to keep them as is
			
 
				+ * @returns {object} - initial state object
			
 
				+ */
			
 
				+function state(list, sortMethod)
			
 
				+{
			
 
				+  var isNamedList = !Array.isArray(list)
			
 
				+    , initState =
			
 
				+    {
			
 
				+      index    : 0,
			
 
				+      keyedList: isNamedList || sortMethod ? Object.keys(list) : null,
			
 
				+      jobs     : {},
			
 
				+      results  : isNamedList ? {} : [],
			
 
				+      size     : isNamedList ? Object.keys(list).length : list.length
			
 
				+    }
			
 
				+    ;
			
 
				+
			
 
				+  if (sortMethod)
			
 
				+  {
			
 
				+    // sort array keys based on it's values
			
 
				+    // sort object's keys just on own merit
			
 
				+    initState.keyedList.sort(isNamedList ? sortMethod : function(a, b)
			
 
				+    {
			
 
				+      return sortMethod(list[a], list[b]);
			
 
				+    });
			
 
				+  }
			
 
				+
			
 
				+  return initState;
			
 
				+}
			
--- a/node_modules/asynckit/lib/streamify.js
+++ b/node_modules/asynckit/lib/streamify.js
@@ -0,0 +1,141 @@
 
				+var async = require('./async.js');
			
 
				+
			
 
				+// API
			
 
				+module.exports = {
			
 
				+  iterator: wrapIterator,
			
 
				+  callback: wrapCallback
			
 
				+};
			
 
				+
			
 
				+/**
			
 
				+ * Wraps iterators with long signature
			
 
				+ *
			
 
				+ * @this    ReadableAsyncKit#
			
 
				+ * @param   {function} iterator - function to wrap
			
 
				+ * @returns {function} - wrapped function
			
 
				+ */
			
 
				+function wrapIterator(iterator)
			
 
				+{
			
 
				+  var stream = this;
			
 
				+
			
 
				+  return function(item, key, cb)
			
 
				+  {
			
 
				+    var aborter
			
 
				+      , wrappedCb = async(wrapIteratorCallback.call(stream, cb, key))
			
 
				+      ;
			
 
				+
			
 
				+    stream.jobs[key] = wrappedCb;
			
 
				+
			
 
				+    // it's either shortcut (item, cb)
			
 
				+    if (iterator.length == 2)
			
 
				+    {
			
 
				+      aborter = iterator(item, wrappedCb);
			
 
				+    }
			
 
				+    // or long format (item, key, cb)
			
 
				+    else
			
 
				+    {
			
 
				+      aborter = iterator(item, key, wrappedCb);
			
 
				+    }
			
 
				+
			
 
				+    return aborter;
			
 
				+  };
			
 
				+}
			
 
				+
			
 
				+/**
			
 
				+ * Wraps provided callback function
			
 
				+ * allowing to execute snitch function before
			
 
				+ * real callback
			
 
				+ *
			
 
				+ * @this    ReadableAsyncKit#
			
 
				+ * @param   {function} callback - function to wrap
			
 
				+ * @returns {function} - wrapped function
			
 
				+ */
			
 
				+function wrapCallback(callback)
			
 
				+{
			
 
				+  var stream = this;
			
 
				+
			
 
				+  var wrapped = function(error, result)
			
 
				+  {
			
 
				+    return finisher.call(stream, error, result, callback);
			
 
				+  };
			
 
				+
			
 
				+  return wrapped;
			
 
				+}
			
 
				+
			
 
				+/**
			
 
				+ * Wraps provided iterator callback function
			
 
				+ * makes sure snitch only called once,
			
 
				+ * but passes secondary calls to the original callback
			
 
				+ *
			
 
				+ * @this    ReadableAsyncKit#
			
 
				+ * @param   {function} callback - callback to wrap
			
 
				+ * @param   {number|string} key - iteration key
			
 
				+ * @returns {function} wrapped callback
			
 
				+ */
			
 
				+function wrapIteratorCallback(callback, key)
			
 
				+{
			
 
				+  var stream = this;
			
 
				+
			
 
				+  return function(error, output)
			
 
				+  {
			
 
				+    // don't repeat yourself
			
 
				+    if (!(key in stream.jobs))
			
 
				+    {
			
 
				+      callback(error, output);
			
 
				+      return;
			
 
				+    }
			
 
				+
			
 
				+    // clean up jobs
			
 
				+    delete stream.jobs[key];
			
 
				+
			
 
				+    return streamer.call(stream, error, {key: key, value: output}, callback);
			
 
				+  };
			
 
				+}
			
 
				+
			
 
				+/**
			
 
				+ * Stream wrapper for iterator callback
			
 
				+ *
			
 
				+ * @this  ReadableAsyncKit#
			
 
				+ * @param {mixed} error - error response
			
 
				+ * @param {mixed} output - iterator output
			
 
				+ * @param {function} callback - callback that expects iterator results
			
 
				+ */
			
 
				+function streamer(error, output, callback)
			
 
				+{
			
 
				+  if (error && !this.error)
			
 
				+  {
			
 
				+    this.error = error;
			
 
				+    this.pause();
			
 
				+    this.emit('error', error);
			
 
				+    // send back value only, as expected
			
 
				+    callback(error, output && output.value);
			
 
				+    return;
			
 
				+  }
			
 
				+
			
 
				+  // stream stuff
			
 
				+  this.push(output);
			
 
				+
			
 
				+  // back to original track
			
 
				+  // send back value only, as expected
			
 
				+  callback(error, output && output.value);
			
 
				+}
			
 
				+
			
 
				+/**
			
 
				+ * Stream wrapper for finishing callback
			
 
				+ *
			
 
				+ * @this  ReadableAsyncKit#
			
 
				+ * @param {mixed} error - error response
			
 
				+ * @param {mixed} output - iterator output
			
 
				+ * @param {function} callback - callback that expects final results
			
 
				+ */
			
 
				+function finisher(error, output, callback)
			
 
				+{
			
 
				+  // signal end of the stream
			
 
				+  // only for successfully finished streams
			
 
				+  if (!error)
			
 
				+  {
			
 
				+    this.push(null);
			
 
				+  }
			
 
				+
			
 
				+  // back to original track
			
 
				+  callback(error, output);
			
 
				+}
			
--- a/node_modules/asynckit/lib/terminator.js
+++ b/node_modules/asynckit/lib/terminator.js
@@ -0,0 +1,29 @@
 
				+var abort = require('./abort.js')
			
 
				+  , async = require('./async.js')
			
 
				+  ;
			
 
				+
			
 
				+// API
			
 
				+module.exports = terminator;
			
 
				+
			
 
				+/**
			
 
				+ * Terminates jobs in the attached state context
			
 
				+ *
			
 
				+ * @this  AsyncKitState#
			
 
				+ * @param {function} callback - final callback to invoke after termination
			
 
				+ */
			
 
				+function terminator(callback)
			
 
				+{
			
 
				+  if (!Object.keys(this.jobs).length)
			
 
				+  {
			
 
				+    return;
			
 
				+  }
			
 
				+
			
 
				+  // fast forward iteration index
			
 
				+  this.index = this.size;
			
 
				+
			
 
				+  // abort jobs
			
 
				+  abort(this);
			
 
				+
			
 
				+  // send back results we have so far
			
 
				+  async(callback)(null, this.results);
			
 
				+}
			
--- a/node_modules/asynckit/package.json
+++ b/node_modules/asynckit/package.json
@@ -0,0 +1,91 @@
 
				+{
			
 
				+  "_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"
			
 
				+  },
			
 
				+  "_requiredBy": [
			
 
				+    "/form-data"
			
 
				+  ],
			
 
				+  "_resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
			
 
				+  "_shasum": "c79ed97f7f34cb8f2ba1bc9790bcc366474b4b79",
			
 
				+  "_spec": "asynckit@^0.4.0",
			
 
				+  "_where": "C:\\Users\\10070\\Desktop\\gitProgram\\h5\\wdkl_screen\\node_modules\\form-data",
			
 
				+  "author": {
			
 
				+    "name": "Alex Indigo",
			
 
				+    "email": "iam@alexindigo.com"
			
 
				+  },
			
 
				+  "bugs": {
			
 
				+    "url": "https://github.com/alexindigo/asynckit/issues"
			
 
				+  },
			
 
				+  "bundleDependencies": false,
			
 
				+  "dependencies": {},
			
 
				+  "deprecated": false,
			
 
				+  "description": "Minimal async jobs utility library, with streams support",
			
 
				+  "devDependencies": {
			
 
				+    "browserify": "^13.0.0",
			
 
				+    "browserify-istanbul": "^2.0.0",
			
 
				+    "coveralls": "^2.11.9",
			
 
				+    "eslint": "^2.9.0",
			
 
				+    "istanbul": "^0.4.3",
			
 
				+    "obake": "^0.1.2",
			
 
				+    "phantomjs-prebuilt": "^2.1.7",
			
 
				+    "pre-commit": "^1.1.3",
			
 
				+    "reamde": "^1.1.0",
			
 
				+    "rimraf": "^2.5.2",
			
 
				+    "size-table": "^0.2.0",
			
 
				+    "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"
			
 
				+}
			
--- a/node_modules/asynckit/parallel.js
+++ b/node_modules/asynckit/parallel.js
@@ -0,0 +1,43 @@
 
				+var iterate    = require('./lib/iterate.js')
			
 
				+  , initState  = require('./lib/state.js')
			
 
				+  , terminator = require('./lib/terminator.js')
			
 
				+  ;
			
 
				+
			
 
				+// Public API
			
 
				+module.exports = parallel;
			
 
				+
			
 
				+/**
			
 
				+ * Runs iterator over provided array elements in parallel
			
 
				+ *
			
 
				+ * @param   {array|object} list - array or object (named list) to iterate over
			
 
				+ * @param   {function} iterator - iterator to run
			
 
				+ * @param   {function} callback - invoked when all elements processed
			
 
				+ * @returns {function} - jobs terminator
			
 
				+ */
			
 
				+function parallel(list, iterator, callback)
			
 
				+{
			
 
				+  var state = initState(list);
			
 
				+
			
 
				+  while (state.index < (state['keyedList'] || list).length)
			
 
				+  {
			
 
				+    iterate(list, iterator, state, function(error, result)
			
 
				+    {
			
 
				+      if (error)
			
 
				+      {
			
 
				+        callback(error, result);
			
 
				+        return;
			
 
				+      }
			
 
				+
			
 
				+      // looks like it's the last one
			
 
				+      if (Object.keys(state.jobs).length === 0)
			
 
				+      {
			
 
				+        callback(null, state.results);
			
 
				+        return;
			
 
				+      }
			
 
				+    });
			
 
				+
			
 
				+    state.index++;
			
 
				+  }
			
 
				+
			
 
				+  return terminator.bind(state, callback);
			
 
				+}
			
--- a/node_modules/asynckit/serial.js
+++ b/node_modules/asynckit/serial.js
@@ -0,0 +1,17 @@
 
				+var serialOrdered = require('./serialOrdered.js');
			
 
				+
			
 
				+// Public API
			
 
				+module.exports = serial;
			
 
				+
			
 
				+/**
			
 
				+ * Runs iterator over provided array elements in series
			
 
				+ *
			
 
				+ * @param   {array|object} list - array or object (named list) to iterate over
			
 
				+ * @param   {function} iterator - iterator to run
			
 
				+ * @param   {function} callback - invoked when all elements processed
			
 
				+ * @returns {function} - jobs terminator
			
 
				+ */
			
 
				+function serial(list, iterator, callback)
			
 
				+{
			
 
				+  return serialOrdered(list, iterator, null, callback);
			
 
				+}
			
--- a/node_modules/asynckit/serialOrdered.js
+++ b/node_modules/asynckit/serialOrdered.js
@@ -0,0 +1,75 @@
 
				+var iterate    = require('./lib/iterate.js')
			
 
				+  , initState  = require('./lib/state.js')
			
 
				+  , terminator = require('./lib/terminator.js')
			
 
				+  ;
			
 
				+
			
 
				+// Public API
			
 
				+module.exports = serialOrdered;
			
 
				+// sorting helpers
			
 
				+module.exports.ascending  = ascending;
			
 
				+module.exports.descending = descending;
			
 
				+
			
 
				+/**
			
 
				+ * Runs iterator over provided sorted array elements in series
			
 
				+ *
			
 
				+ * @param   {array|object} list - array or object (named list) to iterate over
			
 
				+ * @param   {function} iterator - iterator to run
			
 
				+ * @param   {function} sortMethod - custom sort function
			
 
				+ * @param   {function} callback - invoked when all elements processed
			
 
				+ * @returns {function} - jobs terminator
			
 
				+ */
			
 
				+function serialOrdered(list, iterator, sortMethod, callback)
			
 
				+{
			
 
				+  var state = initState(list, sortMethod);
			
 
				+
			
 
				+  iterate(list, iterator, state, function iteratorHandler(error, result)
			
 
				+  {
			
 
				+    if (error)
			
 
				+    {
			
 
				+      callback(error, result);
			
 
				+      return;
			
 
				+    }
			
 
				+
			
 
				+    state.index++;
			
 
				+
			
 
				+    // are we there yet?
			
 
				+    if (state.index < (state['keyedList'] || list).length)
			
 
				+    {
			
 
				+      iterate(list, iterator, state, iteratorHandler);
			
 
				+      return;
			
 
				+    }
			
 
				+
			
 
				+    // done here
			
 
				+    callback(null, state.results);
			
 
				+  });
			
 
				+
			
 
				+  return terminator.bind(state, callback);
			
 
				+}
			
 
				+
			
 
				+/*
			
 
				+ * -- Sort methods
			
 
				+ */
			
 
				+
			
 
				+/**
			
 
				+ * sort helper to sort array elements in ascending order
			
 
				+ *
			
 
				+ * @param   {mixed} a - an item to compare
			
 
				+ * @param   {mixed} b - an item to compare
			
 
				+ * @returns {number} - comparison result
			
 
				+ */
			
 
				+function ascending(a, b)
			
 
				+{
			
 
				+  return a < b ? -1 : a > b ? 1 : 0;
			
 
				+}
			
 
				+
			
 
				+/**
			
 
				+ * sort helper to sort array elements in descending order
			
 
				+ *
			
 
				+ * @param   {mixed} a - an item to compare
			
 
				+ * @param   {mixed} b - an item to compare
			
 
				+ * @returns {number} - comparison result
			
 
				+ */
			
 
				+function descending(a, b)
			
 
				+{
			
 
				+  return -1 * ascending(a, b);
			
 
				+}
			
--- a/node_modules/asynckit/stream.js
+++ b/node_modules/asynckit/stream.js
@@ -0,0 +1,21 @@
 
				+var inherits              = require('util').inherits
			
 
				+  , Readable              = require('stream').Readable
			
 
				+  , ReadableAsyncKit      = require('./lib/readable_asynckit.js')
			
 
				+  , ReadableParallel      = require('./lib/readable_parallel.js')
			
 
				+  , ReadableSerial        = require('./lib/readable_serial.js')
			
 
				+  , ReadableSerialOrdered = require('./lib/readable_serial_ordered.js')
			
 
				+  ;
			
 
				+
			
 
				+// API
			
 
				+module.exports =
			
 
				+{
			
 
				+  parallel      : ReadableParallel,
			
 
				+  serial        : ReadableSerial,
			
 
				+  serialOrdered : ReadableSerialOrdered, 
			
 
				+};
			
 
				+
			
 
				+inherits(ReadableAsyncKit, Readable);
			
 
				+
			
 
				+inherits(ReadableParallel, ReadableAsyncKit);
			
 
				+inherits(ReadableSerial, ReadableAsyncKit);
			
 
				+inherits(ReadableSerialOrdered, ReadableAsyncKit);
			
--- a/node_modules/axios/CHANGELOG.md
+++ b/node_modules/axios/CHANGELOG.md
--- a/node_modules/axios/LICENSE
+++ b/node_modules/axios/LICENSE
@@ -0,0 +1,7 @@
 
				+# Copyright (c) 2014-present Matt Zabriskie & Collaborators
			
 
				+
			
 
				+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/node_modules/axios/MIGRATION_GUIDE.md
+++ b/node_modules/axios/MIGRATION_GUIDE.md
@@ -0,0 +1,3 @@
 
				+# Migration Guide
			
 
				+
			
 
				+## 0.x.x -> 1.1.0
			
--- a/node_modules/axios/README.md
+++ b/node_modules/axios/README.md
--- a/node_modules/axios/dist/axios.js
+++ b/node_modules/axios/dist/axios.js
--- a/node_modules/axios/dist/axios.js.map
+++ b/node_modules/axios/dist/axios.js.map
--- a/node_modules/axios/dist/axios.min.js
+++ b/node_modules/axios/dist/axios.min.js
--- a/node_modules/axios/dist/axios.min.js.map
+++ b/node_modules/axios/dist/axios.min.js.map
--- a/node_modules/axios/dist/browser/axios.cjs
+++ b/node_modules/axios/dist/browser/axios.cjs
--- a/node_modules/axios/dist/browser/axios.cjs.map
+++ b/node_modules/axios/dist/browser/axios.cjs.map
--- a/node_modules/axios/dist/esm/axios.js
+++ b/node_modules/axios/dist/esm/axios.js
--- a/node_modules/axios/dist/esm/axios.js.map
+++ b/node_modules/axios/dist/esm/axios.js.map
--- a/node_modules/axios/dist/esm/axios.min.js
+++ b/node_modules/axios/dist/esm/axios.min.js
--- a/node_modules/axios/dist/esm/axios.min.js.map
+++ b/node_modules/axios/dist/esm/axios.min.js.map
--- a/node_modules/axios/dist/node/axios.cjs
+++ b/node_modules/axios/dist/node/axios.cjs
--- a/node_modules/axios/dist/node/axios.cjs.map
+++ b/node_modules/axios/dist/node/axios.cjs.map
--- a/node_modules/axios/index.d.cts
+++ b/node_modules/axios/index.d.cts
@@ -0,0 +1,550 @@
 
				+interface RawAxiosHeaders {
			
 
				+  [key: string]: axios.AxiosHeaderValue;
			
 
				+}
			
 
				+
			
 
				+type MethodsHeaders = Partial<{
			
 
				+  [Key in axios.Method as Lowercase<Key>]: AxiosHeaders;
			
 
				+} & {common: AxiosHeaders}>;
			
 
				+
			
 
				+type AxiosHeaderMatcher = (this: AxiosHeaders, value: string, name: string, headers: RawAxiosHeaders) => boolean;
			
 
				+
			
 
				+type AxiosHeaderParser = (this: AxiosHeaders, value: axios.AxiosHeaderValue, header: string) => any;
			
 
				+
			
 
				+type CommonRequestHeadersList = 'Accept' | 'Content-Length' | 'User-Agent'| 'Content-Encoding' | 'Authorization';
			
 
				+
			
 
				+type ContentType = axios.AxiosHeaderValue | 'text/html' | 'text/plain' | 'multipart/form-data' | 'application/json' | 'application/x-www-form-urlencoded' | 'application/octet-stream';
			
 
				+
			
 
				+type CommonResponseHeadersList = 'Server' | 'Content-Type' | 'Content-Length' | 'Cache-Control'| 'Content-Encoding';
			
 
				+
			
 
				+declare class AxiosHeaders {
			
 
				+  constructor(
			
 
				+      headers?: RawAxiosHeaders | AxiosHeaders | string
			
 
				+  );
			
 
				+
			
 
				+  [key: string]: any;
			
 
				+
			
 
				+  set(headerName?: string, value?: axios.AxiosHeaderValue, rewrite?: boolean | AxiosHeaderMatcher): AxiosHeaders;
			
 
				+  set(headers?: RawAxiosHeaders | AxiosHeaders | string, rewrite?: boolean): AxiosHeaders;
			
 
				+
			
 
				+  get(headerName: string, parser: RegExp): RegExpExecArray | null;
			
 
				+  get(headerName: string, matcher?: true | AxiosHeaderParser): axios.AxiosHeaderValue;
			
 
				+
			
 
				+  has(header: string, matcher?: AxiosHeaderMatcher): boolean;
			
 
				+
			
 
				+  delete(header: string | string[], matcher?: AxiosHeaderMatcher): boolean;
			
 
				+
			
 
				+  clear(matcher?: AxiosHeaderMatcher): boolean;
			
 
				+
			
 
				+  normalize(format: boolean): AxiosHeaders;
			
 
				+
			
 
				+  concat(...targets: Array<AxiosHeaders | RawAxiosHeaders | string | undefined | null>): AxiosHeaders;
			
 
				+
			
 
				+  toJSON(asStrings?: boolean): RawAxiosHeaders;
			
 
				+
			
 
				+  static from(thing?: AxiosHeaders | RawAxiosHeaders | string): AxiosHeaders;
			
 
				+
			
 
				+  static accessor(header: string | string[]): AxiosHeaders;
			
 
				+
			
 
				+  static concat(...targets: Array<AxiosHeaders | RawAxiosHeaders | string | undefined | null>): AxiosHeaders;
			
 
				+
			
 
				+  setContentType(value: ContentType, rewrite?: boolean | AxiosHeaderMatcher): AxiosHeaders;
			
 
				+  getContentType(parser?: RegExp): RegExpExecArray | null;
			
 
				+  getContentType(matcher?: AxiosHeaderMatcher): axios.AxiosHeaderValue;
			
 
				+  hasContentType(matcher?: AxiosHeaderMatcher): boolean;
			
 
				+
			
 
				+  setContentLength(value: axios.AxiosHeaderValue, rewrite?: boolean | AxiosHeaderMatcher): AxiosHeaders;
			
 
				+  getContentLength(parser?: RegExp): RegExpExecArray | null;
			
 
				+  getContentLength(matcher?: AxiosHeaderMatcher): axios.AxiosHeaderValue;
			
 
				+  hasContentLength(matcher?: AxiosHeaderMatcher): boolean;
			
 
				+
			
 
				+  setAccept(value: axios.AxiosHeaderValue, rewrite?: boolean | AxiosHeaderMatcher): AxiosHeaders;
			
 
				+  getAccept(parser?: RegExp): RegExpExecArray | null;
			
 
				+  getAccept(matcher?: AxiosHeaderMatcher): axios.AxiosHeaderValue;
			
 
				+  hasAccept(matcher?: AxiosHeaderMatcher): boolean;
			
 
				+
			
 
				+  setUserAgent(value: axios.AxiosHeaderValue, rewrite?: boolean | AxiosHeaderMatcher): AxiosHeaders;
			
 
				+  getUserAgent(parser?: RegExp): RegExpExecArray | null;
			
 
				+  getUserAgent(matcher?: AxiosHeaderMatcher): axios.AxiosHeaderValue;
			
 
				+  hasUserAgent(matcher?: AxiosHeaderMatcher): boolean;
			
 
				+
			
 
				+  setContentEncoding(value: axios.AxiosHeaderValue, rewrite?: boolean | AxiosHeaderMatcher): AxiosHeaders;
			
 
				+  getContentEncoding(parser?: RegExp): RegExpExecArray | null;
			
 
				+  getContentEncoding(matcher?: AxiosHeaderMatcher): axios.AxiosHeaderValue;
			
 
				+  hasContentEncoding(matcher?: AxiosHeaderMatcher): boolean;
			
 
				+
			
 
				+  setAuthorization(value: axios.AxiosHeaderValue, rewrite?: boolean | AxiosHeaderMatcher): AxiosHeaders;
			
 
				+  getAuthorization(parser?: RegExp): RegExpExecArray | null;
			
 
				+  getAuthorization(matcher?: AxiosHeaderMatcher): axios.AxiosHeaderValue;
			
 
				+  hasAuthorization(matcher?: AxiosHeaderMatcher): boolean;
			
 
				+
			
 
				+  [Symbol.iterator](): IterableIterator<[string, axios.AxiosHeaderValue]>;
			
 
				+}
			
 
				+
			
 
				+declare class AxiosError<T = unknown, D = any> extends Error {
			
 
				+  constructor(
			
 
				+      message?: string,
			
 
				+      code?: string,
			
 
				+      config?: axios.InternalAxiosRequestConfig<D>,
			
 
				+      request?: any,
			
 
				+      response?: axios.AxiosResponse<T, D>
			
 
				+  );
			
 
				+
			
 
				+  config?: axios.InternalAxiosRequestConfig<D>;
			
 
				+  code?: string;
			
 
				+  request?: any;
			
 
				+  response?: axios.AxiosResponse<T, D>;
			
 
				+  isAxiosError: boolean;
			
 
				+  status?: number;
			
 
				+  toJSON: () => object;
			
 
				+  cause?: Error;
			
 
				+  static readonly ERR_FR_TOO_MANY_REDIRECTS = "ERR_FR_TOO_MANY_REDIRECTS";
			
 
				+  static readonly ERR_BAD_OPTION_VALUE = "ERR_BAD_OPTION_VALUE";
			
 
				+  static readonly ERR_BAD_OPTION = "ERR_BAD_OPTION";
			
 
				+  static readonly ERR_NETWORK = "ERR_NETWORK";
			
 
				+  static readonly ERR_DEPRECATED = "ERR_DEPRECATED";
			
 
				+  static readonly ERR_BAD_RESPONSE = "ERR_BAD_RESPONSE";
			
 
				+  static readonly ERR_BAD_REQUEST = "ERR_BAD_REQUEST";
			
 
				+  static readonly ERR_NOT_SUPPORT = "ERR_NOT_SUPPORT";
			
 
				+  static readonly ERR_INVALID_URL = "ERR_INVALID_URL";
			
 
				+  static readonly ERR_CANCELED = "ERR_CANCELED";
			
 
				+  static readonly ECONNABORTED = "ECONNABORTED";
			
 
				+  static readonly ETIMEDOUT = "ETIMEDOUT";
			
 
				+}
			
 
				+
			
 
				+declare class CanceledError<T> extends AxiosError<T> {
			
 
				+}
			
 
				+
			
 
				+declare class Axios {
			
 
				+  constructor(config?: axios.AxiosRequestConfig);
			
 
				+  defaults: axios.AxiosDefaults;
			
 
				+  interceptors: {
			
 
				+    request: axios.AxiosInterceptorManager<axios.InternalAxiosRequestConfig>;
			
 
				+    response: axios.AxiosInterceptorManager<axios.AxiosResponse>;
			
 
				+  };
			
 
				+  getUri(config?: axios.AxiosRequestConfig): string;
			
 
				+  request<T = any, R = axios.AxiosResponse<T>, D = any>(config: axios.AxiosRequestConfig<D>): Promise<R>;
			
 
				+  get<T = any, R = axios.AxiosResponse<T>, D = any>(url: string, config?: axios.AxiosRequestConfig<D>): Promise<R>;
			
 
				+  delete<T = any, R = axios.AxiosResponse<T>, D = any>(url: string, config?: axios.AxiosRequestConfig<D>): Promise<R>;
			
 
				+  head<T = any, R = axios.AxiosResponse<T>, D = any>(url: string, config?: axios.AxiosRequestConfig<D>): Promise<R>;
			
 
				+  options<T = any, R = axios.AxiosResponse<T>, D = any>(url: string, config?: axios.AxiosRequestConfig<D>): Promise<R>;
			
 
				+  post<T = any, R = axios.AxiosResponse<T>, D = any>(url: string, data?: D, config?: axios.AxiosRequestConfig<D>): Promise<R>;
			
 
				+  put<T = any, R = axios.AxiosResponse<T>, D = any>(url: string, data?: D, config?: axios.AxiosRequestConfig<D>): Promise<R>;
			
 
				+  patch<T = any, R = axios.AxiosResponse<T>, D = any>(url: string, data?: D, config?: axios.AxiosRequestConfig<D>): Promise<R>;
			
 
				+  postForm<T = any, R = axios.AxiosResponse<T>, D = any>(url: string, data?: D, config?: axios.AxiosRequestConfig<D>): Promise<R>;
			
 
				+  putForm<T = any, R = axios.AxiosResponse<T>, D = any>(url: string, data?: D, config?: axios.AxiosRequestConfig<D>): Promise<R>;
			
 
				+  patchForm<T = any, R = axios.AxiosResponse<T>, D = any>(url: string, data?: D, config?: axios.AxiosRequestConfig<D>): Promise<R>;
			
 
				+}
			
 
				+
			
 
				+declare enum HttpStatusCode {
			
 
				+  Continue = 100,
			
 
				+  SwitchingProtocols = 101,
			
 
				+  Processing = 102,
			
 
				+  EarlyHints = 103,
			
 
				+  Ok = 200,
			
 
				+  Created = 201,
			
 
				+  Accepted = 202,
			
 
				+  NonAuthoritativeInformation = 203,
			
 
				+  NoContent = 204,
			
 
				+  ResetContent = 205,
			
 
				+  PartialContent = 206,
			
 
				+  MultiStatus = 207,
			
 
				+  AlreadyReported = 208,
			
 
				+  ImUsed = 226,
			
 
				+  MultipleChoices = 300,
			
 
				+  MovedPermanently = 301,
			
 
				+  Found = 302,
			
 
				+  SeeOther = 303,
			
 
				+  NotModified = 304,
			
 
				+  UseProxy = 305,
			
 
				+  Unused = 306,
			
 
				+  TemporaryRedirect = 307,
			
 
				+  PermanentRedirect = 308,
			
 
				+  BadRequest = 400,
			
 
				+  Unauthorized = 401,
			
 
				+  PaymentRequired = 402,
			
 
				+  Forbidden = 403,
			
 
				+  NotFound = 404,
			
 
				+  MethodNotAllowed = 405,
			
 
				+  NotAcceptable = 406,
			
 
				+  ProxyAuthenticationRequired = 407,
			
 
				+  RequestTimeout = 408,
			
 
				+  Conflict = 409,
			
 
				+  Gone = 410,
			
 
				+  LengthRequired = 411,
			
 
				+  PreconditionFailed = 412,
			
 
				+  PayloadTooLarge = 413,
			
 
				+  UriTooLong = 414,
			
 
				+  UnsupportedMediaType = 415,
			
 
				+  RangeNotSatisfiable = 416,
			
 
				+  ExpectationFailed = 417,
			
 
				+  ImATeapot = 418,
			
 
				+  MisdirectedRequest = 421,
			
 
				+  UnprocessableEntity = 422,
			
 
				+  Locked = 423,
			
 
				+  FailedDependency = 424,
			
 
				+  TooEarly = 425,
			
 
				+  UpgradeRequired = 426,
			
 
				+  PreconditionRequired = 428,
			
 
				+  TooManyRequests = 429,
			
 
				+  RequestHeaderFieldsTooLarge = 431,
			
 
				+  UnavailableForLegalReasons = 451,
			
 
				+  InternalServerError = 500,
			
 
				+  NotImplemented = 501,
			
 
				+  BadGateway = 502,
			
 
				+  ServiceUnavailable = 503,
			
 
				+  GatewayTimeout = 504,
			
 
				+  HttpVersionNotSupported = 505,
			
 
				+  VariantAlsoNegotiates = 506,
			
 
				+  InsufficientStorage = 507,
			
 
				+  LoopDetected = 508,
			
 
				+  NotExtended = 510,
			
 
				+  NetworkAuthenticationRequired = 511,
			
 
				+}
			
 
				+
			
 
				+type InternalAxiosError<T = unknown, D = any> = AxiosError<T, D>;
			
 
				+
			
 
				+declare namespace axios {
			
 
				+  type AxiosError<T = unknown, D = any> = InternalAxiosError<T, D>;
			
 
				+
			
 
				+  type RawAxiosRequestHeaders = Partial<RawAxiosHeaders & {
			
 
				+    [Key in CommonRequestHeadersList]: AxiosHeaderValue;
			
 
				+  } & {
			
 
				+    'Content-Type': ContentType
			
 
				+  }>;
			
 
				+
			
 
				+  type AxiosRequestHeaders = RawAxiosRequestHeaders & AxiosHeaders;
			
 
				+
			
 
				+  type AxiosHeaderValue = AxiosHeaders | string | string[] | number | boolean | null;
			
 
				+
			
 
				+  type RawCommonResponseHeaders = {
			
 
				+    [Key in CommonResponseHeadersList]: AxiosHeaderValue;
			
 
				+  } & {
			
 
				+    "set-cookie": string[];
			
 
				+  };
			
 
				+
			
 
				+  type RawAxiosResponseHeaders = Partial<RawAxiosHeaders & RawCommonResponseHeaders>;
			
 
				+
			
 
				+  type AxiosResponseHeaders = RawAxiosResponseHeaders & AxiosHeaders;
			
 
				+
			
 
				+  interface AxiosRequestTransformer {
			
 
				+    (this: InternalAxiosRequestConfig, data: any, headers: AxiosRequestHeaders): any;
			
 
				+  }
			
 
				+
			
 
				+  interface AxiosResponseTransformer {
			
 
				+    (this: InternalAxiosRequestConfig, data: any, headers: AxiosResponseHeaders, status?: number): any;
			
 
				+  }
			
 
				+
			
 
				+  interface AxiosAdapter {
			
 
				+    (config: InternalAxiosRequestConfig): AxiosPromise;
			
 
				+  }
			
 
				+
			
 
				+  interface AxiosBasicCredentials {
			
 
				+    username: string;
			
 
				+    password: string;
			
 
				+  }
			
 
				+
			
 
				+  interface AxiosProxyConfig {
			
 
				+    host: string;
			
 
				+    port: number;
			
 
				+    auth?: AxiosBasicCredentials;
			
 
				+    protocol?: string;
			
 
				+  }
			
 
				+
			
 
				+  type Method =
			
 
				+    | 'get' | 'GET'
			
 
				+    | 'delete' | 'DELETE'
			
 
				+    | 'head' | 'HEAD'
			
 
				+    | 'options' | 'OPTIONS'
			
 
				+    | 'post' | 'POST'
			
 
				+    | 'put' | 'PUT'
			
 
				+    | 'patch' | 'PATCH'
			
 
				+    | 'purge' | 'PURGE'
			
 
				+    | 'link' | 'LINK'
			
 
				+    | 'unlink' | 'UNLINK';
			
 
				+
			
 
				+  type ResponseType =
			
 
				+    | 'arraybuffer'
			
 
				+    | 'blob'
			
 
				+    | 'document'
			
 
				+    | 'json'
			
 
				+    | 'text'
			
 
				+    | 'stream'
			
 
				+    | 'formdata';
			
 
				+
			
 
				+  type responseEncoding =
			
 
				+    | 'ascii' | 'ASCII'
			
 
				+    | 'ansi' | 'ANSI'
			
 
				+    | 'binary' | 'BINARY'
			
 
				+    | 'base64' | 'BASE64'
			
 
				+    | 'base64url' | 'BASE64URL'
			
 
				+    | 'hex' | 'HEX'
			
 
				+    | 'latin1' | 'LATIN1'
			
 
				+    | 'ucs-2' | 'UCS-2'
			
 
				+    | 'ucs2' | 'UCS2'
			
 
				+    | 'utf-8' | 'UTF-8'
			
 
				+    | 'utf8' | 'UTF8'
			
 
				+    | 'utf16le' | 'UTF16LE';
			
 
				+
			
 
				+  interface TransitionalOptions {
			
 
				+    silentJSONParsing?: boolean;
			
 
				+    forcedJSONParsing?: boolean;
			
 
				+    clarifyTimeoutError?: boolean;
			
 
				+  }
			
 
				+
			
 
				+  interface GenericAbortSignal {
			
 
				+    readonly aborted: boolean;
			
 
				+    onabort?: ((...args: any) => any) | null;
			
 
				+    addEventListener?: (...args: any) => any;
			
 
				+    removeEventListener?: (...args: any) => any;
			
 
				+  }
			
 
				+
			
 
				+  interface FormDataVisitorHelpers {
			
 
				+    defaultVisitor: SerializerVisitor;
			
 
				+    convertValue: (value: any) => any;
			
 
				+    isVisitable: (value: any) => boolean;
			
 
				+  }
			
 
				+
			
 
				+  interface SerializerVisitor {
			
 
				+    (
			
 
				+        this: GenericFormData,
			
 
				+        value: any,
			
 
				+        key: string | number,
			
 
				+        path: null | Array<string | number>,
			
 
				+        helpers: FormDataVisitorHelpers
			
 
				+    ): boolean;
			
 
				+  }
			
 
				+
			
 
				+  interface SerializerOptions {
			
 
				+    visitor?: SerializerVisitor;
			
 
				+    dots?: boolean;
			
 
				+    metaTokens?: boolean;
			
 
				+    indexes?: boolean | null;
			
 
				+  }
			
 
				+
			
 
				+  // tslint:disable-next-line
			
 
				+  interface FormSerializerOptions extends SerializerOptions {
			
 
				+  }
			
 
				+
			
 
				+  interface ParamEncoder {
			
 
				+    (value: any, defaultEncoder: (value: any) => any): any;
			
 
				+  }
			
 
				+
			
 
				+  interface CustomParamsSerializer {
			
 
				+    (params: Record<string, any>, options?: ParamsSerializerOptions): string;
			
 
				+  }
			
 
				+
			
 
				+  interface ParamsSerializerOptions extends SerializerOptions {
			
 
				+    encode?: ParamEncoder;
			
 
				+    serialize?: CustomParamsSerializer;
			
 
				+  }
			
 
				+
			
 
				+  type MaxUploadRate = number;
			
 
				+
			
 
				+  type MaxDownloadRate = number;
			
 
				+
			
 
				+  type BrowserProgressEvent = any;
			
 
				+
			
 
				+  interface AxiosProgressEvent {
			
 
				+    loaded: number;
			
 
				+    total?: number;
			
 
				+    progress?: number;
			
 
				+    bytes: number;
			
 
				+    rate?: number;
			
 
				+    estimated?: number;
			
 
				+    upload?: boolean;
			
 
				+    download?: boolean;
			
 
				+    event?: BrowserProgressEvent;
			
 
				+    lengthComputable: boolean;
			
 
				+  }
			
 
				+
			
 
				+  type Milliseconds = number;
			
 
				+
			
 
				+  type AxiosAdapterName = 'fetch' | 'xhr' | 'http' | string;
			
 
				+
			
 
				+  type AxiosAdapterConfig = AxiosAdapter | AxiosAdapterName;
			
 
				+
			
 
				+  type AddressFamily = 4 | 6 | undefined;
			
 
				+
			
 
				+  interface LookupAddressEntry {
			
 
				+    address: string;
			
 
				+    family?: AddressFamily;
			
 
				+  }
			
 
				+
			
 
				+  type LookupAddress = string | LookupAddressEntry;
			
 
				+
			
 
				+  interface AxiosRequestConfig<D = any> {
			
 
				+    url?: string;
			
 
				+    method?: Method | string;
			
 
				+    baseURL?: string;
			
 
				+    allowAbsoluteUrls?: boolean;
			
 
				+    transformRequest?: AxiosRequestTransformer | AxiosRequestTransformer[];
			
 
				+    transformResponse?: AxiosResponseTransformer | AxiosResponseTransformer[];
			
 
				+    headers?: (RawAxiosRequestHeaders & MethodsHeaders) | AxiosHeaders;
			
 
				+    params?: any;
			
 
				+    paramsSerializer?: ParamsSerializerOptions | CustomParamsSerializer;
			
 
				+    data?: D;
			
 
				+    timeout?: Milliseconds;
			
 
				+    timeoutErrorMessage?: string;
			
 
				+    withCredentials?: boolean;
			
 
				+    adapter?: AxiosAdapterConfig | AxiosAdapterConfig[];
			
 
				+    auth?: AxiosBasicCredentials;
			
 
				+    responseType?: ResponseType;
			
 
				+    responseEncoding?: responseEncoding | string;
			
 
				+    xsrfCookieName?: string;
			
 
				+    xsrfHeaderName?: string;
			
 
				+    onUploadProgress?: (progressEvent: AxiosProgressEvent) => void;
			
 
				+    onDownloadProgress?: (progressEvent: AxiosProgressEvent) => void;
			
 
				+    maxContentLength?: number;
			
 
				+    validateStatus?: ((status: number) => boolean) | null;
			
 
				+    maxBodyLength?: number;
			
 
				+    maxRedirects?: number;
			
 
				+    maxRate?: number | [MaxUploadRate, MaxDownloadRate];
			
 
				+    beforeRedirect?: (options: Record<string, any>, responseDetails: {headers: Record<string, string>, statusCode: HttpStatusCode}) => void;
			
 
				+    socketPath?: string | null;
			
 
				+    transport?: any;
			
 
				+    httpAgent?: any;
			
 
				+    httpsAgent?: any;
			
 
				+    proxy?: AxiosProxyConfig | false;
			
 
				+    cancelToken?: CancelToken;
			
 
				+    decompress?: boolean;
			
 
				+    transitional?: TransitionalOptions;
			
 
				+    signal?: GenericAbortSignal;
			
 
				+    insecureHTTPParser?: boolean;
			
 
				+    env?: {
			
 
				+      FormData?: new (...args: any[]) => object;
			
 
				+    };
			
 
				+    formSerializer?: FormSerializerOptions;
			
 
				+    family?: AddressFamily;
			
 
				+    lookup?: ((hostname: string, options: object, cb: (err: Error | null, address: LookupAddress | LookupAddress[], family?: AddressFamily) => void) => void) |
			
 
				+        ((hostname: string, options: object) => Promise<[address: LookupAddressEntry | LookupAddressEntry[], family?: AddressFamily] | LookupAddress>);
			
 
				+    withXSRFToken?: boolean | ((config: InternalAxiosRequestConfig) => boolean | undefined);
			
 
				+    fetchOptions?: Record<string, any>;
			
 
				+  }
			
 
				+
			
 
				+  // Alias
			
 
				+  type RawAxiosRequestConfig<D = any> = AxiosRequestConfig<D>;
			
 
				+
			
 
				+  interface InternalAxiosRequestConfig<D = any> extends AxiosRequestConfig {
			
 
				+    headers: AxiosRequestHeaders;
			
 
				+  }
			
 
				+
			
 
				+  interface HeadersDefaults {
			
 
				+    common: RawAxiosRequestHeaders;
			
 
				+    delete: RawAxiosRequestHeaders;
			
 
				+    get: RawAxiosRequestHeaders;
			
 
				+    head: RawAxiosRequestHeaders;
			
 
				+    post: RawAxiosRequestHeaders;
			
 
				+    put: RawAxiosRequestHeaders;
			
 
				+    patch: RawAxiosRequestHeaders;
			
 
				+    options?: RawAxiosRequestHeaders;
			
 
				+    purge?: RawAxiosRequestHeaders;
			
 
				+    link?: RawAxiosRequestHeaders;
			
 
				+    unlink?: RawAxiosRequestHeaders;
			
 
				+  }
			
 
				+
			
 
				+  interface AxiosDefaults<D = any> extends Omit<AxiosRequestConfig<D>, 'headers'> {
			
 
				+    headers: HeadersDefaults;
			
 
				+  }
			
 
				+
			
 
				+  interface CreateAxiosDefaults<D = any> extends Omit<AxiosRequestConfig<D>, 'headers'> {
			
 
				+    headers?: RawAxiosRequestHeaders | AxiosHeaders | Partial<HeadersDefaults>;
			
 
				+  }
			
 
				+
			
 
				+  interface AxiosResponse<T = any, D = any>  {
			
 
				+    data: T;
			
 
				+    status: number;
			
 
				+    statusText: string;
			
 
				+    headers: RawAxiosResponseHeaders | AxiosResponseHeaders;
			
 
				+    config: InternalAxiosRequestConfig<D>;
			
 
				+    request?: any;
			
 
				+  }
			
 
				+
			
 
				+  type AxiosPromise<T = any> = Promise<AxiosResponse<T>>;
			
 
				+
			
 
				+  interface CancelStatic {
			
 
				+    new (message?: string): Cancel;
			
 
				+  }
			
 
				+
			
 
				+  interface Cancel {
			
 
				+    message: string | undefined;
			
 
				+  }
			
 
				+
			
 
				+  interface Canceler {
			
 
				+    (message?: string, config?: AxiosRequestConfig, request?: any): void;
			
 
				+  }
			
 
				+
			
 
				+  interface CancelTokenStatic {
			
 
				+    new (executor: (cancel: Canceler) => void): CancelToken;
			
 
				+    source(): CancelTokenSource;
			
 
				+  }
			
 
				+
			
 
				+  interface CancelToken {
			
 
				+    promise: Promise<Cancel>;
			
 
				+    reason?: Cancel;
			
 
				+    throwIfRequested(): void;
			
 
				+  }
			
 
				+
			
 
				+  interface CancelTokenSource {
			
 
				+    token: CancelToken;
			
 
				+    cancel: Canceler;
			
 
				+  }
			
 
				+
			
 
				+  interface AxiosInterceptorOptions {
			
 
				+    synchronous?: boolean;
			
 
				+    runWhen?: (config: InternalAxiosRequestConfig) => boolean;
			
 
				+  }
			
 
				+
			
 
				+  type AxiosRequestInterceptorUse<T> = (onFulfilled?: ((value: T) => T | Promise<T>) | null, onRejected?: ((error: any) => any) | null, options?: AxiosInterceptorOptions) => number;
			
 
				+
			
 
				+  type AxiosResponseInterceptorUse<T> = (onFulfilled?: ((value: T) => T | Promise<T>) | null, onRejected?: ((error: any) => any) | null) => number;
			
 
				+
			
 
				+  interface AxiosInterceptorManager<V> {
			
 
				+    use: V extends AxiosResponse ? AxiosResponseInterceptorUse<V> : AxiosRequestInterceptorUse<V>;
			
 
				+    eject(id: number): void;
			
 
				+    clear(): void;
			
 
				+  }
			
 
				+
			
 
				+  interface AxiosInstance extends Axios {
			
 
				+    <T = any, R = AxiosResponse<T>, D = any>(config: AxiosRequestConfig<D>): Promise<R>;
			
 
				+    <T = any, R = AxiosResponse<T>, D = any>(url: string, config?: AxiosRequestConfig<D>): Promise<R>;
			
 
				+
			
 
				+    defaults: Omit<AxiosDefaults, 'headers'> & {
			
 
				+      headers: HeadersDefaults & {
			
 
				+        [key: string]: AxiosHeaderValue
			
 
				+      }
			
 
				+    };
			
 
				+  }
			
 
				+
			
 
				+  interface GenericFormData {
			
 
				+    append(name: string, value: any, options?: any): any;
			
 
				+  }
			
 
				+
			
 
				+  interface GenericHTMLFormElement {
			
 
				+    name: string;
			
 
				+    method: string;
			
 
				+    submit(): void;
			
 
				+  }
			
 
				+
			
 
				+  interface AxiosStatic extends AxiosInstance {
			
 
				+    create(config?: CreateAxiosDefaults): AxiosInstance;
			
 
				+    Cancel: CancelStatic;
			
 
				+    CancelToken: CancelTokenStatic;
			
 
				+    Axios: typeof Axios;
			
 
				+    AxiosError: typeof AxiosError;
			
 
				+    CanceledError: typeof CanceledError;
			
 
				+    HttpStatusCode: typeof HttpStatusCode;
			
 
				+    readonly VERSION: string;
			
 
				+    isCancel(value: any): value is Cancel;
			
 
				+    all<T>(values: Array<T | Promise<T>>): Promise<T[]>;
			
 
				+    spread<T, R>(callback: (...args: T[]) => R): (array: T[]) => R;
			
 
				+    isAxiosError<T = any, D = any>(payload: any): payload is AxiosError<T, D>;
			
 
				+    toFormData(sourceObj: object, targetFormData?: GenericFormData, options?: FormSerializerOptions): GenericFormData;
			
 
				+    formToJSON(form: GenericFormData|GenericHTMLFormElement): object;
			
 
				+    getAdapter(adapters: AxiosAdapterConfig | AxiosAdapterConfig[] | undefined): AxiosAdapter;
			
 
				+    AxiosHeaders: typeof AxiosHeaders;
			
 
				+  }
			
 
				+}
			
 
				+
			
 
				+declare const axios: axios.AxiosStatic;
			
 
				+
			
 
				+export = axios;
			
--- a/node_modules/axios/index.d.ts
+++ b/node_modules/axios/index.d.ts
@@ -0,0 +1,570 @@
 
				+// TypeScript Version: 4.7
			
 
				+export type AxiosHeaderValue = AxiosHeaders | string | string[] | number | boolean | null;
			
 
				+
			
 
				+interface RawAxiosHeaders {
			
 
				+  [key: string]: AxiosHeaderValue;
			
 
				+}
			
 
				+
			
 
				+type MethodsHeaders = Partial<{
			
 
				+  [Key in Method as Lowercase<Key>]: AxiosHeaders;
			
 
				+} & {common: AxiosHeaders}>;
			
 
				+
			
 
				+type AxiosHeaderMatcher = string | RegExp | ((this: AxiosHeaders, value: string, name: string) => boolean);
			
 
				+
			
 
				+type AxiosHeaderParser = (this: AxiosHeaders, value: AxiosHeaderValue, header: string) => any;
			
 
				+
			
 
				+export class AxiosHeaders {
			
 
				+  constructor(
			
 
				+      headers?: RawAxiosHeaders | AxiosHeaders | string
			
 
				+  );
			
 
				+
			
 
				+  [key: string]: any;
			
 
				+
			
 
				+  set(headerName?: string, value?: AxiosHeaderValue, rewrite?: boolean | AxiosHeaderMatcher): AxiosHeaders;
			
 
				+  set(headers?: RawAxiosHeaders | AxiosHeaders | string, rewrite?: boolean): AxiosHeaders;
			
 
				+
			
 
				+  get(headerName: string, parser: RegExp): RegExpExecArray | null;
			
 
				+  get(headerName: string, matcher?: true | AxiosHeaderParser): AxiosHeaderValue;
			
 
				+
			
 
				+  has(header: string, matcher?: AxiosHeaderMatcher): boolean;
			
 
				+
			
 
				+  delete(header: string | string[], matcher?: AxiosHeaderMatcher): boolean;
			
 
				+
			
 
				+  clear(matcher?: AxiosHeaderMatcher): boolean;
			
 
				+
			
 
				+  normalize(format: boolean): AxiosHeaders;
			
 
				+
			
 
				+  concat(...targets: Array<AxiosHeaders | RawAxiosHeaders | string | undefined | null>): AxiosHeaders;
			
 
				+
			
 
				+  toJSON(asStrings?: boolean): RawAxiosHeaders;
			
 
				+
			
 
				+  static from(thing?: AxiosHeaders | RawAxiosHeaders | string): AxiosHeaders;
			
 
				+
			
 
				+  static accessor(header: string | string[]): AxiosHeaders;
			
 
				+
			
 
				+  static concat(...targets: Array<AxiosHeaders | RawAxiosHeaders | string | undefined | null>): AxiosHeaders;
			
 
				+
			
 
				+  setContentType(value: ContentType, rewrite?: boolean | AxiosHeaderMatcher): AxiosHeaders;
			
 
				+  getContentType(parser?: RegExp): RegExpExecArray | null;
			
 
				+  getContentType(matcher?: AxiosHeaderMatcher): AxiosHeaderValue;
			
 
				+  hasContentType(matcher?: AxiosHeaderMatcher): boolean;
			
 
				+
			
 
				+  setContentLength(value: AxiosHeaderValue, rewrite?: boolean | AxiosHeaderMatcher): AxiosHeaders;
			
 
				+  getContentLength(parser?: RegExp): RegExpExecArray | null;
			
 
				+  getContentLength(matcher?: AxiosHeaderMatcher): AxiosHeaderValue;
			
 
				+  hasContentLength(matcher?: AxiosHeaderMatcher): boolean;
			
 
				+
			
 
				+  setAccept(value: AxiosHeaderValue, rewrite?: boolean | AxiosHeaderMatcher): AxiosHeaders;
			
 
				+  getAccept(parser?: RegExp): RegExpExecArray | null;
			
 
				+  getAccept(matcher?: AxiosHeaderMatcher): AxiosHeaderValue;
			
 
				+  hasAccept(matcher?: AxiosHeaderMatcher): boolean;
			
 
				+
			
 
				+  setUserAgent(value: AxiosHeaderValue, rewrite?: boolean | AxiosHeaderMatcher): AxiosHeaders;
			
 
				+  getUserAgent(parser?: RegExp): RegExpExecArray | null;
			
 
				+  getUserAgent(matcher?: AxiosHeaderMatcher): AxiosHeaderValue;
			
 
				+  hasUserAgent(matcher?: AxiosHeaderMatcher): boolean;
			
 
				+
			
 
				+  setContentEncoding(value: AxiosHeaderValue, rewrite?: boolean | AxiosHeaderMatcher): AxiosHeaders;
			
 
				+  getContentEncoding(parser?: RegExp): RegExpExecArray | null;
			
 
				+  getContentEncoding(matcher?: AxiosHeaderMatcher): AxiosHeaderValue;
			
 
				+  hasContentEncoding(matcher?: AxiosHeaderMatcher): boolean;
			
 
				+
			
 
				+  setAuthorization(value: AxiosHeaderValue, rewrite?: boolean | AxiosHeaderMatcher): AxiosHeaders;
			
 
				+  getAuthorization(parser?: RegExp): RegExpExecArray | null;
			
 
				+  getAuthorization(matcher?: AxiosHeaderMatcher): AxiosHeaderValue;
			
 
				+  hasAuthorization(matcher?: AxiosHeaderMatcher): boolean;
			
 
				+
			
 
				+  [Symbol.iterator](): IterableIterator<[string, AxiosHeaderValue]>;
			
 
				+}
			
 
				+
			
 
				+type CommonRequestHeadersList = 'Accept' | 'Content-Length' | 'User-Agent' | 'Content-Encoding' | 'Authorization';
			
 
				+
			
 
				+type ContentType = AxiosHeaderValue | 'text/html' | 'text/plain' | 'multipart/form-data' | 'application/json' | 'application/x-www-form-urlencoded' | 'application/octet-stream';
			
 
				+
			
 
				+export type RawAxiosRequestHeaders = Partial<RawAxiosHeaders & {
			
 
				+  [Key in CommonRequestHeadersList]: AxiosHeaderValue;
			
 
				+} & {
			
 
				+  'Content-Type': ContentType
			
 
				+}>;
			
 
				+
			
 
				+export type AxiosRequestHeaders = RawAxiosRequestHeaders & AxiosHeaders;
			
 
				+
			
 
				+type CommonResponseHeadersList = 'Server' | 'Content-Type' | 'Content-Length' | 'Cache-Control'| 'Content-Encoding';
			
 
				+
			
 
				+type RawCommonResponseHeaders = {
			
 
				+  [Key in CommonResponseHeadersList]: AxiosHeaderValue;
			
 
				+} & {
			
 
				+  "set-cookie": string[];
			
 
				+};
			
 
				+
			
 
				+export type RawAxiosResponseHeaders = Partial<RawAxiosHeaders & RawCommonResponseHeaders>;
			
 
				+
			
 
				+export type AxiosResponseHeaders = RawAxiosResponseHeaders & AxiosHeaders;
			
 
				+
			
 
				+export interface AxiosRequestTransformer {
			
 
				+  (this: InternalAxiosRequestConfig, data: any, headers: AxiosRequestHeaders): any;
			
 
				+}
			
 
				+
			
 
				+export interface AxiosResponseTransformer {
			
 
				+  (this: InternalAxiosRequestConfig, data: any, headers: AxiosResponseHeaders, status?: number): any;
			
 
				+}
			
 
				+
			
 
				+export interface AxiosAdapter {
			
 
				+  (config: InternalAxiosRequestConfig): AxiosPromise;
			
 
				+}
			
 
				+
			
 
				+export interface AxiosBasicCredentials {
			
 
				+  username: string;
			
 
				+  password: string;
			
 
				+}
			
 
				+
			
 
				+export interface AxiosProxyConfig {
			
 
				+  host: string;
			
 
				+  port: number;
			
 
				+  auth?: AxiosBasicCredentials;
			
 
				+  protocol?: string;
			
 
				+}
			
 
				+
			
 
				+export enum HttpStatusCode {
			
 
				+  Continue = 100,
			
 
				+  SwitchingProtocols = 101,
			
 
				+  Processing = 102,
			
 
				+  EarlyHints = 103,
			
 
				+  Ok = 200,
			
 
				+  Created = 201,
			
 
				+  Accepted = 202,
			
 
				+  NonAuthoritativeInformation = 203,
			
 
				+  NoContent = 204,
			
 
				+  ResetContent = 205,
			
 
				+  PartialContent = 206,
			
 
				+  MultiStatus = 207,
			
 
				+  AlreadyReported = 208,
			
 
				+  ImUsed = 226,
			
 
				+  MultipleChoices = 300,
			
 
				+  MovedPermanently = 301,
			
 
				+  Found = 302,
			
 
				+  SeeOther = 303,
			
 
				+  NotModified = 304,
			
 
				+  UseProxy = 305,
			
 
				+  Unused = 306,
			
 
				+  TemporaryRedirect = 307,
			
 
				+  PermanentRedirect = 308,
			
 
				+  BadRequest = 400,
			
 
				+  Unauthorized = 401,
			
 
				+  PaymentRequired = 402,
			
 
				+  Forbidden = 403,
			
 
				+  NotFound = 404,
			
 
				+  MethodNotAllowed = 405,
			
 
				+  NotAcceptable = 406,
			
 
				+  ProxyAuthenticationRequired = 407,
			
 
				+  RequestTimeout = 408,
			
 
				+  Conflict = 409,
			
 
				+  Gone = 410,
			
 
				+  LengthRequired = 411,
			
 
				+  PreconditionFailed = 412,
			
 
				+  PayloadTooLarge = 413,
			
 
				+  UriTooLong = 414,
			
 
				+  UnsupportedMediaType = 415,
			
 
				+  RangeNotSatisfiable = 416,
			
 
				+  ExpectationFailed = 417,
			
 
				+  ImATeapot = 418,
			
 
				+  MisdirectedRequest = 421,
			
 
				+  UnprocessableEntity = 422,
			
 
				+  Locked = 423,
			
 
				+  FailedDependency = 424,
			
 
				+  TooEarly = 425,
			
 
				+  UpgradeRequired = 426,
			
 
				+  PreconditionRequired = 428,
			
 
				+  TooManyRequests = 429,
			
 
				+  RequestHeaderFieldsTooLarge = 431,
			
 
				+  UnavailableForLegalReasons = 451,
			
 
				+  InternalServerError = 500,
			
 
				+  NotImplemented = 501,
			
 
				+  BadGateway = 502,
			
 
				+  ServiceUnavailable = 503,
			
 
				+  GatewayTimeout = 504,
			
 
				+  HttpVersionNotSupported = 505,
			
 
				+  VariantAlsoNegotiates = 506,
			
 
				+  InsufficientStorage = 507,
			
 
				+  LoopDetected = 508,
			
 
				+  NotExtended = 510,
			
 
				+  NetworkAuthenticationRequired = 511,
			
 
				+}
			
 
				+
			
 
				+export type Method =
			
 
				+    | 'get' | 'GET'
			
 
				+    | 'delete' | 'DELETE'
			
 
				+    | 'head' | 'HEAD'
			
 
				+    | 'options' | 'OPTIONS'
			
 
				+    | 'post' | 'POST'
			
 
				+    | 'put' | 'PUT'
			
 
				+    | 'patch' | 'PATCH'
			
 
				+    | 'purge' | 'PURGE'
			
 
				+    | 'link' | 'LINK'
			
 
				+    | 'unlink' | 'UNLINK';
			
 
				+
			
 
				+export type ResponseType =
			
 
				+    | 'arraybuffer'
			
 
				+    | 'blob'
			
 
				+    | 'document'
			
 
				+    | 'json'
			
 
				+    | 'text'
			
 
				+    | 'stream'
			
 
				+    | 'formdata';
			
 
				+
			
 
				+export type responseEncoding =
			
 
				+    | 'ascii' | 'ASCII'
			
 
				+    | 'ansi' | 'ANSI'
			
 
				+    | 'binary' | 'BINARY'
			
 
				+    | 'base64' | 'BASE64'
			
 
				+    | 'base64url' | 'BASE64URL'
			
 
				+    | 'hex' | 'HEX'
			
 
				+    | 'latin1' | 'LATIN1'
			
 
				+    | 'ucs-2' | 'UCS-2'
			
 
				+    | 'ucs2' | 'UCS2'
			
 
				+    | 'utf-8' | 'UTF-8'
			
 
				+    | 'utf8' | 'UTF8'
			
 
				+    | 'utf16le' | 'UTF16LE';
			
 
				+
			
 
				+export interface TransitionalOptions {
			
 
				+  silentJSONParsing?: boolean;
			
 
				+  forcedJSONParsing?: boolean;
			
 
				+  clarifyTimeoutError?: boolean;
			
 
				+}
			
 
				+
			
 
				+export interface GenericAbortSignal {
			
 
				+  readonly aborted: boolean;
			
 
				+  onabort?: ((...args: any) => any) | null;
			
 
				+  addEventListener?: (...args: any) => any;
			
 
				+  removeEventListener?: (...args: any) => any;
			
 
				+}
			
 
				+
			
 
				+export interface FormDataVisitorHelpers {
			
 
				+  defaultVisitor: SerializerVisitor;
			
 
				+  convertValue: (value: any) => any;
			
 
				+  isVisitable: (value: any) => boolean;
			
 
				+}
			
 
				+
			
 
				+export interface SerializerVisitor {
			
 
				+  (
			
 
				+      this: GenericFormData,
			
 
				+      value: any,
			
 
				+      key: string | number,
			
 
				+      path: null | Array<string | number>,
			
 
				+      helpers: FormDataVisitorHelpers
			
 
				+  ): boolean;
			
 
				+}
			
 
				+
			
 
				+export interface SerializerOptions {
			
 
				+  visitor?: SerializerVisitor;
			
 
				+  dots?: boolean;
			
 
				+  metaTokens?: boolean;
			
 
				+  indexes?: boolean | null;
			
 
				+}
			
 
				+
			
 
				+// tslint:disable-next-line
			
 
				+export interface FormSerializerOptions extends SerializerOptions {
			
 
				+}
			
 
				+
			
 
				+export interface ParamEncoder {
			
 
				+  (value: any, defaultEncoder: (value: any) => any): any;
			
 
				+}
			
 
				+
			
 
				+export interface CustomParamsSerializer {
			
 
				+  (params: Record<string, any>, options?: ParamsSerializerOptions): string;
			
 
				+}
			
 
				+
			
 
				+export interface ParamsSerializerOptions extends SerializerOptions {
			
 
				+  encode?: ParamEncoder;
			
 
				+  serialize?: CustomParamsSerializer;
			
 
				+}
			
 
				+
			
 
				+type MaxUploadRate = number;
			
 
				+
			
 
				+type MaxDownloadRate = number;
			
 
				+
			
 
				+type BrowserProgressEvent = any;
			
 
				+
			
 
				+export interface AxiosProgressEvent {
			
 
				+  loaded: number;
			
 
				+  total?: number;
			
 
				+  progress?: number;
			
 
				+  bytes: number;
			
 
				+  rate?: number;
			
 
				+  estimated?: number;
			
 
				+  upload?: boolean;
			
 
				+  download?: boolean;
			
 
				+  event?: BrowserProgressEvent;
			
 
				+  lengthComputable: boolean;
			
 
				+}
			
 
				+
			
 
				+type Milliseconds = number;
			
 
				+
			
 
				+type AxiosAdapterName = 'fetch' | 'xhr' | 'http' | string;
			
 
				+
			
 
				+type AxiosAdapterConfig = AxiosAdapter | AxiosAdapterName;
			
 
				+
			
 
				+export type AddressFamily = 4 | 6 | undefined;
			
 
				+
			
 
				+export interface LookupAddressEntry {
			
 
				+  address: string;
			
 
				+  family?: AddressFamily;
			
 
				+}
			
 
				+
			
 
				+export type LookupAddress = string | LookupAddressEntry;
			
 
				+
			
 
				+export interface AxiosRequestConfig<D = any> {
			
 
				+  url?: string;
			
 
				+  method?: Method | string;
			
 
				+  baseURL?: string;
			
 
				+  allowAbsoluteUrls?: boolean;
			
 
				+  transformRequest?: AxiosRequestTransformer | AxiosRequestTransformer[];
			
 
				+  transformResponse?: AxiosResponseTransformer | AxiosResponseTransformer[];
			
 
				+  headers?: (RawAxiosRequestHeaders & MethodsHeaders) | AxiosHeaders;
			
 
				+  params?: any;
			
 
				+  paramsSerializer?: ParamsSerializerOptions | CustomParamsSerializer;
			
 
				+  data?: D;
			
 
				+  timeout?: Milliseconds;
			
 
				+  timeoutErrorMessage?: string;
			
 
				+  withCredentials?: boolean;
			
 
				+  adapter?: AxiosAdapterConfig | AxiosAdapterConfig[];
			
 
				+  auth?: AxiosBasicCredentials;
			
 
				+  responseType?: ResponseType;
			
 
				+  responseEncoding?: responseEncoding | string;
			
 
				+  xsrfCookieName?: string;
			
 
				+  xsrfHeaderName?: string;
			
 
				+  onUploadProgress?: (progressEvent: AxiosProgressEvent) => void;
			
 
				+  onDownloadProgress?: (progressEvent: AxiosProgressEvent) => void;
			
 
				+  maxContentLength?: number;
			
 
				+  validateStatus?: ((status: number) => boolean) | null;
			
 
				+  maxBodyLength?: number;
			
 
				+  maxRedirects?: number;
			
 
				+  maxRate?: number | [MaxUploadRate, MaxDownloadRate];
			
 
				+  beforeRedirect?: (options: Record<string, any>, responseDetails: {headers: Record<string, string>, statusCode: HttpStatusCode}) => void;
			
 
				+  socketPath?: string | null;
			
 
				+  transport?: any;
			
 
				+  httpAgent?: any;
			
 
				+  httpsAgent?: any;
			
 
				+  proxy?: AxiosProxyConfig | false;
			
 
				+  cancelToken?: CancelToken;
			
 
				+  decompress?: boolean;
			
 
				+  transitional?: TransitionalOptions;
			
 
				+  signal?: GenericAbortSignal;
			
 
				+  insecureHTTPParser?: boolean;
			
 
				+  env?: {
			
 
				+    FormData?: new (...args: any[]) => object;
			
 
				+  };
			
 
				+  formSerializer?: FormSerializerOptions;
			
 
				+  family?: AddressFamily;
			
 
				+  lookup?: ((hostname: string, options: object, cb: (err: Error | null, address: LookupAddress | LookupAddress[], family?: AddressFamily) => void) => void) |
			
 
				+      ((hostname: string, options: object) => Promise<[address: LookupAddressEntry | LookupAddressEntry[], family?: AddressFamily] | LookupAddress>);
			
 
				+  withXSRFToken?: boolean | ((config: InternalAxiosRequestConfig) => boolean | undefined);
			
 
				+  fetchOptions?: Record<string, any>;
			
 
				+}
			
 
				+
			
 
				+// Alias
			
 
				+export type RawAxiosRequestConfig<D = any> = AxiosRequestConfig<D>;
			
 
				+
			
 
				+export interface InternalAxiosRequestConfig<D = any> extends AxiosRequestConfig<D> {
			
 
				+  headers: AxiosRequestHeaders;
			
 
				+}
			
 
				+
			
 
				+export interface HeadersDefaults {
			
 
				+  common: RawAxiosRequestHeaders;
			
 
				+  delete: RawAxiosRequestHeaders;
			
 
				+  get: RawAxiosRequestHeaders;
			
 
				+  head: RawAxiosRequestHeaders;
			
 
				+  post: RawAxiosRequestHeaders;
			
 
				+  put: RawAxiosRequestHeaders;
			
 
				+  patch: RawAxiosRequestHeaders;
			
 
				+  options?: RawAxiosRequestHeaders;
			
 
				+  purge?: RawAxiosRequestHeaders;
			
 
				+  link?: RawAxiosRequestHeaders;
			
 
				+  unlink?: RawAxiosRequestHeaders;
			
 
				+}
			
 
				+
			
 
				+export interface AxiosDefaults<D = any> extends Omit<AxiosRequestConfig<D>, 'headers'> {
			
 
				+  headers: HeadersDefaults;
			
 
				+}
			
 
				+
			
 
				+export interface CreateAxiosDefaults<D = any> extends Omit<AxiosRequestConfig<D>, 'headers'> {
			
 
				+  headers?: RawAxiosRequestHeaders | AxiosHeaders | Partial<HeadersDefaults>;
			
 
				+}
			
 
				+
			
 
				+export interface AxiosResponse<T = any, D = any> {
			
 
				+  data: T;
			
 
				+  status: number;
			
 
				+  statusText: string;
			
 
				+  headers: RawAxiosResponseHeaders | AxiosResponseHeaders;
			
 
				+  config: InternalAxiosRequestConfig<D>;
			
 
				+  request?: any;
			
 
				+}
			
 
				+
			
 
				+export class AxiosError<T = unknown, D = any> extends Error {
			
 
				+  constructor(
			
 
				+      message?: string,
			
 
				+      code?: string,
			
 
				+      config?: InternalAxiosRequestConfig<D>,
			
 
				+      request?: any,
			
 
				+      response?: AxiosResponse<T, D>
			
 
				+  );
			
 
				+
			
 
				+  config?: InternalAxiosRequestConfig<D>;
			
 
				+  code?: string;
			
 
				+  request?: any;
			
 
				+  response?: AxiosResponse<T, D>;
			
 
				+  isAxiosError: boolean;
			
 
				+  status?: number;
			
 
				+  toJSON: () => object;
			
 
				+  cause?: Error;
			
 
				+  static from<T = unknown, D = any>(
			
 
				+    error: Error | unknown,
			
 
				+    code?: string,
			
 
				+    config?: InternalAxiosRequestConfig<D>,
			
 
				+    request?: any,
			
 
				+    response?: AxiosResponse<T, D>,
			
 
				+    customProps?: object,
			
 
				+): AxiosError<T, D>;
			
 
				+  static readonly ERR_FR_TOO_MANY_REDIRECTS = "ERR_FR_TOO_MANY_REDIRECTS";
			
 
				+  static readonly ERR_BAD_OPTION_VALUE = "ERR_BAD_OPTION_VALUE";
			
 
				+  static readonly ERR_BAD_OPTION = "ERR_BAD_OPTION";
			
 
				+  static readonly ERR_NETWORK = "ERR_NETWORK";
			
 
				+  static readonly ERR_DEPRECATED = "ERR_DEPRECATED";
			
 
				+  static readonly ERR_BAD_RESPONSE = "ERR_BAD_RESPONSE";
			
 
				+  static readonly ERR_BAD_REQUEST = "ERR_BAD_REQUEST";
			
 
				+  static readonly ERR_NOT_SUPPORT = "ERR_NOT_SUPPORT";
			
 
				+  static readonly ERR_INVALID_URL = "ERR_INVALID_URL";
			
 
				+  static readonly ERR_CANCELED = "ERR_CANCELED";
			
 
				+  static readonly ECONNABORTED = "ECONNABORTED";
			
 
				+  static readonly ETIMEDOUT = "ETIMEDOUT";
			
 
				+}
			
 
				+
			
 
				+export class CanceledError<T> extends AxiosError<T> {
			
 
				+}
			
 
				+
			
 
				+export type AxiosPromise<T = any> = Promise<AxiosResponse<T>>;
			
 
				+
			
 
				+export interface CancelStatic {
			
 
				+  new (message?: string): Cancel;
			
 
				+}
			
 
				+
			
 
				+export interface Cancel {
			
 
				+  message: string | undefined;
			
 
				+}
			
 
				+
			
 
				+export interface Canceler {
			
 
				+  (message?: string, config?: AxiosRequestConfig, request?: any): void;
			
 
				+}
			
 
				+
			
 
				+export interface CancelTokenStatic {
			
 
				+  new (executor: (cancel: Canceler) => void): CancelToken;
			
 
				+  source(): CancelTokenSource;
			
 
				+}
			
 
				+
			
 
				+export interface CancelToken {
			
 
				+  promise: Promise<Cancel>;
			
 
				+  reason?: Cancel;
			
 
				+  throwIfRequested(): void;
			
 
				+}
			
 
				+
			
 
				+export interface CancelTokenSource {
			
 
				+  token: CancelToken;
			
 
				+  cancel: Canceler;
			
 
				+}
			
 
				+
			
 
				+export interface AxiosInterceptorOptions {
			
 
				+  synchronous?: boolean;
			
 
				+  runWhen?: (config: InternalAxiosRequestConfig) => boolean;
			
 
				+}
			
 
				+
			
 
				+type AxiosRequestInterceptorUse<T> = (onFulfilled?: ((value: T) => T | Promise<T>) | null, onRejected?: ((error: any) => any) | null, options?: AxiosInterceptorOptions) => number;
			
 
				+
			
 
				+type AxiosResponseInterceptorUse<T> = (onFulfilled?: ((value: T) => T | Promise<T>) | null, onRejected?: ((error: any) => any) | null) => number;
			
 
				+
			
 
				+export interface AxiosInterceptorManager<V> {
			
 
				+  use: V extends AxiosResponse ? AxiosResponseInterceptorUse<V> : AxiosRequestInterceptorUse<V>;
			
 
				+  eject(id: number): void;
			
 
				+  clear(): void;
			
 
				+}
			
 
				+
			
 
				+export class Axios {
			
 
				+  constructor(config?: AxiosRequestConfig);
			
 
				+  defaults: AxiosDefaults;
			
 
				+  interceptors: {
			
 
				+    request: AxiosInterceptorManager<InternalAxiosRequestConfig>;
			
 
				+    response: AxiosInterceptorManager<AxiosResponse>;
			
 
				+  };
			
 
				+  getUri(config?: AxiosRequestConfig): string;
			
 
				+  request<T = any, R = AxiosResponse<T>, D = any>(config: AxiosRequestConfig<D>): Promise<R>;
			
 
				+  get<T = any, R = AxiosResponse<T>, D = any>(url: string, config?: AxiosRequestConfig<D>): Promise<R>;
			
 
				+  delete<T = any, R = AxiosResponse<T>, D = any>(url: string, config?: AxiosRequestConfig<D>): Promise<R>;
			
 
				+  head<T = any, R = AxiosResponse<T>, D = any>(url: string, config?: AxiosRequestConfig<D>): Promise<R>;
			
 
				+  options<T = any, R = AxiosResponse<T>, D = any>(url: string, config?: AxiosRequestConfig<D>): Promise<R>;
			
 
				+  post<T = any, R = AxiosResponse<T>, D = any>(url: string, data?: D, config?: AxiosRequestConfig<D>): Promise<R>;
			
 
				+  put<T = any, R = AxiosResponse<T>, D = any>(url: string, data?: D, config?: AxiosRequestConfig<D>): Promise<R>;
			
 
				+  patch<T = any, R = AxiosResponse<T>, D = any>(url: string, data?: D, config?: AxiosRequestConfig<D>): Promise<R>;
			
 
				+  postForm<T = any, R = AxiosResponse<T>, D = any>(url: string, data?: D, config?: AxiosRequestConfig<D>): Promise<R>;
			
 
				+  putForm<T = any, R = AxiosResponse<T>, D = any>(url: string, data?: D, config?: AxiosRequestConfig<D>): Promise<R>;
			
 
				+  patchForm<T = any, R = AxiosResponse<T>, D = any>(url: string, data?: D, config?: AxiosRequestConfig<D>): Promise<R>;
			
 
				+}
			
 
				+
			
 
				+export interface AxiosInstance extends Axios {
			
 
				+  <T = any, R = AxiosResponse<T>, D = any>(config: AxiosRequestConfig<D>): Promise<R>;
			
 
				+  <T = any, R = AxiosResponse<T>, D = any>(url: string, config?: AxiosRequestConfig<D>): Promise<R>;
			
 
				+
			
 
				+  defaults: Omit<AxiosDefaults, 'headers'> & {
			
 
				+    headers: HeadersDefaults & {
			
 
				+      [key: string]: AxiosHeaderValue
			
 
				+    }
			
 
				+  };
			
 
				+}
			
 
				+
			
 
				+export interface GenericFormData {
			
 
				+  append(name: string, value: any, options?: any): any;
			
 
				+}
			
 
				+
			
 
				+export interface GenericHTMLFormElement {
			
 
				+  name: string;
			
 
				+  method: string;
			
 
				+  submit(): void;
			
 
				+}
			
 
				+
			
 
				+export function getAdapter(adapters: AxiosAdapterConfig | AxiosAdapterConfig[] | undefined): AxiosAdapter;
			
 
				+
			
 
				+export function toFormData(sourceObj: object, targetFormData?: GenericFormData, options?: FormSerializerOptions): GenericFormData;
			
 
				+
			
 
				+export function formToJSON(form: GenericFormData|GenericHTMLFormElement): object;
			
 
				+
			
 
				+export function isAxiosError<T = any, D = any>(payload: any): payload is AxiosError<T, D>;
			
 
				+
			
 
				+export function spread<T, R>(callback: (...args: T[]) => R): (array: T[]) => R;
			
 
				+
			
 
				+export function isCancel(value: any): value is Cancel;
			
 
				+
			
 
				+export function all<T>(values: Array<T | Promise<T>>): Promise<T[]>;
			
 
				+
			
 
				+export function mergeConfig<D = any>(config1: AxiosRequestConfig<D>, config2: AxiosRequestConfig<D>): AxiosRequestConfig<D>;
			
 
				+
			
 
				+export interface AxiosStatic extends AxiosInstance {
			
 
				+  create(config?: CreateAxiosDefaults): AxiosInstance;
			
 
				+  Cancel: CancelStatic;
			
 
				+  CancelToken: CancelTokenStatic;
			
 
				+  Axios: typeof Axios;
			
 
				+  AxiosError: typeof AxiosError;
			
 
				+  HttpStatusCode: typeof HttpStatusCode;
			
 
				+  readonly VERSION: string;
			
 
				+  isCancel: typeof isCancel;
			
 
				+  all: typeof all;
			
 
				+  spread: typeof spread;
			
 
				+  isAxiosError: typeof isAxiosError;
			
 
				+  toFormData: typeof toFormData;
			
 
				+  formToJSON: typeof formToJSON;
			
 
				+  getAdapter: typeof getAdapter;
			
 
				+  CanceledError: typeof CanceledError;
			
 
				+  AxiosHeaders: typeof AxiosHeaders;
			
 
				+  mergeConfig: typeof mergeConfig;
			
 
				+}
			
 
				+
			
 
				+declare const axios: AxiosStatic;
			
 
				+
			
 
				+export default axios;
			
--- a/node_modules/axios/index.js
+++ b/node_modules/axios/index.js
@@ -0,0 +1,43 @@
 
				+import axios from './lib/axios.js';
			
 
				+
			
 
				+// This module is intended to unwrap Axios default export as named.
			
 
				+// Keep top-level export same with static properties
			
 
				+// so that it can keep same with es module or cjs
			
 
				+const {
			
 
				+  Axios,
			
 
				+  AxiosError,
			
 
				+  CanceledError,
			
 
				+  isCancel,
			
 
				+  CancelToken,
			
 
				+  VERSION,
			
 
				+  all,
			
 
				+  Cancel,
			
 
				+  isAxiosError,
			
 
				+  spread,
			
 
				+  toFormData,
			
 
				+  AxiosHeaders,
			
 
				+  HttpStatusCode,
			
 
				+  formToJSON,
			
 
				+  getAdapter,
			
 
				+  mergeConfig
			
 
				+} = axios;
			
 
				+
			
 
				+export {
			
 
				+  axios as default,
			
 
				+  Axios,
			
 
				+  AxiosError,
			
 
				+  CanceledError,
			
 
				+  isCancel,
			
 
				+  CancelToken,
			
 
				+  VERSION,
			
 
				+  all,
			
 
				+  Cancel,
			
 
				+  isAxiosError,
			
 
				+  spread,
			
 
				+  toFormData,
			
 
				+  AxiosHeaders,
			
 
				+  HttpStatusCode,
			
 
				+  formToJSON,
			
 
				+  getAdapter,
			
 
				+  mergeConfig
			
 
				+}
			
--- a/node_modules/axios/lib/adapters/README.md
+++ b/node_modules/axios/lib/adapters/README.md
@@ -0,0 +1,37 @@
 
				+# axios // adapters
			
 
				+
			
 
				+The modules under `adapters/` are modules that handle dispatching a request and settling a returned `Promise` once a response is received.
			
 
				+
			
 
				+## Example
			
 
				+
			
 
				+```js
			
 
				+var settle = require('./../core/settle');
			
 
				+
			
 
				+module.exports = function myAdapter(config) {
			
 
				+  // At this point:
			
 
				+  //  - config has been merged with defaults
			
 
				+  //  - request transformers have already run
			
 
				+  //  - request interceptors have already run
			
 
				+  
			
 
				+  // Make the request using config provided
			
 
				+  // Upon response settle the Promise
			
 
				+
			
 
				+  return new Promise(function(resolve, reject) {
			
 
				+  
			
 
				+    var response = {
			
 
				+      data: responseData,
			
 
				+      status: request.status,
			
 
				+      statusText: request.statusText,
			
 
				+      headers: responseHeaders,
			
 
				+      config: config,
			
 
				+      request: request
			
 
				+    };
			
 
				+
			
 
				+    settle(resolve, reject, response);
			
 
				+
			
 
				+    // From here:
			
 
				+    //  - response transformers will run
			
 
				+    //  - response interceptors will run
			
 
				+  });
			
 
				+}
			
 
				+```
			
--- a/node_modules/axios/lib/adapters/adapters.js
+++ b/node_modules/axios/lib/adapters/adapters.js
@@ -0,0 +1,79 @@
 
				+import utils from '../utils.js';
			
 
				+import httpAdapter from './http.js';
			
 
				+import xhrAdapter from './xhr.js';
			
 
				+import fetchAdapter from './fetch.js';
			
 
				+import AxiosError from "../core/AxiosError.js";
			
 
				+
			
 
				+const knownAdapters = {
			
 
				+  http: httpAdapter,
			
 
				+  xhr: xhrAdapter,
			
 
				+  fetch: fetchAdapter
			
 
				+}
			
 
				+
			
 
				+utils.forEach(knownAdapters, (fn, value) => {
			
 
				+  if (fn) {
			
 
				+    try {
			
 
				+      Object.defineProperty(fn, 'name', {value});
			
 
				+    } catch (e) {
			
 
				+      // eslint-disable-next-line no-empty
			
 
				+    }
			
 
				+    Object.defineProperty(fn, 'adapterName', {value});
			
 
				+  }
			
 
				+});
			
 
				+
			
 
				+const renderReason = (reason) => `- ${reason}`;
			
 
				+
			
 
				+const isResolvedHandle = (adapter) => utils.isFunction(adapter) || adapter === null || adapter === false;
			
 
				+
			
 
				+export default {
			
 
				+  getAdapter: (adapters) => {
			
 
				+    adapters = utils.isArray(adapters) ? adapters : [adapters];
			
 
				+
			
 
				+    const {length} = adapters;
			
 
				+    let nameOrAdapter;
			
 
				+    let adapter;
			
 
				+
			
 
				+    const rejectedReasons = {};
			
 
				+
			
 
				+    for (let i = 0; i < length; i++) {
			
 
				+      nameOrAdapter = adapters[i];
			
 
				+      let id;
			
 
				+
			
 
				+      adapter = nameOrAdapter;
			
 
				+
			
 
				+      if (!isResolvedHandle(nameOrAdapter)) {
			
 
				+        adapter = knownAdapters[(id = String(nameOrAdapter)).toLowerCase()];
			
 
				+
			
 
				+        if (adapter === undefined) {
			
 
				+          throw new AxiosError(`Unknown adapter '${id}'`);
			
 
				+        }
			
 
				+      }
			
 
				+
			
 
				+      if (adapter) {
			
 
				+        break;
			
 
				+      }
			
 
				+
			
 
				+      rejectedReasons[id || '#' + i] = adapter;
			
 
				+    }
			
 
				+
			
 
				+    if (!adapter) {
			
 
				+
			
 
				+      const reasons = Object.entries(rejectedReasons)
			
 
				+        .map(([id, state]) => `adapter ${id} ` +
			
 
				+          (state === false ? 'is not supported by the environment' : 'is not available in the build')
			
 
				+        );
			
 
				+
			
 
				+      let s = length ?
			
 
				+        (reasons.length > 1 ? 'since :\n' + reasons.map(renderReason).join('\n') : ' ' + renderReason(reasons[0])) :
			
 
				+        'as no adapter specified';
			
 
				+
			
 
				+      throw new AxiosError(
			
 
				+        `There is no suitable adapter to dispatch the request ` + s,
			
 
				+        'ERR_NOT_SUPPORT'
			
 
				+      );
			
 
				+    }
			
 
				+
			
 
				+    return adapter;
			
 
				+  },
			
 
				+  adapters: knownAdapters
			
 
				+}
			
--- a/node_modules/axios/lib/adapters/fetch.js
+++ b/node_modules/axios/lib/adapters/fetch.js
@@ -0,0 +1,229 @@
 
				+import platform from "../platform/index.js";
			
 
				+import utils from "../utils.js";
			
 
				+import AxiosError from "../core/AxiosError.js";
			
 
				+import composeSignals from "../helpers/composeSignals.js";
			
 
				+import {trackStream} from "../helpers/trackStream.js";
			
 
				+import AxiosHeaders from "../core/AxiosHeaders.js";
			
 
				+import {progressEventReducer, progressEventDecorator, asyncDecorator} from "../helpers/progressEventReducer.js";
			
 
				+import resolveConfig from "../helpers/resolveConfig.js";
			
 
				+import settle from "../core/settle.js";
			
 
				+
			
 
				+const isFetchSupported = typeof fetch === 'function' && typeof Request === 'function' && typeof Response === 'function';
			
 
				+const isReadableStreamSupported = isFetchSupported && typeof ReadableStream === 'function';
			
 
				+
			
 
				+// used only inside the fetch adapter
			
 
				+const encodeText = isFetchSupported && (typeof TextEncoder === 'function' ?
			
 
				+    ((encoder) => (str) => encoder.encode(str))(new TextEncoder()) :
			
 
				+    async (str) => new Uint8Array(await new Response(str).arrayBuffer())
			
 
				+);
			
 
				+
			
 
				+const test = (fn, ...args) => {
			
 
				+  try {
			
 
				+    return !!fn(...args);
			
 
				+  } catch (e) {
			
 
				+    return false
			
 
				+  }
			
 
				+}
			
 
				+
			
 
				+const supportsRequestStream = isReadableStreamSupported && test(() => {
			
 
				+  let duplexAccessed = false;
			
 
				+
			
 
				+  const hasContentType = new Request(platform.origin, {
			
 
				+    body: new ReadableStream(),
			
 
				+    method: 'POST',
			
 
				+    get duplex() {
			
 
				+      duplexAccessed = true;
			
 
				+      return 'half';
			
 
				+    },
			
 
				+  }).headers.has('Content-Type');
			
 
				+
			
 
				+  return duplexAccessed && !hasContentType;
			
 
				+});
			
 
				+
			
 
				+const DEFAULT_CHUNK_SIZE = 64 * 1024;
			
 
				+
			
 
				+const supportsResponseStream = isReadableStreamSupported &&
			
 
				+  test(() => utils.isReadableStream(new Response('').body));
			
 
				+
			
 
				+
			
 
				+const resolvers = {
			
 
				+  stream: supportsResponseStream && ((res) => res.body)
			
 
				+};
			
 
				+
			
 
				+isFetchSupported && (((res) => {
			
 
				+  ['text', 'arrayBuffer', 'blob', 'formData', 'stream'].forEach(type => {
			
 
				+    !resolvers[type] && (resolvers[type] = utils.isFunction(res[type]) ? (res) => res[type]() :
			
 
				+      (_, config) => {
			
 
				+        throw new AxiosError(`Response type '${type}' is not supported`, AxiosError.ERR_NOT_SUPPORT, config);
			
 
				+      })
			
 
				+  });
			
 
				+})(new Response));
			
 
				+
			
 
				+const getBodyLength = async (body) => {
			
 
				+  if (body == null) {
			
 
				+    return 0;
			
 
				+  }
			
 
				+
			
 
				+  if(utils.isBlob(body)) {
			
 
				+    return body.size;
			
 
				+  }
			
 
				+
			
 
				+  if(utils.isSpecCompliantForm(body)) {
			
 
				+    const _request = new Request(platform.origin, {
			
 
				+      method: 'POST',
			
 
				+      body,
			
 
				+    });
			
 
				+    return (await _request.arrayBuffer()).byteLength;
			
 
				+  }
			
 
				+
			
 
				+  if(utils.isArrayBufferView(body) || utils.isArrayBuffer(body)) {
			
 
				+    return body.byteLength;
			
 
				+  }
			
 
				+
			
 
				+  if(utils.isURLSearchParams(body)) {
			
 
				+    body = body + '';
			
 
				+  }
			
 
				+
			
 
				+  if(utils.isString(body)) {
			
 
				+    return (await encodeText(body)).byteLength;
			
 
				+  }
			
 
				+}
			
 
				+
			
 
				+const resolveBodyLength = async (headers, body) => {
			
 
				+  const length = utils.toFiniteNumber(headers.getContentLength());
			
 
				+
			
 
				+  return length == null ? getBodyLength(body) : length;
			
 
				+}
			
 
				+
			
 
				+export default isFetchSupported && (async (config) => {
			
 
				+  let {
			
 
				+    url,
			
 
				+    method,
			
 
				+    data,
			
 
				+    signal,
			
 
				+    cancelToken,
			
 
				+    timeout,
			
 
				+    onDownloadProgress,
			
 
				+    onUploadProgress,
			
 
				+    responseType,
			
 
				+    headers,
			
 
				+    withCredentials = 'same-origin',
			
 
				+    fetchOptions
			
 
				+  } = resolveConfig(config);
			
 
				+
			
 
				+  responseType = responseType ? (responseType + '').toLowerCase() : 'text';
			
 
				+
			
 
				+  let composedSignal = composeSignals([signal, cancelToken && cancelToken.toAbortSignal()], timeout);
			
 
				+
			
 
				+  let request;
			
 
				+
			
 
				+  const unsubscribe = composedSignal && composedSignal.unsubscribe && (() => {
			
 
				+      composedSignal.unsubscribe();
			
 
				+  });
			
 
				+
			
 
				+  let requestContentLength;
			
 
				+
			
 
				+  try {
			
 
				+    if (
			
 
				+      onUploadProgress && supportsRequestStream && method !== 'get' && method !== 'head' &&
			
 
				+      (requestContentLength = await resolveBodyLength(headers, data)) !== 0
			
 
				+    ) {
			
 
				+      let _request = new Request(url, {
			
 
				+        method: 'POST',
			
 
				+        body: data,
			
 
				+        duplex: "half"
			
 
				+      });
			
 
				+
			
 
				+      let contentTypeHeader;
			
 
				+
			
 
				+      if (utils.isFormData(data) && (contentTypeHeader = _request.headers.get('content-type'))) {
			
 
				+        headers.setContentType(contentTypeHeader)
			
 
				+      }
			
 
				+
			
 
				+      if (_request.body) {
			
 
				+        const [onProgress, flush] = progressEventDecorator(
			
 
				+          requestContentLength,
			
 
				+          progressEventReducer(asyncDecorator(onUploadProgress))
			
 
				+        );
			
 
				+
			
 
				+        data = trackStream(_request.body, DEFAULT_CHUNK_SIZE, onProgress, flush);
			
 
				+      }
			
 
				+    }
			
 
				+
			
 
				+    if (!utils.isString(withCredentials)) {
			
 
				+      withCredentials = withCredentials ? 'include' : 'omit';
			
 
				+    }
			
 
				+
			
 
				+    // Cloudflare Workers throws when credentials are defined
			
 
				+    // see https://github.com/cloudflare/workerd/issues/902
			
 
				+    const isCredentialsSupported = "credentials" in Request.prototype;
			
 
				+    request = new Request(url, {
			
 
				+      ...fetchOptions,
			
 
				+      signal: composedSignal,
			
 
				+      method: method.toUpperCase(),
			
 
				+      headers: headers.normalize().toJSON(),
			
 
				+      body: data,
			
 
				+      duplex: "half",
			
 
				+      credentials: isCredentialsSupported ? withCredentials : undefined
			
 
				+    });
			
 
				+
			
 
				+    let response = await fetch(request);
			
 
				+
			
 
				+    const isStreamResponse = supportsResponseStream && (responseType === 'stream' || responseType === 'response');
			
 
				+
			
 
				+    if (supportsResponseStream && (onDownloadProgress || (isStreamResponse && unsubscribe))) {
			
 
				+      const options = {};
			
 
				+
			
 
				+      ['status', 'statusText', 'headers'].forEach(prop => {
			
 
				+        options[prop] = response[prop];
			
 
				+      });
			
 
				+
			
 
				+      const responseContentLength = utils.toFiniteNumber(response.headers.get('content-length'));
			
 
				+
			
 
				+      const [onProgress, flush] = onDownloadProgress && progressEventDecorator(
			
 
				+        responseContentLength,
			
 
				+        progressEventReducer(asyncDecorator(onDownloadProgress), true)
			
 
				+      ) || [];
			
 
				+
			
 
				+      response = new Response(
			
 
				+        trackStream(response.body, DEFAULT_CHUNK_SIZE, onProgress, () => {
			
 
				+          flush && flush();
			
 
				+          unsubscribe && unsubscribe();
			
 
				+        }),
			
 
				+        options
			
 
				+      );
			
 
				+    }
			
 
				+
			
 
				+    responseType = responseType || 'text';
			
 
				+
			
 
				+    let responseData = await resolvers[utils.findKey(resolvers, responseType) || 'text'](response, config);
			
 
				+
			
 
				+    !isStreamResponse && unsubscribe && unsubscribe();
			
 
				+
			
 
				+    return await new Promise((resolve, reject) => {
			
 
				+      settle(resolve, reject, {
			
 
				+        data: responseData,
			
 
				+        headers: AxiosHeaders.from(response.headers),
			
 
				+        status: response.status,
			
 
				+        statusText: response.statusText,
			
 
				+        config,
			
 
				+        request
			
 
				+      })
			
 
				+    })
			
 
				+  } catch (err) {
			
 
				+    unsubscribe && unsubscribe();
			
 
				+
			
 
				+    if (err && err.name === 'TypeError' && /fetch/i.test(err.message)) {
			
 
				+      throw Object.assign(
			
 
				+        new AxiosError('Network Error', AxiosError.ERR_NETWORK, config, request),
			
 
				+        {
			
 
				+          cause: err.cause || err
			
 
				+        }
			
 
				+      )
			
 
				+    }
			
 
				+
			
 
				+    throw AxiosError.from(err, err && err.code, config, request);
			
 
				+  }
			
 
				+});
			
 
				+
			
 
				+
			
--- a/node_modules/axios/lib/adapters/http.js
+++ b/node_modules/axios/lib/adapters/http.js
@@ -0,0 +1,695 @@
 
				+'use strict';
			
 
				+
			
 
				+import utils from './../utils.js';
			
 
				+import settle from './../core/settle.js';
			
 
				+import buildFullPath from '../core/buildFullPath.js';
			
 
				+import buildURL from './../helpers/buildURL.js';
			
 
				+import proxyFromEnv from 'proxy-from-env';
			
 
				+import http from 'http';
			
 
				+import https from 'https';
			
 
				+import util from 'util';
			
 
				+import followRedirects from 'follow-redirects';
			
 
				+import zlib from 'zlib';
			
 
				+import {VERSION} from '../env/data.js';
			
 
				+import transitionalDefaults from '../defaults/transitional.js';
			
 
				+import AxiosError from '../core/AxiosError.js';
			
 
				+import CanceledError from '../cancel/CanceledError.js';
			
 
				+import platform from '../platform/index.js';
			
 
				+import fromDataURI from '../helpers/fromDataURI.js';
			
 
				+import stream from 'stream';
			
 
				+import AxiosHeaders from '../core/AxiosHeaders.js';
			
 
				+import AxiosTransformStream from '../helpers/AxiosTransformStream.js';
			
 
				+import {EventEmitter} from 'events';
			
 
				+import formDataToStream from "../helpers/formDataToStream.js";
			
 
				+import readBlob from "../helpers/readBlob.js";
			
 
				+import ZlibHeaderTransformStream from '../helpers/ZlibHeaderTransformStream.js';
			
 
				+import callbackify from "../helpers/callbackify.js";
			
 
				+import {progressEventReducer, progressEventDecorator, asyncDecorator} from "../helpers/progressEventReducer.js";
			
 
				+
			
 
				+const zlibOptions = {
			
 
				+  flush: zlib.constants.Z_SYNC_FLUSH,
			
 
				+  finishFlush: zlib.constants.Z_SYNC_FLUSH
			
 
				+};
			
 
				+
			
 
				+const brotliOptions = {
			
 
				+  flush: zlib.constants.BROTLI_OPERATION_FLUSH,
			
 
				+  finishFlush: zlib.constants.BROTLI_OPERATION_FLUSH
			
 
				+}
			
 
				+
			
 
				+const isBrotliSupported = utils.isFunction(zlib.createBrotliDecompress);
			
 
				+
			
 
				+const {http: httpFollow, https: httpsFollow} = followRedirects;
			
 
				+
			
 
				+const isHttps = /https:?/;
			
 
				+
			
 
				+const supportedProtocols = platform.protocols.map(protocol => {
			
 
				+  return protocol + ':';
			
 
				+});
			
 
				+
			
 
				+const flushOnFinish = (stream, [throttled, flush]) => {
			
 
				+  stream
			
 
				+    .on('end', flush)
			
 
				+    .on('error', flush);
			
 
				+
			
 
				+  return throttled;
			
 
				+}
			
 
				+
			
 
				+/**
			
 
				+ * If the proxy or config beforeRedirects functions are defined, call them with the options
			
 
				+ * object.
			
 
				+ *
			
 
				+ * @param {Object<string, any>} options - The options object that was passed to the request.
			
 
				+ *
			
 
				+ * @returns {Object<string, any>}
			
 
				+ */
			
 
				+function dispatchBeforeRedirect(options, responseDetails) {
			
 
				+  if (options.beforeRedirects.proxy) {
			
 
				+    options.beforeRedirects.proxy(options);
			
 
				+  }
			
 
				+  if (options.beforeRedirects.config) {
			
 
				+    options.beforeRedirects.config(options, responseDetails);
			
 
				+  }
			
 
				+}
			
 
				+
			
 
				+/**
			
 
				+ * If the proxy or config afterRedirects functions are defined, call them with the options
			
 
				+ *
			
 
				+ * @param {http.ClientRequestArgs} options
			
 
				+ * @param {AxiosProxyConfig} configProxy configuration from Axios options object
			
 
				+ * @param {string} location
			
 
				+ *
			
 
				+ * @returns {http.ClientRequestArgs}
			
 
				+ */
			
 
				+function setProxy(options, configProxy, location) {
			
 
				+  let proxy = configProxy;
			
 
				+  if (!proxy && proxy !== false) {
			
 
				+    const proxyUrl = proxyFromEnv.getProxyForUrl(location);
			
 
				+    if (proxyUrl) {
			
 
				+      proxy = new URL(proxyUrl);
			
 
				+    }
			
 
				+  }
			
 
				+  if (proxy) {
			
 
				+    // Basic proxy authorization
			
 
				+    if (proxy.username) {
			
 
				+      proxy.auth = (proxy.username || '') + ':' + (proxy.password || '');
			
 
				+    }
			
 
				+
			
 
				+    if (proxy.auth) {
			
 
				+      // Support proxy auth object form
			
 
				+      if (proxy.auth.username || proxy.auth.password) {
			
 
				+        proxy.auth = (proxy.auth.username || '') + ':' + (proxy.auth.password || '');
			
 
				+      }
			
 
				+      const base64 = Buffer
			
 
				+        .from(proxy.auth, 'utf8')
			
 
				+        .toString('base64');
			
 
				+      options.headers['Proxy-Authorization'] = 'Basic ' + base64;
			
 
				+    }
			
 
				+
			
 
				+    options.headers.host = options.hostname + (options.port ? ':' + options.port : '');
			
 
				+    const proxyHost = proxy.hostname || proxy.host;
			
 
				+    options.hostname = proxyHost;
			
 
				+    // Replace 'host' since options is not a URL object
			
 
				+    options.host = proxyHost;
			
 
				+    options.port = proxy.port;
			
 
				+    options.path = location;
			
 
				+    if (proxy.protocol) {
			
 
				+      options.protocol = proxy.protocol.includes(':') ? proxy.protocol : `${proxy.protocol}:`;
			
 
				+    }
			
 
				+  }
			
 
				+
			
 
				+  options.beforeRedirects.proxy = function beforeRedirect(redirectOptions) {
			
 
				+    // Configure proxy for redirected request, passing the original config proxy to apply
			
 
				+    // the exact same logic as if the redirected request was performed by axios directly.
			
 
				+    setProxy(redirectOptions, configProxy, redirectOptions.href);
			
 
				+  };
			
 
				+}
			
 
				+
			
 
				+const isHttpAdapterSupported = typeof process !== 'undefined' && utils.kindOf(process) === 'process';
			
 
				+
			
 
				+// temporary hotfix
			
 
				+
			
 
				+const wrapAsync = (asyncExecutor) => {
			
 
				+  return new Promise((resolve, reject) => {
			
 
				+    let onDone;
			
 
				+    let isDone;
			
 
				+
			
 
				+    const done = (value, isRejected) => {
			
 
				+      if (isDone) return;
			
 
				+      isDone = true;
			
 
				+      onDone && onDone(value, isRejected);
			
 
				+    }
			
 
				+
			
 
				+    const _resolve = (value) => {
			
 
				+      done(value);
			
 
				+      resolve(value);
			
 
				+    };
			
 
				+
			
 
				+    const _reject = (reason) => {
			
 
				+      done(reason, true);
			
 
				+      reject(reason);
			
 
				+    }
			
 
				+
			
 
				+    asyncExecutor(_resolve, _reject, (onDoneHandler) => (onDone = onDoneHandler)).catch(_reject);
			
 
				+  })
			
 
				+};
			
 
				+
			
 
				+const resolveFamily = ({address, family}) => {
			
 
				+  if (!utils.isString(address)) {
			
 
				+    throw TypeError('address must be a string');
			
 
				+  }
			
 
				+  return ({
			
 
				+    address,
			
 
				+    family: family || (address.indexOf('.') < 0 ? 6 : 4)
			
 
				+  });
			
 
				+}
			
 
				+
			
 
				+const buildAddressEntry = (address, family) => resolveFamily(utils.isObject(address) ? address : {address, family});
			
 
				+
			
 
				+/*eslint consistent-return:0*/
			
 
				+export default isHttpAdapterSupported && function httpAdapter(config) {
			
 
				+  return wrapAsync(async function dispatchHttpRequest(resolve, reject, onDone) {
			
 
				+    let {data, lookup, family} = config;
			
 
				+    const {responseType, responseEncoding} = config;
			
 
				+    const method = config.method.toUpperCase();
			
 
				+    let isDone;
			
 
				+    let rejected = false;
			
 
				+    let req;
			
 
				+
			
 
				+    if (lookup) {
			
 
				+      const _lookup = callbackify(lookup, (value) => utils.isArray(value) ? value : [value]);
			
 
				+      // hotfix to support opt.all option which is required for node 20.x
			
 
				+      lookup = (hostname, opt, cb) => {
			
 
				+        _lookup(hostname, opt, (err, arg0, arg1) => {
			
 
				+          if (err) {
			
 
				+            return cb(err);
			
 
				+          }
			
 
				+
			
 
				+          const addresses = utils.isArray(arg0) ? arg0.map(addr => buildAddressEntry(addr)) : [buildAddressEntry(arg0, arg1)];
			
 
				+
			
 
				+          opt.all ? cb(err, addresses) : cb(err, addresses[0].address, addresses[0].family);
			
 
				+        });
			
 
				+      }
			
 
				+    }
			
 
				+
			
 
				+    // temporary internal emitter until the AxiosRequest class will be implemented
			
 
				+    const emitter = new EventEmitter();
			
 
				+
			
 
				+    const onFinished = () => {
			
 
				+      if (config.cancelToken) {
			
 
				+        config.cancelToken.unsubscribe(abort);
			
 
				+      }
			
 
				+
			
 
				+      if (config.signal) {
			
 
				+        config.signal.removeEventListener('abort', abort);
			
 
				+      }
			
 
				+
			
 
				+      emitter.removeAllListeners();
			
 
				+    }
			
 
				+
			
 
				+    onDone((value, isRejected) => {
			
 
				+      isDone = true;
			
 
				+      if (isRejected) {
			
 
				+        rejected = true;
			
 
				+        onFinished();
			
 
				+      }
			
 
				+    });
			
 
				+
			
 
				+    function abort(reason) {
			
 
				+      emitter.emit('abort', !reason || reason.type ? new CanceledError(null, config, req) : reason);
			
 
				+    }
			
 
				+
			
 
				+    emitter.once('abort', reject);
			
 
				+
			
 
				+    if (config.cancelToken || config.signal) {
			
 
				+      config.cancelToken && config.cancelToken.subscribe(abort);
			
 
				+      if (config.signal) {
			
 
				+        config.signal.aborted ? abort() : config.signal.addEventListener('abort', abort);
			
 
				+      }
			
 
				+    }
			
 
				+
			
 
				+    // Parse url
			
 
				+    const fullPath = buildFullPath(config.baseURL, config.url, config.allowAbsoluteUrls);
			
 
				+    const parsed = new URL(fullPath, platform.hasBrowserEnv ? platform.origin : undefined);
			
 
				+    const protocol = parsed.protocol || supportedProtocols[0];
			
 
				+
			
 
				+    if (protocol === 'data:') {
			
 
				+      let convertedData;
			
 
				+
			
 
				+      if (method !== 'GET') {
			
 
				+        return settle(resolve, reject, {
			
 
				+          status: 405,
			
 
				+          statusText: 'method not allowed',
			
 
				+          headers: {},
			
 
				+          config
			
 
				+        });
			
 
				+      }
			
 
				+
			
 
				+      try {
			
 
				+        convertedData = fromDataURI(config.url, responseType === 'blob', {
			
 
				+          Blob: config.env && config.env.Blob
			
 
				+        });
			
 
				+      } catch (err) {
			
 
				+        throw AxiosError.from(err, AxiosError.ERR_BAD_REQUEST, config);
			
 
				+      }
			
 
				+
			
 
				+      if (responseType === 'text') {
			
 
				+        convertedData = convertedData.toString(responseEncoding);
			
 
				+
			
 
				+        if (!responseEncoding || responseEncoding === 'utf8') {
			
 
				+          convertedData = utils.stripBOM(convertedData);
			
 
				+        }
			
 
				+      } else if (responseType === 'stream') {
			
 
				+        convertedData = stream.Readable.from(convertedData);
			
 
				+      }
			
 
				+
			
 
				+      return settle(resolve, reject, {
			
 
				+        data: convertedData,
			
 
				+        status: 200,
			
 
				+        statusText: 'OK',
			
 
				+        headers: new AxiosHeaders(),
			
 
				+        config
			
 
				+      });
			
 
				+    }
			
 
				+
			
 
				+    if (supportedProtocols.indexOf(protocol) === -1) {
			
 
				+      return reject(new AxiosError(
			
 
				+        'Unsupported protocol ' + protocol,
			
 
				+        AxiosError.ERR_BAD_REQUEST,
			
 
				+        config
			
 
				+      ));
			
 
				+    }
			
 
				+
			
 
				+    const headers = AxiosHeaders.from(config.headers).normalize();
			
 
				+
			
 
				+    // Set User-Agent (required by some servers)
			
 
				+    // See https://github.com/axios/axios/issues/69
			
 
				+    // User-Agent is specified; handle case where no UA header is desired
			
 
				+    // Only set header if it hasn't been set in config
			
 
				+    headers.set('User-Agent', 'axios/' + VERSION, false);
			
 
				+
			
 
				+    const {onUploadProgress, onDownloadProgress} = config;
			
 
				+    const maxRate = config.maxRate;
			
 
				+    let maxUploadRate = undefined;
			
 
				+    let maxDownloadRate = undefined;
			
 
				+
			
 
				+    // support for spec compliant FormData objects
			
 
				+    if (utils.isSpecCompliantForm(data)) {
			
 
				+      const userBoundary = headers.getContentType(/boundary=([-_\w\d]{10,70})/i);
			
 
				+
			
 
				+      data = formDataToStream(data, (formHeaders) => {
			
 
				+        headers.set(formHeaders);
			
 
				+      }, {
			
 
				+        tag: `axios-${VERSION}-boundary`,
			
 
				+        boundary: userBoundary && userBoundary[1] || undefined
			
 
				+      });
			
 
				+      // support for https://www.npmjs.com/package/form-data api
			
 
				+    } else if (utils.isFormData(data) && utils.isFunction(data.getHeaders)) {
			
 
				+      headers.set(data.getHeaders());
			
 
				+
			
 
				+      if (!headers.hasContentLength()) {
			
 
				+        try {
			
 
				+          const knownLength = await util.promisify(data.getLength).call(data);
			
 
				+          Number.isFinite(knownLength) && knownLength >= 0 && headers.setContentLength(knownLength);
			
 
				+          /*eslint no-empty:0*/
			
 
				+        } catch (e) {
			
 
				+        }
			
 
				+      }
			
 
				+    } else if (utils.isBlob(data) || utils.isFile(data)) {
			
 
				+      data.size && headers.setContentType(data.type || 'application/octet-stream');
			
 
				+      headers.setContentLength(data.size || 0);
			
 
				+      data = stream.Readable.from(readBlob(data));
			
 
				+    } else if (data && !utils.isStream(data)) {
			
 
				+      if (Buffer.isBuffer(data)) {
			
 
				+        // Nothing to do...
			
 
				+      } else if (utils.isArrayBuffer(data)) {
			
 
				+        data = Buffer.from(new Uint8Array(data));
			
 
				+      } else if (utils.isString(data)) {
			
 
				+        data = Buffer.from(data, 'utf-8');
			
 
				+      } else {
			
 
				+        return reject(new AxiosError(
			
 
				+          'Data after transformation must be a string, an ArrayBuffer, a Buffer, or a Stream',
			
 
				+          AxiosError.ERR_BAD_REQUEST,
			
 
				+          config
			
 
				+        ));
			
 
				+      }
			
 
				+
			
 
				+      // Add Content-Length header if data exists
			
 
				+      headers.setContentLength(data.length, false);
			
 
				+
			
 
				+      if (config.maxBodyLength > -1 && data.length > config.maxBodyLength) {
			
 
				+        return reject(new AxiosError(
			
 
				+          'Request body larger than maxBodyLength limit',
			
 
				+          AxiosError.ERR_BAD_REQUEST,
			
 
				+          config
			
 
				+        ));
			
 
				+      }
			
 
				+    }
			
 
				+
			
 
				+    const contentLength = utils.toFiniteNumber(headers.getContentLength());
			
 
				+
			
 
				+    if (utils.isArray(maxRate)) {
			
 
				+      maxUploadRate = maxRate[0];
			
 
				+      maxDownloadRate = maxRate[1];
			
 
				+    } else {
			
 
				+      maxUploadRate = maxDownloadRate = maxRate;
			
 
				+    }
			
 
				+
			
 
				+    if (data && (onUploadProgress || maxUploadRate)) {
			
 
				+      if (!utils.isStream(data)) {
			
 
				+        data = stream.Readable.from(data, {objectMode: false});
			
 
				+      }
			
 
				+
			
 
				+      data = stream.pipeline([data, new AxiosTransformStream({
			
 
				+        maxRate: utils.toFiniteNumber(maxUploadRate)
			
 
				+      })], utils.noop);
			
 
				+
			
 
				+      onUploadProgress && data.on('progress', flushOnFinish(
			
 
				+        data,
			
 
				+        progressEventDecorator(
			
 
				+          contentLength,
			
 
				+          progressEventReducer(asyncDecorator(onUploadProgress), false, 3)
			
 
				+        )
			
 
				+      ));
			
 
				+    }
			
 
				+
			
 
				+    // HTTP basic authentication
			
 
				+    let auth = undefined;
			
 
				+    if (config.auth) {
			
 
				+      const username = config.auth.username || '';
			
 
				+      const password = config.auth.password || '';
			
 
				+      auth = username + ':' + password;
			
 
				+    }
			
 
				+
			
 
				+    if (!auth && parsed.username) {
			
 
				+      const urlUsername = parsed.username;
			
 
				+      const urlPassword = parsed.password;
			
 
				+      auth = urlUsername + ':' + urlPassword;
			
 
				+    }
			
 
				+
			
 
				+    auth && headers.delete('authorization');
			
 
				+
			
 
				+    let path;
			
 
				+
			
 
				+    try {
			
 
				+      path = buildURL(
			
 
				+        parsed.pathname + parsed.search,
			
 
				+        config.params,
			
 
				+        config.paramsSerializer
			
 
				+      ).replace(/^\?/, '');
			
 
				+    } catch (err) {
			
 
				+      const customErr = new Error(err.message);
			
 
				+      customErr.config = config;
			
 
				+      customErr.url = config.url;
			
 
				+      customErr.exists = true;
			
 
				+      return reject(customErr);
			
 
				+    }
			
 
				+
			
 
				+    headers.set(
			
 
				+      'Accept-Encoding',
			
 
				+      'gzip, compress, deflate' + (isBrotliSupported ? ', br' : ''), false
			
 
				+      );
			
 
				+
			
 
				+    const options = {
			
 
				+      path,
			
 
				+      method: method,
			
 
				+      headers: headers.toJSON(),
			
 
				+      agents: { http: config.httpAgent, https: config.httpsAgent },
			
 
				+      auth,
			
 
				+      protocol,
			
 
				+      family,
			
 
				+      beforeRedirect: dispatchBeforeRedirect,
			
 
				+      beforeRedirects: {}
			
 
				+    };
			
 
				+
			
 
				+    // cacheable-lookup integration hotfix
			
 
				+    !utils.isUndefined(lookup) && (options.lookup = lookup);
			
 
				+
			
 
				+    if (config.socketPath) {
			
 
				+      options.socketPath = config.socketPath;
			
 
				+    } else {
			
 
				+      options.hostname = parsed.hostname.startsWith("[") ? parsed.hostname.slice(1, -1) : parsed.hostname;
			
 
				+      options.port = parsed.port;
			
 
				+      setProxy(options, config.proxy, protocol + '//' + parsed.hostname + (parsed.port ? ':' + parsed.port : '') + options.path);
			
 
				+    }
			
 
				+
			
 
				+    let transport;
			
 
				+    const isHttpsRequest = isHttps.test(options.protocol);
			
 
				+    options.agent = isHttpsRequest ? config.httpsAgent : config.httpAgent;
			
 
				+    if (config.transport) {
			
 
				+      transport = config.transport;
			
 
				+    } else if (config.maxRedirects === 0) {
			
 
				+      transport = isHttpsRequest ? https : http;
			
 
				+    } else {
			
 
				+      if (config.maxRedirects) {
			
 
				+        options.maxRedirects = config.maxRedirects;
			
 
				+      }
			
 
				+      if (config.beforeRedirect) {
			
 
				+        options.beforeRedirects.config = config.beforeRedirect;
			
 
				+      }
			
 
				+      transport = isHttpsRequest ? httpsFollow : httpFollow;
			
 
				+    }
			
 
				+
			
 
				+    if (config.maxBodyLength > -1) {
			
 
				+      options.maxBodyLength = config.maxBodyLength;
			
 
				+    } else {
			
 
				+      // follow-redirects does not skip comparison, so it should always succeed for axios -1 unlimited
			
 
				+      options.maxBodyLength = Infinity;
			
 
				+    }
			
 
				+
			
 
				+    if (config.insecureHTTPParser) {
			
 
				+      options.insecureHTTPParser = config.insecureHTTPParser;
			
 
				+    }
			
 
				+
			
 
				+    // Create the request
			
 
				+    req = transport.request(options, function handleResponse(res) {
			
 
				+      if (req.destroyed) return;
			
 
				+
			
 
				+      const streams = [res];
			
 
				+
			
 
				+      const responseLength = +res.headers['content-length'];
			
 
				+
			
 
				+      if (onDownloadProgress || maxDownloadRate) {
			
 
				+        const transformStream = new AxiosTransformStream({
			
 
				+          maxRate: utils.toFiniteNumber(maxDownloadRate)
			
 
				+        });
			
 
				+
			
 
				+        onDownloadProgress && transformStream.on('progress', flushOnFinish(
			
 
				+          transformStream,
			
 
				+          progressEventDecorator(
			
 
				+            responseLength,
			
 
				+            progressEventReducer(asyncDecorator(onDownloadProgress), true, 3)
			
 
				+          )
			
 
				+        ));
			
 
				+
			
 
				+        streams.push(transformStream);
			
 
				+      }
			
 
				+
			
 
				+      // decompress the response body transparently if required
			
 
				+      let responseStream = res;
			
 
				+
			
 
				+      // return the last request in case of redirects
			
 
				+      const lastRequest = res.req || req;
			
 
				+
			
 
				+      // if decompress disabled we should not decompress
			
 
				+      if (config.decompress !== false && res.headers['content-encoding']) {
			
 
				+        // if no content, but headers still say that it is encoded,
			
 
				+        // remove the header not confuse downstream operations
			
 
				+        if (method === 'HEAD' || res.statusCode === 204) {
			
 
				+          delete res.headers['content-encoding'];
			
 
				+        }
			
 
				+
			
 
				+        switch ((res.headers['content-encoding'] || '').toLowerCase()) {
			
 
				+        /*eslint default-case:0*/
			
 
				+        case 'gzip':
			
 
				+        case 'x-gzip':
			
 
				+        case 'compress':
			
 
				+        case 'x-compress':
			
 
				+          // add the unzipper to the body stream processing pipeline
			
 
				+          streams.push(zlib.createUnzip(zlibOptions));
			
 
				+
			
 
				+          // remove the content-encoding in order to not confuse downstream operations
			
 
				+          delete res.headers['content-encoding'];
			
 
				+          break;
			
 
				+        case 'deflate':
			
 
				+          streams.push(new ZlibHeaderTransformStream());
			
 
				+
			
 
				+          // add the unzipper to the body stream processing pipeline
			
 
				+          streams.push(zlib.createUnzip(zlibOptions));
			
 
				+
			
 
				+          // remove the content-encoding in order to not confuse downstream operations
			
 
				+          delete res.headers['content-encoding'];
			
 
				+          break;
			
 
				+        case 'br':
			
 
				+          if (isBrotliSupported) {
			
 
				+            streams.push(zlib.createBrotliDecompress(brotliOptions));
			
 
				+            delete res.headers['content-encoding'];
			
 
				+          }
			
 
				+        }
			
 
				+      }
			
 
				+
			
 
				+      responseStream = streams.length > 1 ? stream.pipeline(streams, utils.noop) : streams[0];
			
 
				+
			
 
				+      const offListeners = stream.finished(responseStream, () => {
			
 
				+        offListeners();
			
 
				+        onFinished();
			
 
				+      });
			
 
				+
			
 
				+      const response = {
			
 
				+        status: res.statusCode,
			
 
				+        statusText: res.statusMessage,
			
 
				+        headers: new AxiosHeaders(res.headers),
			
 
				+        config,
			
 
				+        request: lastRequest
			
 
				+      };
			
 
				+
			
 
				+      if (responseType === 'stream') {
			
 
				+        response.data = responseStream;
			
 
				+        settle(resolve, reject, response);
			
 
				+      } else {
			
 
				+        const responseBuffer = [];
			
 
				+        let totalResponseBytes = 0;
			
 
				+
			
 
				+        responseStream.on('data', function handleStreamData(chunk) {
			
 
				+          responseBuffer.push(chunk);
			
 
				+          totalResponseBytes += chunk.length;
			
 
				+
			
 
				+          // make sure the content length is not over the maxContentLength if specified
			
 
				+          if (config.maxContentLength > -1 && totalResponseBytes > config.maxContentLength) {
			
 
				+            // stream.destroy() emit aborted event before calling reject() on Node.js v16
			
 
				+            rejected = true;
			
 
				+            responseStream.destroy();
			
 
				+            reject(new AxiosError('maxContentLength size of ' + config.maxContentLength + ' exceeded',
			
 
				+              AxiosError.ERR_BAD_RESPONSE, config, lastRequest));
			
 
				+          }
			
 
				+        });
			
 
				+
			
 
				+        responseStream.on('aborted', function handlerStreamAborted() {
			
 
				+          if (rejected) {
			
 
				+            return;
			
 
				+          }
			
 
				+
			
 
				+          const err = new AxiosError(
			
 
				+            'stream has been aborted',
			
 
				+            AxiosError.ERR_BAD_RESPONSE,
			
 
				+            config,
			
 
				+            lastRequest
			
 
				+          );
			
 
				+          responseStream.destroy(err);
			
 
				+          reject(err);
			
 
				+        });
			
 
				+
			
 
				+        responseStream.on('error', function handleStreamError(err) {
			
 
				+          if (req.destroyed) return;
			
 
				+          reject(AxiosError.from(err, null, config, lastRequest));
			
 
				+        });
			
 
				+
			
 
				+        responseStream.on('end', function handleStreamEnd() {
			
 
				+          try {
			
 
				+            let responseData = responseBuffer.length === 1 ? responseBuffer[0] : Buffer.concat(responseBuffer);
			
 
				+            if (responseType !== 'arraybuffer') {
			
 
				+              responseData = responseData.toString(responseEncoding);
			
 
				+              if (!responseEncoding || responseEncoding === 'utf8') {
			
 
				+                responseData = utils.stripBOM(responseData);
			
 
				+              }
			
 
				+            }
			
 
				+            response.data = responseData;
			
 
				+          } catch (err) {
			
 
				+            return reject(AxiosError.from(err, null, config, response.request, response));
			
 
				+          }
			
 
				+          settle(resolve, reject, response);
			
 
				+        });
			
 
				+      }
			
 
				+
			
 
				+      emitter.once('abort', err => {
			
 
				+        if (!responseStream.destroyed) {
			
 
				+          responseStream.emit('error', err);
			
 
				+          responseStream.destroy();
			
 
				+        }
			
 
				+      });
			
 
				+    });
			
 
				+
			
 
				+    emitter.once('abort', err => {
			
 
				+      reject(err);
			
 
				+      req.destroy(err);
			
 
				+    });
			
 
				+
			
 
				+    // Handle errors
			
 
				+    req.on('error', function handleRequestError(err) {
			
 
				+      // @todo remove
			
 
				+      // if (req.aborted && err.code !== AxiosError.ERR_FR_TOO_MANY_REDIRECTS) return;
			
 
				+      reject(AxiosError.from(err, null, config, req));
			
 
				+    });
			
 
				+
			
 
				+    // set tcp keep alive to prevent drop connection by peer
			
 
				+    req.on('socket', function handleRequestSocket(socket) {
			
 
				+      // default interval of sending ack packet is 1 minute
			
 
				+      socket.setKeepAlive(true, 1000 * 60);
			
 
				+    });
			
 
				+
			
 
				+    // Handle request timeout
			
 
				+    if (config.timeout) {
			
 
				+      // This is forcing a int timeout to avoid problems if the `req` interface doesn't handle other types.
			
 
				+      const timeout = parseInt(config.timeout, 10);
			
 
				+
			
 
				+      if (Number.isNaN(timeout)) {
			
 
				+        reject(new AxiosError(
			
 
				+          'error trying to parse `config.timeout` to int',
			
 
				+          AxiosError.ERR_BAD_OPTION_VALUE,
			
 
				+          config,
			
 
				+          req
			
 
				+        ));
			
 
				+
			
 
				+        return;
			
 
				+      }
			
 
				+
			
 
				+      // Sometime, the response will be very slow, and does not respond, the connect event will be block by event loop system.
			
 
				+      // And timer callback will be fired, and abort() will be invoked before connection, then get "socket hang up" and code ECONNRESET.
			
 
				+      // At this time, if we have a large number of request, nodejs will hang up some socket on background. and the number will up and up.
			
 
				+      // And then these socket which be hang up will devouring CPU little by little.
			
 
				+      // ClientRequest.setTimeout will be fired on the specify milliseconds, and can make sure that abort() will be fired after connect.
			
 
				+      req.setTimeout(timeout, function handleRequestTimeout() {
			
 
				+        if (isDone) return;
			
 
				+        let timeoutErrorMessage = config.timeout ? 'timeout of ' + config.timeout + 'ms exceeded' : 'timeout exceeded';
			
 
				+        const transitional = config.transitional || transitionalDefaults;
			
 
				+        if (config.timeoutErrorMessage) {
			
 
				+          timeoutErrorMessage = config.timeoutErrorMessage;
			
 
				+        }
			
 
				+        reject(new AxiosError(
			
 
				+          timeoutErrorMessage,
			
 
				+          transitional.clarifyTimeoutError ? AxiosError.ETIMEDOUT : AxiosError.ECONNABORTED,
			
 
				+          config,
			
 
				+          req
			
 
				+        ));
			
 
				+        abort();
			
 
				+      });
			
 
				+    }
			
 
				+
			
 
				+
			
 
				+    // Send the request
			
 
				+    if (utils.isStream(data)) {
			
 
				+      let ended = false;
			
 
				+      let errored = false;
			
 
				+
			
 
				+      data.on('end', () => {
			
 
				+        ended = true;
			
 
				+      });
			
 
				+
			
 
				+      data.once('error', err => {
			
 
				+        errored = true;
			
 
				+        req.destroy(err);
			
 
				+      });
			
 
				+
			
 
				+      data.on('close', () => {
			
 
				+        if (!ended && !errored) {
			
 
				+          abort(new CanceledError('Request stream has been aborted', config, req));
			
 
				+        }
			
 
				+      });
			
 
				+
			
 
				+      data.pipe(req);
			
 
				+    } else {
			
 
				+      req.end(data);
			
 
				+    }
			
 
				+  });
			
 
				+}
			
 
				+
			
 
				+export const __setProxy = setProxy;
			
--- a/node_modules/axios/lib/adapters/xhr.js
+++ b/node_modules/axios/lib/adapters/xhr.js
@@ -0,0 +1,197 @@
 
				+import utils from './../utils.js';
			
 
				+import settle from './../core/settle.js';
			
 
				+import transitionalDefaults from '../defaults/transitional.js';
			
 
				+import AxiosError from '../core/AxiosError.js';
			
 
				+import CanceledError from '../cancel/CanceledError.js';
			
 
				+import parseProtocol from '../helpers/parseProtocol.js';
			
 
				+import platform from '../platform/index.js';
			
 
				+import AxiosHeaders from '../core/AxiosHeaders.js';
			
 
				+import {progressEventReducer} from '../helpers/progressEventReducer.js';
			
 
				+import resolveConfig from "../helpers/resolveConfig.js";
			
 
				+
			
 
				+const isXHRAdapterSupported = typeof XMLHttpRequest !== 'undefined';
			
 
				+
			
 
				+export default isXHRAdapterSupported && function (config) {
			
 
				+  return new Promise(function dispatchXhrRequest(resolve, reject) {
			
 
				+    const _config = resolveConfig(config);
			
 
				+    let requestData = _config.data;
			
 
				+    const requestHeaders = AxiosHeaders.from(_config.headers).normalize();
			
 
				+    let {responseType, onUploadProgress, onDownloadProgress} = _config;
			
 
				+    let onCanceled;
			
 
				+    let uploadThrottled, downloadThrottled;
			
 
				+    let flushUpload, flushDownload;
			
 
				+
			
 
				+    function done() {
			
 
				+      flushUpload && flushUpload(); // flush events
			
 
				+      flushDownload && flushDownload(); // flush events
			
 
				+
			
 
				+      _config.cancelToken && _config.cancelToken.unsubscribe(onCanceled);
			
 
				+
			
 
				+      _config.signal && _config.signal.removeEventListener('abort', onCanceled);
			
 
				+    }
			
 
				+
			
 
				+    let request = new XMLHttpRequest();
			
 
				+
			
 
				+    request.open(_config.method.toUpperCase(), _config.url, true);
			
 
				+
			
 
				+    // Set the request timeout in MS
			
 
				+    request.timeout = _config.timeout;
			
 
				+
			
 
				+    function onloadend() {
			
 
				+      if (!request) {
			
 
				+        return;
			
 
				+      }
			
 
				+      // Prepare the response
			
 
				+      const responseHeaders = AxiosHeaders.from(
			
 
				+        'getAllResponseHeaders' in request && request.getAllResponseHeaders()
			
 
				+      );
			
 
				+      const responseData = !responseType || responseType === 'text' || responseType === 'json' ?
			
 
				+        request.responseText : request.response;
			
 
				+      const response = {
			
 
				+        data: responseData,
			
 
				+        status: request.status,
			
 
				+        statusText: request.statusText,
			
 
				+        headers: responseHeaders,
			
 
				+        config,
			
 
				+        request
			
 
				+      };
			
 
				+
			
 
				+      settle(function _resolve(value) {
			
 
				+        resolve(value);
			
 
				+        done();
			
 
				+      }, function _reject(err) {
			
 
				+        reject(err);
			
 
				+        done();
			
 
				+      }, response);
			
 
				+
			
 
				+      // Clean up request
			
 
				+      request = null;
			
 
				+    }
			
 
				+
			
 
				+    if ('onloadend' in request) {
			
 
				+      // Use onloadend if available
			
 
				+      request.onloadend = onloadend;
			
 
				+    } else {
			
 
				+      // Listen for ready state to emulate onloadend
			
 
				+      request.onreadystatechange = function handleLoad() {
			
 
				+        if (!request || request.readyState !== 4) {
			
 
				+          return;
			
 
				+        }
			
 
				+
			
 
				+        // The request errored out and we didn't get a response, this will be
			
 
				+        // handled by onerror instead
			
 
				+        // With one exception: request that using file: protocol, most browsers
			
 
				+        // will return status as 0 even though it's a successful request
			
 
				+        if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf('file:') === 0)) {
			
 
				+          return;
			
 
				+        }
			
 
				+        // readystate handler is calling before onerror or ontimeout handlers,
			
 
				+        // so we should call onloadend on the next 'tick'
			
 
				+        setTimeout(onloadend);
			
 
				+      };
			
 
				+    }
			
 
				+
			
 
				+    // Handle browser request cancellation (as opposed to a manual cancellation)
			
 
				+    request.onabort = function handleAbort() {
			
 
				+      if (!request) {
			
 
				+        return;
			
 
				+      }
			
 
				+
			
 
				+      reject(new AxiosError('Request aborted', AxiosError.ECONNABORTED, config, request));
			
 
				+
			
 
				+      // Clean up request
			
 
				+      request = null;
			
 
				+    };
			
 
				+
			
 
				+    // Handle low level network errors
			
 
				+    request.onerror = function handleError() {
			
 
				+      // Real errors are hidden from us by the browser
			
 
				+      // onerror should only fire if it's a network error
			
 
				+      reject(new AxiosError('Network Error', AxiosError.ERR_NETWORK, config, request));
			
 
				+
			
 
				+      // Clean up request
			
 
				+      request = null;
			
 
				+    };
			
 
				+
			
 
				+    // Handle timeout
			
 
				+    request.ontimeout = function handleTimeout() {
			
 
				+      let timeoutErrorMessage = _config.timeout ? 'timeout of ' + _config.timeout + 'ms exceeded' : 'timeout exceeded';
			
 
				+      const transitional = _config.transitional || transitionalDefaults;
			
 
				+      if (_config.timeoutErrorMessage) {
			
 
				+        timeoutErrorMessage = _config.timeoutErrorMessage;
			
 
				+      }
			
 
				+      reject(new AxiosError(
			
 
				+        timeoutErrorMessage,
			
 
				+        transitional.clarifyTimeoutError ? AxiosError.ETIMEDOUT : AxiosError.ECONNABORTED,
			
 
				+        config,
			
 
				+        request));
			
 
				+
			
 
				+      // Clean up request
			
 
				+      request = null;
			
 
				+    };
			
 
				+
			
 
				+    // Remove Content-Type if data is undefined
			
 
				+    requestData === undefined && requestHeaders.setContentType(null);
			
 
				+
			
 
				+    // Add headers to the request
			
 
				+    if ('setRequestHeader' in request) {
			
 
				+      utils.forEach(requestHeaders.toJSON(), function setRequestHeader(val, key) {
			
 
				+        request.setRequestHeader(key, val);
			
 
				+      });
			
 
				+    }
			
 
				+
			
 
				+    // Add withCredentials to request if needed
			
 
				+    if (!utils.isUndefined(_config.withCredentials)) {
			
 
				+      request.withCredentials = !!_config.withCredentials;
			
 
				+    }
			
 
				+
			
 
				+    // Add responseType to request if needed
			
 
				+    if (responseType && responseType !== 'json') {
			
 
				+      request.responseType = _config.responseType;
			
 
				+    }
			
 
				+
			
 
				+    // Handle progress if needed
			
 
				+    if (onDownloadProgress) {
			
 
				+      ([downloadThrottled, flushDownload] = progressEventReducer(onDownloadProgress, true));
			
 
				+      request.addEventListener('progress', downloadThrottled);
			
 
				+    }
			
 
				+
			
 
				+    // Not all browsers support upload events
			
 
				+    if (onUploadProgress && request.upload) {
			
 
				+      ([uploadThrottled, flushUpload] = progressEventReducer(onUploadProgress));
			
 
				+
			
 
				+      request.upload.addEventListener('progress', uploadThrottled);
			
 
				+
			
 
				+      request.upload.addEventListener('loadend', flushUpload);
			
 
				+    }
			
 
				+
			
 
				+    if (_config.cancelToken || _config.signal) {
			
 
				+      // Handle cancellation
			
 
				+      // eslint-disable-next-line func-names
			
 
				+      onCanceled = cancel => {
			
 
				+        if (!request) {
			
 
				+          return;
			
 
				+        }
			
 
				+        reject(!cancel || cancel.type ? new CanceledError(null, config, request) : cancel);
			
 
				+        request.abort();
			
 
				+        request = null;
			
 
				+      };
			
 
				+
			
 
				+      _config.cancelToken && _config.cancelToken.subscribe(onCanceled);
			
 
				+      if (_config.signal) {
			
 
				+        _config.signal.aborted ? onCanceled() : _config.signal.addEventListener('abort', onCanceled);
			
 
				+      }
			
 
				+    }
			
 
				+
			
 
				+    const protocol = parseProtocol(_config.url);
			
 
				+
			
 
				+    if (protocol && platform.protocols.indexOf(protocol) === -1) {
			
 
				+      reject(new AxiosError('Unsupported protocol ' + protocol + ':', AxiosError.ERR_BAD_REQUEST, config));
			
 
				+      return;
			
 
				+    }
			
 
				+
			
 
				+
			
 
				+    // Send the request
			
 
				+    request.send(requestData || null);
			
 
				+  });
			
 
				+}
			
--- a/node_modules/axios/lib/axios.js
+++ b/node_modules/axios/lib/axios.js
@@ -0,0 +1,89 @@
 
				+'use strict';
			
 
				+
			
 
				+import utils from './utils.js';
			
 
				+import bind from './helpers/bind.js';
			
 
				+import Axios from './core/Axios.js';
			
 
				+import mergeConfig from './core/mergeConfig.js';
			
 
				+import defaults from './defaults/index.js';
			
 
				+import formDataToJSON from './helpers/formDataToJSON.js';
			
 
				+import CanceledError from './cancel/CanceledError.js';
			
 
				+import CancelToken from './cancel/CancelToken.js';
			
 
				+import isCancel from './cancel/isCancel.js';
			
 
				+import {VERSION} from './env/data.js';
			
 
				+import toFormData from './helpers/toFormData.js';
			
 
				+import AxiosError from './core/AxiosError.js';
			
 
				+import spread from './helpers/spread.js';
			
 
				+import isAxiosError from './helpers/isAxiosError.js';
			
 
				+import AxiosHeaders from "./core/AxiosHeaders.js";
			
 
				+import adapters from './adapters/adapters.js';
			
 
				+import HttpStatusCode from './helpers/HttpStatusCode.js';
			
 
				+
			
 
				+/**
			
 
				+ * Create an instance of Axios
			
 
				+ *
			
 
				+ * @param {Object} defaultConfig The default config for the instance
			
 
				+ *
			
 
				+ * @returns {Axios} A new instance of Axios
			
 
				+ */
			
 
				+function createInstance(defaultConfig) {
			
 
				+  const context = new Axios(defaultConfig);
			
 
				+  const instance = bind(Axios.prototype.request, context);
			
 
				+
			
 
				+  // Copy axios.prototype to instance
			
 
				+  utils.extend(instance, Axios.prototype, context, {allOwnKeys: true});
			
 
				+
			
 
				+  // Copy context to instance
			
 
				+  utils.extend(instance, context, null, {allOwnKeys: true});
			
 
				+
			
 
				+  // Factory for creating new instances
			
 
				+  instance.create = function create(instanceConfig) {
			
 
				+    return createInstance(mergeConfig(defaultConfig, instanceConfig));
			
 
				+  };
			
 
				+
			
 
				+  return instance;
			
 
				+}
			
 
				+
			
 
				+// Create the default instance to be exported
			
 
				+const axios = createInstance(defaults);
			
 
				+
			
 
				+// Expose Axios class to allow class inheritance
			
 
				+axios.Axios = Axios;
			
 
				+
			
 
				+// Expose Cancel & CancelToken
			
 
				+axios.CanceledError = CanceledError;
			
 
				+axios.CancelToken = CancelToken;
			
 
				+axios.isCancel = isCancel;
			
 
				+axios.VERSION = VERSION;
			
 
				+axios.toFormData = toFormData;
			
 
				+
			
 
				+// Expose AxiosError class
			
 
				+axios.AxiosError = AxiosError;
			
 
				+
			
 
				+// alias for CanceledError for backward compatibility
			
 
				+axios.Cancel = axios.CanceledError;
			
 
				+
			
 
				+// Expose all/spread
			
 
				+axios.all = function all(promises) {
			
 
				+  return Promise.all(promises);
			
 
				+};
			
 
				+
			
 
				+axios.spread = spread;
			
 
				+
			
 
				+// Expose isAxiosError
			
 
				+axios.isAxiosError = isAxiosError;
			
 
				+
			
 
				+// Expose mergeConfig
			
 
				+axios.mergeConfig = mergeConfig;
			
 
				+
			
 
				+axios.AxiosHeaders = AxiosHeaders;
			
 
				+
			
 
				+axios.formToJSON = thing => formDataToJSON(utils.isHTMLForm(thing) ? new FormData(thing) : thing);
			
 
				+
			
 
				+axios.getAdapter = adapters.getAdapter;
			
 
				+
			
 
				+axios.HttpStatusCode = HttpStatusCode;
			
 
				+
			
 
				+axios.default = axios;
			
 
				+
			
 
				+// this module should only have a default export
			
 
				+export default axios
			
--- a/node_modules/axios/lib/cancel/CancelToken.js
+++ b/node_modules/axios/lib/cancel/CancelToken.js
@@ -0,0 +1,135 @@
 
				+'use strict';
			
 
				+
			
 
				+import CanceledError from './CanceledError.js';
			
 
				+
			
 
				+/**
			
 
				+ * A `CancelToken` is an object that can be used to request cancellation of an operation.
			
 
				+ *
			
 
				+ * @param {Function} executor The executor function.
			
 
				+ *
			
 
				+ * @returns {CancelToken}
			
 
				+ */
			
 
				+class CancelToken {
			
 
				+  constructor(executor) {
			
 
				+    if (typeof executor !== 'function') {
			
 
				+      throw new TypeError('executor must be a function.');
			
 
				+    }
			
 
				+
			
 
				+    let resolvePromise;
			
 
				+
			
 
				+    this.promise = new Promise(function promiseExecutor(resolve) {
			
 
				+      resolvePromise = resolve;
			
 
				+    });
			
 
				+
			
 
				+    const token = this;
			
 
				+
			
 
				+    // eslint-disable-next-line func-names
			
 
				+    this.promise.then(cancel => {
			
 
				+      if (!token._listeners) return;
			
 
				+
			
 
				+      let i = token._listeners.length;
			
 
				+
			
 
				+      while (i-- > 0) {
			
 
				+        token._listeners[i](cancel);
			
 
				+      }
			
 
				+      token._listeners = null;
			
 
				+    });
			
 
				+
			
 
				+    // eslint-disable-next-line func-names
			
 
				+    this.promise.then = onfulfilled => {
			
 
				+      let _resolve;
			
 
				+      // eslint-disable-next-line func-names
			
 
				+      const promise = new Promise(resolve => {
			
 
				+        token.subscribe(resolve);
			
 
				+        _resolve = resolve;
			
 
				+      }).then(onfulfilled);
			
 
				+
			
 
				+      promise.cancel = function reject() {
			
 
				+        token.unsubscribe(_resolve);
			
 
				+      };
			
 
				+
			
 
				+      return promise;
			
 
				+    };
			
 
				+
			
 
				+    executor(function cancel(message, config, request) {
			
 
				+      if (token.reason) {
			
 
				+        // Cancellation has already been requested
			
 
				+        return;
			
 
				+      }
			
 
				+
			
 
				+      token.reason = new CanceledError(message, config, request);
			
 
				+      resolvePromise(token.reason);
			
 
				+    });
			
 
				+  }
			
 
				+
			
 
				+  /**
			
 
				+   * Throws a `CanceledError` if cancellation has been requested.
			
 
				+   */
			
 
				+  throwIfRequested() {
			
 
				+    if (this.reason) {
			
 
				+      throw this.reason;
			
 
				+    }
			
 
				+  }
			
 
				+
			
 
				+  /**
			
 
				+   * Subscribe to the cancel signal
			
 
				+   */
			
 
				+
			
 
				+  subscribe(listener) {
			
 
				+    if (this.reason) {
			
 
				+      listener(this.reason);
			
 
				+      return;
			
 
				+    }
			
 
				+
			
 
				+    if (this._listeners) {
			
 
				+      this._listeners.push(listener);
			
 
				+    } else {
			
 
				+      this._listeners = [listener];
			
 
				+    }
			
 
				+  }
			
 
				+
			
 
				+  /**
			
 
				+   * Unsubscribe from the cancel signal
			
 
				+   */
			
 
				+
			
 
				+  unsubscribe(listener) {
			
 
				+    if (!this._listeners) {
			
 
				+      return;
			
 
				+    }
			
 
				+    const index = this._listeners.indexOf(listener);
			
 
				+    if (index !== -1) {
			
 
				+      this._listeners.splice(index, 1);
			
 
				+    }
			
 
				+  }
			
 
				+
			
 
				+  toAbortSignal() {
			
 
				+    const controller = new AbortController();
			
 
				+
			
 
				+    const abort = (err) => {
			
 
				+      controller.abort(err);
			
 
				+    };
			
 
				+
			
 
				+    this.subscribe(abort);
			
 
				+
			
 
				+    controller.signal.unsubscribe = () => this.unsubscribe(abort);
			
 
				+
			
 
				+    return controller.signal;
			
 
				+  }
			
 
				+
			
 
				+  /**
			
 
				+   * Returns an object that contains a new `CancelToken` and a function that, when called,
			
 
				+   * cancels the `CancelToken`.
			
 
				+   */
			
 
				+  static source() {
			
 
				+    let cancel;
			
 
				+    const token = new CancelToken(function executor(c) {
			
 
				+      cancel = c;
			
 
				+    });
			
 
				+    return {
			
 
				+      token,
			
 
				+      cancel
			
 
				+    };
			
 
				+  }
			
 
				+}
			
 
				+
			
 
				+export default CancelToken;
			
--- a/node_modules/axios/lib/cancel/CanceledError.js
+++ b/node_modules/axios/lib/cancel/CanceledError.js
@@ -0,0 +1,25 @@
 
				+'use strict';
			
 
				+
			
 
				+import AxiosError from '../core/AxiosError.js';
			
 
				+import utils from '../utils.js';
			
 
				+
			
 
				+/**
			
 
				+ * A `CanceledError` is an object that is thrown when an operation is canceled.
			
 
				+ *
			
 
				+ * @param {string=} message The message.
			
 
				+ * @param {Object=} config The config.
			
 
				+ * @param {Object=} request The request.
			
 
				+ *
			
 
				+ * @returns {CanceledError} The created error.
			
 
				+ */
			
 
				+function CanceledError(message, config, request) {
			
 
				+  // eslint-disable-next-line no-eq-null,eqeqeq
			
 
				+  AxiosError.call(this, message == null ? 'canceled' : message, AxiosError.ERR_CANCELED, config, request);
			
 
				+  this.name = 'CanceledError';
			
 
				+}
			
 
				+
			
 
				+utils.inherits(CanceledError, AxiosError, {
			
 
				+  __CANCEL__: true
			
 
				+});
			
 
				+
			
 
				+export default CanceledError;
			
--- a/node_modules/axios/lib/cancel/isCancel.js
+++ b/node_modules/axios/lib/cancel/isCancel.js
@@ -0,0 +1,5 @@
 
				+'use strict';
			
 
				+
			
 
				+export default function isCancel(value) {
			
 
				+  return !!(value && value.__CANCEL__);
			
 
				+}
			
--- a/node_modules/axios/lib/core/Axios.js
+++ b/node_modules/axios/lib/core/Axios.js
@@ -0,0 +1,242 @@
 
				+'use strict';
			
 
				+
			
 
				+import utils from './../utils.js';
			
 
				+import buildURL from '../helpers/buildURL.js';
			
 
				+import InterceptorManager from './InterceptorManager.js';
			
 
				+import dispatchRequest from './dispatchRequest.js';
			
 
				+import mergeConfig from './mergeConfig.js';
			
 
				+import buildFullPath from './buildFullPath.js';
			
 
				+import validator from '../helpers/validator.js';
			
 
				+import AxiosHeaders from './AxiosHeaders.js';
			
 
				+
			
 
				+const validators = validator.validators;
			
 
				+
			
 
				+/**
			
 
				+ * Create a new instance of Axios
			
 
				+ *
			
 
				+ * @param {Object} instanceConfig The default config for the instance
			
 
				+ *
			
 
				+ * @return {Axios} A new instance of Axios
			
 
				+ */
			
 
				+class Axios {
			
 
				+  constructor(instanceConfig) {
			
 
				+    this.defaults = instanceConfig;
			
 
				+    this.interceptors = {
			
 
				+      request: new InterceptorManager(),
			
 
				+      response: new InterceptorManager()
			
 
				+    };
			
 
				+  }
			
 
				+
			
 
				+  /**
			
 
				+   * Dispatch a request
			
 
				+   *
			
 
				+   * @param {String|Object} configOrUrl The config specific for this request (merged with this.defaults)
			
 
				+   * @param {?Object} config
			
 
				+   *
			
 
				+   * @returns {Promise} The Promise to be fulfilled
			
 
				+   */
			
 
				+  async request(configOrUrl, config) {
			
 
				+    try {
			
 
				+      return await this._request(configOrUrl, config);
			
 
				+    } catch (err) {
			
 
				+      if (err instanceof Error) {
			
 
				+        let dummy = {};
			
 
				+
			
 
				+        Error.captureStackTrace ? Error.captureStackTrace(dummy) : (dummy = new Error());
			
 
				+
			
 
				+        // slice off the Error: ... line
			
 
				+        const stack = dummy.stack ? dummy.stack.replace(/^.+\n/, '') : '';
			
 
				+        try {
			
 
				+          if (!err.stack) {
			
 
				+            err.stack = stack;
			
 
				+            // match without the 2 top stack lines
			
 
				+          } else if (stack && !String(err.stack).endsWith(stack.replace(/^.+\n.+\n/, ''))) {
			
 
				+            err.stack += '\n' + stack
			
 
				+          }
			
 
				+        } catch (e) {
			
 
				+          // ignore the case where "stack" is an un-writable property
			
 
				+        }
			
 
				+      }
			
 
				+
			
 
				+      throw err;
			
 
				+    }
			
 
				+  }
			
 
				+
			
 
				+  _request(configOrUrl, config) {
			
 
				+    /*eslint no-param-reassign:0*/
			
 
				+    // Allow for axios('example/url'[, config]) a la fetch API
			
 
				+    if (typeof configOrUrl === 'string') {
			
 
				+      config = config || {};
			
 
				+      config.url = configOrUrl;
			
 
				+    } else {
			
 
				+      config = configOrUrl || {};
			
 
				+    }
			
 
				+
			
 
				+    config = mergeConfig(this.defaults, config);
			
 
				+
			
 
				+    const {transitional, paramsSerializer, headers} = config;
			
 
				+
			
 
				+    if (transitional !== undefined) {
			
 
				+      validator.assertOptions(transitional, {
			
 
				+        silentJSONParsing: validators.transitional(validators.boolean),
			
 
				+        forcedJSONParsing: validators.transitional(validators.boolean),
			
 
				+        clarifyTimeoutError: validators.transitional(validators.boolean)
			
 
				+      }, false);
			
 
				+    }
			
 
				+
			
 
				+    if (paramsSerializer != null) {
			
 
				+      if (utils.isFunction(paramsSerializer)) {
			
 
				+        config.paramsSerializer = {
			
 
				+          serialize: paramsSerializer
			
 
				+        }
			
 
				+      } else {
			
 
				+        validator.assertOptions(paramsSerializer, {
			
 
				+          encode: validators.function,
			
 
				+          serialize: validators.function
			
 
				+        }, true);
			
 
				+      }
			
 
				+    }
			
 
				+
			
 
				+    // Set config.allowAbsoluteUrls
			
 
				+    if (config.allowAbsoluteUrls !== undefined) {
			
 
				+      // do nothing
			
 
				+    } else if (this.defaults.allowAbsoluteUrls !== undefined) {
			
 
				+      config.allowAbsoluteUrls = this.defaults.allowAbsoluteUrls;
			
 
				+    } else {
			
 
				+      config.allowAbsoluteUrls = true;
			
 
				+    }
			
 
				+
			
 
				+    validator.assertOptions(config, {
			
 
				+      baseUrl: validators.spelling('baseURL'),
			
 
				+      withXsrfToken: validators.spelling('withXSRFToken')
			
 
				+    }, true);
			
 
				+
			
 
				+    // Set config.method
			
 
				+    config.method = (config.method || this.defaults.method || 'get').toLowerCase();
			
 
				+
			
 
				+    // Flatten headers
			
 
				+    let contextHeaders = headers && utils.merge(
			
 
				+      headers.common,
			
 
				+      headers[config.method]
			
 
				+    );
			
 
				+
			
 
				+    headers && utils.forEach(
			
 
				+      ['delete', 'get', 'head', 'post', 'put', 'patch', 'common'],
			
 
				+      (method) => {
			
 
				+        delete headers[method];
			
 
				+      }
			
 
				+    );
			
 
				+
			
 
				+    config.headers = AxiosHeaders.concat(contextHeaders, headers);
			
 
				+
			
 
				+    // filter out skipped interceptors
			
 
				+    const requestInterceptorChain = [];
			
 
				+    let synchronousRequestInterceptors = true;
			
 
				+    this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {
			
 
				+      if (typeof interceptor.runWhen === 'function' && interceptor.runWhen(config) === false) {
			
 
				+        return;
			
 
				+      }
			
 
				+
			
 
				+      synchronousRequestInterceptors = synchronousRequestInterceptors && interceptor.synchronous;
			
 
				+
			
 
				+      requestInterceptorChain.unshift(interceptor.fulfilled, interceptor.rejected);
			
 
				+    });
			
 
				+
			
 
				+    const responseInterceptorChain = [];
			
 
				+    this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {
			
 
				+      responseInterceptorChain.push(interceptor.fulfilled, interceptor.rejected);
			
 
				+    });
			
 
				+
			
 
				+    let promise;
			
 
				+    let i = 0;
			
 
				+    let len;
			
 
				+
			
 
				+    if (!synchronousRequestInterceptors) {
			
 
				+      const chain = [dispatchRequest.bind(this), undefined];
			
 
				+      chain.unshift.apply(chain, requestInterceptorChain);
			
 
				+      chain.push.apply(chain, responseInterceptorChain);
			
 
				+      len = chain.length;
			
 
				+
			
 
				+      promise = Promise.resolve(config);
			
 
				+
			
 
				+      while (i < len) {
			
 
				+        promise = promise.then(chain[i++], chain[i++]);
			
 
				+      }
			
 
				+
			
 
				+      return promise;
			
 
				+    }
			
 
				+
			
 
				+    len = requestInterceptorChain.length;
			
 
				+
			
 
				+    let newConfig = config;
			
 
				+
			
 
				+    i = 0;
			
 
				+
			
 
				+    while (i < len) {
			
 
				+      const onFulfilled = requestInterceptorChain[i++];
			
 
				+      const onRejected = requestInterceptorChain[i++];
			
 
				+      try {
			
 
				+        newConfig = onFulfilled(newConfig);
			
 
				+      } catch (error) {
			
 
				+        onRejected.call(this, error);
			
 
				+        break;
			
 
				+      }
			
 
				+    }
			
 
				+
			
 
				+    try {
			
 
				+      promise = dispatchRequest.call(this, newConfig);
			
 
				+    } catch (error) {
			
 
				+      return Promise.reject(error);
			
 
				+    }
			
 
				+
			
 
				+    i = 0;
			
 
				+    len = responseInterceptorChain.length;
			
 
				+
			
 
				+    while (i < len) {
			
 
				+      promise = promise.then(responseInterceptorChain[i++], responseInterceptorChain[i++]);
			
 
				+    }
			
 
				+
			
 
				+    return promise;
			
 
				+  }
			
 
				+
			
 
				+  getUri(config) {
			
 
				+    config = mergeConfig(this.defaults, config);
			
 
				+    const fullPath = buildFullPath(config.baseURL, config.url, config.allowAbsoluteUrls);
			
 
				+    return buildURL(fullPath, config.params, config.paramsSerializer);
			
 
				+  }
			
 
				+}
			
 
				+
			
 
				+// Provide aliases for supported request methods
			
 
				+utils.forEach(['delete', 'get', 'head', 'options'], function forEachMethodNoData(method) {
			
 
				+  /*eslint func-names:0*/
			
 
				+  Axios.prototype[method] = function(url, config) {
			
 
				+    return this.request(mergeConfig(config || {}, {
			
 
				+      method,
			
 
				+      url,
			
 
				+      data: (config || {}).data
			
 
				+    }));
			
 
				+  };
			
 
				+});
			
 
				+
			
 
				+utils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {
			
 
				+  /*eslint func-names:0*/
			
 
				+
			
 
				+  function generateHTTPMethod(isForm) {
			
 
				+    return function httpMethod(url, data, config) {
			
 
				+      return this.request(mergeConfig(config || {}, {
			
 
				+        method,
			
 
				+        headers: isForm ? {
			
 
				+          'Content-Type': 'multipart/form-data'
			
 
				+        } : {},
			
 
				+        url,
			
 
				+        data
			
 
				+      }));
			
 
				+    };
			
 
				+  }
			
 
				+
			
 
				+  Axios.prototype[method] = generateHTTPMethod();
			
 
				+
			
 
				+  Axios.prototype[method + 'Form'] = generateHTTPMethod(true);
			
 
				+});
			
 
				+
			
 
				+export default Axios;
			
--- a/node_modules/axios/lib/core/AxiosError.js
+++ b/node_modules/axios/lib/core/AxiosError.js
@@ -0,0 +1,103 @@
 
				+'use strict';
			
 
				+
			
 
				+import utils from '../utils.js';
			
 
				+
			
 
				+/**
			
 
				+ * Create an Error with the specified message, config, error code, request and response.
			
 
				+ *
			
 
				+ * @param {string} message The error message.
			
 
				+ * @param {string} [code] The error code (for example, 'ECONNABORTED').
			
 
				+ * @param {Object} [config] The config.
			
 
				+ * @param {Object} [request] The request.
			
 
				+ * @param {Object} [response] The response.
			
 
				+ *
			
 
				+ * @returns {Error} The created error.
			
 
				+ */
			
 
				+function AxiosError(message, code, config, request, response) {
			
 
				+  Error.call(this);
			
 
				+
			
 
				+  if (Error.captureStackTrace) {
			
 
				+    Error.captureStackTrace(this, this.constructor);
			
 
				+  } else {
			
 
				+    this.stack = (new Error()).stack;
			
 
				+  }
			
 
				+
			
 
				+  this.message = message;
			
 
				+  this.name = 'AxiosError';
			
 
				+  code && (this.code = code);
			
 
				+  config && (this.config = config);
			
 
				+  request && (this.request = request);
			
 
				+  if (response) {
			
 
				+    this.response = response;
			
 
				+    this.status = response.status ? response.status : null;
			
 
				+  }
			
 
				+}
			
 
				+
			
 
				+utils.inherits(AxiosError, Error, {
			
 
				+  toJSON: function toJSON() {
			
 
				+    return {
			
 
				+      // Standard
			
 
				+      message: this.message,
			
 
				+      name: this.name,
			
 
				+      // Microsoft
			
 
				+      description: this.description,
			
 
				+      number: this.number,
			
 
				+      // Mozilla
			
 
				+      fileName: this.fileName,
			
 
				+      lineNumber: this.lineNumber,
			
 
				+      columnNumber: this.columnNumber,
			
 
				+      stack: this.stack,
			
 
				+      // Axios
			
 
				+      config: utils.toJSONObject(this.config),
			
 
				+      code: this.code,
			
 
				+      status: this.status
			
 
				+    };
			
 
				+  }
			
 
				+});
			
 
				+
			
 
				+const prototype = AxiosError.prototype;
			
 
				+const descriptors = {};
			
 
				+
			
 
				+[
			
 
				+  'ERR_BAD_OPTION_VALUE',
			
 
				+  'ERR_BAD_OPTION',
			
 
				+  'ECONNABORTED',
			
 
				+  'ETIMEDOUT',
			
 
				+  'ERR_NETWORK',
			
 
				+  'ERR_FR_TOO_MANY_REDIRECTS',
			
 
				+  'ERR_DEPRECATED',
			
 
				+  'ERR_BAD_RESPONSE',
			
 
				+  'ERR_BAD_REQUEST',
			
 
				+  'ERR_CANCELED',
			
 
				+  'ERR_NOT_SUPPORT',
			
 
				+  'ERR_INVALID_URL'
			
 
				+// eslint-disable-next-line func-names
			
 
				+].forEach(code => {
			
 
				+  descriptors[code] = {value: code};
			
 
				+});
			
 
				+
			
 
				+Object.defineProperties(AxiosError, descriptors);
			
 
				+Object.defineProperty(prototype, 'isAxiosError', {value: true});
			
 
				+
			
 
				+// eslint-disable-next-line func-names
			
 
				+AxiosError.from = (error, code, config, request, response, customProps) => {
			
 
				+  const axiosError = Object.create(prototype);
			
 
				+
			
 
				+  utils.toFlatObject(error, axiosError, function filter(obj) {
			
 
				+    return obj !== Error.prototype;
			
 
				+  }, prop => {
			
 
				+    return prop !== 'isAxiosError';
			
 
				+  });
			
 
				+
			
 
				+  AxiosError.call(axiosError, error.message, code, config, request, response);
			
 
				+
			
 
				+  axiosError.cause = error;
			
 
				+
			
 
				+  axiosError.name = error.name;
			
 
				+
			
 
				+  customProps && Object.assign(axiosError, customProps);
			
 
				+
			
 
				+  return axiosError;
			
 
				+};
			
 
				+
			
 
				+export default AxiosError;
			
--- a/node_modules/axios/lib/core/AxiosHeaders.js
+++ b/node_modules/axios/lib/core/AxiosHeaders.js
@@ -0,0 +1,302 @@
 
				+'use strict';
			
 
				+
			
 
				+import utils from '../utils.js';
			
 
				+import parseHeaders from '../helpers/parseHeaders.js';
			
 
				+
			
 
				+const $internals = Symbol('internals');
			
 
				+
			
 
				+function normalizeHeader(header) {
			
 
				+  return header && String(header).trim().toLowerCase();
			
 
				+}
			
 
				+
			
 
				+function normalizeValue(value) {
			
 
				+  if (value === false || value == null) {
			
 
				+    return value;
			
 
				+  }
			
 
				+
			
 
				+  return utils.isArray(value) ? value.map(normalizeValue) : String(value);
			
 
				+}
			
 
				+
			
 
				+function parseTokens(str) {
			
 
				+  const tokens = Object.create(null);
			
 
				+  const tokensRE = /([^\s,;=]+)\s*(?:=\s*([^,;]+))?/g;
			
 
				+  let match;
			
 
				+
			
 
				+  while ((match = tokensRE.exec(str))) {
			
 
				+    tokens[match[1]] = match[2];
			
 
				+  }
			
 
				+
			
 
				+  return tokens;
			
 
				+}
			
 
				+
			
 
				+const isValidHeaderName = (str) => /^[-_a-zA-Z0-9^`|~,!#$%&'*+.]+$/.test(str.trim());
			
 
				+
			
 
				+function matchHeaderValue(context, value, header, filter, isHeaderNameFilter) {
			
 
				+  if (utils.isFunction(filter)) {
			
 
				+    return filter.call(this, value, header);
			
 
				+  }
			
 
				+
			
 
				+  if (isHeaderNameFilter) {
			
 
				+    value = header;
			
 
				+  }
			
 
				+
			
 
				+  if (!utils.isString(value)) return;
			
 
				+
			
 
				+  if (utils.isString(filter)) {
			
 
				+    return value.indexOf(filter) !== -1;
			
 
				+  }
			
 
				+
			
 
				+  if (utils.isRegExp(filter)) {
			
 
				+    return filter.test(value);
			
 
				+  }
			
 
				+}
			
 
				+
			
 
				+function formatHeader(header) {
			
 
				+  return header.trim()
			
 
				+    .toLowerCase().replace(/([a-z\d])(\w*)/g, (w, char, str) => {
			
 
				+      return char.toUpperCase() + str;
			
 
				+    });
			
 
				+}
			
 
				+
			
 
				+function buildAccessors(obj, header) {
			
 
				+  const accessorName = utils.toCamelCase(' ' + header);
			
 
				+
			
 
				+  ['get', 'set', 'has'].forEach(methodName => {
			
 
				+    Object.defineProperty(obj, methodName + accessorName, {
			
 
				+      value: function(arg1, arg2, arg3) {
			
 
				+        return this[methodName].call(this, header, arg1, arg2, arg3);
			
 
				+      },
			
 
				+      configurable: true
			
 
				+    });
			
 
				+  });
			
 
				+}
			
 
				+
			
 
				+class AxiosHeaders {
			
 
				+  constructor(headers) {
			
 
				+    headers && this.set(headers);
			
 
				+  }
			
 
				+
			
 
				+  set(header, valueOrRewrite, rewrite) {
			
 
				+    const self = this;
			
 
				+
			
 
				+    function setHeader(_value, _header, _rewrite) {
			
 
				+      const lHeader = normalizeHeader(_header);
			
 
				+
			
 
				+      if (!lHeader) {
			
 
				+        throw new Error('header name must be a non-empty string');
			
 
				+      }
			
 
				+
			
 
				+      const key = utils.findKey(self, lHeader);
			
 
				+
			
 
				+      if(!key || self[key] === undefined || _rewrite === true || (_rewrite === undefined && self[key] !== false)) {
			
 
				+        self[key || _header] = normalizeValue(_value);
			
 
				+      }
			
 
				+    }
			
 
				+
			
 
				+    const setHeaders = (headers, _rewrite) =>
			
 
				+      utils.forEach(headers, (_value, _header) => setHeader(_value, _header, _rewrite));
			
 
				+
			
 
				+    if (utils.isPlainObject(header) || header instanceof this.constructor) {
			
 
				+      setHeaders(header, valueOrRewrite)
			
 
				+    } else if(utils.isString(header) && (header = header.trim()) && !isValidHeaderName(header)) {
			
 
				+      setHeaders(parseHeaders(header), valueOrRewrite);
			
 
				+    } else if (utils.isHeaders(header)) {
			
 
				+      for (const [key, value] of header.entries()) {
			
 
				+        setHeader(value, key, rewrite);
			
 
				+      }
			
 
				+    } else {
			
 
				+      header != null && setHeader(valueOrRewrite, header, rewrite);
			
 
				+    }
			
 
				+
			
 
				+    return this;
			
 
				+  }
			
 
				+
			
 
				+  get(header, parser) {
			
 
				+    header = normalizeHeader(header);
			
 
				+
			
 
				+    if (header) {
			
 
				+      const key = utils.findKey(this, header);
			
 
				+
			
 
				+      if (key) {
			
 
				+        const value = this[key];
			
 
				+
			
 
				+        if (!parser) {
			
 
				+          return value;
			
 
				+        }
			
 
				+
			
 
				+        if (parser === true) {
			
 
				+          return parseTokens(value);
			
 
				+        }
			
 
				+
			
 
				+        if (utils.isFunction(parser)) {
			
 
				+          return parser.call(this, value, key);
			
 
				+        }
			
 
				+
			
 
				+        if (utils.isRegExp(parser)) {
			
 
				+          return parser.exec(value);
			
 
				+        }
			
 
				+
			
 
				+        throw new TypeError('parser must be boolean|regexp|function');
			
 
				+      }
			
 
				+    }
			
 
				+  }
			
 
				+
			
 
				+  has(header, matcher) {
			
 
				+    header = normalizeHeader(header);
			
 
				+
			
 
				+    if (header) {
			
 
				+      const key = utils.findKey(this, header);
			
 
				+
			
 
				+      return !!(key && this[key] !== undefined && (!matcher || matchHeaderValue(this, this[key], key, matcher)));
			
 
				+    }
			
 
				+
			
 
				+    return false;
			
 
				+  }
			
 
				+
			
 
				+  delete(header, matcher) {
			
 
				+    const self = this;
			
 
				+    let deleted = false;
			
 
				+
			
 
				+    function deleteHeader(_header) {
			
 
				+      _header = normalizeHeader(_header);
			
 
				+
			
 
				+      if (_header) {
			
 
				+        const key = utils.findKey(self, _header);
			
 
				+
			
 
				+        if (key && (!matcher || matchHeaderValue(self, self[key], key, matcher))) {
			
 
				+          delete self[key];
			
 
				+
			
 
				+          deleted = true;
			
 
				+        }
			
 
				+      }
			
 
				+    }
			
 
				+
			
 
				+    if (utils.isArray(header)) {
			
 
				+      header.forEach(deleteHeader);
			
 
				+    } else {
			
 
				+      deleteHeader(header);
			
 
				+    }
			
 
				+
			
 
				+    return deleted;
			
 
				+  }
			
 
				+
			
 
				+  clear(matcher) {
			
 
				+    const keys = Object.keys(this);
			
 
				+    let i = keys.length;
			
 
				+    let deleted = false;
			
 
				+
			
 
				+    while (i--) {
			
 
				+      const key = keys[i];
			
 
				+      if(!matcher || matchHeaderValue(this, this[key], key, matcher, true)) {
			
 
				+        delete this[key];
			
 
				+        deleted = true;
			
 
				+      }
			
 
				+    }
			
 
				+
			
 
				+    return deleted;
			
 
				+  }
			
 
				+
			
 
				+  normalize(format) {
			
 
				+    const self = this;
			
 
				+    const headers = {};
			
 
				+
			
 
				+    utils.forEach(this, (value, header) => {
			
 
				+      const key = utils.findKey(headers, header);
			
 
				+
			
 
				+      if (key) {
			
 
				+        self[key] = normalizeValue(value);
			
 
				+        delete self[header];
			
 
				+        return;
			
 
				+      }
			
 
				+
			
 
				+      const normalized = format ? formatHeader(header) : String(header).trim();
			
 
				+
			
 
				+      if (normalized !== header) {
			
 
				+        delete self[header];
			
 
				+      }
			
 
				+
			
 
				+      self[normalized] = normalizeValue(value);
			
 
				+
			
 
				+      headers[normalized] = true;
			
 
				+    });
			
 
				+
			
 
				+    return this;
			
 
				+  }
			
 
				+
			
 
				+  concat(...targets) {
			
 
				+    return this.constructor.concat(this, ...targets);
			
 
				+  }
			
 
				+
			
 
				+  toJSON(asStrings) {
			
 
				+    const obj = Object.create(null);
			
 
				+
			
 
				+    utils.forEach(this, (value, header) => {
			
 
				+      value != null && value !== false && (obj[header] = asStrings && utils.isArray(value) ? value.join(', ') : value);
			
 
				+    });
			
 
				+
			
 
				+    return obj;
			
 
				+  }
			
 
				+
			
 
				+  [Symbol.iterator]() {
			
 
				+    return Object.entries(this.toJSON())[Symbol.iterator]();
			
 
				+  }
			
 
				+
			
 
				+  toString() {
			
 
				+    return Object.entries(this.toJSON()).map(([header, value]) => header + ': ' + value).join('\n');
			
 
				+  }
			
 
				+
			
 
				+  get [Symbol.toStringTag]() {
			
 
				+    return 'AxiosHeaders';
			
 
				+  }
			
 
				+
			
 
				+  static from(thing) {
			
 
				+    return thing instanceof this ? thing : new this(thing);
			
 
				+  }
			
 
				+
			
 
				+  static concat(first, ...targets) {
			
 
				+    const computed = new this(first);
			
 
				+
			
 
				+    targets.forEach((target) => computed.set(target));
			
 
				+
			
 
				+    return computed;
			
 
				+  }
			
 
				+
			
 
				+  static accessor(header) {
			
 
				+    const internals = this[$internals] = (this[$internals] = {
			
 
				+      accessors: {}
			
 
				+    });
			
 
				+
			
 
				+    const accessors = internals.accessors;
			
 
				+    const prototype = this.prototype;
			
 
				+
			
 
				+    function defineAccessor(_header) {
			
 
				+      const lHeader = normalizeHeader(_header);
			
 
				+
			
 
				+      if (!accessors[lHeader]) {
			
 
				+        buildAccessors(prototype, _header);
			
 
				+        accessors[lHeader] = true;
			
 
				+      }
			
 
				+    }
			
 
				+
			
 
				+    utils.isArray(header) ? header.forEach(defineAccessor) : defineAccessor(header);
			
 
				+
			
 
				+    return this;
			
 
				+  }
			
 
				+}
			
 
				+
			
 
				+AxiosHeaders.accessor(['Content-Type', 'Content-Length', 'Accept', 'Accept-Encoding', 'User-Agent', 'Authorization']);
			
 
				+
			
 
				+// reserved names hotfix
			
 
				+utils.reduceDescriptors(AxiosHeaders.prototype, ({value}, key) => {
			
 
				+  let mapped = key[0].toUpperCase() + key.slice(1); // map `set` => `Set`
			
 
				+  return {
			
 
				+    get: () => value,
			
 
				+    set(headerValue) {
			
 
				+      this[mapped] = headerValue;
			
 
				+    }
			
 
				+  }
			
 
				+});
			
 
				+
			
 
				+utils.freezeMethods(AxiosHeaders);
			
 
				+
			
 
				+export default AxiosHeaders;
			
--- a/node_modules/axios/lib/core/InterceptorManager.js
+++ b/node_modules/axios/lib/core/InterceptorManager.js
@@ -0,0 +1,71 @@
 
				+'use strict';
			
 
				+
			
 
				+import utils from './../utils.js';
			
 
				+
			
 
				+class InterceptorManager {
			
 
				+  constructor() {
			
 
				+    this.handlers = [];
			
 
				+  }
			
 
				+
			
 
				+  /**
			
 
				+   * Add a new interceptor to the stack
			
 
				+   *
			
 
				+   * @param {Function} fulfilled The function to handle `then` for a `Promise`
			
 
				+   * @param {Function} rejected The function to handle `reject` for a `Promise`
			
 
				+   *
			
 
				+   * @return {Number} An ID used to remove interceptor later
			
 
				+   */
			
 
				+  use(fulfilled, rejected, options) {
			
 
				+    this.handlers.push({
			
 
				+      fulfilled,
			
 
				+      rejected,
			
 
				+      synchronous: options ? options.synchronous : false,
			
 
				+      runWhen: options ? options.runWhen : null
			
 
				+    });
			
 
				+    return this.handlers.length - 1;
			
 
				+  }
			
 
				+
			
 
				+  /**
			
 
				+   * Remove an interceptor from the stack
			
 
				+   *
			
 
				+   * @param {Number} id The ID that was returned by `use`
			
 
				+   *
			
 
				+   * @returns {Boolean} `true` if the interceptor was removed, `false` otherwise
			
 
				+   */
			
 
				+  eject(id) {
			
 
				+    if (this.handlers[id]) {
			
 
				+      this.handlers[id] = null;
			
 
				+    }
			
 
				+  }
			
 
				+
			
 
				+  /**
			
 
				+   * Clear all interceptors from the stack
			
 
				+   *
			
 
				+   * @returns {void}
			
 
				+   */
			
 
				+  clear() {
			
 
				+    if (this.handlers) {
			
 
				+      this.handlers = [];
			
 
				+    }
			
 
				+  }
			
 
				+
			
 
				+  /**
			
 
				+   * Iterate over all the registered interceptors
			
 
				+   *
			
 
				+   * This method is particularly useful for skipping over any
			
 
				+   * interceptors that may have become `null` calling `eject`.
			
 
				+   *
			
 
				+   * @param {Function} fn The function to call for each interceptor
			
 
				+   *
			
 
				+   * @returns {void}
			
 
				+   */
			
 
				+  forEach(fn) {
			
 
				+    utils.forEach(this.handlers, function forEachHandler(h) {
			
 
				+      if (h !== null) {
			
 
				+        fn(h);
			
 
				+      }
			
 
				+    });
			
 
				+  }
			
 
				+}
			
 
				+
			
 
				+export default InterceptorManager;
			
--- a/node_modules/axios/lib/core/README.md
+++ b/node_modules/axios/lib/core/README.md
@@ -0,0 +1,8 @@
 
				+# axios // core
			
 
				+
			
 
				+The modules found in `core/` should be modules that are specific to the domain logic of axios. These modules would most likely not make sense to be consumed outside of the axios module, as their logic is too specific. Some examples of core modules are:
			
 
				+
			
 
				+- Dispatching requests
			
 
				+  - Requests sent via `adapters/` (see lib/adapters/README.md)
			
 
				+- Managing interceptors
			
 
				+- Handling config
			
--- a/node_modules/axios/lib/core/buildFullPath.js
+++ b/node_modules/axios/lib/core/buildFullPath.js
@@ -0,0 +1,22 @@
 
				+'use strict';
			
 
				+
			
 
				+import isAbsoluteURL from '../helpers/isAbsoluteURL.js';
			
 
				+import combineURLs from '../helpers/combineURLs.js';
			
 
				+
			
 
				+/**
			
 
				+ * Creates a new URL by combining the baseURL with the requestedURL,
			
 
				+ * only when the requestedURL is not already an absolute URL.
			
 
				+ * If the requestURL is absolute, this function returns the requestedURL untouched.
			
 
				+ *
			
 
				+ * @param {string} baseURL The base URL
			
 
				+ * @param {string} requestedURL Absolute or relative URL to combine
			
 
				+ *
			
 
				+ * @returns {string} The combined full path
			
 
				+ */
			
 
				+export default function buildFullPath(baseURL, requestedURL, allowAbsoluteUrls) {
			
 
				+  let isRelativeUrl = !isAbsoluteURL(requestedURL);
			
 
				+  if (baseURL && (isRelativeUrl || allowAbsoluteUrls == false)) {
			
 
				+    return combineURLs(baseURL, requestedURL);
			
 
				+  }
			
 
				+  return requestedURL;
			
 
				+}
			
--- a/node_modules/axios/lib/core/dispatchRequest.js
+++ b/node_modules/axios/lib/core/dispatchRequest.js
@@ -0,0 +1,81 @@
 
				+'use strict';
			
 
				+
			
 
				+import transformData from './transformData.js';
			
 
				+import isCancel from '../cancel/isCancel.js';
			
 
				+import defaults from '../defaults/index.js';
			
 
				+import CanceledError from '../cancel/CanceledError.js';
			
 
				+import AxiosHeaders from '../core/AxiosHeaders.js';
			
 
				+import adapters from "../adapters/adapters.js";
			
 
				+
			
 
				+/**
			
 
				+ * Throws a `CanceledError` if cancellation has been requested.
			
 
				+ *
			
 
				+ * @param {Object} config The config that is to be used for the request
			
 
				+ *
			
 
				+ * @returns {void}
			
 
				+ */
			
 
				+function throwIfCancellationRequested(config) {
			
 
				+  if (config.cancelToken) {
			
 
				+    config.cancelToken.throwIfRequested();
			
 
				+  }
			
 
				+
			
 
				+  if (config.signal && config.signal.aborted) {
			
 
				+    throw new CanceledError(null, config);
			
 
				+  }
			
 
				+}
			
 
				+
			
 
				+/**
			
 
				+ * Dispatch a request to the server using the configured adapter.
			
 
				+ *
			
 
				+ * @param {object} config The config that is to be used for the request
			
 
				+ *
			
 
				+ * @returns {Promise} The Promise to be fulfilled
			
 
				+ */
			
 
				+export default function dispatchRequest(config) {
			
 
				+  throwIfCancellationRequested(config);
			
 
				+
			
 
				+  config.headers = AxiosHeaders.from(config.headers);
			
 
				+
			
 
				+  // Transform request data
			
 
				+  config.data = transformData.call(
			
 
				+    config,
			
 
				+    config.transformRequest
			
 
				+  );
			
 
				+
			
 
				+  if (['post', 'put', 'patch'].indexOf(config.method) !== -1) {
			
 
				+    config.headers.setContentType('application/x-www-form-urlencoded', false);
			
 
				+  }
			
 
				+
			
 
				+  const adapter = adapters.getAdapter(config.adapter || defaults.adapter);
			
 
				+
			
 
				+  return adapter(config).then(function onAdapterResolution(response) {
			
 
				+    throwIfCancellationRequested(config);
			
 
				+
			
 
				+    // Transform response data
			
 
				+    response.data = transformData.call(
			
 
				+      config,
			
 
				+      config.transformResponse,
			
 
				+      response
			
 
				+    );
			
 
				+
			
 
				+    response.headers = AxiosHeaders.from(response.headers);
			
 
				+
			
 
				+    return response;
			
 
				+  }, function onAdapterRejection(reason) {
			
 
				+    if (!isCancel(reason)) {
			
 
				+      throwIfCancellationRequested(config);
			
 
				+
			
 
				+      // Transform response data
			
 
				+      if (reason && reason.response) {
			
 
				+        reason.response.data = transformData.call(
			
 
				+          config,
			
 
				+          config.transformResponse,
			
 
				+          reason.response
			
 
				+        );
			
 
				+        reason.response.headers = AxiosHeaders.from(reason.response.headers);
			
 
				+      }
			
 
				+    }
			
 
				+
			
 
				+    return Promise.reject(reason);
			
 
				+  });
			
 
				+}
			
--- a/node_modules/axios/lib/core/mergeConfig.js
+++ b/node_modules/axios/lib/core/mergeConfig.js
@@ -0,0 +1,106 @@
 
				+'use strict';
			
 
				+
			
 
				+import utils from '../utils.js';
			
 
				+import AxiosHeaders from "./AxiosHeaders.js";
			
 
				+
			
 
				+const headersToObject = (thing) => thing instanceof AxiosHeaders ? { ...thing } : thing;
			
 
				+
			
 
				+/**
			
 
				+ * Config-specific merge-function which creates a new config-object
			
 
				+ * by merging two configuration objects together.
			
 
				+ *
			
 
				+ * @param {Object} config1
			
 
				+ * @param {Object} config2
			
 
				+ *
			
 
				+ * @returns {Object} New object resulting from merging config2 to config1
			
 
				+ */
			
 
				+export default function mergeConfig(config1, config2) {
			
 
				+  // eslint-disable-next-line no-param-reassign
			
 
				+  config2 = config2 || {};
			
 
				+  const config = {};
			
 
				+
			
 
				+  function getMergedValue(target, source, prop, caseless) {
			
 
				+    if (utils.isPlainObject(target) && utils.isPlainObject(source)) {
			
 
				+      return utils.merge.call({caseless}, target, source);
			
 
				+    } else if (utils.isPlainObject(source)) {
			
 
				+      return utils.merge({}, source);
			
 
				+    } else if (utils.isArray(source)) {
			
 
				+      return source.slice();
			
 
				+    }
			
 
				+    return source;
			
 
				+  }
			
 
				+
			
 
				+  // eslint-disable-next-line consistent-return
			
 
				+  function mergeDeepProperties(a, b, prop , caseless) {
			
 
				+    if (!utils.isUndefined(b)) {
			
 
				+      return getMergedValue(a, b, prop , caseless);
			
 
				+    } else if (!utils.isUndefined(a)) {
			
 
				+      return getMergedValue(undefined, a, prop , caseless);
			
 
				+    }
			
 
				+  }
			
 
				+
			
 
				+  // eslint-disable-next-line consistent-return
			
 
				+  function valueFromConfig2(a, b) {
			
 
				+    if (!utils.isUndefined(b)) {
			
 
				+      return getMergedValue(undefined, b);
			
 
				+    }
			
 
				+  }
			
 
				+
			
 
				+  // eslint-disable-next-line consistent-return
			
 
				+  function defaultToConfig2(a, b) {
			
 
				+    if (!utils.isUndefined(b)) {
			
 
				+      return getMergedValue(undefined, b);
			
 
				+    } else if (!utils.isUndefined(a)) {
			
 
				+      return getMergedValue(undefined, a);
			
 
				+    }
			
 
				+  }
			
 
				+
			
 
				+  // eslint-disable-next-line consistent-return
			
 
				+  function mergeDirectKeys(a, b, prop) {
			
 
				+    if (prop in config2) {
			
 
				+      return getMergedValue(a, b);
			
 
				+    } else if (prop in config1) {
			
 
				+      return getMergedValue(undefined, a);
			
 
				+    }
			
 
				+  }
			
 
				+
			
 
				+  const mergeMap = {
			
 
				+    url: valueFromConfig2,
			
 
				+    method: valueFromConfig2,
			
 
				+    data: valueFromConfig2,
			
 
				+    baseURL: defaultToConfig2,
			
 
				+    transformRequest: defaultToConfig2,
			
 
				+    transformResponse: defaultToConfig2,
			
 
				+    paramsSerializer: defaultToConfig2,
			
 
				+    timeout: defaultToConfig2,
			
 
				+    timeoutMessage: defaultToConfig2,
			
 
				+    withCredentials: defaultToConfig2,
			
 
				+    withXSRFToken: defaultToConfig2,
			
 
				+    adapter: defaultToConfig2,
			
 
				+    responseType: defaultToConfig2,
			
 
				+    xsrfCookieName: defaultToConfig2,
			
 
				+    xsrfHeaderName: defaultToConfig2,
			
 
				+    onUploadProgress: defaultToConfig2,
			
 
				+    onDownloadProgress: defaultToConfig2,
			
 
				+    decompress: defaultToConfig2,
			
 
				+    maxContentLength: defaultToConfig2,
			
 
				+    maxBodyLength: defaultToConfig2,
			
 
				+    beforeRedirect: defaultToConfig2,
			
 
				+    transport: defaultToConfig2,
			
 
				+    httpAgent: defaultToConfig2,
			
 
				+    httpsAgent: defaultToConfig2,
			
 
				+    cancelToken: defaultToConfig2,
			
 
				+    socketPath: defaultToConfig2,
			
 
				+    responseEncoding: defaultToConfig2,
			
 
				+    validateStatus: mergeDirectKeys,
			
 
				+    headers: (a, b , prop) => mergeDeepProperties(headersToObject(a), headersToObject(b),prop, true)
			
 
				+  };
			
 
				+
			
 
				+  utils.forEach(Object.keys(Object.assign({}, config1, config2)), function computeConfigValue(prop) {
			
 
				+    const merge = mergeMap[prop] || mergeDeepProperties;
			
 
				+    const configValue = merge(config1[prop], config2[prop], prop);
			
 
				+    (utils.isUndefined(configValue) && merge !== mergeDirectKeys) || (config[prop] = configValue);
			
 
				+  });
			
 
				+
			
 
				+  return config;
			
 
				+}
			
--- a/node_modules/axios/lib/core/settle.js
+++ b/node_modules/axios/lib/core/settle.js
@@ -0,0 +1,27 @@
 
				+'use strict';
			
 
				+
			
 
				+import AxiosError from './AxiosError.js';
			
 
				+
			
 
				+/**
			
 
				+ * Resolve or reject a Promise based on response status.
			
 
				+ *
			
 
				+ * @param {Function} resolve A function that resolves the promise.
			
 
				+ * @param {Function} reject A function that rejects the promise.
			
 
				+ * @param {object} response The response.
			
 
				+ *
			
 
				+ * @returns {object} The response.
			
 
				+ */
			
 
				+export default function settle(resolve, reject, response) {
			
 
				+  const validateStatus = response.config.validateStatus;
			
 
				+  if (!response.status || !validateStatus || validateStatus(response.status)) {
			
 
				+    resolve(response);
			
 
				+  } else {
			
 
				+    reject(new AxiosError(
			
 
				+      'Request failed with status code ' + response.status,
			
 
				+      [AxiosError.ERR_BAD_REQUEST, AxiosError.ERR_BAD_RESPONSE][Math.floor(response.status / 100) - 4],
			
 
				+      response.config,
			
 
				+      response.request,
			
 
				+      response
			
 
				+    ));
			
 
				+  }
			
 
				+}
			
--- a/node_modules/axios/lib/core/transformData.js
+++ b/node_modules/axios/lib/core/transformData.js
@@ -0,0 +1,28 @@
 
				+'use strict';
			
 
				+
			
 
				+import utils from './../utils.js';
			
 
				+import defaults from '../defaults/index.js';
			
 
				+import AxiosHeaders from '../core/AxiosHeaders.js';
			
 
				+
			
 
				+/**
			
 
				+ * Transform the data for a request or a response
			
 
				+ *
			
 
				+ * @param {Array|Function} fns A single function or Array of functions
			
 
				+ * @param {?Object} response The response object
			
 
				+ *
			
 
				+ * @returns {*} The resulting transformed data
			
 
				+ */
			
 
				+export default function transformData(fns, response) {
			
 
				+  const config = this || defaults;
			
 
				+  const context = response || config;
			
 
				+  const headers = AxiosHeaders.from(context.headers);
			
 
				+  let data = context.data;
			
 
				+
			
 
				+  utils.forEach(fns, function transform(fn) {
			
 
				+    data = fn.call(config, data, headers.normalize(), response ? response.status : undefined);
			
 
				+  });
			
 
				+
			
 
				+  headers.normalize();
			
 
				+
			
 
				+  return data;
			
 
				+}
			
--- a/node_modules/axios/lib/defaults/index.js
+++ b/node_modules/axios/lib/defaults/index.js
@@ -0,0 +1,161 @@
 
				+'use strict';
			
 
				+
			
 
				+import utils from '../utils.js';
			
 
				+import AxiosError from '../core/AxiosError.js';
			
 
				+import transitionalDefaults from './transitional.js';
			
 
				+import toFormData from '../helpers/toFormData.js';
			
 
				+import toURLEncodedForm from '../helpers/toURLEncodedForm.js';
			
 
				+import platform from '../platform/index.js';
			
 
				+import formDataToJSON from '../helpers/formDataToJSON.js';
			
 
				+
			
 
				+/**
			
 
				+ * It takes a string, tries to parse it, and if it fails, it returns the stringified version
			
 
				+ * of the input
			
 
				+ *
			
 
				+ * @param {any} rawValue - The value to be stringified.
			
 
				+ * @param {Function} parser - A function that parses a string into a JavaScript object.
			
 
				+ * @param {Function} encoder - A function that takes a value and returns a string.
			
 
				+ *
			
 
				+ * @returns {string} A stringified version of the rawValue.
			
 
				+ */
			
 
				+function stringifySafely(rawValue, parser, encoder) {
			
 
				+  if (utils.isString(rawValue)) {
			
 
				+    try {
			
 
				+      (parser || JSON.parse)(rawValue);
			
 
				+      return utils.trim(rawValue);
			
 
				+    } catch (e) {
			
 
				+      if (e.name !== 'SyntaxError') {
			
 
				+        throw e;
			
 
				+      }
			
 
				+    }
			
 
				+  }
			
 
				+
			
 
				+  return (encoder || JSON.stringify)(rawValue);
			
 
				+}
			
 
				+
			
 
				+const defaults = {
			
 
				+
			
 
				+  transitional: transitionalDefaults,
			
 
				+
			
 
				+  adapter: ['xhr', 'http', 'fetch'],
			
 
				+
			
 
				+  transformRequest: [function transformRequest(data, headers) {
			
 
				+    const contentType = headers.getContentType() || '';
			
 
				+    const hasJSONContentType = contentType.indexOf('application/json') > -1;
			
 
				+    const isObjectPayload = utils.isObject(data);
			
 
				+
			
 
				+    if (isObjectPayload && utils.isHTMLForm(data)) {
			
 
				+      data = new FormData(data);
			
 
				+    }
			
 
				+
			
 
				+    const isFormData = utils.isFormData(data);
			
 
				+
			
 
				+    if (isFormData) {
			
 
				+      return hasJSONContentType ? JSON.stringify(formDataToJSON(data)) : data;
			
 
				+    }
			
 
				+
			
 
				+    if (utils.isArrayBuffer(data) ||
			
 
				+      utils.isBuffer(data) ||
			
 
				+      utils.isStream(data) ||
			
 
				+      utils.isFile(data) ||
			
 
				+      utils.isBlob(data) ||
			
 
				+      utils.isReadableStream(data)
			
 
				+    ) {
			
 
				+      return data;
			
 
				+    }
			
 
				+    if (utils.isArrayBufferView(data)) {
			
 
				+      return data.buffer;
			
 
				+    }
			
 
				+    if (utils.isURLSearchParams(data)) {
			
 
				+      headers.setContentType('application/x-www-form-urlencoded;charset=utf-8', false);
			
 
				+      return data.toString();
			
 
				+    }
			
 
				+
			
 
				+    let isFileList;
			
 
				+
			
 
				+    if (isObjectPayload) {
			
 
				+      if (contentType.indexOf('application/x-www-form-urlencoded') > -1) {
			
 
				+        return toURLEncodedForm(data, this.formSerializer).toString();
			
 
				+      }
			
 
				+
			
 
				+      if ((isFileList = utils.isFileList(data)) || contentType.indexOf('multipart/form-data') > -1) {
			
 
				+        const _FormData = this.env && this.env.FormData;
			
 
				+
			
 
				+        return toFormData(
			
 
				+          isFileList ? {'files[]': data} : data,
			
 
				+          _FormData && new _FormData(),
			
 
				+          this.formSerializer
			
 
				+        );
			
 
				+      }
			
 
				+    }
			
 
				+
			
 
				+    if (isObjectPayload || hasJSONContentType ) {
			
 
				+      headers.setContentType('application/json', false);
			
 
				+      return stringifySafely(data);
			
 
				+    }
			
 
				+
			
 
				+    return data;
			
 
				+  }],
			
 
				+
			
 
				+  transformResponse: [function transformResponse(data) {
			
 
				+    const transitional = this.transitional || defaults.transitional;
			
 
				+    const forcedJSONParsing = transitional && transitional.forcedJSONParsing;
			
 
				+    const JSONRequested = this.responseType === 'json';
			
 
				+
			
 
				+    if (utils.isResponse(data) || utils.isReadableStream(data)) {
			
 
				+      return data;
			
 
				+    }
			
 
				+
			
 
				+    if (data && utils.isString(data) && ((forcedJSONParsing && !this.responseType) || JSONRequested)) {
			
 
				+      const silentJSONParsing = transitional && transitional.silentJSONParsing;
			
 
				+      const strictJSONParsing = !silentJSONParsing && JSONRequested;
			
 
				+
			
 
				+      try {
			
 
				+        return JSON.parse(data);
			
 
				+      } catch (e) {
			
 
				+        if (strictJSONParsing) {
			
 
				+          if (e.name === 'SyntaxError') {
			
 
				+            throw AxiosError.from(e, AxiosError.ERR_BAD_RESPONSE, this, null, this.response);
			
 
				+          }
			
 
				+          throw e;
			
 
				+        }
			
 
				+      }
			
 
				+    }
			
 
				+
			
 
				+    return data;
			
 
				+  }],
			
 
				+
			
 
				+  /**
			
 
				+   * A timeout in milliseconds to abort a request. If set to 0 (default) a
			
 
				+   * timeout is not created.
			
 
				+   */
			
 
				+  timeout: 0,
			
 
				+
			
 
				+  xsrfCookieName: 'XSRF-TOKEN',
			
 
				+  xsrfHeaderName: 'X-XSRF-TOKEN',
			
 
				+
			
 
				+  maxContentLength: -1,
			
 
				+  maxBodyLength: -1,
			
 
				+
			
 
				+  env: {
			
 
				+    FormData: platform.classes.FormData,
			
 
				+    Blob: platform.classes.Blob
			
 
				+  },
			
 
				+
			
 
				+  validateStatus: function validateStatus(status) {
			
 
				+    return status >= 200 && status < 300;
			
 
				+  },
			
 
				+
			
 
				+  headers: {
			
 
				+    common: {
			
 
				+      'Accept': 'application/json, text/plain, */*',
			
 
				+      'Content-Type': undefined
			
 
				+    }
			
 
				+  }
			
 
				+};
			
 
				+
			
 
				+utils.forEach(['delete', 'get', 'head', 'post', 'put', 'patch'], (method) => {
			
 
				+  defaults.headers[method] = {};
			
 
				+});
			
 
				+
			
 
				+export default defaults;
			
--- a/node_modules/axios/lib/defaults/transitional.js
+++ b/node_modules/axios/lib/defaults/transitional.js
@@ -0,0 +1,7 @@
 
				+'use strict';
			
 
				+
			
 
				+export default {
			
 
				+  silentJSONParsing: true,
			
 
				+  forcedJSONParsing: true,
			
 
				+  clarifyTimeoutError: false
			
 
				+};
			
--- a/node_modules/axios/lib/env/README.md
+++ b/node_modules/axios/lib/env/README.md
@@ -0,0 +1,3 @@
 
				+# axios // env
			
 
				+
			
 
				+The `data.js` file is updated automatically when the package version is upgrading. Please do not edit it manually.
			
--- a/node_modules/axios/lib/env/classes/FormData.js
+++ b/node_modules/axios/lib/env/classes/FormData.js
@@ -0,0 +1,2 @@
 
				+import _FormData from 'form-data';
			
 
				+export default typeof FormData !== 'undefined' ? FormData : _FormData;
			
--- a/node_modules/axios/lib/env/data.js
+++ b/node_modules/axios/lib/env/data.js
@@ -0,0 +1 @@
 
				+export const VERSION = "1.8.4";
			
--- a/node_modules/axios/lib/helpers/AxiosTransformStream.js
+++ b/node_modules/axios/lib/helpers/AxiosTransformStream.js
@@ -0,0 +1,143 @@
 
				+'use strict';
			
 
				+
			
 
				+import stream from 'stream';
			
 
				+import utils from '../utils.js';
			
 
				+
			
 
				+const kInternals = Symbol('internals');
			
 
				+
			
 
				+class AxiosTransformStream extends stream.Transform{
			
 
				+  constructor(options) {
			
 
				+    options = utils.toFlatObject(options, {
			
 
				+      maxRate: 0,
			
 
				+      chunkSize: 64 * 1024,
			
 
				+      minChunkSize: 100,
			
 
				+      timeWindow: 500,
			
 
				+      ticksRate: 2,
			
 
				+      samplesCount: 15
			
 
				+    }, null, (prop, source) => {
			
 
				+      return !utils.isUndefined(source[prop]);
			
 
				+    });
			
 
				+
			
 
				+    super({
			
 
				+      readableHighWaterMark: options.chunkSize
			
 
				+    });
			
 
				+
			
 
				+    const internals = this[kInternals] = {
			
 
				+      timeWindow: options.timeWindow,
			
 
				+      chunkSize: options.chunkSize,
			
 
				+      maxRate: options.maxRate,
			
 
				+      minChunkSize: options.minChunkSize,
			
 
				+      bytesSeen: 0,
			
 
				+      isCaptured: false,
			
 
				+      notifiedBytesLoaded: 0,
			
 
				+      ts: Date.now(),
			
 
				+      bytes: 0,
			
 
				+      onReadCallback: null
			
 
				+    };
			
 
				+
			
 
				+    this.on('newListener', event => {
			
 
				+      if (event === 'progress') {
			
 
				+        if (!internals.isCaptured) {
			
 
				+          internals.isCaptured = true;
			
 
				+        }
			
 
				+      }
			
 
				+    });
			
 
				+  }
			
 
				+
			
 
				+  _read(size) {
			
 
				+    const internals = this[kInternals];
			
 
				+
			
 
				+    if (internals.onReadCallback) {
			
 
				+      internals.onReadCallback();
			
 
				+    }
			
 
				+
			
 
				+    return super._read(size);
			
 
				+  }
			
 
				+
			
 
				+  _transform(chunk, encoding, callback) {
			
 
				+    const internals = this[kInternals];
			
 
				+    const maxRate = internals.maxRate;
			
 
				+
			
 
				+    const readableHighWaterMark = this.readableHighWaterMark;
			
 
				+
			
 
				+    const timeWindow = internals.timeWindow;
			
 
				+
			
 
				+    const divider = 1000 / timeWindow;
			
 
				+    const bytesThreshold = (maxRate / divider);
			
 
				+    const minChunkSize = internals.minChunkSize !== false ? Math.max(internals.minChunkSize, bytesThreshold * 0.01) : 0;
			
 
				+
			
 
				+    const pushChunk = (_chunk, _callback) => {
			
 
				+      const bytes = Buffer.byteLength(_chunk);
			
 
				+      internals.bytesSeen += bytes;
			
 
				+      internals.bytes += bytes;
			
 
				+
			
 
				+      internals.isCaptured && this.emit('progress', internals.bytesSeen);
			
 
				+
			
 
				+      if (this.push(_chunk)) {
			
 
				+        process.nextTick(_callback);
			
 
				+      } else {
			
 
				+        internals.onReadCallback = () => {
			
 
				+          internals.onReadCallback = null;
			
 
				+          process.nextTick(_callback);
			
 
				+        };
			
 
				+      }
			
 
				+    }
			
 
				+
			
 
				+    const transformChunk = (_chunk, _callback) => {
			
 
				+      const chunkSize = Buffer.byteLength(_chunk);
			
 
				+      let chunkRemainder = null;
			
 
				+      let maxChunkSize = readableHighWaterMark;
			
 
				+      let bytesLeft;
			
 
				+      let passed = 0;
			
 
				+
			
 
				+      if (maxRate) {
			
 
				+        const now = Date.now();
			
 
				+
			
 
				+        if (!internals.ts || (passed = (now - internals.ts)) >= timeWindow) {
			
 
				+          internals.ts = now;
			
 
				+          bytesLeft = bytesThreshold - internals.bytes;
			
 
				+          internals.bytes = bytesLeft < 0 ? -bytesLeft : 0;
			
 
				+          passed = 0;
			
 
				+        }
			
 
				+
			
 
				+        bytesLeft = bytesThreshold - internals.bytes;
			
 
				+      }
			
 
				+
			
 
				+      if (maxRate) {
			
 
				+        if (bytesLeft <= 0) {
			
 
				+          // next time window
			
 
				+          return setTimeout(() => {
			
 
				+            _callback(null, _chunk);
			
 
				+          }, timeWindow - passed);
			
 
				+        }
			
 
				+
			
 
				+        if (bytesLeft < maxChunkSize) {
			
 
				+          maxChunkSize = bytesLeft;
			
 
				+        }
			
 
				+      }
			
 
				+
			
 
				+      if (maxChunkSize && chunkSize > maxChunkSize && (chunkSize - maxChunkSize) > minChunkSize) {
			
 
				+        chunkRemainder = _chunk.subarray(maxChunkSize);
			
 
				+        _chunk = _chunk.subarray(0, maxChunkSize);
			
 
				+      }
			
 
				+
			
 
				+      pushChunk(_chunk, chunkRemainder ? () => {
			
 
				+        process.nextTick(_callback, null, chunkRemainder);
			
 
				+      } : _callback);
			
 
				+    };
			
 
				+
			
 
				+    transformChunk(chunk, function transformNextChunk(err, _chunk) {
			
 
				+      if (err) {
			
 
				+        return callback(err);
			
 
				+      }
			
 
				+
			
 
				+      if (_chunk) {
			
 
				+        transformChunk(_chunk, transformNextChunk);
			
 
				+      } else {
			
 
				+        callback(null);
			
 
				+      }
			
 
				+    });
			
 
				+  }
			
 
				+}
			
 
				+
			
 
				+export default AxiosTransformStream;
			
--- a/node_modules/axios/lib/helpers/AxiosURLSearchParams.js
+++ b/node_modules/axios/lib/helpers/AxiosURLSearchParams.js
@@ -0,0 +1,58 @@
 
				+'use strict';
			
 
				+
			
 
				+import toFormData from './toFormData.js';
			
 
				+
			
 
				+/**
			
 
				+ * It encodes a string by replacing all characters that are not in the unreserved set with
			
 
				+ * their percent-encoded equivalents
			
 
				+ *
			
 
				+ * @param {string} str - The string to encode.
			
 
				+ *
			
 
				+ * @returns {string} The encoded string.
			
 
				+ */
			
 
				+function encode(str) {
			
 
				+  const charMap = {
			
 
				+    '!': '%21',
			
 
				+    "'": '%27',
			
 
				+    '(': '%28',
			
 
				+    ')': '%29',
			
 
				+    '~': '%7E',
			
 
				+    '%20': '+',
			
 
				+    '%00': '\x00'
			
 
				+  };
			
 
				+  return encodeURIComponent(str).replace(/[!'()~]|%20|%00/g, function replacer(match) {
			
 
				+    return charMap[match];
			
 
				+  });
			
 
				+}
			
 
				+
			
 
				+/**
			
 
				+ * It takes a params object and converts it to a FormData object
			
 
				+ *
			
 
				+ * @param {Object<string, any>} params - The parameters to be converted to a FormData object.
			
 
				+ * @param {Object<string, any>} options - The options object passed to the Axios constructor.
			
 
				+ *
			
 
				+ * @returns {void}
			
 
				+ */
			
 
				+function AxiosURLSearchParams(params, options) {
			
 
				+  this._pairs = [];
			
 
				+
			
 
				+  params && toFormData(params, this, options);
			
 
				+}
			
 
				+
			
 
				+const prototype = AxiosURLSearchParams.prototype;
			
 
				+
			
 
				+prototype.append = function append(name, value) {
			
 
				+  this._pairs.push([name, value]);
			
 
				+};
			
 
				+
			
 
				+prototype.toString = function toString(encoder) {
			
 
				+  const _encode = encoder ? function(value) {
			
 
				+    return encoder.call(this, value, encode);
			
 
				+  } : encode;
			
 
				+
			
 
				+  return this._pairs.map(function each(pair) {
			
 
				+    return _encode(pair[0]) + '=' + _encode(pair[1]);
			
 
				+  }, '').join('&');
			
 
				+};
			
 
				+
			
 
				+export default AxiosURLSearchParams;
			
--- a/node_modules/axios/lib/helpers/HttpStatusCode.js
+++ b/node_modules/axios/lib/helpers/HttpStatusCode.js
@@ -0,0 +1,71 @@
 
				+const HttpStatusCode = {
			
 
				+  Continue: 100,
			
 
				+  SwitchingProtocols: 101,
			
 
				+  Processing: 102,
			
 
				+  EarlyHints: 103,
			
 
				+  Ok: 200,
			
 
				+  Created: 201,
			
 
				+  Accepted: 202,
			
 
				+  NonAuthoritativeInformation: 203,
			
 
				+  NoContent: 204,
			
 
				+  ResetContent: 205,
			
 
				+  PartialContent: 206,
			
 
				+  MultiStatus: 207,
			
 
				+  AlreadyReported: 208,
			
 
				+  ImUsed: 226,
			
 
				+  MultipleChoices: 300,
			
 
				+  MovedPermanently: 301,
			
 
				+  Found: 302,
			
 
				+  SeeOther: 303,
			
 
				+  NotModified: 304,
			
 
				+  UseProxy: 305,
			
 
				+  Unused: 306,
			
 
				+  TemporaryRedirect: 307,
			
 
				+  PermanentRedirect: 308,
			
 
				+  BadRequest: 400,
			
 
				+  Unauthorized: 401,
			
 
				+  PaymentRequired: 402,
			
 
				+  Forbidden: 403,
			
 
				+  NotFound: 404,
			
 
				+  MethodNotAllowed: 405,
			
 
				+  NotAcceptable: 406,
			
 
				+  ProxyAuthenticationRequired: 407,
			
 
				+  RequestTimeout: 408,
			
 
				+  Conflict: 409,
			
 
				+  Gone: 410,
			
 
				+  LengthRequired: 411,
			
 
				+  PreconditionFailed: 412,
			
 
				+  PayloadTooLarge: 413,
			
 
				+  UriTooLong: 414,
			
 
				+  UnsupportedMediaType: 415,
			
 
				+  RangeNotSatisfiable: 416,
			
 
				+  ExpectationFailed: 417,
			
 
				+  ImATeapot: 418,
			
 
				+  MisdirectedRequest: 421,
			
 
				+  UnprocessableEntity: 422,
			
 
				+  Locked: 423,
			
 
				+  FailedDependency: 424,
			
 
				+  TooEarly: 425,
			
 
				+  UpgradeRequired: 426,
			
 
				+  PreconditionRequired: 428,
			
 
				+  TooManyRequests: 429,
			
 
				+  RequestHeaderFieldsTooLarge: 431,
			
 
				+  UnavailableForLegalReasons: 451,
			
 
				+  InternalServerError: 500,
			
 
				+  NotImplemented: 501,
			
 
				+  BadGateway: 502,
			
 
				+  ServiceUnavailable: 503,
			
 
				+  GatewayTimeout: 504,
			
 
				+  HttpVersionNotSupported: 505,
			
 
				+  VariantAlsoNegotiates: 506,
			
 
				+  InsufficientStorage: 507,
			
 
				+  LoopDetected: 508,
			
 
				+  NotExtended: 510,
			
 
				+  NetworkAuthenticationRequired: 511,
			
 
				+};
			
 
				+
			
 
				+Object.entries(HttpStatusCode).forEach(([key, value]) => {
			
 
				+  HttpStatusCode[value] = key;
			
 
				+});
			
 
				+
			
 
				+export default HttpStatusCode;
			
--- a/node_modules/axios/lib/helpers/README.md
+++ b/node_modules/axios/lib/helpers/README.md
@@ -0,0 +1,7 @@
 
				+# axios // helpers
			
 
				+
			
 
				+The modules found in `helpers/` should be generic modules that are _not_ specific to the domain logic of axios. These modules could theoretically be published to npm on their own and consumed by other modules or apps. Some examples of generic modules are things like:
			
 
				+
			
 
				+- Browser polyfills
			
 
				+- Managing cookies
			
 
				+- Parsing HTTP headers
			
--- a/node_modules/axios/lib/helpers/ZlibHeaderTransformStream.js
+++ b/node_modules/axios/lib/helpers/ZlibHeaderTransformStream.js
@@ -0,0 +1,28 @@
 
				+"use strict";
			
 
				+
			
 
				+import stream from "stream";
			
 
				+
			
 
				+class ZlibHeaderTransformStream extends stream.Transform {
			
 
				+  __transform(chunk, encoding, callback) {
			
 
				+    this.push(chunk);
			
 
				+    callback();
			
 
				+  }
			
 
				+
			
 
				+  _transform(chunk, encoding, callback) {
			
 
				+    if (chunk.length !== 0) {
			
 
				+      this._transform = this.__transform;
			
 
				+
			
 
				+      // Add Default Compression headers if no zlib headers are present
			
 
				+      if (chunk[0] !== 120) { // Hex: 78
			
 
				+        const header = Buffer.alloc(2);
			
 
				+        header[0] = 120; // Hex: 78
			
 
				+        header[1] = 156; // Hex: 9C 
			
 
				+        this.push(header, encoding);
			
 
				+      }
			
 
				+    }
			
 
				+
			
 
				+    this.__transform(chunk, encoding, callback);
			
 
				+  }
			
 
				+}
			
 
				+
			
 
				+export default ZlibHeaderTransformStream;
			
--- a/node_modules/axios/lib/helpers/bind.js
+++ b/node_modules/axios/lib/helpers/bind.js
@@ -0,0 +1,7 @@
 
				+'use strict';
			
 
				+
			
 
				+export default function bind(fn, thisArg) {
			
 
				+  return function wrap() {
			
 
				+    return fn.apply(thisArg, arguments);
			
 
				+  };
			
 
				+}
			
--- a/node_modules/axios/lib/helpers/buildURL.js
+++ b/node_modules/axios/lib/helpers/buildURL.js
@@ -0,0 +1,69 @@
 
				+'use strict';
			
 
				+
			
 
				+import utils from '../utils.js';
			
 
				+import AxiosURLSearchParams from '../helpers/AxiosURLSearchParams.js';
			
 
				+
			
 
				+/**
			
 
				+ * It replaces all instances of the characters `:`, `$`, `,`, `+`, `[`, and `]` with their
			
 
				+ * URI encoded counterparts
			
 
				+ *
			
 
				+ * @param {string} val The value to be encoded.
			
 
				+ *
			
 
				+ * @returns {string} The encoded value.
			
 
				+ */
			
 
				+function encode(val) {
			
 
				+  return encodeURIComponent(val).
			
 
				+    replace(/%3A/gi, ':').
			
 
				+    replace(/%24/g, '$').
			
 
				+    replace(/%2C/gi, ',').
			
 
				+    replace(/%20/g, '+').
			
 
				+    replace(/%5B/gi, '[').
			
 
				+    replace(/%5D/gi, ']');
			
 
				+}
			
 
				+
			
 
				+/**
			
 
				+ * Build a URL by appending params to the end
			
 
				+ *
			
 
				+ * @param {string} url The base of the url (e.g., http://www.google.com)
			
 
				+ * @param {object} [params] The params to be appended
			
 
				+ * @param {?(object|Function)} options
			
 
				+ *
			
 
				+ * @returns {string} The formatted url
			
 
				+ */
			
 
				+export default function buildURL(url, params, options) {
			
 
				+  /*eslint no-param-reassign:0*/
			
 
				+  if (!params) {
			
 
				+    return url;
			
 
				+  }
			
 
				+  
			
 
				+  const _encode = options && options.encode || encode;
			
 
				+
			
 
				+  if (utils.isFunction(options)) {
			
 
				+    options = {
			
 
				+      serialize: options
			
 
				+    };
			
 
				+  } 
			
 
				+
			
 
				+  const serializeFn = options && options.serialize;
			
 
				+
			
 
				+  let serializedParams;
			
 
				+
			
 
				+  if (serializeFn) {
			
 
				+    serializedParams = serializeFn(params, options);
			
 
				+  } else {
			
 
				+    serializedParams = utils.isURLSearchParams(params) ?
			
 
				+      params.toString() :
			
 
				+      new AxiosURLSearchParams(params, options).toString(_encode);
			
 
				+  }
			
 
				+
			
 
				+  if (serializedParams) {
			
 
				+    const hashmarkIndex = url.indexOf("#");
			
 
				+
			
 
				+    if (hashmarkIndex !== -1) {
			
 
				+      url = url.slice(0, hashmarkIndex);
			
 
				+    }
			
 
				+    url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams;
			
 
				+  }
			
 
				+
			
 
				+  return url;
			
 
				+}
			
--- a/node_modules/axios/lib/helpers/callbackify.js
+++ b/node_modules/axios/lib/helpers/callbackify.js
@@ -0,0 +1,16 @@
 
				+import utils from "../utils.js";
			
 
				+
			
 
				+const callbackify = (fn, reducer) => {
			
 
				+  return utils.isAsyncFn(fn) ? function (...args) {
			
 
				+    const cb = args.pop();
			
 
				+    fn.apply(this, args).then((value) => {
			
 
				+      try {
			
 
				+        reducer ? cb(null, ...reducer(value)) : cb(null, value);
			
 
				+      } catch (err) {
			
 
				+        cb(err);
			
 
				+      }
			
 
				+    }, cb);
			
 
				+  } : fn;
			
 
				+}
			
 
				+
			
 
				+export default callbackify;
			
--- a/node_modules/axios/lib/helpers/combineURLs.js
+++ b/node_modules/axios/lib/helpers/combineURLs.js
@@ -0,0 +1,15 @@
 
				+'use strict';
			
 
				+
			
 
				+/**
			
 
				+ * Creates a new URL by combining the specified URLs
			
 
				+ *
			
 
				+ * @param {string} baseURL The base URL
			
 
				+ * @param {string} relativeURL The relative URL
			
 
				+ *
			
 
				+ * @returns {string} The combined URL
			
 
				+ */
			
 
				+export default function combineURLs(baseURL, relativeURL) {
			
 
				+  return relativeURL
			
 
				+    ? baseURL.replace(/\/?\/$/, '') + '/' + relativeURL.replace(/^\/+/, '')
			
 
				+    : baseURL;
			
 
				+}
			
--- a/node_modules/axios/lib/helpers/composeSignals.js
+++ b/node_modules/axios/lib/helpers/composeSignals.js
@@ -0,0 +1,48 @@
 
				+import CanceledError from "../cancel/CanceledError.js";
			
 
				+import AxiosError from "../core/AxiosError.js";
			
 
				+import utils from '../utils.js';
			
 
				+
			
 
				+const composeSignals = (signals, timeout) => {
			
 
				+  const {length} = (signals = signals ? signals.filter(Boolean) : []);
			
 
				+
			
 
				+  if (timeout || length) {
			
 
				+    let controller = new AbortController();
			
 
				+
			
 
				+    let aborted;
			
 
				+
			
 
				+    const onabort = function (reason) {
			
 
				+      if (!aborted) {
			
 
				+        aborted = true;
			
 
				+        unsubscribe();
			
 
				+        const err = reason instanceof Error ? reason : this.reason;
			
 
				+        controller.abort(err instanceof AxiosError ? err : new CanceledError(err instanceof Error ? err.message : err));
			
 
				+      }
			
 
				+    }
			
 
				+
			
 
				+    let timer = timeout && setTimeout(() => {
			
 
				+      timer = null;
			
 
				+      onabort(new AxiosError(`timeout ${timeout} of ms exceeded`, AxiosError.ETIMEDOUT))
			
 
				+    }, timeout)
			
 
				+
			
 
				+    const unsubscribe = () => {
			
 
				+      if (signals) {
			
 
				+        timer && clearTimeout(timer);
			
 
				+        timer = null;
			
 
				+        signals.forEach(signal => {
			
 
				+          signal.unsubscribe ? signal.unsubscribe(onabort) : signal.removeEventListener('abort', onabort);
			
 
				+        });
			
 
				+        signals = null;
			
 
				+      }
			
 
				+    }
			
 
				+
			
 
				+    signals.forEach((signal) => signal.addEventListener('abort', onabort));
			
 
				+
			
 
				+    const {signal} = controller;
			
 
				+
			
 
				+    signal.unsubscribe = () => utils.asap(unsubscribe);
			
 
				+
			
 
				+    return signal;
			
 
				+  }
			
 
				+}
			
 
				+
			
 
				+export default composeSignals;
			
--- a/node_modules/axios/lib/helpers/cookies.js
+++ b/node_modules/axios/lib/helpers/cookies.js
@@ -0,0 +1,42 @@
 
				+import utils from './../utils.js';
			
 
				+import platform from '../platform/index.js';
			
 
				+
			
 
				+export default platform.hasStandardBrowserEnv ?
			
 
				+
			
 
				+  // Standard browser envs support document.cookie
			
 
				+  {
			
 
				+    write(name, value, expires, path, domain, secure) {
			
 
				+      const cookie = [name + '=' + encodeURIComponent(value)];
			
 
				+
			
 
				+      utils.isNumber(expires) && cookie.push('expires=' + new Date(expires).toGMTString());
			
 
				+
			
 
				+      utils.isString(path) && cookie.push('path=' + path);
			
 
				+
			
 
				+      utils.isString(domain) && cookie.push('domain=' + domain);
			
 
				+
			
 
				+      secure === true && cookie.push('secure');
			
 
				+
			
 
				+      document.cookie = cookie.join('; ');
			
 
				+    },
			
 
				+
			
 
				+    read(name) {
			
 
				+      const match = document.cookie.match(new RegExp('(^|;\\s*)(' + name + ')=([^;]*)'));
			
 
				+      return (match ? decodeURIComponent(match[3]) : null);
			
 
				+    },
			
 
				+
			
 
				+    remove(name) {
			
 
				+      this.write(name, '', Date.now() - 86400000);
			
 
				+    }
			
 
				+  }
			
 
				+
			
 
				+  :
			
 
				+
			
 
				+  // Non-standard browser env (web workers, react-native) lack needed support.
			
 
				+  {
			
 
				+    write() {},
			
 
				+    read() {
			
 
				+      return null;
			
 
				+    },
			
 
				+    remove() {}
			
 
				+  };
			
 
				+
			
--- a/node_modules/axios/lib/helpers/deprecatedMethod.js
+++ b/node_modules/axios/lib/helpers/deprecatedMethod.js
@@ -0,0 +1,26 @@
 
				+'use strict';
			
 
				+
			
 
				+/*eslint no-console:0*/
			
 
				+
			
 
				+/**
			
 
				+ * Supply a warning to the developer that a method they are using
			
 
				+ * has been deprecated.
			
 
				+ *
			
 
				+ * @param {string} method The name of the deprecated method
			
 
				+ * @param {string} [instead] The alternate method to use if applicable
			
 
				+ * @param {string} [docs] The documentation URL to get further details
			
 
				+ *
			
 
				+ * @returns {void}
			
 
				+ */
			
 
				+export default function deprecatedMethod(method, instead, docs) {
			
 
				+  try {
			
 
				+    console.warn(
			
 
				+      'DEPRECATED method `' + method + '`.' +
			
 
				+      (instead ? ' Use `' + instead + '` instead.' : '') +
			
 
				+      ' This method will be removed in a future release.');
			
 
				+
			
 
				+    if (docs) {
			
 
				+      console.warn('For more information about usage see ' + docs);
			
 
				+    }
			
 
				+  } catch (e) { /* Ignore */ }
			
 
				+}
			
--- a/node_modules/axios/lib/helpers/formDataToJSON.js
+++ b/node_modules/axios/lib/helpers/formDataToJSON.js
@@ -0,0 +1,95 @@
 
				+'use strict';
			
 
				+
			
 
				+import utils from '../utils.js';
			
 
				+
			
 
				+/**
			
 
				+ * It takes a string like `foo[x][y][z]` and returns an array like `['foo', 'x', 'y', 'z']
			
 
				+ *
			
 
				+ * @param {string} name - The name of the property to get.
			
 
				+ *
			
 
				+ * @returns An array of strings.
			
 
				+ */
			
 
				+function parsePropPath(name) {
			
 
				+  // foo[x][y][z]
			
 
				+  // foo.x.y.z
			
 
				+  // foo-x-y-z
			
 
				+  // foo x y z
			
 
				+  return utils.matchAll(/\w+|\[(\w*)]/g, name).map(match => {
			
 
				+    return match[0] === '[]' ? '' : match[1] || match[0];
			
 
				+  });
			
 
				+}
			
 
				+
			
 
				+/**
			
 
				+ * Convert an array to an object.
			
 
				+ *
			
 
				+ * @param {Array<any>} arr - The array to convert to an object.
			
 
				+ *
			
 
				+ * @returns An object with the same keys and values as the array.
			
 
				+ */
			
 
				+function arrayToObject(arr) {
			
 
				+  const obj = {};
			
 
				+  const keys = Object.keys(arr);
			
 
				+  let i;
			
 
				+  const len = keys.length;
			
 
				+  let key;
			
 
				+  for (i = 0; i < len; i++) {
			
 
				+    key = keys[i];
			
 
				+    obj[key] = arr[key];
			
 
				+  }
			
 
				+  return obj;
			
 
				+}
			
 
				+
			
 
				+/**
			
 
				+ * It takes a FormData object and returns a JavaScript object
			
 
				+ *
			
 
				+ * @param {string} formData The FormData object to convert to JSON.
			
 
				+ *
			
 
				+ * @returns {Object<string, any> | null} The converted object.
			
 
				+ */
			
 
				+function formDataToJSON(formData) {
			
 
				+  function buildPath(path, value, target, index) {
			
 
				+    let name = path[index++];
			
 
				+
			
 
				+    if (name === '__proto__') return true;
			
 
				+
			
 
				+    const isNumericKey = Number.isFinite(+name);
			
 
				+    const isLast = index >= path.length;
			
 
				+    name = !name && utils.isArray(target) ? target.length : name;
			
 
				+
			
 
				+    if (isLast) {
			
 
				+      if (utils.hasOwnProp(target, name)) {
			
 
				+        target[name] = [target[name], value];
			
 
				+      } else {
			
 
				+        target[name] = value;
			
 
				+      }
			
 
				+
			
 
				+      return !isNumericKey;
			
 
				+    }
			
 
				+
			
 
				+    if (!target[name] || !utils.isObject(target[name])) {
			
 
				+      target[name] = [];
			
 
				+    }
			
 
				+
			
 
				+    const result = buildPath(path, value, target[name], index);
			
 
				+
			
 
				+    if (result && utils.isArray(target[name])) {
			
 
				+      target[name] = arrayToObject(target[name]);
			
 
				+    }
			
 
				+
			
 
				+    return !isNumericKey;
			
 
				+  }
			
 
				+
			
 
				+  if (utils.isFormData(formData) && utils.isFunction(formData.entries)) {
			
 
				+    const obj = {};
			
 
				+
			
 
				+    utils.forEachEntry(formData, (name, value) => {
			
 
				+      buildPath(parsePropPath(name), value, obj, 0);
			
 
				+    });
			
 
				+
			
 
				+    return obj;
			
 
				+  }
			
 
				+
			
 
				+  return null;
			
 
				+}
			
 
				+
			
 
				+export default formDataToJSON;
			
--- a/node_modules/axios/lib/helpers/formDataToStream.js
+++ b/node_modules/axios/lib/helpers/formDataToStream.js
@@ -0,0 +1,112 @@
 
				+import util from 'util';
			
 
				+import {Readable} from 'stream';
			
 
				+import utils from "../utils.js";
			
 
				+import readBlob from "./readBlob.js";
			
 
				+import platform from "../platform/index.js";
			
 
				+
			
 
				+const BOUNDARY_ALPHABET = platform.ALPHABET.ALPHA_DIGIT + '-_';
			
 
				+
			
 
				+const textEncoder = typeof TextEncoder === 'function' ? new TextEncoder() : new util.TextEncoder();
			
 
				+
			
 
				+const CRLF = '\r\n';
			
 
				+const CRLF_BYTES = textEncoder.encode(CRLF);
			
 
				+const CRLF_BYTES_COUNT = 2;
			
 
				+
			
 
				+class FormDataPart {
			
 
				+  constructor(name, value) {
			
 
				+    const {escapeName} = this.constructor;
			
 
				+    const isStringValue = utils.isString(value);
			
 
				+
			
 
				+    let headers = `Content-Disposition: form-data; name="${escapeName(name)}"${
			
 
				+      !isStringValue && value.name ? `; filename="${escapeName(value.name)}"` : ''
			
 
				+    }${CRLF}`;
			
 
				+
			
 
				+    if (isStringValue) {
			
 
				+      value = textEncoder.encode(String(value).replace(/\r?\n|\r\n?/g, CRLF));
			
 
				+    } else {
			
 
				+      headers += `Content-Type: ${value.type || "application/octet-stream"}${CRLF}`
			
 
				+    }
			
 
				+
			
 
				+    this.headers = textEncoder.encode(headers + CRLF);
			
 
				+
			
 
				+    this.contentLength = isStringValue ? value.byteLength : value.size;
			
 
				+
			
 
				+    this.size = this.headers.byteLength + this.contentLength + CRLF_BYTES_COUNT;
			
 
				+
			
 
				+    this.name = name;
			
 
				+    this.value = value;
			
 
				+  }
			
 
				+
			
 
				+  async *encode(){
			
 
				+    yield this.headers;
			
 
				+
			
 
				+    const {value} = this;
			
 
				+
			
 
				+    if(utils.isTypedArray(value)) {
			
 
				+      yield value;
			
 
				+    } else {
			
 
				+      yield* readBlob(value);
			
 
				+    }
			
 
				+
			
 
				+    yield CRLF_BYTES;
			
 
				+  }
			
 
				+
			
 
				+  static escapeName(name) {
			
 
				+      return String(name).replace(/[\r\n"]/g, (match) => ({
			
 
				+        '\r' : '%0D',
			
 
				+        '\n' : '%0A',
			
 
				+        '"' : '%22',
			
 
				+      }[match]));
			
 
				+  }
			
 
				+}
			
 
				+
			
 
				+const formDataToStream = (form, headersHandler, options) => {
			
 
				+  const {
			
 
				+    tag = 'form-data-boundary',
			
 
				+    size = 25,
			
 
				+    boundary = tag + '-' + platform.generateString(size, BOUNDARY_ALPHABET)
			
 
				+  } = options || {};
			
 
				+
			
 
				+  if(!utils.isFormData(form)) {
			
 
				+    throw TypeError('FormData instance required');
			
 
				+  }
			
 
				+
			
 
				+  if (boundary.length < 1 || boundary.length > 70) {
			
 
				+    throw Error('boundary must be 10-70 characters long')
			
 
				+  }
			
 
				+
			
 
				+  const boundaryBytes = textEncoder.encode('--' + boundary + CRLF);
			
 
				+  const footerBytes = textEncoder.encode('--' + boundary + '--' + CRLF + CRLF);
			
 
				+  let contentLength = footerBytes.byteLength;
			
 
				+
			
 
				+  const parts = Array.from(form.entries()).map(([name, value]) => {
			
 
				+    const part = new FormDataPart(name, value);
			
 
				+    contentLength += part.size;
			
 
				+    return part;
			
 
				+  });
			
 
				+
			
 
				+  contentLength += boundaryBytes.byteLength * parts.length;
			
 
				+
			
 
				+  contentLength = utils.toFiniteNumber(contentLength);
			
 
				+
			
 
				+  const computedHeaders = {
			
 
				+    'Content-Type': `multipart/form-data; boundary=${boundary}`
			
 
				+  }
			
 
				+
			
 
				+  if (Number.isFinite(contentLength)) {
			
 
				+    computedHeaders['Content-Length'] = contentLength;
			
 
				+  }
			
 
				+
			
 
				+  headersHandler && headersHandler(computedHeaders);
			
 
				+
			
 
				+  return Readable.from((async function *() {
			
 
				+    for(const part of parts) {
			
 
				+      yield boundaryBytes;
			
 
				+      yield* part.encode();
			
 
				+    }
			
 
				+
			
 
				+    yield footerBytes;
			
 
				+  })());
			
 
				+};
			
 
				+
			
 
				+export default formDataToStream;
			
--- a/node_modules/axios/lib/helpers/fromDataURI.js
+++ b/node_modules/axios/lib/helpers/fromDataURI.js
@@ -0,0 +1,53 @@
 
				+'use strict';
			
 
				+
			
 
				+import AxiosError from '../core/AxiosError.js';
			
 
				+import parseProtocol from './parseProtocol.js';
			
 
				+import platform from '../platform/index.js';
			
 
				+
			
 
				+const DATA_URL_PATTERN = /^(?:([^;]+);)?(?:[^;]+;)?(base64|),([\s\S]*)$/;
			
 
				+
			
 
				+/**
			
 
				+ * Parse data uri to a Buffer or Blob
			
 
				+ *
			
 
				+ * @param {String} uri
			
 
				+ * @param {?Boolean} asBlob
			
 
				+ * @param {?Object} options
			
 
				+ * @param {?Function} options.Blob
			
 
				+ *
			
 
				+ * @returns {Buffer|Blob}
			
 
				+ */
			
 
				+export default function fromDataURI(uri, asBlob, options) {
			
 
				+  const _Blob = options && options.Blob || platform.classes.Blob;
			
 
				+  const protocol = parseProtocol(uri);
			
 
				+
			
 
				+  if (asBlob === undefined && _Blob) {
			
 
				+    asBlob = true;
			
 
				+  }
			
 
				+
			
 
				+  if (protocol === 'data') {
			
 
				+    uri = protocol.length ? uri.slice(protocol.length + 1) : uri;
			
 
				+
			
 
				+    const match = DATA_URL_PATTERN.exec(uri);
			
 
				+
			
 
				+    if (!match) {
			
 
				+      throw new AxiosError('Invalid URL', AxiosError.ERR_INVALID_URL);
			
 
				+    }
			
 
				+
			
 
				+    const mime = match[1];
			
 
				+    const isBase64 = match[2];
			
 
				+    const body = match[3];
			
 
				+    const buffer = Buffer.from(decodeURIComponent(body), isBase64 ? 'base64' : 'utf8');
			
 
				+
			
 
				+    if (asBlob) {
			
 
				+      if (!_Blob) {
			
 
				+        throw new AxiosError('Blob is not supported', AxiosError.ERR_NOT_SUPPORT);
			
 
				+      }
			
 
				+
			
 
				+      return new _Blob([buffer], {type: mime});
			
 
				+    }
			
 
				+
			
 
				+    return buffer;
			
 
				+  }
			
 
				+
			
 
				+  throw new AxiosError('Unsupported protocol ' + protocol, AxiosError.ERR_NOT_SUPPORT);
			
 
				+}
			
--- a/node_modules/axios/lib/helpers/isAbsoluteURL.js
+++ b/node_modules/axios/lib/helpers/isAbsoluteURL.js
@@ -0,0 +1,15 @@
 
				+'use strict';
			
 
				+
			
 
				+/**
			
 
				+ * Determines whether the specified URL is absolute
			
 
				+ *
			
 
				+ * @param {string} url The URL to test
			
 
				+ *
			
 
				+ * @returns {boolean} True if the specified URL is absolute, otherwise false
			
 
				+ */
			
 
				+export default function isAbsoluteURL(url) {
			
 
				+  // A URL is considered absolute if it begins with "<scheme>://" or "//" (protocol-relative URL).
			
 
				+  // RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed
			
 
				+  // by any combination of letters, digits, plus, period, or hyphen.
			
 
				+  return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(url);
			
 
				+}
			
--- a/node_modules/axios/lib/helpers/isAxiosError.js
+++ b/node_modules/axios/lib/helpers/isAxiosError.js
@@ -0,0 +1,14 @@
 
				+'use strict';
			
 
				+
			
 
				+import utils from './../utils.js';
			
 
				+
			
 
				+/**
			
 
				+ * Determines whether the payload is an error thrown by Axios
			
 
				+ *
			
 
				+ * @param {*} payload The value to test
			
 
				+ *
			
 
				+ * @returns {boolean} True if the payload is an error thrown by Axios, otherwise false
			
 
				+ */
			
 
				+export default function isAxiosError(payload) {
			
 
				+  return utils.isObject(payload) && (payload.isAxiosError === true);
			
 
				+}
			
--- a/node_modules/axios/lib/helpers/isURLSameOrigin.js
+++ b/node_modules/axios/lib/helpers/isURLSameOrigin.js
@@ -0,0 +1,14 @@
 
				+import platform from '../platform/index.js';
			
 
				+
			
 
				+export default platform.hasStandardBrowserEnv ? ((origin, isMSIE) => (url) => {
			
 
				+  url = new URL(url, platform.origin);
			
 
				+
			
 
				+  return (
			
 
				+    origin.protocol === url.protocol &&
			
 
				+    origin.host === url.host &&
			
 
				+    (isMSIE || origin.port === url.port)
			
 
				+  );
			
 
				+})(
			
 
				+  new URL(platform.origin),
			
 
				+  platform.navigator && /(msie|trident)/i.test(platform.navigator.userAgent)
			
 
				+) : () => true;
			
--- a/node_modules/axios/lib/helpers/null.js
+++ b/node_modules/axios/lib/helpers/null.js
@@ -0,0 +1,2 @@
 
				+// eslint-disable-next-line strict
			
 
				+export default null;
			
--- a/node_modules/axios/lib/helpers/parseHeaders.js
+++ b/node_modules/axios/lib/helpers/parseHeaders.js
@@ -0,0 +1,55 @@
 
				+'use strict';
			
 
				+
			
 
				+import utils from './../utils.js';
			
 
				+
			
 
				+// RawAxiosHeaders whose duplicates are ignored by node
			
 
				+// c.f. https://nodejs.org/api/http.html#http_message_headers
			
 
				+const ignoreDuplicateOf = utils.toObjectSet([
			
 
				+  'age', 'authorization', 'content-length', 'content-type', 'etag',
			
 
				+  'expires', 'from', 'host', 'if-modified-since', 'if-unmodified-since',
			
 
				+  'last-modified', 'location', 'max-forwards', 'proxy-authorization',
			
 
				+  'referer', 'retry-after', 'user-agent'
			
 
				+]);
			
 
				+
			
 
				+/**
			
 
				+ * Parse headers into an object
			
 
				+ *
			
 
				+ * ```
			
 
				+ * Date: Wed, 27 Aug 2014 08:58:49 GMT
			
 
				+ * Content-Type: application/json
			
 
				+ * Connection: keep-alive
			
 
				+ * Transfer-Encoding: chunked
			
 
				+ * ```
			
 
				+ *
			
 
				+ * @param {String} rawHeaders Headers needing to be parsed
			
 
				+ *
			
 
				+ * @returns {Object} Headers parsed into an object
			
 
				+ */
			
 
				+export default rawHeaders => {
			
 
				+  const parsed = {};
			
 
				+  let key;
			
 
				+  let val;
			
 
				+  let i;
			
 
				+
			
 
				+  rawHeaders && rawHeaders.split('\n').forEach(function parser(line) {
			
 
				+    i = line.indexOf(':');
			
 
				+    key = line.substring(0, i).trim().toLowerCase();
			
 
				+    val = line.substring(i + 1).trim();
			
 
				+
			
 
				+    if (!key || (parsed[key] && ignoreDuplicateOf[key])) {
			
 
				+      return;
			
 
				+    }
			
 
				+
			
 
				+    if (key === 'set-cookie') {
			
 
				+      if (parsed[key]) {
			
 
				+        parsed[key].push(val);
			
 
				+      } else {
			
 
				+        parsed[key] = [val];
			
 
				+      }
			
 
				+    } else {
			
 
				+      parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;
			
 
				+    }
			
 
				+  });
			
 
				+
			
 
				+  return parsed;
			
 
				+};
			
--- a/node_modules/axios/lib/helpers/parseProtocol.js
+++ b/node_modules/axios/lib/helpers/parseProtocol.js
@@ -0,0 +1,6 @@
 
				+'use strict';
			
 
				+
			
 
				+export default function parseProtocol(url) {
			
 
				+  const match = /^([-+\w]{1,25})(:?\/\/|:)/.exec(url);
			
 
				+  return match && match[1] || '';
			
 
				+}
			
--- a/node_modules/axios/lib/helpers/progressEventReducer.js
+++ b/node_modules/axios/lib/helpers/progressEventReducer.js
@@ -0,0 +1,44 @@
 
				+import speedometer from "./speedometer.js";
			
 
				+import throttle from "./throttle.js";
			
 
				+import utils from "../utils.js";
			
 
				+
			
 
				+export const progressEventReducer = (listener, isDownloadStream, freq = 3) => {
			
 
				+  let bytesNotified = 0;
			
 
				+  const _speedometer = speedometer(50, 250);
			
 
				+
			
 
				+  return throttle(e => {
			
 
				+    const loaded = e.loaded;
			
 
				+    const total = e.lengthComputable ? e.total : undefined;
			
 
				+    const progressBytes = loaded - bytesNotified;
			
 
				+    const rate = _speedometer(progressBytes);
			
 
				+    const inRange = loaded <= total;
			
 
				+
			
 
				+    bytesNotified = loaded;
			
 
				+
			
 
				+    const data = {
			
 
				+      loaded,
			
 
				+      total,
			
 
				+      progress: total ? (loaded / total) : undefined,
			
 
				+      bytes: progressBytes,
			
 
				+      rate: rate ? rate : undefined,
			
 
				+      estimated: rate && total && inRange ? (total - loaded) / rate : undefined,
			
 
				+      event: e,
			
 
				+      lengthComputable: total != null,
			
 
				+      [isDownloadStream ? 'download' : 'upload']: true
			
 
				+    };
			
 
				+
			
 
				+    listener(data);
			
 
				+  }, freq);
			
 
				+}
			
 
				+
			
 
				+export const progressEventDecorator = (total, throttled) => {
			
 
				+  const lengthComputable = total != null;
			
 
				+
			
 
				+  return [(loaded) => throttled[0]({
			
 
				+    lengthComputable,
			
 
				+    total,
			
 
				+    loaded
			
 
				+  }), throttled[1]];
			
 
				+}
			
 
				+
			
 
				+export const asyncDecorator = (fn) => (...args) => utils.asap(() => fn(...args));
			
--- a/node_modules/axios/lib/helpers/readBlob.js
+++ b/node_modules/axios/lib/helpers/readBlob.js
@@ -0,0 +1,15 @@
 
				+const {asyncIterator} = Symbol;
			
 
				+
			
 
				+const readBlob = async function* (blob) {
			
 
				+  if (blob.stream) {
			
 
				+    yield* blob.stream()
			
 
				+  } else if (blob.arrayBuffer) {
			
 
				+    yield await blob.arrayBuffer()
			
 
				+  } else if (blob[asyncIterator]) {
			
 
				+    yield* blob[asyncIterator]();
			
 
				+  } else {
			
 
				+    yield blob;
			
 
				+  }
			
 
				+}
			
 
				+
			
 
				+export default readBlob;
			
--- a/node_modules/axios/lib/helpers/resolveConfig.js
+++ b/node_modules/axios/lib/helpers/resolveConfig.js
@@ -0,0 +1,57 @@
 
				+import platform from "../platform/index.js";
			
 
				+import utils from "../utils.js";
			
 
				+import isURLSameOrigin from "./isURLSameOrigin.js";
			
 
				+import cookies from "./cookies.js";
			
 
				+import buildFullPath from "../core/buildFullPath.js";
			
 
				+import mergeConfig from "../core/mergeConfig.js";
			
 
				+import AxiosHeaders from "../core/AxiosHeaders.js";
			
 
				+import buildURL from "./buildURL.js";
			
 
				+
			
 
				+export default (config) => {
			
 
				+  const newConfig = mergeConfig({}, config);
			
 
				+
			
 
				+  let {data, withXSRFToken, xsrfHeaderName, xsrfCookieName, headers, auth} = newConfig;
			
 
				+
			
 
				+  newConfig.headers = headers = AxiosHeaders.from(headers);
			
 
				+
			
 
				+  newConfig.url = buildURL(buildFullPath(newConfig.baseURL, newConfig.url, newConfig.allowAbsoluteUrls), config.params, config.paramsSerializer);
			
 
				+
			
 
				+  // HTTP basic authentication
			
 
				+  if (auth) {
			
 
				+    headers.set('Authorization', 'Basic ' +
			
 
				+      btoa((auth.username || '') + ':' + (auth.password ? unescape(encodeURIComponent(auth.password)) : ''))
			
 
				+    );
			
 
				+  }
			
 
				+
			
 
				+  let contentType;
			
 
				+
			
 
				+  if (utils.isFormData(data)) {
			
 
				+    if (platform.hasStandardBrowserEnv || platform.hasStandardBrowserWebWorkerEnv) {
			
 
				+      headers.setContentType(undefined); // Let the browser set it
			
 
				+    } else if ((contentType = headers.getContentType()) !== false) {
			
 
				+      // fix semicolon duplication issue for ReactNative FormData implementation
			
 
				+      const [type, ...tokens] = contentType ? contentType.split(';').map(token => token.trim()).filter(Boolean) : [];
			
 
				+      headers.setContentType([type || 'multipart/form-data', ...tokens].join('; '));
			
 
				+    }
			
 
				+  }
			
 
				+
			
 
				+  // Add xsrf header
			
 
				+  // This is only done if running in a standard browser environment.
			
 
				+  // Specifically not if we're in a web worker, or react-native.
			
 
				+
			
 
				+  if (platform.hasStandardBrowserEnv) {
			
 
				+    withXSRFToken && utils.isFunction(withXSRFToken) && (withXSRFToken = withXSRFToken(newConfig));
			
 
				+
			
 
				+    if (withXSRFToken || (withXSRFToken !== false && isURLSameOrigin(newConfig.url))) {
			
 
				+      // Add xsrf header
			
 
				+      const xsrfValue = xsrfHeaderName && xsrfCookieName && cookies.read(xsrfCookieName);
			
 
				+
			
 
				+      if (xsrfValue) {
			
 
				+        headers.set(xsrfHeaderName, xsrfValue);
			
 
				+      }
			
 
				+    }
			
 
				+  }
			
 
				+
			
 
				+  return newConfig;
			
 
				+}
			
 
				+
			
--- a/node_modules/axios/lib/helpers/speedometer.js
+++ b/node_modules/axios/lib/helpers/speedometer.js
@@ -0,0 +1,55 @@
 
				+'use strict';
			
 
				+
			
 
				+/**
			
 
				+ * Calculate data maxRate
			
 
				+ * @param {Number} [samplesCount= 10]
			
 
				+ * @param {Number} [min= 1000]
			
 
				+ * @returns {Function}
			
 
				+ */
			
 
				+function speedometer(samplesCount, min) {
			
 
				+  samplesCount = samplesCount || 10;
			
 
				+  const bytes = new Array(samplesCount);
			
 
				+  const timestamps = new Array(samplesCount);
			
 
				+  let head = 0;
			
 
				+  let tail = 0;
			
 
				+  let firstSampleTS;
			
 
				+
			
 
				+  min = min !== undefined ? min : 1000;
			
 
				+
			
 
				+  return function push(chunkLength) {
			
 
				+    const now = Date.now();
			
 
				+
			
 
				+    const startedAt = timestamps[tail];
			
 
				+
			
 
				+    if (!firstSampleTS) {
			
 
				+      firstSampleTS = now;
			
 
				+    }
			
 
				+
			
 
				+    bytes[head] = chunkLength;
			
 
				+    timestamps[head] = now;
			
 
				+
			
 
				+    let i = tail;
			
 
				+    let bytesCount = 0;
			
 
				+
			
 
				+    while (i !== head) {
			
 
				+      bytesCount += bytes[i++];
			
 
				+      i = i % samplesCount;
			
 
				+    }
			
 
				+
			
 
				+    head = (head + 1) % samplesCount;
			
 
				+
			
 
				+    if (head === tail) {
			
 
				+      tail = (tail + 1) % samplesCount;
			
 
				+    }
			
 
				+
			
 
				+    if (now - firstSampleTS < min) {
			
 
				+      return;
			
 
				+    }
			
 
				+
			
 
				+    const passed = startedAt && now - startedAt;
			
 
				+
			
 
				+    return passed ? Math.round(bytesCount * 1000 / passed) : undefined;
			
 
				+  };
			
 
				+}
			
 
				+
			
 
				+export default speedometer;
			
--- a/node_modules/axios/lib/helpers/spread.js
+++ b/node_modules/axios/lib/helpers/spread.js