w-component-vue 2.4.44 → 2.4.46

package/src/components/WTimedayRange.vue

@@ -30,6 +30,10 @@
 
             <WTimedayRangeCore
                 :pickColor="pickColor"
+                :hoverColor="hoverColor"
+                :funRenderYear="funRenderYear"
+                :funRenderMonth="funRenderMonth"
+                :funRenderDayOfWeek="funRenderDayOfWeek"
                 :textFontSize="textFontSize"
                 :textColor="textColor"
                 :between="between"
@@ -79,6 +83,10 @@ import WTimedayRangeCore from './WTimedayRangeCore.vue'
  * @vue-prop {String} [textFontSize='0.85rem'] 輸入文字大小字串，預設'0.85rem'
  * @vue-prop {String} [textColor='black'] 輸入文字顏色字串，預設'black'
  * @vue-prop {String} [pickColor='deep-orange darken-1'] 輸入日期彈窗中選擇指定日期之顏色字串，預設'deep-orange darken-1'
+ * @vue-prop {String} [hoverColor='#ddd'] 輸入日期彈窗中滑鼠移入時之背景顏色字串，預設'#ddd'
+ * @vue-prop {Function} [funRenderYear=null] 輸入渲染年份之函數，傳入年數值回傳顯示字串，預設null，未給時回傳'{年}y'
+ * @vue-prop {Function} [funRenderMonth=null] 輸入渲染月份之函數，傳入月數值回傳顯示字串，預設null，未給時回傳'{月}m'
+ * @vue-prop {Function} [funRenderDayOfWeek=null] 輸入渲染星期幾之函數，傳入星期幾數值(0=日)回傳顯示字串，預設null，未給時回傳對應英文縮寫
  * @vue-prop {Number} [placementDistX=0] 輸入日期彈窗之水平向右平移數字，單位為px，預設0
  * @vue-prop {Number} [placementDistY=7] 輸入日期彈窗之垂直向下平移數字，單位為px，預設7
  * @vue-prop {String} [textEmpty='Select a date'] 輸入尚未輸入日期之顯示文字字串，預設'Select a date'
@@ -188,6 +196,22 @@ export default {
             type: String,
             default: 'deep-orange darken-1',
         },
+        hoverColor: {
+            type: String,
+            default: '#ddd',
+        },
+        funRenderYear: {
+            type: Function,
+            default: null,
+        },
+        funRenderMonth: {
+            type: Function,
+            default: null,
+        },
+        funRenderDayOfWeek: {
+            type: Function,
+            default: null,
+        },
         placementDistX: {
             type: Number,
             default: 0,

package/src/components/WTimedayRangeCore.vue

@@ -8,6 +8,10 @@
                 :textFontSize="textFontSize"
                 :textColor="textColor"
                 :pickColor="pickColor"
+                :hoverColor="hoverColor"
+                :funRenderYear="funRenderYear"
+                :funRenderMonth="funRenderMonth"
+                :funRenderDayOfWeek="funRenderDayOfWeek"
                 :placementDistX="placementDistX"
                 :placementDistY="placementDistY"
                 :textEmpty="textEmpty"
@@ -26,6 +30,10 @@
                 :textFontSize="textFontSize"
                 :textColor="textColor"
                 :pickColor="pickColor"
+                :hoverColor="hoverColor"
+                :funRenderYear="funRenderYear"
+                :funRenderMonth="funRenderMonth"
+                :funRenderDayOfWeek="funRenderDayOfWeek"
                 :placementDistX="placementDistX"
                 :placementDistY="placementDistY"
                 :textEmpty="textEmpty"
@@ -52,6 +60,10 @@ import WTimedayCore from './WTimedayCore.vue'
  * @vue-prop {String} [textFontSize='0.85rem'] 輸入文字大小字串，預設'0.85rem'
  * @vue-prop {String} [textColor='black'] 輸入文字顏色字串，預設'black'
  * @vue-prop {String} [pickColor='deep-orange darken-1'] 輸入日期彈窗中選擇指定日期之顏色字串，預設'deep-orange darken-1'
+ * @vue-prop {String} [hoverColor='#ddd'] 輸入日期彈窗中滑鼠移入時之背景顏色字串，預設'#ddd'
+ * @vue-prop {Function} [funRenderYear=null] 輸入渲染年份之函數，傳入年數值回傳顯示字串，預設null，未給時回傳'{年}y'
+ * @vue-prop {Function} [funRenderMonth=null] 輸入渲染月份之函數，傳入月數值回傳顯示字串，預設null，未給時回傳'{月}m'
+ * @vue-prop {Function} [funRenderDayOfWeek=null] 輸入渲染星期幾之函數，傳入星期幾數值(0=日)回傳顯示字串，預設null，未給時回傳對應英文縮寫
  * @vue-prop {Number} [placementDistX=0] 輸入日期彈窗之水平向右平移數字，單位為px，預設0
  * @vue-prop {Number} [placementDistY=7] 輸入日期彈窗之垂直向下平移數字，單位為px，預設7
  * @vue-prop {String} [textEmpty='Select a date'] 輸入尚未輸入日期之顯示文字字串，預設'Select a date'
@@ -86,6 +98,22 @@ export default {
             type: String,
             default: 'deep-orange darken-1',
         },
+        hoverColor: {
+            type: String,
+            default: '#ddd',
+        },
+        funRenderYear: {
+            type: Function,
+            default: null,
+        },
+        funRenderMonth: {
+            type: Function,
+            default: null,
+        },
+        funRenderDayOfWeek: {
+            type: Function,
+            default: null,
+        },
         placementDistX: {
             type: Number,
             default: 0,

package/src/components/WTimeminute.vue

@@ -36,6 +36,10 @@
                 :textFontSize="textFontSize"
                 :textColor="textColor"
                 :pickColor="pickColor"
+                :hoverColor="hoverColor"
+                :funRenderYear="funRenderYear"
+                :funRenderMonth="funRenderMonth"
+                :funRenderDayOfWeek="funRenderDayOfWeek"
                 :expansionIcon="expansionIcon"
                 :expansionIconSize="expansionIconSize"
                 :expansionIconColor="expansionIconColor"
@@ -85,6 +89,10 @@ import WTimeminuteCore from './WTimeminuteCore.vue'
  * @vue-prop {String} [textFontSize='0.85rem'] 輸入文字大小字串，預設'0.85rem'
  * @vue-prop {String} [textColor='black'] 輸入文字顏色字串，預設'black'
  * @vue-prop {String} [pickColor='deep-orange darken-1'] 輸入日期彈窗中選擇指定日期之顏色字串，預設'deep-orange darken-1'
+ * @vue-prop {String} [hoverColor='#ddd'] 輸入日期彈窗中滑鼠移入時之背景顏色字串，預設'#ddd'
+ * @vue-prop {Function} [funRenderYear=null] 輸入渲染年份之函數，傳入年數值回傳顯示字串，預設null，未給時回傳'{年}y'
+ * @vue-prop {Function} [funRenderMonth=null] 輸入渲染月份之函數，傳入月數值回傳顯示字串，預設null，未給時回傳'{月}m'
+ * @vue-prop {Function} [funRenderDayOfWeek=null] 輸入渲染星期幾之函數，傳入星期幾數值(0=日)回傳顯示字串，預設null，未給時回傳對應英文縮寫
  * @vue-prop {String} [expansionIcon=mdiPlay] 輸入顯隱圖標字串，可為mdi,md,fa代號或mdi/js路徑，預設使用mdi的圖標(mdiPlay)
  * @vue-prop {Number} [expansionIconSize=18] 輸入顯隱圖標尺寸數字，單位為px，預設18
  * @vue-prop {String} [expansionIconColor='grey'] 輸入顯隱圖標顏色字串，預設'grey'
@@ -205,6 +213,22 @@ export default {
             type: String,
             default: 'deep-orange darken-1',
         },
+        hoverColor: {
+            type: String,
+            default: '#ddd',
+        },
+        funRenderYear: {
+            type: Function,
+            default: null,
+        },
+        funRenderMonth: {
+            type: Function,
+            default: null,
+        },
+        funRenderDayOfWeek: {
+            type: Function,
+            default: null,
+        },
         expansionIcon: {
             type: String,
             default: mdiPlay,

package/src/components/WTimeminuteCore.vue

@@ -12,6 +12,10 @@
                 :textFontSize="textFontSize"
                 :textColor="textColor"
                 :pickColor="pickColor"
+                :hoverColor="hoverColor"
+                :funRenderYear="funRenderYear"
+                :funRenderMonth="funRenderMonth"
+                :funRenderDayOfWeek="funRenderDayOfWeek"
                 :placementDistX="placementDistX"
                 :placementDistY="placementDistY"
                 :textEmpty="textEmpty"
@@ -73,6 +77,10 @@ import WTextSuggestCore from './WTextSuggestCore.vue'
  * @vue-prop {String} [textFontSize='0.85rem'] 輸入文字大小字串，預設'0.85rem'
  * @vue-prop {String} [textColor='black'] 輸入文字顏色字串，預設'black'
  * @vue-prop {String} [pickColor='deep-orange darken-1'] 輸入日期彈窗中選擇指定日期之顏色字串，預設'deep-orange darken-1'
+ * @vue-prop {String} [hoverColor='#ddd'] 輸入日期彈窗中滑鼠移入時之背景顏色字串，預設'#ddd'
+ * @vue-prop {Function} [funRenderYear=null] 輸入渲染年份之函數，傳入年數值回傳顯示字串，預設null，未給時回傳'{年}y'
+ * @vue-prop {Function} [funRenderMonth=null] 輸入渲染月份之函數，傳入月數值回傳顯示字串，預設null，未給時回傳'{月}m'
+ * @vue-prop {Function} [funRenderDayOfWeek=null] 輸入渲染星期幾之函數，傳入星期幾數值(0=日)回傳顯示字串，預設null，未給時回傳對應英文縮寫
  * @vue-prop {String} [expansionIcon=mdiPlay] 輸入顯隱圖標字串，可為mdi,md,fa代號或mdi/js路徑，預設使用mdi的圖標(mdiPlay)
  * @vue-prop {Number} [expansionIconSize=18] 輸入顯隱圖標尺寸數字，單位為px，預設18
  * @vue-prop {String} [expansionIconColor='grey'] 輸入顯隱圖標顏色字串，預設'grey'
@@ -119,6 +127,22 @@ export default {
             type: String,
             default: 'deep-orange darken-1',
         },
+        hoverColor: {
+            type: String,
+            default: '#ddd',
+        },
+        funRenderYear: {
+            type: Function,
+            default: null,
+        },
+        funRenderMonth: {
+            type: Function,
+            default: null,
+        },
+        funRenderDayOfWeek: {
+            type: Function,
+            default: null,
+        },
         expansionIcon: {
             type: String,
             default: mdiPlay,

package/src/components/WTimeminuteRange.vue

@@ -32,6 +32,10 @@
                 :textFontSize="textFontSize"
                 :textColor="textColor"
                 :pickColor="pickColor"
+                :hoverColor="hoverColor"
+                :funRenderYear="funRenderYear"
+                :funRenderMonth="funRenderMonth"
+                :funRenderDayOfWeek="funRenderDayOfWeek"
                 :expansionIcon="expansionIcon"
                 :expansionIconSize="expansionIconSize"
                 :expansionIconColor="expansionIconColor"
@@ -90,6 +94,10 @@ import WTimeminuteRangeCore from './WTimeminuteRangeCore.vue'
  * @vue-prop {String} [textFontSize='0.85rem'] 輸入文字大小字串，預設'0.85rem'
  * @vue-prop {String} [textColor='black'] 輸入文字顏色字串，預設'black'
  * @vue-prop {String} [pickColor='deep-orange darken-1'] 輸入日期彈窗中選擇指定日期之顏色字串，預設'deep-orange darken-1'
+ * @vue-prop {String} [hoverColor='#ddd'] 輸入日期彈窗中滑鼠移入時之背景顏色字串，預設'#ddd'
+ * @vue-prop {Function} [funRenderYear=null] 輸入渲染年份之函數，傳入年數值回傳顯示字串，預設null，未給時回傳'{年}y'
+ * @vue-prop {Function} [funRenderMonth=null] 輸入渲染月份之函數，傳入月數值回傳顯示字串，預設null，未給時回傳'{月}m'
+ * @vue-prop {Function} [funRenderDayOfWeek=null] 輸入渲染星期幾之函數，傳入星期幾數值(0=日)回傳顯示字串，預設null，未給時回傳對應英文縮寫
  * @vue-prop {String} [expansionIcon=mdiPlay] 輸入顯隱圖標字串，可為mdi,md,fa代號或mdi/js路徑，預設使用mdi的圖標(mdiPlay)
  * @vue-prop {Number} [expansionIconSize=18] 輸入顯隱圖標尺寸數字，單位為px，預設18
  * @vue-prop {String} [expansionIconColor='grey'] 輸入顯隱圖標顏色字串，預設'grey'
@@ -218,6 +226,22 @@ export default {
             type: String,
             default: 'deep-orange darken-1',
         },
+        hoverColor: {
+            type: String,
+            default: '#ddd',
+        },
+        funRenderYear: {
+            type: Function,
+            default: null,
+        },
+        funRenderMonth: {
+            type: Function,
+            default: null,
+        },
+        funRenderDayOfWeek: {
+            type: Function,
+            default: null,
+        },
         expansionIcon: {
             type: String,
             default: mdiPlay,

package/src/components/WTimeminuteRangeCore.vue

@@ -12,6 +12,10 @@
                 :textFontSize="textFontSize"
                 :textColor="textColor"
                 :pickColor="pickColor"
+                :hoverColor="hoverColor"
+                :funRenderYear="funRenderYear"
+                :funRenderMonth="funRenderMonth"
+                :funRenderDayOfWeek="funRenderDayOfWeek"
                 :expansionIcon="expansionIcon"
                 :expansionIconSize="expansionIconSize"
                 :expansionIconColor="expansionIconColor"
@@ -37,6 +41,10 @@
                 :textFontSize="textFontSize"
                 :textColor="textColor"
                 :pickColor="pickColor"
+                :hoverColor="hoverColor"
+                :funRenderYear="funRenderYear"
+                :funRenderMonth="funRenderMonth"
+                :funRenderDayOfWeek="funRenderDayOfWeek"
                 :expansionIcon="expansionIcon"
                 :expansionIconSize="expansionIconSize"
                 :expansionIconColor="expansionIconColor"
@@ -71,6 +79,10 @@ import WTimeminuteCore from './WTimeminuteCore.vue'
  * @vue-prop {String} [textFontSize='0.85rem'] 輸入文字大小字串，預設'0.85rem'
  * @vue-prop {String} [textColor='black'] 輸入文字顏色字串，預設'black'
  * @vue-prop {String} [pickColor='deep-orange darken-1'] 輸入日期彈窗中選擇指定日期之顏色字串，預設'deep-orange darken-1'
+ * @vue-prop {String} [hoverColor='#ddd'] 輸入日期彈窗中滑鼠移入時之背景顏色字串，預設'#ddd'
+ * @vue-prop {Function} [funRenderYear=null] 輸入渲染年份之函數，傳入年數值回傳顯示字串，預設null，未給時回傳'{年}y'
+ * @vue-prop {Function} [funRenderMonth=null] 輸入渲染月份之函數，傳入月數值回傳顯示字串，預設null，未給時回傳'{月}m'
+ * @vue-prop {Function} [funRenderDayOfWeek=null] 輸入渲染星期幾之函數，傳入星期幾數值(0=日)回傳顯示字串，預設null，未給時回傳對應英文縮寫
  * @vue-prop {String} [expansionIcon=mdiPlay] 輸入顯隱圖標字串，可為mdi,md,fa代號或mdi/js路徑，預設使用mdi的圖標(mdiPlay)
  * @vue-prop {Number} [expansionIconSize=18] 輸入顯隱圖標尺寸數字，單位為px，預設18
  * @vue-prop {String} [expansionIconColor='grey'] 輸入顯隱圖標顏色字串，預設'grey'
@@ -124,6 +136,22 @@ export default {
             type: String,
             default: 'deep-orange darken-1',
         },
+        hoverColor: {
+            type: String,
+            default: '#ddd',
+        },
+        funRenderYear: {
+            type: Function,
+            default: null,
+        },
+        funRenderMonth: {
+            type: Function,
+            default: null,
+        },
+        funRenderDayOfWeek: {
+            type: Function,
+            default: null,
+        },
         expansionIcon: {
             type: String,
             default: mdiPlay,

package/src/js/convertColor.mjs

@@ -52,9 +52,9 @@ function getHexColor(key0, key1, def) {
 
 
 /**
- * 轉換vuetify color為hex顏色字串
+ * 轉換描述color為hex顏色字串
  *
- * @param {String} color 輸入vuetify顏色字串
+ * @param {String} color 輸入描述顏色字串
  * @returns {String} hex 回傳hex顏色字串
  */
 function convertColor(color) {

package/src/js/convertToTreeWk.wk.umd.js

@@ -1 +1 @@
-const d="function"==typeof Buffer,l="function"==typeof TextDecoder?new TextDecoder:void 0,m=("function"==typeof TextEncoder&&new TextEncoder,Array.prototype.slice.call("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=")),I=(d=>{let l={};return m.forEach(((d,m)=>l[d]=m)),l})(),Z=/^(?:[A-Za-z\d+\/]{4})*?(?:[A-Za-z\d+\/]{2}(?:==)?|[A-Za-z\d+\/]{3}=?)?$/,b=String.fromCharCode.bind(String),i="function"==typeof Uint8Array.from?Uint8Array.from.bind(Uint8Array):d=>new Uint8Array(Array.prototype.slice.call(d,0)),c=d=>d.replace(/[^A-Za-z0-9\+\/]/g,""),X=d=>{let l,I,Z,b,i="";const c=d.length%3;for(let c=0;c<d.length;){if((I=d.charCodeAt(c++))>255||(Z=d.charCodeAt(c++))>255||(b=d.charCodeAt(c++))>255)throw new TypeError("invalid character found");l=I<<16|Z<<8|b,i+=m[l>>18&63]+m[l>>12&63]+m[l>>6&63]+m[63&l]}return c?i.slice(0,c-3)+"===".substring(c):i},y=/[\xC0-\xDF][\x80-\xBF]|[\xE0-\xEF][\x80-\xBF]{2}|[\xF0-\xF7][\x80-\xBF]{3}/g,C=d=>{switch(d.length){case 4:var l=((7&d.charCodeAt(0))<<18|(63&d.charCodeAt(1))<<12|(63&d.charCodeAt(2))<<6|63&d.charCodeAt(3))-65536;return b(55296+(l>>>10))+b(56320+(1023&l));case 3:return b((15&d.charCodeAt(0))<<12|(63&d.charCodeAt(1))<<6|63&d.charCodeAt(2));default:return b((31&d.charCodeAt(0))<<6|63&d.charCodeAt(1))}},W=d=>d.replace(y,C),G=d=>{if(d=d.replace(/\s+/g,""),!Z.test(d))throw new TypeError("malformed base64.");let l,m,i;d+="==".slice(2-(3&d.length));let c=[];for(let Z=0;Z<d.length;)l=I[d.charAt(Z++)]<<18|I[d.charAt(Z++)]<<12|(m=I[d.charAt(Z++)])<<6|(i=I[d.charAt(Z++)]),64===m?c.push(b(l>>16&255)):64===i?c.push(b(l>>16&255,l>>8&255)):c.push(b(l>>16&255,l>>8&255,255&l));return c.join("")},p="function"==typeof atob?d=>atob(c(d)):d?d=>Buffer.from(d,"base64").toString("binary"):G,K=d?d=>i(Buffer.from(d,"base64")):d=>i(p(d).split("").map((d=>d.charCodeAt(0)))),V=d?d=>Buffer.from(d,"base64").toString("utf8"):l?d=>l.decode(K(d)):d=>W(p(d)),h=d=>c(d.replace(/[-_]/g,(d=>"-"==d?"+":"/"))),o=d=>V(h(d)),u=o;var Y={};!function(d){var l=Object.prototype.hasOwnProperty,m="~";function I(){}function Z(d,l,m){this.fn=d,this.context=l,this.once=m||!1}function b(d,l,I,b,i){if("function"!=typeof I)throw new TypeError("The listener must be a function");var c=new Z(I,b||d,i),X=m?m+l:l;return d._events[X]?d._events[X].fn?d._events[X]=[d._events[X],c]:d._events[X].push(c):(d._events[X]=c,d._eventsCount++),d}function i(d,l){0==--d._eventsCount?d._events=new I:delete d._events[l]}function c(){this._events=new I,this._eventsCount=0}Object.create&&(I.prototype=Object.create(null),(new I).__proto__||(m=!1)),c.prototype.eventNames=function(){var d,I,Z=[];if(0===this._eventsCount)return Z;for(I in d=this._events)l.call(d,I)&&Z.push(m?I.slice(1):I);return Object.getOwnPropertySymbols?Z.concat(Object.getOwnPropertySymbols(d)):Z},c.prototype.listeners=function(d){var l=m?m+d:d,I=this._events[l];if(!I)return[];if(I.fn)return[I.fn];for(var Z=0,b=I.length,i=new Array(b);Z<b;Z++)i[Z]=I[Z].fn;return i},c.prototype.listenerCount=function(d){var l=m?m+d:d,I=this._events[l];return I?I.fn?1:I.length:0},c.prototype.emit=function(d,l,I,Z,b,i){var c=m?m+d:d;if(!this._events[c])return!1;var X,y,C=this._events[c],W=arguments.length;if(C.fn){switch(C.once&&this.removeListener(d,C.fn,void 0,!0),W){case 1:return C.fn.call(C.context),!0;case 2:return C.fn.call(C.context,l),!0;case 3:return C.fn.call(C.context,l,I),!0;case 4:return C.fn.call(C.context,l,I,Z),!0;case 5:return C.fn.call(C.context,l,I,Z,b),!0;case 6:return C.fn.call(C.context,l,I,Z,b,i),!0}for(y=1,X=new Array(W-1);y<W;y++)X[y-1]=arguments[y];C.fn.apply(C.context,X)}else{var G,p=C.length;for(y=0;y<p;y++)switch(C[y].once&&this.removeListener(d,C[y].fn,void 0,!0),W){case 1:C[y].fn.call(C[y].context);break;case 2:C[y].fn.call(C[y].context,l);break;case 3:C[y].fn.call(C[y].context,l,I);break;case 4:C[y].fn.call(C[y].context,l,I,Z);break;default:if(!X)for(G=1,X=new Array(W-1);G<W;G++)X[G-1]=arguments[G];C[y].fn.apply(C[y].context,X)}}return!0},c.prototype.on=function(d,l,m){return b(this,d,l,m,!1)},c.prototype.once=function(d,l,m){return b(this,d,l,m,!0)},c.prototype.removeListener=function(d,l,I,Z){var b=m?m+d:d;if(!this._events[b])return this;if(!l)return i(this,b),this;var c=this._events[b];if(c.fn)c.fn!==l||Z&&!c.once||I&&c.context!==I||i(this,b);else{for(var X=0,y=[],C=c.length;X<C;X++)(c[X].fn!==l||Z&&!c[X].once||I&&c[X].context!==I)&&y.push(c[X]);y.length?this._events[b]=1===y.length?y[0]:y:i(this,b)}return this},c.prototype.removeAllListeners=function(d){var l;return d?(l=m?m+d:d,this._events[l]&&i(this,l)):(this._events=new I,this._eventsCount=0),this},c.prototype.off=c.prototype.removeListener,c.prototype.addListener=c.prototype.on,c.prefixed=m,c.EventEmitter=c,d.exports=c}({get exports(){return Y},set exports(d){Y=d}});var g=Y;let n;!function(){if("browser"!==("undefined"!=typeof window&&void 0!==window.document?"browser":"nodejs"))return null;let d=u("


"use strict";var t=Array.isArray,r="object"==typeof global&&global&&global.Object===Object&&global,e="object"==typeof self&&self&&self.Object===Object&&self,n=r||e||Function("return this")(),o=n.Symbol,u=Object.prototype,i=u.hasOwnProperty,c=u.toString,a=o?o.toStringTag:void 0;var f=Object.prototype.toString;var l="[object Null]",s="[object Undefined]",p=o?o.toStringTag:void 0;function v(t){return null==t?void 0===t?s:l:p&&p in Object(t)?function(t){var r=i.call(t,a),e=t[a];try{t[a]=void 0;var n=!0}catch(t){}var o=c.call(t);return n&&(r?t[a]=e:delete t[a]),o}(t):function(t){return f.call(t)}(t)}function b(t){return null!=t&&"object"==typeof t}var y="[object Symbol]";function h(t){return"symbol"==typeof t||b(t)&&v(t)==y}var d=/\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,j=/^\w*$/;function g(r,e){if(t(r))return!1;var n=typeof r;return!("number"!=n&&"symbol"!=n&&"boolean"!=n&&null!=r&&!h(r))||(j.test(r)||!d.test(r)||null!=e&&r in Object(e))}function _(t){var r=typeof t;return null!=t&&("object"==r||"function"==r)}var O="[object AsyncFunction]",w="[object Function]",m="[object GeneratorFunction]",A="[object Proxy]";function x(t){if(!_(t))return!1;var r=v(t);return r==w||r==m||r==O||r==A}var S,P=n["__core-js_shared__"],z=(S=/[^.]+$/.exec(P&&P.keys&&P.keys.IE_PROTO||""))?"Symbol(src)_1."+S:"";var E=Function.prototype.toString;function I(t){if(null!=t){try{return E.call(t)}catch(t){}try{return t+""}catch(t){}}return""}var N=/^\[object .+?Constructor\]$/,T=Function.prototype,$=Object.prototype,C=T.toString,F=$.hasOwnProperty,M=RegExp("^"+C.call(F).replace(/[\\^$.*+?()[\]{}|]/g,"\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g,"$1.*?")+"$");function U(t){return!(!_(t)||(r=t,z&&z in r))&&(x(t)?M:N).test(I(t));var r}function k(t,r){var e=function(t,r){return null==t?void 0:t[r]}(t,r);return U(e)?e:void 0}var B=k(Object,"create");var D=Object.prototype.hasOwnProperty;var R=Object.prototype.hasOwnProperty;function L(t){var r=-1,e=null==t?0:t.length;for(this.clear();++r<e;){var n=t[r];this.set(n[0],n[1])}}function V(t,r){return t===r||t!=t&&r!=r}function K(t,r){for(var e=t.length;e--;)if(V(t[e][0],r))return e;return-1}L.prototype.clear=function(){this.__data__=B?B(null):{},this.size=0},L.prototype.delete=function(t){var r=this.has(t)&&delete this.__data__[t];return this.size-=r?1:0,r},L.prototype.get=function(t){var r=this.__data__;if(B){var e=r[t];return"__lodash_hash_undefined__"===e?void 0:e}return D.call(r,t)?r[t]:void 0},L.prototype.has=function(t){var r=this.__data__;return B?void 0!==r[t]:R.call(r,t)},L.prototype.set=function(t,r){var e=this.__data__;return this.size+=this.has(t)?0:1,e[t]=B&&void 0===r?"__lodash_hash_undefined__":r,this};var W=Array.prototype.splice;function q(t){var r=-1,e=null==t?0:t.length;for(this.clear();++r<e;){var n=t[r];this.set(n[0],n[1])}}q.prototype.clear=function(){this.__data__=[],this.size=0},q.prototype.delete=function(t){var r=this.__data__,e=K(r,t);return!(e<0)&&(e==r.length-1?r.pop():W.call(r,e,1),--this.size,!0)},q.prototype.get=function(t){var r=this.__data__,e=K(r,t);return e<0?void 0:r[e][1]},q.prototype.has=function(t){return K(this.__data__,t)>-1},q.prototype.set=function(t,r){var e=this.__data__,n=K(e,t);return n<0?(++this.size,e.push([t,r])):e[n][1]=r,this};var G=k(n,"Map");function H(t,r){var e,n,o=t.__data__;return("string"==(n=typeof(e=r))||"number"==n||"symbol"==n||"boolean"==n?"__proto__"!==e:null===e)?o["string"==typeof r?"string":"hash"]:o.map}function J(t){var r=-1,e=null==t?0:t.length;for(this.clear();++r<e;){var n=t[r];this.set(n[0],n[1])}}J.prototype.clear=function(){this.size=0,this.__data__={hash:new L,map:new(G||q),string:new L}},J.prototype.delete=function(t){var r=H(this,t).delete(t);return this.size-=r?1:0,r},J.prototype.get=function(t){return H(this,t).get(t)},J.prototype.has=function(t){return H(this,t).has(t)},J.prototype.set=function(t,r){var e=H(this,t),n=e.size;return e.set(t,r),this.size+=e.size==n?0:1,this};var Q="Expected a function";function X(t,r){if("function"!=typeof t||null!=r&&"function"!=typeof r)throw new TypeError(Q);var e=function(){var n=arguments,o=r?r.apply(this,n):n[0],u=e.cache;if(u.has(o))return u.get(o);var i=t.apply(this,n);return e.cache=u.set(o,i)||u,i};return e.cache=new(X.Cache||J),e}X.Cache=J;var Y,Z,tt,rt=/[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g,et=/\\(\\)?/g,nt=(Y=function(t){var r=[];return 46===t.charCodeAt(0)&&r.push(""),t.replace(rt,(function(t,e,n,o){r.push(n?o.replace(et,"$1"):e||t)})),r},Z=X(Y,(function(t){return 500===tt.size&&tt.clear(),t})),tt=Z.cache,Z),ot=nt;function ut(t,r){for(var e=-1,n=null==t?0:t.length,o=Array(n);++e<n;)o[e]=r(t[e],e,t);return o}var it=1/0,ct=o?o.prototype:void 0,at=ct?ct.toString:void 0;function ft(r){if("string"==typeof r)return r;if(t(r))return ut(r,ft)+"";if(h(r))return at?at.call(r):"";var e=r+"";return"0"==e&&1/r==-it?"-0":e}function lt(r,e){return t(r)?r:g(r,e)?[r]:ot(function(t){return null==t?"":ft(t)}(r))}var st=1/0;function pt(t){if("string"==typeof t||h(t))return t;var r=t+"";return"0"==r&&1/t==-st?"-0":r}function vt(t,r){for(var e=0,n=(r=lt(r,t)).length;null!=t&&e<n;)t=t[pt(r[e++])];return e&&e==n?t:void 0}function bt(t,r,e){var n=null==t?void 0:vt(t,r);return void 0===n?e:n}function yt(t){return"[object String]"===Object.prototype.toString.call(t)}function ht(t){return!(!yt(t)||""===t)}function dt(t){return"[object Object]"===Object.prototype.toString.call(t)}function jt(t){if(dt(t)){for(let r in t)return!0;return!1}return!1}function gt(t){return"[object Array]"===Object.prototype.toString.call(t)}function _t(t){return t!=t}function Ot(t){return!!function(t){return"[object Undefined]"===Object.prototype.toString.call(t)}(t)||(!!function(t){return"[object Null]"===Object.prototype.toString.call(t)}(t)||(!!function(t){if(dt(t)){for(let r in t)return!1;return!0}return!1}(t)||(!!function(t){return!(!yt(t)||""!==t)}(t)||(!!function(t){return!!gt(t)&&0===t.length}(t)||!!_t(t)))))}function wt(t){return!!gt(t)&&(0!==t.length&&(1!==t.length||!Ot(t[0])))}var mt="[object Boolean]";function At(t){return!0===(r=t)||!1===r||b(r)&&v(r)==mt;var r}function xt(t){var r=this.__data__=new q(t);this.size=r.size}xt.prototype.clear=function(){this.__data__=new q,this.size=0},xt.prototype.delete=function(t){var r=this.__data__,e=r.delete(t);return this.size=r.size,e},xt.prototype.get=function(t){return this.__data__.get(t)},xt.prototype.has=function(t){return this.__data__.has(t)},xt.prototype.set=function(t,r){var e=this.__data__;if(e instanceof q){var n=e.__data__;if(!G||n.length<199)return n.push([t,r]),this.size=++e.size,this;e=this.__data__=new J(n)}return e.set(t,r),this.size=e.size,this};function St(t){var r=-1,e=null==t?0:t.length;for(this.__data__=new J;++r<e;)this.add(t[r])}function Pt(t,r){for(var e=-1,n=null==t?0:t.length;++e<n;)if(r(t[e],e,t))return!0;return!1}function zt(t,r){return t.has(r)}St.prototype.add=St.prototype.push=function(t){return this.__data__.set(t,"__lodash_hash_undefined__"),this},St.prototype.has=function(t){return this.__data__.has(t)};var Et=1,It=2;function Nt(t,r,e,n,o,u){var i=e&Et,c=t.length,a=r.length;if(c!=a&&!(i&&a>c))return!1;var f=u.get(t),l=u.get(r);if(f&&l)return f==r&&l==t;var s=-1,p=!0,v=e&It?new St:void 0;for(u.set(t,r),u.set(r,t);++s<c;){var b=t[s],y=r[s];if(n)var h=i?n(y,b,s,r,t,u):n(b,y,s,t,r,u);if(void 0!==h){if(h)continue;p=!1;break}if(v){if(!Pt(r,(function(t,r){if(!zt(v,r)&&(b===t||o(b,t,e,n,u)))return v.push(r)}))){p=!1;break}}else if(b!==y&&!o(b,y,e,n,u)){p=!1;break}}return u.delete(t),u.delete(r),p}var Tt=n.Uint8Array;function $t(t){var r=-1,e=Array(t.size);return t.forEach((function(t,n){e[++r]=[n,t]})),e}function Ct(t){var r=-1,e=Array(t.size);return t.forEach((function(t){e[++r]=t})),e}var Ft=1,Mt=2,Ut="[object Boolean]",kt="[object Date]",Bt="[object Error]",Dt="[object Map]",Rt="[object Number]",Lt="[object RegExp]",Vt="[object Set]",Kt="[object String]",Wt="[object Symbol]",qt="[object ArrayBuffer]",Gt="[object DataView]",Ht=o?o.prototype:void 0,Jt=Ht?Ht.valueOf:void 0;function Qt(t,r){for(var e=-1,n=r.length,o=t.length;++e<n;)t[o+e]=r[e];return t}function Xt(r,e,n){var o=e(r);return t(r)?o:Qt(o,n(r))}function Yt(){return[]}var Zt=Object.prototype.propertyIsEnumerable,tr=Object.getOwnPropertySymbols,rr=tr?function(t){return null==t?[]:(t=Object(t),function(t,r){for(var e=-1,n=null==t?0:t.length,o=0,u=[];++e<n;){var i=t[e];r(i,e,t)&&(u[o++]=i)}return u}(tr(t),(function(r){return Zt.call(t,r)})))}:Yt,er=rr;function nr(t){return b(t)&&"[object Arguments]"==v(t)}var or=Object.prototype,ur=or.hasOwnProperty,ir=or.propertyIsEnumerable,cr=nr(function(){return arguments}())?nr:function(t){return b(t)&&ur.call(t,"callee")&&!ir.call(t,"callee")};var ar="object"==typeof exports&&exports&&!exports.nodeType&&exports,fr=ar&&"object"==typeof module&&module&&!module.nodeType&&module,lr=fr&&fr.exports===ar?n.Buffer:void 0,sr=(lr?lr.isBuffer:void 0)||function(){return!1},pr=9007199254740991,vr=/^(?:0|[1-9]\d*)$/;function br(t,r){var e=typeof t;return!!(r=null==r?pr:r)&&("number"==e||"symbol"!=e&&vr.test(t))&&t>-1&&t%1==0&&t<r}var yr=9007199254740991;function hr(t){return"number"==typeof t&&t>-1&&t%1==0&&t<=yr}var dr={};function jr(t){return function(r){return t(r)}}dr["[object Float32Array]"]=dr["[object Float64Array]"]=dr["[object Int8Array]"]=dr["[object Int16Array]"]=dr["[object Int32Array]"]=dr["[object Uint8Array]"]=dr["[object Uint8ClampedArray]"]=dr["[object Uint16Array]"]=dr["[object Uint32Array]"]=!0,dr["[object Arguments]"]=dr["[object Array]"]=dr["[object ArrayBuffer]"]=dr["[object Boolean]"]=dr["[object DataView]"]=dr["[object Date]"]=dr["[object Error]"]=dr["[object Function]"]=dr["[object Map]"]=dr["[object Number]"]=dr["[object Object]"]=dr["[object RegExp]"]=dr["[object Set]"]=dr["[object String]"]=dr["[object WeakMap]"]=!1;var gr="object"==typeof exports&&exports&&!exports.nodeType&&exports,_r=gr&&"object"==typeof module&&module&&!module.nodeType&&module,Or=_r&&_r.exports===gr&&r.process,wr=function(){try{var t=_r&&_r.require&&_r.require("util").types;return t||Or&&Or.binding&&Or.binding("util")}catch(t){}}(),mr=wr&&wr.isTypedArray,Ar=mr?jr(mr):function(t){return b(t)&&hr(t.length)&&!!dr[v(t)]},xr=Object.prototype.hasOwnProperty;function Sr(r,e){var n=t(r),o=!n&&cr(r),u=!n&&!o&&sr(r),i=!n&&!o&&!u&&Ar(r),c=n||o||u||i,a=c?function(t,r){for(var e=-1,n=Array(t);++e<t;)n[e]=r(e);return n}(r.length,String):[],f=a.length;for(var l in r)!e&&!xr.call(r,l)||c&&("length"==l||u&&("offset"==l||"parent"==l)||i&&("buffer"==l||"byteLength"==l||"byteOffset"==l)||br(l,f))||a.push(l);return a}var Pr=Object.prototype;function zr(t){var r=t&&t.constructor;return t===("function"==typeof r&&r.prototype||Pr)}function Er(t,r){return function(e){return t(r(e))}}var Ir=Er(Object.keys,Object),Nr=Object.prototype.hasOwnProperty;function Tr(t){if(!zr(t))return Ir(t);var r=[];for(var e in Object(t))Nr.call(t,e)&&"constructor"!=e&&r.push(e);return r}function $r(t){return null!=t&&hr(t.length)&&!x(t)}function Cr(t){return $r(t)?Sr(t):Tr(t)}function Fr(t){return Xt(t,Cr,er)}var Mr=1,Ur=Object.prototype.hasOwnProperty;var kr=k(n,"DataView"),Br=k(n,"Promise"),Dr=k(n,"Set"),Rr=k(n,"WeakMap"),Lr="[object Map]",Vr="[object Promise]",Kr="[object Set]",Wr="[object WeakMap]",qr="[object DataView]",Gr=I(kr),Hr=I(G),Jr=I(Br),Qr=I(Dr),Xr=I(Rr),Yr=v;(kr&&Yr(new kr(new ArrayBuffer(1)))!=qr||G&&Yr(new G)!=Lr||Br&&Yr(Br.resolve())!=Vr||Dr&&Yr(new Dr)!=Kr||Rr&&Yr(new Rr)!=Wr)&&(Yr=function(t){var r=v(t),e="[object Object]"==r?t.constructor:void 0,n=e?I(e):"";if(n)switch(n){case Gr:return qr;case Hr:return Lr;case Jr:return Vr;case Qr:return Kr;case Xr:return Wr}return r});var Zr=Yr,te=1,re="[object Arguments]",ee="[object Array]",ne="[object Object]",oe=Object.prototype.hasOwnProperty;function ue(r,e,n,o,u,i){var c=t(r),a=t(e),f=c?ee:Zr(r),l=a?ee:Zr(e),s=(f=f==re?ne:f)==ne,p=(l=l==re?ne:l)==ne,v=f==l;if(v&&sr(r)){if(!sr(e))return!1;c=!0,s=!1}if(v&&!s)return i||(i=new xt),c||Ar(r)?Nt(r,e,n,o,u,i):function(t,r,e,n,o,u,i){switch(e){case Gt:if(t.byteLength!=r.byteLength||t.byteOffset!=r.byteOffset)return!1;t=t.buffer,r=r.buffer;case qt:return!(t.byteLength!=r.byteLength||!u(new Tt(t),new Tt(r)));case Ut:case kt:case Rt:return V(+t,+r);case Bt:return t.name==r.name&&t.message==r.message;case Lt:case Kt:return t==r+"";case Dt:var c=$t;case Vt:var a=n&Ft;if(c||(c=Ct),t.size!=r.size&&!a)return!1;var f=i.get(t);if(f)return f==r;n|=Mt,i.set(t,r);var l=Nt(c(t),c(r),n,o,u,i);return i.delete(t),l;case Wt:if(Jt)return Jt.call(t)==Jt.call(r)}return!1}(r,e,f,n,o,u,i);if(!(n&te)){var b=s&&oe.call(r,"__wrapped__"),y=p&&oe.call(e,"__wrapped__");if(b||y){var h=b?r.value():r,d=y?e.value():e;return i||(i=new xt),u(h,d,n,o,i)}}return!!v&&(i||(i=new xt),function(t,r,e,n,o,u){var i=e&Mr,c=Fr(t),a=c.length;if(a!=Fr(r).length&&!i)return!1;for(var f=a;f--;){var l=c[f];if(!(i?l in r:Ur.call(r,l)))return!1}var s=u.get(t),p=u.get(r);if(s&&p)return s==r&&p==t;var v=!0;u.set(t,r),u.set(r,t);for(var b=i;++f<a;){var y=t[l=c[f]],h=r[l];if(n)var d=i?n(h,y,l,r,t,u):n(y,h,l,t,r,u);if(!(void 0===d?y===h||o(y,h,e,n,u):d)){v=!1;break}b||(b="constructor"==l)}if(v&&!b){var j=t.constructor,g=r.constructor;j==g||!("constructor"in t)||!("constructor"in r)||"function"==typeof j&&j instanceof j&&"function"==typeof g&&g instanceof g||(v=!1)}return u.delete(t),u.delete(r),v}(r,e,n,o,u,i))}function ie(t,r,e,n,o){return t===r||(null==t||null==r||!b(t)&&!b(r)?t!=t&&r!=r:ue(t,r,e,n,ie,o))}var ce=1,ae=2;function fe(t){return t==t&&!_(t)}function le(t,r){return function(e){return null!=e&&(e[t]===r&&(void 0!==r||t in Object(e)))}}function se(t){var r=function(t){for(var r=Cr(t),e=r.length;e--;){var n=r[e],o=t[n];r[e]=[n,o,fe(o)]}return r}(t);return 1==r.length&&r[0][2]?le(r[0][0],r[0][1]):function(e){return e===t||function(t,r,e,n){var o=e.length,u=o,i=!n;if(null==t)return!u;for(t=Object(t);o--;){var c=e[o];if(i&&c[2]?c[1]!==t[c[0]]:!(c[0]in t))return!1}for(;++o<u;){var a=(c=e[o])[0],f=t[a],l=c[1];if(i&&c[2]){if(void 0===f&&!(a in t))return!1}else{var s=new xt;if(n)var p=n(f,l,a,t,r,s);if(!(void 0===p?ie(l,f,ce|ae,n,s):p))return!1}}return!0}(e,t,r)}}function pe(t,r){return null!=t&&r in Object(t)}function ve(r,e){return null!=r&&function(r,e,n){for(var o=-1,u=(e=lt(e,r)).length,i=!1;++o<u;){var c=pt(e[o]);if(!(i=null!=r&&n(r,c)))break;r=r[c]}return i||++o!=u?i:!!(u=null==r?0:r.length)&&hr(u)&&br(c,u)&&(t(r)||cr(r))}(r,e,pe)}var be=1,ye=2;function he(t){return t}function de(t){return function(r){return null==r?void 0:r[t]}}function je(t){return g(t)?de(pt(t)):function(t){return function(r){return vt(r,t)}}(t)}function ge(r){return"function"==typeof r?r:null==r?he:"object"==typeof r?t(r)?(e=r[0],n=r[1],g(e)&&fe(n)?le(pt(e),n):function(t){var r=bt(t,e);return void 0===r&&r===n?ve(t,e):ie(n,r,be|ye)}):se(r):je(r);var e,n}var _e,Oe=function(t,r,e){for(var n=-1,o=Object(t),u=e(t),i=u.length;i--;){var c=u[_e?i:++n];if(!1===r(o[c],c,o))break}return t};var we=function(t,r){return function(e,n){if(null==e)return e;if(!$r(e))return t(e,n);for(var o=e.length,u=r?o:-1,i=Object(e);(r?u--:++u<o)&&!1!==n(i[u],u,i););return e}}((function(t,r){return t&&Oe(t,r,Cr)})),me=we;function Ae(t,r){var e=-1,n=$r(t)?Array(t.length):[];return me(t,(function(t,o,u){n[++e]=r(t,o,u)})),n}var xe=Array.prototype.join;var Se="[object String]";var Pe=de("length"),ze=RegExp("[\\u200d\\ud800-\\udfff\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff\\ufe0e\\ufe0f]");var Ee="\\ud800-\\udfff",Ie="["+Ee+"]",Ne="[\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff]",Te="\\ud83c[\\udffb-\\udfff]",$e="[^"+Ee+"]",Ce="(?:\\ud83c[\\udde6-\\uddff]){2}",Fe="[\\ud800-\\udbff][\\udc00-\\udfff]",Me="(?:"+Ne+"|"+Te+")"+"?",Ue="[\\ufe0e\\ufe0f]?",ke=Ue+Me+("(?:\\u200d(?:"+[$e,Ce,Fe].join("|")+")"+Ue+Me+")*"),Be="(?:"+[$e+Ne+"?",Ne,Ce,Fe,Ie].join("|")+")",De=RegExp(Te+"(?="+Te+")|"+Be+ke,"g");function Re(t){return function(t){return ze.test(t)}(t)?function(t){for(var r=De.lastIndex=0;De.test(t);)++r;return r}(t):Pe(t)}var Le="[object Map]",Ve="[object Set]";function Ke(r){if(null==r)return 0;if($r(r))return"string"==typeof(e=r)||!t(e)&&b(e)&&v(e)==Se?Re(r):r.length;var e,n=Zr(r);return n==Le||n==Ve?r.size:Tr(r).length}var We="[object Number]";function qe(t,r){for(var e=-1,n=null==t?0:t.length;++e<n&&!1!==r(t[e],e,t););return t}var Ge=function(){try{var t=k(Object,"defineProperty");return t({},"",{}),t}catch(t){}}(),He=Ge;function Je(t,r,e){"__proto__"==r&&He?He(t,r,{configurable:!0,enumerable:!0,value:e,writable:!0}):t[r]=e}var Qe=Object.prototype.hasOwnProperty;function Xe(t,r,e){var n=t[r];Qe.call(t,r)&&V(n,e)&&(void 0!==e||r in t)||Je(t,r,e)}function Ye(t,r,e,n){var o=!e;e||(e={});for(var u=-1,i=r.length;++u<i;){var c=r[u],a=n?n(e[c],t[c],c,e,t):void 0;void 0===a&&(a=t[c]),o?Je(e,c,a):Xe(e,c,a)}return e}var Ze=Object.prototype.hasOwnProperty;function tn(t){if(!_(t))return function(t){var r=[];if(null!=t)for(var e in Object(t))r.push(e);return r}(t);var r=zr(t),e=[];for(var n in t)("constructor"!=n||!r&&Ze.call(t,n))&&e.push(n);return e}function rn(t){return $r(t)?Sr(t,!0):tn(t)}var en="object"==typeof exports&&exports&&!exports.nodeType&&exports,nn=en&&"object"==typeof module&&module&&!module.nodeType&&module,on=nn&&nn.exports===en?n.Buffer:void 0,un=on?on.allocUnsafe:void 0;var cn=Er(Object.getPrototypeOf,Object),an=Object.getOwnPropertySymbols?function(t){for(var r=[];t;)Qt(r,er(t)),t=cn(t);return r}:Yt,fn=an;function ln(t){return Xt(t,rn,fn)}var sn=Object.prototype.hasOwnProperty;function pn(t){var r=new t.constructor(t.byteLength);return new Tt(r).set(new Tt(t)),r}var vn=/\w*$/;var bn=o?o.prototype:void 0,yn=bn?bn.valueOf:void 0;var hn="[object Boolean]",dn="[object Date]",jn="[object Map]",gn="[object Number]",_n="[object RegExp]",On="[object Set]",wn="[object String]",mn="[object Symbol]",An="[object ArrayBuffer]",xn="[object DataView]",Sn="[object Float32Array]",Pn="[object Float64Array]",zn="[object Int8Array]",En="[object Int16Array]",In="[object Int32Array]",Nn="[object Uint8Array]",Tn="[object Uint8ClampedArray]",$n="[object Uint16Array]",Cn="[object Uint32Array]";function Fn(t,r,e){var n,o=t.constructor;switch(r){case An:return pn(t);case hn:case dn:return new o(+t);case xn:return function(t,r){var e=r?pn(t.buffer):t.buffer;return new t.constructor(e,t.byteOffset,t.byteLength)}(t,e);case Sn:case Pn:case zn:case En:case In:case Nn:case Tn:case $n:case Cn:return function(t,r){var e=r?pn(t.buffer):t.buffer;return new t.constructor(e,t.byteOffset,t.length)}(t,e);case jn:return new o;case gn:case wn:return new o(t);case _n:return function(t){var r=new t.constructor(t.source,vn.exec(t));return r.lastIndex=t.lastIndex,r}(t);case On:return new o;case mn:return n=t,yn?Object(yn.call(n)):{}}}var Mn=Object.create,Un=function(){function t(){}return function(r){if(!_(r))return{};if(Mn)return Mn(r);t.prototype=r;var e=new t;return t.prototype=void 0,e}}(),kn=Un;var Bn=wr&&wr.isMap,Dn=Bn?jr(Bn):function(t){return b(t)&&"[object Map]"==Zr(t)};var Rn=wr&&wr.isSet,Ln=Rn?jr(Rn):function(t){return b(t)&&"[object Set]"==Zr(t)},Vn=1,Kn=2,Wn=4,qn="[object Arguments]",Gn="[object Function]",Hn="[object GeneratorFunction]",Jn="[object Object]",Qn={};function Xn(r,e,n,o,u,i){var c,a=e&Vn,f=e&Kn,l=e&Wn;if(n&&(c=u?n(r,o,u,i):n(r)),void 0!==c)return c;if(!_(r))return r;var s=t(r);if(s){if(c=function(t){var r=t.length,e=new t.constructor(r);return r&&"string"==typeof t[0]&&sn.call(t,"index")&&(e.index=t.index,e.input=t.input),e}(r),!a)return function(t,r){var e=-1,n=t.length;for(r||(r=Array(n));++e<n;)r[e]=t[e];return r}(r,c)}else{var p=Zr(r),v=p==Gn||p==Hn;if(sr(r))return function(t,r){if(r)return t.slice();var e=t.length,n=un?un(e):new t.constructor(e);return t.copy(n),n}(r,a);if(p==Jn||p==qn||v&&!u){if(c=f||v?{}:function(t){return"function"!=typeof t.constructor||zr(t)?{}:kn(cn(t))}(r),!a)return f?function(t,r){return Ye(t,fn(t),r)}(r,function(t,r){return t&&Ye(r,rn(r),t)}(c,r)):function(t,r){return Ye(t,er(t),r)}(r,function(t,r){return t&&Ye(r,Cr(r),t)}(c,r))}else{if(!Qn[p])return u?r:{};c=Fn(r,p,a)}}i||(i=new xt);var b=i.get(r);if(b)return b;i.set(r,c),Ln(r)?r.forEach((function(t){c.add(Xn(t,e,n,t,r,i))})):Dn(r)&&r.forEach((function(t,o){c.set(o,Xn(t,e,n,o,r,i))}));var y=s?void 0:(l?f?ln:Fr:f?rn:Cr)(r);return qe(y||r,(function(t,o){y&&(t=r[o=t]),Xe(c,o,Xn(t,e,n,o,r,i))})),c}Qn[qn]=Qn["[object Array]"]=Qn["[object ArrayBuffer]"]=Qn["[object DataView]"]=Qn["[object Boolean]"]=Qn["[object Date]"]=Qn["[object Float32Array]"]=Qn["[object Float64Array]"]=Qn["[object Int8Array]"]=Qn["[object Int16Array]"]=Qn["[object Int32Array]"]=Qn["[object Map]"]=Qn["[object Number]"]=Qn[Jn]=Qn["[object RegExp]"]=Qn["[object Set]"]=Qn["[object String]"]=Qn["[object Symbol]"]=Qn["[object Uint8Array]"]=Qn["[object Uint8ClampedArray]"]=Qn["[object Uint16Array]"]=Qn["[object Uint32Array]"]=!0,Qn["[object Error]"]=Qn[Gn]=Qn["[object WeakMap]"]=!1;var Yn=1,Zn=4;function to(t){return Xn(t,Yn|Zn)}function ro(t){let r=!1;if(ht(t))r=!isNaN(Number(t));else if(function(t){return"[object Number]"===Object.prototype.toString.call(t)}(t)){if(_t(t))return!1;r=!0}return r}function eo(t){if(!ht(t)&&!ro(t)&&!h(t))return"";let r="";try{r=String(t)}catch(t){}try{r=t.toString()}catch(t){}return r}var no=Math.ceil,oo=Math.max;var uo=/\s/;var io=/^\s+/;function co(t){return t?t.slice(0,function(t){for(var r=t.length;r--&&uo.test(t.charAt(r)););return r}(t)+1).replace(io,""):t}var ao=NaN,fo=/^[-+]0x[0-9a-f]+$/i,lo=/^0b[01]+$/i,so=/^0o[0-7]+$/i,po=parseInt;var vo=1/0,bo=17976931348623157e292;function yo(t){return t?(t=function(t){if("number"==typeof t)return t;if(h(t))return ao;if(_(t)){var r="function"==typeof t.valueOf?t.valueOf():t;t=_(r)?r+"":r}if("string"!=typeof t)return 0===t?t:+t;t=co(t);var e=lo.test(t);return e||so.test(t)?po(t.slice(2),e?2:8):fo.test(t)?ao:+t}(t))===vo||t===-vo?(t<0?-1:1)*bo:t==t?t:0:0===t?t:0}var ho=function(t){return function(r,e,n){return n&&"number"!=typeof n&&function(t,r,e){if(!_(e))return!1;var n=typeof r;return!!("number"==n?$r(e)&&br(r,e.length):"string"==n&&r in e)&&V(e[r],t)}(r,e,n)&&(e=n=void 0),r=yo(r),void 0===e?(e=r,r=0):e=yo(e),function(t,r,e,n){for(var o=-1,u=oo(no((r-t)/(e||1)),0),i=Array(u);u--;)i[n?u:++o]=t,t+=e;return i}(r,e,n=void 0===n?r<e?1:-1:yo(n),t)}}(),jo=ho;function go(t,r=null,e={}){x(r)||(r=t=>t);let n=bt(e,"force",!1);return At(n)||(n=!1),function(t,r,e=!1){let n=[];if(!gt(t)&&!dt(t))return r(t,null,[]);function o(t){if(gt(t))return jo(Ke(t));if(dt(t)){let r=Object.getOwnPropertyNames(t),n=null;return e&&(n=Object.getOwnPropertySymbols(t)),gt(r)||(r=[]),gt(n)||(n=[]),[...r,...n]}return t}return function t(e,u){if(gt(e))return o(e).map((o=>{let u=e[o],i=to(n);return n.push(o),u=r(u,o,i),u=t(u),n.pop(),u}));if(dt(e)){let u=o(e),i={};return u.map((o=>{let u=e[o],c=to(n);n.push(o),u=r(u,o,c),u=t(u),n.pop(),i[o]=u})),i}return e}(t)}(t,r,n)}function _o(r,e={}){if(!jt(r)&&!wt(r))return[];let n=bt(e,"bindKey",null);ht(n)||(n="id");let o=bt(e,"bindParent",null);ht(o)||(o="parentId");let u=bt(e,"bindBelong",null);ht(u)||(u="key");let i=bt(e,"bindText",null);ht(i)||(i="text");let c=bt(e,"bindType",null);ht(c)||(c="type");let a=bt(e,"bindNumOfChilren",null);function f(r,e){var n,o;var u,i;return r=to(r),o=t=>h(t)?eo(t):t,r=(t(n=r)?ut:Ae)(n,ge(o)),h(e)&&(e=eo(e)),(ht(e)||ro(e))&&r.push(e),i="-",null==(u=r)?"":xe.call(u,i)}ht(a)||(a="numOfChilren");let l=[];return go(r,((t,r,e)=>{let s=f(e,r),p=f(e,null),y="node";dt(t)?y="object":gt(t)&&(y="array");let h={[n]:s,[o]:p,[c]:y};if((ht(r)||function(t){return"number"==typeof t||b(t)&&v(t)==We}(r))&&(h[u]=r),dt(t)||gt(t)||(h[i]=t),dt(t)||gt(t)){let r=null;dt(t)?r=Ke(Cr(t)):gt(t)&&(r=Ke(t)),h[a]=r}return l.push(h),t}),{force:!0}),l}function Oo(r,e){var n;return(t(r)?qe:me)(r,"function"==typeof(n=e)?n:he)}function wo(t,r,e){return null==t?t:function(t,r,e,n){if(!_(t))return t;for(var o=-1,u=(r=lt(r,t)).length,i=u-1,c=t;null!=c&&++o<u;){var a=pt(r[o]),f=e;if("__proto__"===a||"constructor"===a||"prototype"===a)return t;if(o!=i){var l=c[a];void 0===(f=n?n(l,a,c):void 0)&&(f=_(l)?l:br(r[o+1])?[]:{})}Xe(c,a,f),c=c[a]}return t}(t,r,e)}function mo(t,r){return r.length<2?t:vt(t,function(t,r,e){var n=-1,o=t.length;r<0&&(r=-r>o?0:o+r),(e=e>o?o:e)<0&&(e+=o),o=r>e?0:e-r>>>0,r>>>=0;for(var u=Array(o);++n<o;)u[n]=t[n+r];return u}(r,0,-1))}var Ao=Object.prototype.hasOwnProperty;function xo(t,r){var e=-1,n=(r=lt(r,t)).length;if(!n)return!0;for(var o=null==t||"object"!=typeof t&&"function"!=typeof t;++e<n;){var u=r[e];if("string"==typeof u){if("__proto__"===u&&!Ao.call(t,"__proto__"))return!1;if("constructor"===u&&e+1<n&&"string"==typeof r[e+1]&&"prototype"===r[e+1]){if(o&&0===e)continue;return!1}}}var i=mo(t,r);return null==i||delete i[pt(function(t){var r=null==t?0:t.length;return r?t[r-1]:void 0}(r))]}var So="[object Object]",Po=Function.prototype,zo=Object.prototype,Eo=Po.toString,Io=zo.hasOwnProperty,No=Eo.call(Object);function To(t){return function(t){if(!b(t)||v(t)!=So)return!1;var r=cn(t);if(null===r)return!0;var e=Io.call(r,"constructor")&&r.constructor;return"function"==typeof e&&e instanceof e&&Eo.call(e)==No}(t)?void 0:t}var $o=o?o.isConcatSpreadable:void 0;function Co(r){return t(r)||cr(r)||!!($o&&r&&r[$o])}function Fo(t,r,e,n,o){var u=-1,i=t.length;for(e||(e=Co),o||(o=[]);++u<i;){var c=t[u];r>0&&e(c)?r>1?Fo(c,r-1,e,n,o):Qt(o,c):n||(o[o.length]=c)}return o}function Mo(t){return(null==t?0:t.length)?Fo(t,1):[]}var Uo=Math.max;var ko=He?function(t,r){return He(t,"toString",{configurable:!0,enumerable:!1,value:(e=r,function(){return e}),writable:!0});var e}:he,Bo=ko,Do=Date.now;var Ro=function(t){var r=0,e=0;return function(){var n=Do(),o=16-(n-e);if(e=n,o>0){if(++r>=800)return arguments[0]}else r=0;return t.apply(void 0,arguments)}}(Bo),Lo=Ro;var Vo=function(t){return Lo(function(t,r,e){return r=Uo(void 0===r?t.length-1:r,0),function(){for(var n=arguments,o=-1,u=Uo(n.length-r,0),i=Array(u);++o<u;)i[o]=n[r+o];o=-1;for(var c=Array(r+1);++o<r;)c[o]=n[o];return c[r]=e(i),function(t,r,e){switch(e.length){case 0:return t.call(r);case 1:return t.call(r,e[0]);case 2:return t.call(r,e[0],e[1]);case 3:return t.call(r,e[0],e[1],e[2])}return t.apply(r,e)}(t,this,c)}}(t,void 0,Mo),t+"")}((function(t,r){var e={};if(null==t)return e;var n=!1;r=ut(r,(function(r){return r=lt(r,t),n||(n=r.length>1),r})),Ye(t,ln(t),e),n&&(e=Xn(e,7,To));for(var o=r.length;o--;)xo(e,r[o]);return e})),Ko=Vo;function Wo(t,r={}){let e="$level",n="$parents";if(!wt(t))return[];let o=bt(r,"bindKey",null);ht(o)||(o="id");let u=bt(r,"bindParent",null);ht(u)||(u="parentId");let i=bt(r,"bindChildren",null);ht(i)||(i="children");let c=bt(r,"saveExtProps",null);At(c)||(c=!1),t=function(t){let r=[];function i(i){let c=[];Oo(t,((t,a)=>{let f=bt(t,u),l=bt(i,o);if(f&&l&&f===l){let u=bt(i,n,[]);u=to(u),u.push(i[o]),r.push({[e]:i[e]+1,[n]:u,...t})}else c.push(t)})),t=c}if(t=to(t),function(){let o=[];Oo(t,((t,i)=>{Ot(t[u])?r.push({[e]:0,[n]:[],...t}):o.push(t)})),t=o}(),0===r.length)return r;let c=-1;for(;c+=1,!(c>r.length-1);){if(i(r[c]),0===t.length)break}return r}(t);let a=function(t){let r=[];function a(t){return c?t:Ko(t,[e,n])}let f={};return Oo(t,((n,c)=>{if(0===n[e]){let t=a(n);r.push(t),f[n[o]]=[c]}else{let e=function(r){for(let e=0;e<t.length;e++){let n=t[e];if(r[u]===n[o])return n}return null}(n);if(null!==e){let t=f[e[o]];t=[...t,i];let u=bt(r,t,[]),c=a(n);u.push(c),f[n[o]]=[...t,u.length-1],wo(r,t,u)}else console.log(`can not find parent for ${bt(n,u)}`)}})),r}(t);return a}let convertToTreeWk=async function(t,r={}){return function(t,r={}){if(!jt(t)&&!wt(t))return[];let e=bt(r,"bindKey",null);ht(e)||(e="id");let n=bt(r,"bindParent",null);ht(n)||(n="parentId");let o=bt(r,"bindText",null);ht(o)||(o="text");let u=bt(r,"bindChildren",null);ht(u)||(u="children");let i=bt(r,"bindType",null);ht(i)||(i="type");let c=bt(r,"bindNumOfChilren",null);ht(c)||(c="numOfChilren");let a=bt(r,"bindRoot",null);ht(a)||(a="root");let f=bt(r,"saveExtProps",null);return At(f)||(f=!1),ht(a)&&(t={[a]:t}),Wo(_o(t,{bindKey:e,bindParent:n,bindText:o,bindType:i,bindNumOfChilren:c}),{bindKey:e,bindParent:n,bindChildren:u,saveExtProps:f})}(t,r)};


let instance = null
function init(input){

    //init
    let r
    
        r = {
            main: convertToTreeWk
        }
        

    //on
    

    //save
    instance = r

}

function sendMessage(data) {
    
        self.postMessage(data)
        
}

async function run(data) {
    // console.log('inner worker run',data)

    //mode
    let mode = data.mode

    //check
    if(mode !== 'init' && mode !== 'call'){
        return
    }

    //init
    if(mode === 'init'){
        
        try{

            //type
            let type = data.type

            //input
            let input = data.input
    
            //instance
            if(type === 'function'){
                init(...input)
            }
            else if(type === 'object'){
                instance = convertToTreeWk
            }

        }
        catch(err){
        
            //sendMessage
            let res = {
                mode: 'emit',
                evName: 'error',
                msg: err,
            }
            sendMessage(res)

        }
            
    }

    //check
    if(mode === 'call'){
        let state = ''
        let msg = null

        try{

            //fun
            let fun = instance[data.fun]

            //input
            let input = data.input

            //exec
            await fun(...input)
                .then((suc) => {
                    state='success'
                    msg=suc
                })
                .catch((err) => {
                    state='error'
                    msg=err
                })

        }
        catch(err){
            state = 'error'
            msg = err
        }
        
        //sendMessage
        let res = {
            mode: 'return',
            id: data.id,
            fun: data.fun,
            state,
            msg,
        }
        sendMessage(res)

    }

}

function recvMessage(data) {
    // console.log('inner worker recv:', data)

    //dataRecv
    let dataRecv = data

    //run
    run(dataRecv)

}


        self.onmessage = function (e) {
            recvMessage(e.data)
        }
        

try{
    process.on('unhandledRejection', (err) => {
        console.log('inner:unhandledRejection', err)
    })
    process.on('uncaughtException', (err) => {
        console.log('inner:uncaughtException', err)
    })
    process.on('uncaughtExceptionMonitor', (err) => {
        console.log('inner:uncaughtExceptionMonitor', err)
    })
}
catch(err){}

");function l(){let l=new g;let m=function(d){try{let l=new Blob([d]),m=window.URL||window.webkitURL;return new Worker(m.createObjectURL(l))}catch(d){Z(d)}}(d);if(!m)return Z("invalid worker"),null;function I(){let d=function(){let d,l,m=new Promise((function(){d=arguments[0],l=arguments[1]}));return m.resolve=d,m.reject=l,m}(),I=function(){let d=arguments.length>0&&void 0!==arguments[0]?arguments[0]:10,l=[],m="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".split(""),I=m.length;for(let Z=0;Z<d;Z++)l[Z]=m[0|Math.random()*I];return l.join("")}(),Z={mode:"call",id:I,fun:"main",input:[...arguments]};return m.postMessage(Z),l.once(I,(l=>{"success"===l.state?d.resolve(l.msg):d.reject(l.msg)})),d}function Z(d){l.emit("error",d)}return m.onmessage=function(d){!function(d){let m=d,I=m.mode;"emit"!==I&&"return"!==I||("emit"===I&&l.emit(m.evName,m.msg),"return"===I&&l.emit(m.id,m))}(d.data)},m.onerror=Z,m.onmessageerror=function(d){Z(d.data)},function(){let d={mode:"init",type:"function",input:[...arguments]};m.postMessage(d)}([...arguments]),l.main=I,l.main=I,l.terminate=function(){m?(m.terminate(),m=void 0):Z("worker has been terminated")},l}n=async function(){let d=[...arguments],m=l();return await m.main(...d).finally((()=>{m.terminate()}))}}();try{process.on("unhandledRejection",(d=>{console.log("outer:unhandledRejection",d)})),process.on("uncaughtException",(d=>{console.log("outer:uncaughtException",d)})),process.on("uncaughtExceptionMonitor",(d=>{console.log("outer:uncaughtExceptionMonitor",d)}))}catch(d){}var t=n;export{t as default};
+const d="function"==typeof Buffer,l="function"==typeof TextDecoder?new TextDecoder:void 0,I=("function"==typeof TextEncoder&&new TextEncoder,Array.prototype.slice.call("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=")),m=(()=>{let d={};return I.forEach((l,I)=>d[l]=I),d})(),b=/^(?:[A-Za-z\d+\/]{4})*?(?:[A-Za-z\d+\/]{2}(?:==)?|[A-Za-z\d+\/]{3}=?)?$/,i=String.fromCharCode.bind(String),Z="function"==typeof Uint8Array.from?Uint8Array.from.bind(Uint8Array):d=>new Uint8Array(Array.prototype.slice.call(d,0)),X=d=>d.replace(/[^A-Za-z0-9\+\/]/g,""),c=d=>{let l,m,b,i,Z="";const X=d.length%3;for(let X=0;X<d.length;){if((m=d.charCodeAt(X++))>255||(b=d.charCodeAt(X++))>255||(i=d.charCodeAt(X++))>255)throw new TypeError("invalid character found");l=m<<16|b<<8|i,Z+=I[l>>18&63]+I[l>>12&63]+I[l>>6&63]+I[63&l]}return X?Z.slice(0,X-3)+"===".substring(X):Z},C=/[\xC0-\xDF][\x80-\xBF]|[\xE0-\xEF][\x80-\xBF]{2}|[\xF0-\xF7][\x80-\xBF]{3}/g,y=d=>{switch(d.length){case 4:var l=((7&d.charCodeAt(0))<<18|(63&d.charCodeAt(1))<<12|(63&d.charCodeAt(2))<<6|63&d.charCodeAt(3))-65536;return i((l>>>10)+55296)+i(56320+(1023&l));case 3:return i((15&d.charCodeAt(0))<<12|(63&d.charCodeAt(1))<<6|63&d.charCodeAt(2));default:return i((31&d.charCodeAt(0))<<6|63&d.charCodeAt(1))}},K=d=>d.replace(C,y),G=d=>{if(d=d.replace(/\s+/g,""),!b.test(d))throw new TypeError("malformed base64.");let l,I,Z;d+="==".slice(2-(3&d.length));let X=[];for(let b=0;b<d.length;)l=m[d.charAt(b++)]<<18|m[d.charAt(b++)]<<12|(I=m[d.charAt(b++)])<<6|(Z=m[d.charAt(b++)]),64===I?X.push(i(l>>16&255)):64===Z?X.push(i(l>>16&255,l>>8&255)):X.push(i(l>>16&255,l>>8&255,255&l));return X.join("")},p="function"==typeof atob?d=>atob(X(d)):d?d=>Buffer.from(d,"base64").toString("binary"):G,W=d?d=>Z(Buffer.from(d,"base64")):d=>Z(p(d).split("").map(d=>d.charCodeAt(0))),h=d?d=>Buffer.from(d,"base64").toString("utf8"):l?d=>l.decode(W(d)):d=>K(p(d)),V=d=>X(d.replace(/[-_]/g,d=>"-"==d?"+":"/")),t=d=>h(V(d)),Y=t;function u(d){return d&&d.__esModule&&Object.prototype.hasOwnProperty.call(d,"default")?d.default:d}var g={exports:{}};!function(d){var l=Object.prototype.hasOwnProperty,I="~";function m(){}function b(d,l,I){this.fn=d,this.context=l,this.once=I||!1}function i(d,l,m,i,Z){if("function"!=typeof m)throw new TypeError("The listener must be a function");var X=new b(m,i||d,Z),c=I?I+l:l;return d._events[c]?d._events[c].fn?d._events[c]=[d._events[c],X]:d._events[c].push(X):(d._events[c]=X,d._eventsCount++),d}function Z(d,l){0===--d._eventsCount?d._events=new m:delete d._events[l]}function X(){this._events=new m,this._eventsCount=0}Object.create&&(m.prototype=Object.create(null),(new m).__proto__||(I=!1)),X.prototype.eventNames=function(){var d,m,b=[];if(0===this._eventsCount)return b;for(m in d=this._events)l.call(d,m)&&b.push(I?m.slice(1):m);return Object.getOwnPropertySymbols?b.concat(Object.getOwnPropertySymbols(d)):b},X.prototype.listeners=function(d){var l=I?I+d:d,m=this._events[l];if(!m)return[];if(m.fn)return[m.fn];for(var b=0,i=m.length,Z=new Array(i);b<i;b++)Z[b]=m[b].fn;return Z},X.prototype.listenerCount=function(d){var l=I?I+d:d,m=this._events[l];return m?m.fn?1:m.length:0},X.prototype.emit=function(d,l,m,b,i,Z){var X=I?I+d:d;if(!this._events[X])return!1;var c,C,y=this._events[X],K=arguments.length;if(y.fn){switch(y.once&&this.removeListener(d,y.fn,void 0,!0),K){case 1:return y.fn.call(y.context),!0;case 2:return y.fn.call(y.context,l),!0;case 3:return y.fn.call(y.context,l,m),!0;case 4:return y.fn.call(y.context,l,m,b),!0;case 5:return y.fn.call(y.context,l,m,b,i),!0;case 6:return y.fn.call(y.context,l,m,b,i,Z),!0}for(C=1,c=new Array(K-1);C<K;C++)c[C-1]=arguments[C];y.fn.apply(y.context,c)}else{var G,p=y.length;for(C=0;C<p;C++)switch(y[C].once&&this.removeListener(d,y[C].fn,void 0,!0),K){case 1:y[C].fn.call(y[C].context);break;case 2:y[C].fn.call(y[C].context,l);break;case 3:y[C].fn.call(y[C].context,l,m);break;case 4:y[C].fn.call(y[C].context,l,m,b);break;default:if(!c)for(G=1,c=new Array(K-1);G<K;G++)c[G-1]=arguments[G];y[C].fn.apply(y[C].context,c)}}return!0},X.prototype.on=function(d,l,I){return i(this,d,l,I,!1)},X.prototype.once=function(d,l,I){return i(this,d,l,I,!0)},X.prototype.removeListener=function(d,l,m,b){var i=I?I+d:d;if(!this._events[i])return this;if(!l)return Z(this,i),this;var X=this._events[i];if(X.fn)X.fn!==l||b&&!X.once||m&&X.context!==m||Z(this,i);else{for(var c=0,C=[],y=X.length;c<y;c++)(X[c].fn!==l||b&&!X[c].once||m&&X[c].context!==m)&&C.push(X[c]);C.length?this._events[i]=1===C.length?C[0]:C:Z(this,i)}return this},X.prototype.removeAllListeners=function(d){var l;return d?(l=I?I+d:d,this._events[l]&&Z(this,l)):(this._events=new m,this._eventsCount=0),this},X.prototype.off=X.prototype.removeListener,X.prototype.addListener=X.prototype.on,X.prefixed=I,X.EventEmitter=X,d.exports=X}(g);var o=u(g.exports);let n;!function(){if("browser"!==("undefined"!=typeof window&&void 0!==window.document?"browser":"nodejs"))return null;let d=Y("


"use strict";var t=Array.isArray,r="object"==typeof global&&global&&global.Object===Object&&global,e="object"==typeof self&&self&&self.Object===Object&&self,n=r||e||Function("return this")(),o=n.Symbol,u=Object.prototype,i=u.hasOwnProperty,c=u.toString,a=o?o.toStringTag:void 0;var f=Object.prototype.toString;var l=o?o.toStringTag:void 0;function s(t){return null==t?void 0===t?"[object Undefined]":"[object Null]":l&&l in Object(t)?function(t){var r=i.call(t,a),e=t[a];try{t[a]=void 0;var n=!0}catch(t){}var o=c.call(t);return n&&(r?t[a]=e:delete t[a]),o}(t):function(t){return f.call(t)}(t)}function p(t){return null!=t&&"object"==typeof t}function b(t){return"symbol"==typeof t||p(t)&&"[object Symbol]"==s(t)}var v=/\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,y=/^\w*$/;function h(r,e){if(t(r))return!1;var n=typeof r;return!("number"!=n&&"symbol"!=n&&"boolean"!=n&&null!=r&&!b(r))||(y.test(r)||!v.test(r)||null!=e&&r in Object(e))}function d(t){var r=typeof t;return null!=t&&("object"==r||"function"==r)}function j(t){if(!d(t))return!1;var r=s(t);return"[object Function]"==r||"[object GeneratorFunction]"==r||"[object AsyncFunction]"==r||"[object Proxy]"==r}var g,_=n["__core-js_shared__"],O=(g=/[^.]+$/.exec(_&&_.keys&&_.keys.IE_PROTO||""))?"Symbol(src)_1."+g:"";var w=Function.prototype.toString;function m(t){if(null!=t){try{return w.call(t)}catch(t){}try{return t+""}catch(t){}}return""}var A=/^\[object .+?Constructor\]$/,x=Function.prototype,S=Object.prototype,P=x.toString,z=S.hasOwnProperty,E=RegExp("^"+P.call(z).replace(/[\\^$.*+?()[\]{}|]/g,"\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g,"$1.*?")+"$");function I(t){return!(!d(t)||(r=t,O&&O in r))&&(j(t)?E:A).test(m(t));var r}function N(t,r){var e=function(t,r){return null==t?void 0:t[r]}(t,r);return I(e)?e:void 0}var T=N(Object,"create");var $=Object.prototype.hasOwnProperty;var C=Object.prototype.hasOwnProperty;function F(t){var r=-1,e=null==t?0:t.length;for(this.clear();++r<e;){var n=t[r];this.set(n[0],n[1])}}function M(t,r){return t===r||t!=t&&r!=r}function U(t,r){for(var e=t.length;e--;)if(M(t[e][0],r))return e;return-1}F.prototype.clear=function(){this.__data__=T?T(null):{},this.size=0},F.prototype.delete=function(t){var r=this.has(t)&&delete this.__data__[t];return this.size-=r?1:0,r},F.prototype.get=function(t){var r=this.__data__;if(T){var e=r[t];return"__lodash_hash_undefined__"===e?void 0:e}return $.call(r,t)?r[t]:void 0},F.prototype.has=function(t){var r=this.__data__;return T?void 0!==r[t]:C.call(r,t)},F.prototype.set=function(t,r){var e=this.__data__;return this.size+=this.has(t)?0:1,e[t]=T&&void 0===r?"__lodash_hash_undefined__":r,this};var k=Array.prototype.splice;function B(t){var r=-1,e=null==t?0:t.length;for(this.clear();++r<e;){var n=t[r];this.set(n[0],n[1])}}B.prototype.clear=function(){this.__data__=[],this.size=0},B.prototype.delete=function(t){var r=this.__data__,e=U(r,t);return!(e<0)&&(e==r.length-1?r.pop():k.call(r,e,1),--this.size,!0)},B.prototype.get=function(t){var r=this.__data__,e=U(r,t);return e<0?void 0:r[e][1]},B.prototype.has=function(t){return U(this.__data__,t)>-1},B.prototype.set=function(t,r){var e=this.__data__,n=U(e,t);return n<0?(++this.size,e.push([t,r])):e[n][1]=r,this};var D=N(n,"Map");function R(t,r){var e,n,o=t.__data__;return("string"==(n=typeof(e=r))||"number"==n||"symbol"==n||"boolean"==n?"__proto__"!==e:null===e)?o["string"==typeof r?"string":"hash"]:o.map}function L(t){var r=-1,e=null==t?0:t.length;for(this.clear();++r<e;){var n=t[r];this.set(n[0],n[1])}}L.prototype.clear=function(){this.size=0,this.__data__={hash:new F,map:new(D||B),string:new F}},L.prototype.delete=function(t){var r=R(this,t).delete(t);return this.size-=r?1:0,r},L.prototype.get=function(t){return R(this,t).get(t)},L.prototype.has=function(t){return R(this,t).has(t)},L.prototype.set=function(t,r){var e=R(this,t),n=e.size;return e.set(t,r),this.size+=e.size==n?0:1,this};function V(t,r){if("function"!=typeof t||null!=r&&"function"!=typeof r)throw new TypeError("Expected a function");var e=function(){var n=arguments,o=r?r.apply(this,n):n[0],u=e.cache;if(u.has(o))return u.get(o);var i=t.apply(this,n);return e.cache=u.set(o,i)||u,i};return e.cache=new(V.Cache||L),e}V.Cache=L;var K,W,q,G=/[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g,H=/\\(\\)?/g,J=(K=function(t){var r=[];return 46===t.charCodeAt(0)&&r.push(""),t.replace(G,function(t,e,n,o){r.push(n?o.replace(H,"$1"):e||t)}),r},W=V(K,function(t){return 500===q.size&&q.clear(),t}),q=W.cache,W),Q=J;function X(t,r){for(var e=-1,n=null==t?0:t.length,o=Array(n);++e<n;)o[e]=r(t[e],e,t);return o}var Y=o?o.prototype:void 0,Z=Y?Y.toString:void 0;function tt(r){if("string"==typeof r)return r;if(t(r))return X(r,tt)+"";if(b(r))return Z?Z.call(r):"";var e=r+"";return"0"==e&&1/r==-1/0?"-0":e}function rt(r,e){return t(r)?r:h(r,e)?[r]:Q(function(t){return null==t?"":tt(t)}(r))}function et(t){if("string"==typeof t||b(t))return t;var r=t+"";return"0"==r&&1/t==-1/0?"-0":r}function nt(t,r){for(var e=0,n=(r=rt(r,t)).length;null!=t&&e<n;)t=t[et(r[e++])];return e&&e==n?t:void 0}function ot(t,r,e){var n=null==t?void 0:nt(t,r);return void 0===n?e:n}function ut(t){return"[object String]"===Object.prototype.toString.call(t)}function it(t){return!(!ut(t)||""===t)}function ct(t){return"[object Object]"===Object.prototype.toString.call(t)}function at(t){if(ct(t)){for(let r in t)return!0;return!1}return!1}function ft(t){return"[object Array]"===Object.prototype.toString.call(t)}function lt(t){return t!=t}function st(t){return!!function(t){return"[object Undefined]"===Object.prototype.toString.call(t)}(t)||(!!function(t){return"[object Null]"===Object.prototype.toString.call(t)}(t)||(!!function(t){if(ct(t)){for(let r in t)return!1;return!0}return!1}(t)||(!!function(t){return!(!ut(t)||""!==t)}(t)||(!!function(t){return!!ft(t)&&0===t.length}(t)||!!lt(t)))))}function pt(t){return!!ft(t)&&(0!==t.length&&(1!==t.length||!st(t[0])))}function bt(t){return!0===(r=t)||!1===r||p(r)&&"[object Boolean]"==s(r);var r}function vt(t){var r=this.__data__=new B(t);this.size=r.size}vt.prototype.clear=function(){this.__data__=new B,this.size=0},vt.prototype.delete=function(t){var r=this.__data__,e=r.delete(t);return this.size=r.size,e},vt.prototype.get=function(t){return this.__data__.get(t)},vt.prototype.has=function(t){return this.__data__.has(t)},vt.prototype.set=function(t,r){var e=this.__data__;if(e instanceof B){var n=e.__data__;if(!D||n.length<199)return n.push([t,r]),this.size=++e.size,this;e=this.__data__=new L(n)}return e.set(t,r),this.size=e.size,this};function yt(t){var r=-1,e=null==t?0:t.length;for(this.__data__=new L;++r<e;)this.add(t[r])}function ht(t,r){for(var e=-1,n=null==t?0:t.length;++e<n;)if(r(t[e],e,t))return!0;return!1}function dt(t,r){return t.has(r)}yt.prototype.add=yt.prototype.push=function(t){return this.__data__.set(t,"__lodash_hash_undefined__"),this},yt.prototype.has=function(t){return this.__data__.has(t)};function jt(t,r,e,n,o,u){var i=1&e,c=t.length,a=r.length;if(c!=a&&!(i&&a>c))return!1;var f=u.get(t),l=u.get(r);if(f&&l)return f==r&&l==t;var s=-1,p=!0,b=2&e?new yt:void 0;for(u.set(t,r),u.set(r,t);++s<c;){var v=t[s],y=r[s];if(n)var h=i?n(y,v,s,r,t,u):n(v,y,s,t,r,u);if(void 0!==h){if(h)continue;p=!1;break}if(b){if(!ht(r,function(t,r){if(!dt(b,r)&&(v===t||o(v,t,e,n,u)))return b.push(r)})){p=!1;break}}else if(v!==y&&!o(v,y,e,n,u)){p=!1;break}}return u.delete(t),u.delete(r),p}var gt=n.Uint8Array;function _t(t){var r=-1,e=Array(t.size);return t.forEach(function(t,n){e[++r]=[n,t]}),e}function Ot(t){var r=-1,e=Array(t.size);return t.forEach(function(t){e[++r]=t}),e}var wt=o?o.prototype:void 0,mt=wt?wt.valueOf:void 0;function At(t,r){for(var e=-1,n=r.length,o=t.length;++e<n;)t[o+e]=r[e];return t}function xt(r,e,n){var o=e(r);return t(r)?o:At(o,n(r))}function St(){return[]}var Pt=Object.prototype.propertyIsEnumerable,zt=Object.getOwnPropertySymbols,Et=zt?function(t){return null==t?[]:(t=Object(t),function(t,r){for(var e=-1,n=null==t?0:t.length,o=0,u=[];++e<n;){var i=t[e];r(i,e,t)&&(u[o++]=i)}return u}(zt(t),function(r){return Pt.call(t,r)}))}:St,It=Et;function Nt(t){return p(t)&&"[object Arguments]"==s(t)}var Tt=Object.prototype,$t=Tt.hasOwnProperty,Ct=Tt.propertyIsEnumerable,Ft=Nt(function(){return arguments}())?Nt:function(t){return p(t)&&$t.call(t,"callee")&&!Ct.call(t,"callee")};var Mt="object"==typeof exports&&exports&&!exports.nodeType&&exports,Ut=Mt&&"object"==typeof module&&module&&!module.nodeType&&module,kt=Ut&&Ut.exports===Mt?n.Buffer:void 0,Bt=(kt?kt.isBuffer:void 0)||function(){return!1},Dt=/^(?:0|[1-9]\d*)$/;function Rt(t,r){var e=typeof t;return!!(r=null==r?9007199254740991:r)&&("number"==e||"symbol"!=e&&Dt.test(t))&&t>-1&&t%1==0&&t<r}function Lt(t){return"number"==typeof t&&t>-1&&t%1==0&&t<=9007199254740991}var Vt={};function Kt(t){return function(r){return t(r)}}Vt["[object Float32Array]"]=Vt["[object Float64Array]"]=Vt["[object Int8Array]"]=Vt["[object Int16Array]"]=Vt["[object Int32Array]"]=Vt["[object Uint8Array]"]=Vt["[object Uint8ClampedArray]"]=Vt["[object Uint16Array]"]=Vt["[object Uint32Array]"]=!0,Vt["[object Arguments]"]=Vt["[object Array]"]=Vt["[object ArrayBuffer]"]=Vt["[object Boolean]"]=Vt["[object DataView]"]=Vt["[object Date]"]=Vt["[object Error]"]=Vt["[object Function]"]=Vt["[object Map]"]=Vt["[object Number]"]=Vt["[object Object]"]=Vt["[object RegExp]"]=Vt["[object Set]"]=Vt["[object String]"]=Vt["[object WeakMap]"]=!1;var Wt="object"==typeof exports&&exports&&!exports.nodeType&&exports,qt=Wt&&"object"==typeof module&&module&&!module.nodeType&&module,Gt=qt&&qt.exports===Wt&&r.process,Ht=function(){try{var t=qt&&qt.require&&qt.require("util").types;return t||Gt&&Gt.binding&&Gt.binding("util")}catch(t){}}(),Jt=Ht&&Ht.isTypedArray,Qt=Jt?Kt(Jt):function(t){return p(t)&&Lt(t.length)&&!!Vt[s(t)]},Xt=Object.prototype.hasOwnProperty;function Yt(r,e){var n=t(r),o=!n&&Ft(r),u=!n&&!o&&Bt(r),i=!n&&!o&&!u&&Qt(r),c=n||o||u||i,a=c?function(t,r){for(var e=-1,n=Array(t);++e<t;)n[e]=r(e);return n}(r.length,String):[],f=a.length;for(var l in r)!e&&!Xt.call(r,l)||c&&("length"==l||u&&("offset"==l||"parent"==l)||i&&("buffer"==l||"byteLength"==l||"byteOffset"==l)||Rt(l,f))||a.push(l);return a}var Zt=Object.prototype;function tr(t){var r=t&&t.constructor;return t===("function"==typeof r&&r.prototype||Zt)}function rr(t,r){return function(e){return t(r(e))}}var er=rr(Object.keys,Object),nr=Object.prototype.hasOwnProperty;function or(t){if(!tr(t))return er(t);var r=[];for(var e in Object(t))nr.call(t,e)&&"constructor"!=e&&r.push(e);return r}function ur(t){return null!=t&&Lt(t.length)&&!j(t)}function ir(t){return ur(t)?Yt(t):or(t)}function cr(t){return xt(t,ir,It)}var ar=Object.prototype.hasOwnProperty;var fr=N(n,"DataView"),lr=N(n,"Promise"),sr=N(n,"Set"),pr=N(n,"WeakMap"),br="[object Map]",vr="[object Promise]",yr="[object Set]",hr="[object WeakMap]",dr="[object DataView]",jr=m(fr),gr=m(D),_r=m(lr),Or=m(sr),wr=m(pr),mr=s;(fr&&mr(new fr(new ArrayBuffer(1)))!=dr||D&&mr(new D)!=br||lr&&mr(lr.resolve())!=vr||sr&&mr(new sr)!=yr||pr&&mr(new pr)!=hr)&&(mr=function(t){var r=s(t),e="[object Object]"==r?t.constructor:void 0,n=e?m(e):"";if(n)switch(n){case jr:return dr;case gr:return br;case _r:return vr;case Or:return yr;case wr:return hr}return r});var Ar=mr,xr="[object Arguments]",Sr="[object Array]",Pr="[object Object]",zr=Object.prototype.hasOwnProperty;function Er(r,e,n,o,u,i){var c=t(r),a=t(e),f=c?Sr:Ar(r),l=a?Sr:Ar(e),s=(f=f==xr?Pr:f)==Pr,p=(l=l==xr?Pr:l)==Pr,b=f==l;if(b&&Bt(r)){if(!Bt(e))return!1;c=!0,s=!1}if(b&&!s)return i||(i=new vt),c||Qt(r)?jt(r,e,n,o,u,i):function(t,r,e,n,o,u,i){switch(e){case"[object DataView]":if(t.byteLength!=r.byteLength||t.byteOffset!=r.byteOffset)return!1;t=t.buffer,r=r.buffer;case"[object ArrayBuffer]":return!(t.byteLength!=r.byteLength||!u(new gt(t),new gt(r)));case"[object Boolean]":case"[object Date]":case"[object Number]":return M(+t,+r);case"[object Error]":return t.name==r.name&&t.message==r.message;case"[object RegExp]":case"[object String]":return t==r+"";case"[object Map]":var c=_t;case"[object Set]":var a=1&n;if(c||(c=Ot),t.size!=r.size&&!a)return!1;var f=i.get(t);if(f)return f==r;n|=2,i.set(t,r);var l=jt(c(t),c(r),n,o,u,i);return i.delete(t),l;case"[object Symbol]":if(mt)return mt.call(t)==mt.call(r)}return!1}(r,e,f,n,o,u,i);if(!(1&n)){var v=s&&zr.call(r,"__wrapped__"),y=p&&zr.call(e,"__wrapped__");if(v||y){var h=v?r.value():r,d=y?e.value():e;return i||(i=new vt),u(h,d,n,o,i)}}return!!b&&(i||(i=new vt),function(t,r,e,n,o,u){var i=1&e,c=cr(t),a=c.length;if(a!=cr(r).length&&!i)return!1;for(var f=a;f--;){var l=c[f];if(!(i?l in r:ar.call(r,l)))return!1}var s=u.get(t),p=u.get(r);if(s&&p)return s==r&&p==t;var b=!0;u.set(t,r),u.set(r,t);for(var v=i;++f<a;){var y=t[l=c[f]],h=r[l];if(n)var d=i?n(h,y,l,r,t,u):n(y,h,l,t,r,u);if(!(void 0===d?y===h||o(y,h,e,n,u):d)){b=!1;break}v||(v="constructor"==l)}if(b&&!v){var j=t.constructor,g=r.constructor;j==g||!("constructor"in t)||!("constructor"in r)||"function"==typeof j&&j instanceof j&&"function"==typeof g&&g instanceof g||(b=!1)}return u.delete(t),u.delete(r),b}(r,e,n,o,u,i))}function Ir(t,r,e,n,o){return t===r||(null==t||null==r||!p(t)&&!p(r)?t!=t&&r!=r:Er(t,r,e,n,Ir,o))}function Nr(t){return t==t&&!d(t)}function Tr(t,r){return function(e){return null!=e&&(e[t]===r&&(void 0!==r||t in Object(e)))}}function $r(t){var r=function(t){for(var r=ir(t),e=r.length;e--;){var n=r[e],o=t[n];r[e]=[n,o,Nr(o)]}return r}(t);return 1==r.length&&r[0][2]?Tr(r[0][0],r[0][1]):function(e){return e===t||function(t,r,e,n){var o=e.length,u=o,i=!n;if(null==t)return!u;for(t=Object(t);o--;){var c=e[o];if(i&&c[2]?c[1]!==t[c[0]]:!(c[0]in t))return!1}for(;++o<u;){var a=(c=e[o])[0],f=t[a],l=c[1];if(i&&c[2]){if(void 0===f&&!(a in t))return!1}else{var s=new vt;if(n)var p=n(f,l,a,t,r,s);if(!(void 0===p?Ir(l,f,3,n,s):p))return!1}}return!0}(e,t,r)}}function Cr(t,r){return null!=t&&r in Object(t)}function Fr(r,e){return null!=r&&function(r,e,n){for(var o=-1,u=(e=rt(e,r)).length,i=!1;++o<u;){var c=et(e[o]);if(!(i=null!=r&&n(r,c)))break;r=r[c]}return i||++o!=u?i:!!(u=null==r?0:r.length)&&Lt(u)&&Rt(c,u)&&(t(r)||Ft(r))}(r,e,Cr)}function Mr(t){return t}function Ur(t){return function(r){return null==r?void 0:r[t]}}function kr(t){return h(t)?Ur(et(t)):function(t){return function(r){return nt(r,t)}}(t)}function Br(r){return"function"==typeof r?r:null==r?Mr:"object"==typeof r?t(r)?(e=r[0],n=r[1],h(e)&&Nr(n)?Tr(et(e),n):function(t){var r=ot(t,e);return void 0===r&&r===n?Fr(t,e):Ir(n,r,3)}):$r(r):kr(r);var e,n}var Dr,Rr=function(t,r,e){for(var n=-1,o=Object(t),u=e(t),i=u.length;i--;){var c=u[Dr?i:++n];if(!1===r(o[c],c,o))break}return t};var Lr=function(t,r){return function(e,n){if(null==e)return e;if(!ur(e))return t(e,n);for(var o=e.length,u=r?o:-1,i=Object(e);(r?u--:++u<o)&&!1!==n(i[u],u,i););return e}}(function(t,r){return t&&Rr(t,r,ir)}),Vr=Lr;function Kr(t,r){var e=-1,n=ur(t)?Array(t.length):[];return Vr(t,function(t,o,u){n[++e]=r(t,o,u)}),n}var Wr=Array.prototype.join;var qr=Ur("length"),Gr=RegExp("[\\u200d\\ud800-\\udfff\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff\\ufe0e\\ufe0f]");var Hr="\\ud800-\\udfff",Jr="["+Hr+"]",Qr="[\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff]",Xr="\\ud83c[\\udffb-\\udfff]",Yr="[^"+Hr+"]",Zr="(?:\\ud83c[\\udde6-\\uddff]){2}",te="[\\ud800-\\udbff][\\udc00-\\udfff]",re="(?:"+Qr+"|"+Xr+")"+"?",ee="[\\ufe0e\\ufe0f]?",ne=ee+re+("(?:\\u200d(?:"+[Yr,Zr,te].join("|")+")"+ee+re+")*"),oe="(?:"+[Yr+Qr+"?",Qr,Zr,te,Jr].join("|")+")",ue=RegExp(Xr+"(?="+Xr+")|"+oe+ne,"g");function ie(t){return function(t){return Gr.test(t)}(t)?function(t){for(var r=ue.lastIndex=0;ue.test(t);)++r;return r}(t):qr(t)}function ce(r){if(null==r)return 0;if(ur(r))return"string"==typeof(e=r)||!t(e)&&p(e)&&"[object String]"==s(e)?ie(r):r.length;var e,n=Ar(r);return"[object Map]"==n||"[object Set]"==n?r.size:or(r).length}function ae(t,r){for(var e=-1,n=null==t?0:t.length;++e<n&&!1!==r(t[e],e,t););return t}var fe=function(){try{var t=N(Object,"defineProperty");return t({},"",{}),t}catch(t){}}(),le=fe;function se(t,r,e){"__proto__"==r&&le?le(t,r,{configurable:!0,enumerable:!0,value:e,writable:!0}):t[r]=e}var pe=Object.prototype.hasOwnProperty;function be(t,r,e){var n=t[r];pe.call(t,r)&&M(n,e)&&(void 0!==e||r in t)||se(t,r,e)}function ve(t,r,e,n){var o=!e;e||(e={});for(var u=-1,i=r.length;++u<i;){var c=r[u],a=n?n(e[c],t[c],c,e,t):void 0;void 0===a&&(a=t[c]),o?se(e,c,a):be(e,c,a)}return e}var ye=Object.prototype.hasOwnProperty;function he(t){if(!d(t))return function(t){var r=[];if(null!=t)for(var e in Object(t))r.push(e);return r}(t);var r=tr(t),e=[];for(var n in t)("constructor"!=n||!r&&ye.call(t,n))&&e.push(n);return e}function de(t){return ur(t)?Yt(t,!0):he(t)}var je="object"==typeof exports&&exports&&!exports.nodeType&&exports,ge=je&&"object"==typeof module&&module&&!module.nodeType&&module,_e=ge&&ge.exports===je?n.Buffer:void 0,Oe=_e?_e.allocUnsafe:void 0;var we=rr(Object.getPrototypeOf,Object),me=Object.getOwnPropertySymbols?function(t){for(var r=[];t;)At(r,It(t)),t=we(t);return r}:St,Ae=me;function xe(t){return xt(t,de,Ae)}var Se=Object.prototype.hasOwnProperty;function Pe(t){var r=new t.constructor(t.byteLength);return new gt(r).set(new gt(t)),r}var ze=/\w*$/;var Ee=o?o.prototype:void 0,Ie=Ee?Ee.valueOf:void 0;function Ne(t,r,e){var n,o=t.constructor;switch(r){case"[object ArrayBuffer]":return Pe(t);case"[object Boolean]":case"[object Date]":return new o(+t);case"[object DataView]":return function(t,r){var e=r?Pe(t.buffer):t.buffer;return new t.constructor(e,t.byteOffset,t.byteLength)}(t,e);case"[object Float32Array]":case"[object Float64Array]":case"[object Int8Array]":case"[object Int16Array]":case"[object Int32Array]":case"[object Uint8Array]":case"[object Uint8ClampedArray]":case"[object Uint16Array]":case"[object Uint32Array]":return function(t,r){var e=r?Pe(t.buffer):t.buffer;return new t.constructor(e,t.byteOffset,t.length)}(t,e);case"[object Map]":case"[object Set]":return new o;case"[object Number]":case"[object String]":return new o(t);case"[object RegExp]":return function(t){var r=new t.constructor(t.source,ze.exec(t));return r.lastIndex=t.lastIndex,r}(t);case"[object Symbol]":return n=t,Ie?Object(Ie.call(n)):{}}}var Te=Object.create,$e=function(){function t(){}return function(r){if(!d(r))return{};if(Te)return Te(r);t.prototype=r;var e=new t;return t.prototype=void 0,e}}(),Ce=$e;var Fe=Ht&&Ht.isMap,Me=Fe?Kt(Fe):function(t){return p(t)&&"[object Map]"==Ar(t)};var Ue=Ht&&Ht.isSet,ke=Ue?Kt(Ue):function(t){return p(t)&&"[object Set]"==Ar(t)},Be="[object Arguments]",De="[object Function]",Re="[object Object]",Le={};function Ve(r,e,n,o,u,i){var c,a=1&e,f=2&e,l=4&e;if(n&&(c=u?n(r,o,u,i):n(r)),void 0!==c)return c;if(!d(r))return r;var s=t(r);if(s){if(c=function(t){var r=t.length,e=new t.constructor(r);return r&&"string"==typeof t[0]&&Se.call(t,"index")&&(e.index=t.index,e.input=t.input),e}(r),!a)return function(t,r){var e=-1,n=t.length;for(r||(r=Array(n));++e<n;)r[e]=t[e];return r}(r,c)}else{var p=Ar(r),b=p==De||"[object GeneratorFunction]"==p;if(Bt(r))return function(t,r){if(r)return t.slice();var e=t.length,n=Oe?Oe(e):new t.constructor(e);return t.copy(n),n}(r,a);if(p==Re||p==Be||b&&!u){if(c=f||b?{}:function(t){return"function"!=typeof t.constructor||tr(t)?{}:Ce(we(t))}(r),!a)return f?function(t,r){return ve(t,Ae(t),r)}(r,function(t,r){return t&&ve(r,de(r),t)}(c,r)):function(t,r){return ve(t,It(t),r)}(r,function(t,r){return t&&ve(r,ir(r),t)}(c,r))}else{if(!Le[p])return u?r:{};c=Ne(r,p,a)}}i||(i=new vt);var v=i.get(r);if(v)return v;i.set(r,c),ke(r)?r.forEach(function(t){c.add(Ve(t,e,n,t,r,i))}):Me(r)&&r.forEach(function(t,o){c.set(o,Ve(t,e,n,o,r,i))});var y=s?void 0:(l?f?xe:cr:f?de:ir)(r);return ae(y||r,function(t,o){y&&(t=r[o=t]),be(c,o,Ve(t,e,n,o,r,i))}),c}Le[Be]=Le["[object Array]"]=Le["[object ArrayBuffer]"]=Le["[object DataView]"]=Le["[object Boolean]"]=Le["[object Date]"]=Le["[object Float32Array]"]=Le["[object Float64Array]"]=Le["[object Int8Array]"]=Le["[object Int16Array]"]=Le["[object Int32Array]"]=Le["[object Map]"]=Le["[object Number]"]=Le[Re]=Le["[object RegExp]"]=Le["[object Set]"]=Le["[object String]"]=Le["[object Symbol]"]=Le["[object Uint8Array]"]=Le["[object Uint8ClampedArray]"]=Le["[object Uint16Array]"]=Le["[object Uint32Array]"]=!0,Le["[object Error]"]=Le[De]=Le["[object WeakMap]"]=!1;function Ke(t){return Ve(t,5)}function We(t){let r=!1;if(it(t))r=!isNaN(Number(t));else if(function(t){return"[object Number]"===Object.prototype.toString.call(t)}(t)){if(lt(t))return!1;r=!0}return r}function qe(t){if(!it(t)&&!We(t)&&!b(t))return"";let r="";try{r=String(t)}catch(t){}try{r=t.toString()}catch(t){}return r}var Ge=Math.ceil,He=Math.max;var Je=/\s/;var Qe=/^\s+/;function Xe(t){return t?t.slice(0,function(t){for(var r=t.length;r--&&Je.test(t.charAt(r)););return r}(t)+1).replace(Qe,""):t}var Ye=/^[-+]0x[0-9a-f]+$/i,Ze=/^0b[01]+$/i,tn=/^0o[0-7]+$/i,rn=parseInt;var en=1/0;function nn(t){return t?(t=function(t){if("number"==typeof t)return t;if(b(t))return NaN;if(d(t)){var r="function"==typeof t.valueOf?t.valueOf():t;t=d(r)?r+"":r}if("string"!=typeof t)return 0===t?t:+t;t=Xe(t);var e=Ze.test(t);return e||tn.test(t)?rn(t.slice(2),e?2:8):Ye.test(t)?NaN:+t}(t))===en||t===-1/0?17976931348623157e292*(t<0?-1:1):t==t?t:0:0===t?t:0}var on=function(t){return function(r,e,n){return n&&"number"!=typeof n&&function(t,r,e){if(!d(e))return!1;var n=typeof r;return!!("number"==n?ur(e)&&Rt(r,e.length):"string"==n&&r in e)&&M(e[r],t)}(r,e,n)&&(e=n=void 0),r=nn(r),void 0===e?(e=r,r=0):e=nn(e),function(t,r,e,n){for(var o=-1,u=He(Ge((r-t)/(e||1)),0),i=Array(u);u--;)i[n?u:++o]=t,t+=e;return i}(r,e,n=void 0===n?r<e?1:-1:nn(n),t)}}(),un=on;function cn(t,r=null,e={}){j(r)||(r=t=>t);let n=ot(e,"force",!1);return bt(n)||(n=!1),function(t,r,e=!1){let n=[];if(!ft(t)&&!ct(t))return r(t,null,[]);function o(t){if(ft(t))return un(ce(t));if(ct(t)){let r=Object.getOwnPropertyNames(t),n=null;return e&&(n=Object.getOwnPropertySymbols(t)),ft(r)||(r=[]),ft(n)||(n=[]),[...r,...n]}return t}return function t(e,u){if(ft(e))return o(e).map(o=>{let u=e[o],i=Ke(n);return n.push(o),u=r(u,o,i),u=t(u),n.pop(),u});if(ct(e)){let u=o(e),i={};return u.map(o=>{let u=e[o],c=Ke(n);n.push(o),u=r(u,o,c),u=t(u),n.pop(),i[o]=u}),i}return e}(t)}(t,r,n)}function an(r,e={}){if(!at(r)&&!pt(r))return[];let n=ot(e,"bindKey",null);it(n)||(n="id");let o=ot(e,"bindParent",null);it(o)||(o="parentId");let u=ot(e,"bindBelong",null);it(u)||(u="key");let i=ot(e,"bindText",null);it(i)||(i="text");let c=ot(e,"bindType",null);it(c)||(c="type");let a=ot(e,"bindNumOfChilren",null);function f(r,e){var n,o;var u,i;return r=Ke(r),o=t=>b(t)?qe(t):t,r=(t(n=r)?X:Kr)(n,Br(o)),b(e)&&(e=qe(e)),(it(e)||We(e))&&r.push(e),i="-",null==(u=r)?"":Wr.call(u,i)}it(a)||(a="numOfChilren");let l=[];return cn(r,(t,r,e)=>{let b=f(e,r),v=f(e,null),y="node";ct(t)?y="object":ft(t)&&(y="array");let h={[n]:b,[o]:v,[c]:y};if((it(r)||function(t){return"number"==typeof t||p(t)&&"[object Number]"==s(t)}(r))&&(h[u]=r),ct(t)||ft(t)||(h[i]=t),ct(t)||ft(t)){let r=null;ct(t)?r=ce(ir(t)):ft(t)&&(r=ce(t)),h[a]=r}return l.push(h),t},{force:!0}),l}function fn(r,e){var n;return(t(r)?ae:Vr)(r,"function"==typeof(n=e)?n:Mr)}function ln(t,r,e){return null==t?t:function(t,r,e,n){if(!d(t))return t;for(var o=-1,u=(r=rt(r,t)).length,i=u-1,c=t;null!=c&&++o<u;){var a=et(r[o]),f=e;if("__proto__"===a||"constructor"===a||"prototype"===a)return t;if(o!=i){var l=c[a];void 0===(f=n?n(l,a,c):void 0)&&(f=d(l)?l:Rt(r[o+1])?[]:{})}be(c,a,f),c=c[a]}return t}(t,r,e)}function sn(t,r){return r.length<2?t:nt(t,function(t,r,e){var n=-1,o=t.length;r<0&&(r=-r>o?0:o+r),(e=e>o?o:e)<0&&(e+=o),o=r>e?0:e-r>>>0,r>>>=0;for(var u=Array(o);++n<o;)u[n]=t[n+r];return u}(r,0,-1))}var pn=Object.prototype.hasOwnProperty;function bn(t,r){var e=-1,n=(r=rt(r,t)).length;if(!n)return!0;for(;++e<n;){var o=et(r[e]);if("__proto__"===o&&!pn.call(t,"__proto__"))return!1;if(("constructor"===o||"prototype"===o)&&e<n-1)return!1}var u=sn(t,r);return null==u||delete u[et(function(t){var r=null==t?0:t.length;return r?t[r-1]:void 0}(r))]}var vn=Function.prototype,yn=Object.prototype,hn=vn.toString,dn=yn.hasOwnProperty,jn=hn.call(Object);function gn(t){return function(t){if(!p(t)||"[object Object]"!=s(t))return!1;var r=we(t);if(null===r)return!0;var e=dn.call(r,"constructor")&&r.constructor;return"function"==typeof e&&e instanceof e&&hn.call(e)==jn}(t)?void 0:t}var _n=o?o.isConcatSpreadable:void 0;function On(r){return t(r)||Ft(r)||!!(_n&&r&&r[_n])}function wn(t,r,e,n,o){var u=-1,i=t.length;for(e||(e=On),o||(o=[]);++u<i;){var c=t[u];r>0&&e(c)?r>1?wn(c,r-1,e,n,o):At(o,c):n||(o[o.length]=c)}return o}function mn(t){return(null==t?0:t.length)?wn(t,1):[]}var An=Math.max;var xn=le?function(t,r){return le(t,"toString",{configurable:!0,enumerable:!1,value:(e=r,function(){return e}),writable:!0});var e}:Mr,Sn=xn,Pn=Date.now;var zn=function(t){var r=0,e=0;return function(){var n=Pn(),o=16-(n-e);if(e=n,o>0){if(++r>=800)return arguments[0]}else r=0;return t.apply(void 0,arguments)}}(Sn),En=zn;var In=function(t){return En(function(t,r,e){return r=An(void 0===r?t.length-1:r,0),function(){for(var n=arguments,o=-1,u=An(n.length-r,0),i=Array(u);++o<u;)i[o]=n[r+o];o=-1;for(var c=Array(r+1);++o<r;)c[o]=n[o];return c[r]=e(i),function(t,r,e){switch(e.length){case 0:return t.call(r);case 1:return t.call(r,e[0]);case 2:return t.call(r,e[0],e[1]);case 3:return t.call(r,e[0],e[1],e[2])}return t.apply(r,e)}(t,this,c)}}(t,void 0,mn),t+"")}(function(t,r){var e={};if(null==t)return e;var n=!1;r=X(r,function(r){return r=rt(r,t),n||(n=r.length>1),r}),ve(t,xe(t),e),n&&(e=Ve(e,7,gn));for(var o=r.length;o--;)bn(e,r[o]);return e}),Nn=In;function Tn(t,r={}){let e="$level",n="$parents";if(!pt(t))return[];let o=ot(r,"bindKey",null);it(o)||(o="id");let u=ot(r,"bindParent",null);it(u)||(u="parentId");let i=ot(r,"bindChildren",null);it(i)||(i="children");let c=ot(r,"saveExtProps",null);bt(c)||(c=!1),t=function(t){let r=[];function i(i){let c=[];fn(t,(t,a)=>{let f=ot(t,u),l=ot(i,o);if(f&&l&&f===l){let u=ot(i,n,[]);u=Ke(u),u.push(i[o]),r.push({[e]:i[e]+1,[n]:u,...t})}else c.push(t)}),t=c}if(t=Ke(t),function(){let o=[];fn(t,(t,i)=>{st(t[u])?r.push({[e]:0,[n]:[],...t}):o.push(t)}),t=o}(),0===r.length)return r;let c=-1;for(;c+=1,!(c>r.length-1);){if(i(r[c]),0===t.length)break}return r}(t);let a=function(t){let r=[];function a(t){return c?t:Nn(t,[e,n])}let f={};return fn(t,(n,c)=>{if(0===n[e]){let t=a(n);r.push(t),f[n[o]]=[c]}else{let e=function(r){for(let e=0;e<t.length;e++){let n=t[e];if(r[u]===n[o])return n}return null}(n);if(null!==e){let t=f[e[o]];t=[...t,i];let u=ot(r,t,[]),c=a(n);u.push(c),f[n[o]]=[...t,u.length-1],ln(r,t,u)}else console.log(`can not find parent for ${ot(n,u)}`)}}),r}(t);return a}let convertToTreeWk=async function(t,r={}){return function(t,r={}){if(!at(t)&&!pt(t))return[];let e=ot(r,"bindKey",null);it(e)||(e="id");let n=ot(r,"bindParent",null);it(n)||(n="parentId");let o=ot(r,"bindText",null);it(o)||(o="text");let u=ot(r,"bindChildren",null);it(u)||(u="children");let i=ot(r,"bindType",null);it(i)||(i="type");let c=ot(r,"bindNumOfChilren",null);it(c)||(c="numOfChilren");let a=ot(r,"bindRoot",null);it(a)||(a="root");let f=ot(r,"saveExtProps",null);return bt(f)||(f=!1),it(a)&&(t={[a]:t}),Tn(an(t,{bindKey:e,bindParent:n,bindText:o,bindType:i,bindNumOfChilren:c}),{bindKey:e,bindParent:n,bindChildren:u,saveExtProps:f})}(t,r)};


let instance = null
function init(input){

    //init
    let r
    
        r = {
            main: convertToTreeWk
        }
        

    //on
    

    //save
    instance = r

}

function sendMessage(data) {
    
        self.postMessage(data)
        
}

async function run(data) {
    // console.log('inner worker run',data)

    //mode
    let mode = data.mode

    //check
    if(mode !== 'init' && mode !== 'call'){
        return
    }

    //init
    if(mode === 'init'){
        
        try{

            //type
            let type = data.type

            //input
            let input = data.input
    
            //instance
            if(type === 'function'){
                init(...input)
            }
            else if(type === 'object'){
                instance = convertToTreeWk
            }

        }
        catch(err){
        
            //sendMessage
            let res = {
                mode: 'emit',
                evName: 'error',
                msg: err,
            }
            sendMessage(res)

        }
            
    }

    //check
    if(mode === 'call'){
        let state = ''
        let msg = null

        try{

            //fun
            let fun = instance[data.fun]

            //input
            let input = data.input

            //exec
            await fun(...input)
                .then((suc) => {
                    state='success'
                    msg=suc
                })
                .catch((err) => {
                    state='error'
                    msg=err
                })

        }
        catch(err){
            state = 'error'
            msg = err
        }
        
        //sendMessage
        let res = {
            mode: 'return',
            id: data.id,
            fun: data.fun,
            state,
            msg,
        }
        sendMessage(res)

    }

}

function recvMessage(data) {
    // console.log('inner worker recv:', data)

    //dataRecv
    let dataRecv = data

    //run
    run(dataRecv)

}


        self.onmessage = function (e) {
            recvMessage(e.data)
        }
        

try{
    process.on('unhandledRejection', (err) => {
        console.log('inner:unhandledRejection', err)
    })
    process.on('uncaughtException', (err) => {
        console.log('inner:uncaughtException', err)
    })
    process.on('uncaughtExceptionMonitor', (err) => {
        console.log('inner:uncaughtExceptionMonitor', err)
    })
}
catch(err){}

");function l(){let l=new o;let I=function(d){try{let l=new Blob([d]),I=window.URL||window.webkitURL;return new Worker(I.createObjectURL(l))}catch(d){b(d)}}(d);if(!I)return b("invalid worker"),null;function m(){let d=function(){let d,l,I=new Promise(function(){d=arguments[0],l=arguments[1]});return I.resolve=d,I.reject=l,I}(),m=function(d=10){let l=[],I="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".split(""),m=I.length;for(let b=0;b<d;b++)l[b]=I[0|Math.random()*m];return l.join("")}(),b={mode:"call",id:m,fun:"main",input:[...arguments]};return I.postMessage(b),l.once(m,l=>{"success"===l.state?d.resolve(l.msg):d.reject(l.msg)}),d}function b(d){l.emit("error",d)}return I.onmessage=function(d){!function(d){let I=d,m=I.mode;"emit"!==m&&"return"!==m||("emit"===m&&l.emit(I.evName,I.msg),"return"===m&&l.emit(I.id,I))}(d.data)},I.onerror=b,I.onmessageerror=function(d){b(d.data)},function(){let d={mode:"init",type:"function",input:[...arguments]};I.postMessage(d)}([...arguments]),l.main=m,l.main=m,l.terminate=function(){I?(I.terminate(),I=void 0):b("worker has been terminated")},l}n=async function(){let d=[...arguments],I=l();return await I.main(...d).finally(()=>{I.terminate()})}}();try{process.on("unhandledRejection",d=>{console.log("outer:unhandledRejection",d)}),process.on("uncaughtException",d=>{console.log("outer:uncaughtException",d)}),process.on("uncaughtExceptionMonitor",d=>{console.log("outer:uncaughtExceptionMonitor",d)})}catch(d){}var H=n;export{H as default};

package/src/js/domResize.mjs

@@ -20,7 +20,7 @@ function domResize() {
         let id = `r${genID()}`
         el.setAttribute('ev-resize', id)
 
-        //de, 不能用vuetify的v-resize, 因是基於window resize無法偵測單純的元素尺寸變化
+        //de
         let de = domDetect(() => {
             return el
         })