首页 发现 帮助
登录
zk-platform
/
server
2
0
派生 0
文件 工单管理 0 合并请求 0 Wiki
分支: master
分支列表 标签列表
server
/
ses-app
/
ses-app-ios
/
SDK
/
Bundles
/
uni-jsframework-vue3-dev.js

uni-jsframework-vue3-dev.js 718 KB
永久链接 文件历史 原始文件

12 
  1. //{"version":"3.6.4","encode":"base64"}
    2. 

  2. var __UniServiceStartTime__ = Date.now();var global=this; var process={env:{}}; var setTimeout=global.setTimeout;
(()=>{var wI=Object.defineProperty;var SI=(v,c)=>{for(var b in c)wI(v,b,{get:c[b],enumerable:!0})};var fs=Object.freeze;function gu({getCurrentPages:v,uni:c,UniShared:b,Vue:T,VueShared:B}){var C=function(k,u,I,Ge){"use strict";function At(){let Be=v(),at=Be.length;if(at)return Be[at-1]}function tn(){let Be=At();if(Be)return Be.$vm}function A(Be,at,yt){if(u.isString(Be))yt=at,at=Be,Be=tn();else if(typeof Be=="number"){let sn=v().find(cn=>cn.$page.id===Be);sn?Be=sn.$vm:Be=tn()}if(!Be)return;if(Be.__call_hook)return Be.__call_hook(at,yt);let Zt=Be.$[at];return Zt&&I.invokeArrayFns(Zt,yt)}function se(Be,at,yt,Zt){u.isFunction(at)&&Ge.injectHook(Be,at.bind(yt),Zt)}function En(Be,at,yt){let Zt=Be.mpType||yt.$mpType;if(!!Zt&&(Object.keys(Be).forEach(sn=>{if(sn.indexOf("on")===0){let cn=Be[sn];u.isArray(cn)?cn.forEach(gr=>se(sn,gr,yt,at)):se(sn,cn,yt,at)}}),Zt==="page")){at.__isVisible=!0;try{A(yt,I.ON_LOAD,at.attrs.__pageQuery),delete at.attrs.__pageQuery,A(yt,I.ON_SHOW)}catch(sn){console.error(sn.message+I.LINEFEED+sn.stack)}}}function Gn(Be,at){bt(at,Be.$renderjs,Be["$"+I.RENDERJS_MODULES])}function bt(Be,at,yt={}){if(!u.isArray(at))return;let Zt=Be.uid,sn=Be.$wxsModules||(Be.$wxsModules=[]),cn=Be.ctx;at.forEach(gr=>{yt[gr]&&(cn[gr]=Q(Zt,yt[gr],gr),sn.push(gr))})}function Q(Be,at,yt){let Zt={};return new Proxy(Zt,{get(sn,cn){return Zt[cn]||(Zt[cn]=ae(Be,at,yt,cn))}})}function ae(Be,at,yt,Zt){let sn=()=>{},cn=()=>I.WXS_PROTOCOL+JSON.stringify([Be,at,yt+"."+Zt]);return new Proxy(sn,{get(gr,yr){return yr==="toJSON"?cn:sn[yr]||(sn[yr]=ae(Be,at,yt+"."+Zt,yr))},apply(gr,yr,Ii){return I.WXS_PROTOCOL+JSON.stringify([Be,at,yt+"."+Zt,[...Ii]])}})}function hn(Be,at){bt(at,Be.$wxs,Be["$"+I.WXS_MODULES])}function Ft(Be,at,yt){hn(Be,at),Gn(Be,at),En(Be,at,yt)}function Vt(Be,at,yt){return Be[at]=yt}function zr(Be){return function(yt,Zt,sn){if(!Zt)throw yt;let cn=Be._instance;if(!cn||!cn.proxy)throw yt;A(cn.proxy,I.ON_ERROR,yt)}}function ei(Be,at){return Be?[...new Set([].concat(Be,at))]:at}function Tr(Be){I.UniLifecycleHooks.forEach(at=>{Be[at]=ei})}let mn,Gt="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",an=/^(?:[A-Za-z\d+/]{4})*?(?:[A-Za-z\d+/]{2}(?:==)?|[A-Za-z\d+/]{3}=?)?$/;typeof atob!="function"?mn=function(Be){if(Be=String(Be).replace(/[\t\n\f\r ]+/g,""),!an.test(Be))throw new Error("Failed to execute 'atob' on 'Window': The string to be decoded is not correctly encoded.");Be+="==".slice(2-(Be.length&3));for(var at,yt="",Zt,sn,cn=0;cn<Be.length;)at=Gt.indexOf(Be.charAt(cn++))<<18|Gt.indexOf(Be.charAt(cn++))<<12|(Zt=Gt.indexOf(Be.charAt(cn++)))<<6|(sn=Gt.indexOf(Be.charAt(cn++))),yt+=Zt===64?String.fromCharCode(at>>16&255):sn===64?String.fromCharCode(at>>16&255,at>>8&255):String.fromCharCode(at>>16&255,at>>8&255,at&255);return yt}:mn=atob;function Pn(Be){return decodeURIComponent(mn(Be).split("").map(function(at){return"%"+("00"+at.charCodeAt(0).toString(16)).slice(-2)}).join(""))}function Un(){let Be=c.getStorageSync("uni_id_token")||"",at=Be.split(".");if(!Be||at.length!==3)return{uid:null,role:[],permission:[],tokenExpired:0};let yt;try{yt=JSON.parse(Pn(at[1]))}catch(Zt){throw new Error("\u83B7\u53D6\u5F53\u524D\u7528\u6237\u4FE1\u606F\u51FA\u9519\uFF0C\u8BE6\u7EC6\u9519\u8BEF\u4FE1\u606F\u4E3A\uFF1A"+Zt.message)}return yt.tokenExpired=yt.exp*1e3,delete yt.exp,delete yt.iat,yt}function ir(Be){Be.uniIDHasRole=function(at){let{role:yt}=Un();return yt.indexOf(at)>-1},Be.uniIDHasPermission=function(at){let{permission:yt}=Un();return this.uniIDHasRole("admin")||yt.indexOf(at)>-1},Be.uniIDTokenValid=function(){let{tokenExpired:at}=Un();return at>Date.now()}}function Fn(Be){let at=Be._context.config;u.isFunction(Be._component.onError)&&(at.errorHandler=zr(Be)),Tr(at.optionMergeStrategies);let yt=at.globalProperties;ir(yt),yt.$set=Vt,yt.$applyOptions=Ft,I.invokeCreateVueAppHook(Be)}return k.initApp=Fn,Object.defineProperty(k,"__esModule",{value:!0}),k}({},B,b,T);return C}function Xu(v,{nvue:c,UniShared:b,VueShared:T,VueReactivity:B}){let C={platform:c.config.env.platform,UniShared:b,VueShared:T,VueReactivity:B};return v(C,c.document)}function CI({setTimeout:v,clearTimeout:c,uni:b,getCurrentPages:T,Vue:B,weex:C,plus:k,BroadcastChannel:u,UniViewJSBridge:I,VueShared:Ge,UniShared:At}){var tn=function(A,se,En){"use strict";let Gn=["navigate","redirect","switchTab","reLaunch","navigateBack"],bt=["slide-in-right","slide-in-left","slide-in-top","slide-in-bottom","fade-in","zoom-out","zoom-fade-out","pop-in","none"],Q=["slide-out-right","slide-out-left","slide-out-top","slide-out-bottom","fade-out","zoom-in","zoom-fade-in","pop-out","none"],ae={hoverClass:{type:String,default:"navigator-hover"},url:{type:String,default:""},openType:{type:String,default:"navigate",validator(_){return Boolean(~Gn.indexOf(_))}},delta:{type:Number,default:1},hoverStartTime:{type:[Number,String],default:50},hoverStayTime:{type:[Number,String],default:600},exists:{type:String,default:""},hoverStopPropagation:{type:Boolean,default:!1},animationType:{type:String,default:"",validator(_){return!_||bt.concat(Q).includes(_)}},animationDuration:{type:[String,Number],default:300}};function hn(_){return()=>{if(_.openType!=="navigateBack"&&!_.url){console.error("<navigator/> should have url attribute when using navigateTo, redirectTo, reLaunch or switchTab");return}let F=parseInt(_.animationDuration);switch(_.openType){case"navigate":b.navigateTo({url:_.url,animationType:_.animationType||"pop-in",animationDuration:F});break;case"redirect":b.redirectTo({url:_.url,exists:_.exists});break;case"switchTab":b.switchTab({url:_.url});break;case"reLaunch":b.reLaunch({url:_.url});break;case"navigateBack":b.navigateBack({delta:_.delta,animationType:_.animationType||"pop-out",animationDuration:F});break}}}function Ft(_){if(_.hoverClass&&_.hoverClass!=="none"){let F={hoverClass:_.hoverClass};return se.hasOwn(_,"hoverStartTime")&&(F.hoverStartTime=_.hoverStartTime),se.hasOwn(_,"hoverStayTime")&&(F.hoverStayTime=_.hoverStayTime),se.hasOwn(_,"hoverStopPropagation")&&(F.hoverStopPropagation=_.hoverStopPropagation),F}return{}}function Vt(_,F){return A.createElementVNode("u-text",se.extend({appendAsTree:!0},F),_)}let zr=[{"navigator-hover":{"":{backgroundColor:"rgba(0,0,0,0.1)",opacity:.7}}}];var ei=A.defineComponent({name:"Navigator",props:ae,styles:zr,setup(_,{slots:F}){let q=hn(_);return()=>A.createVNode("view",A.mergeProps(Ft(_),{onClick:q}),[F.default&&F.default()])}});function Tr(_){return Symbol(_)}function mn(){return A.getCurrentInstance().root.proxy.$page.id}let Gt,an,Pn;function Un(){return typeof window=="object"&&typeof navigator=="object"&&typeof document=="object"?"webview":"v8"}function ir(){return Gt.webview.currentWebview().id}let Fn,Be,at={};function yt(_){let F=_.data&&_.data.__message;if(!F||!F.__page)return;let q=F.__page,W=at[q];W&&W(F),F.keep||delete at[q]}function Zt(_,F){Un()==="v8"?Pn?(Fn&&Fn.close(),Fn=new Pn(ir()),Fn.onmessage=yt):Be||(Be=an.requireModule("globalEvent"),Be.addEventListener("plusMessage",yt)):window.__plusMessage=yt,at[_]=F}class sn{constructor(F){this.webview=F}sendMessage(F){let q=JSON.parse(JSON.stringify({__message:{data:F}})),W=this.webview.id;Pn?new Pn(W).postMessage(q):Gt.webview.postMessageToUniNView&&Gt.webview.postMessageToUniNView(q,W)}close(){this.webview.close()}}function cn({context:_={},url:F,data:q={},style:W={},onMessage:ee,onClose:re}){Gt=_.plus||k,an=_.weex||(typeof C=="object"?C:null),Pn=_.BroadcastChannel||(typeof u=="object"?u:null);let pe={autoBackButton:!0,titleSize:"17px"},Ce=`page${Date.now()}`;W=se.extend({},W),W.titleNView!==!1&&W.titleNView!=="none"&&(W.titleNView=se.extend(pe,W.titleNView));let Me={top:0,bottom:0,usingComponents:{},popGesture:"close",scrollIndicator:"none",animationType:"pop-in",animationDuration:200,uniNView:{path:`/${F}.js`,defaultFontSize:16,viewport:Gt.screen.resolutionWidth}};W=se.extend(Me,W);let $e=Gt.webview.create("",Ce,W,{extras:{from:ir(),runtime:Un(),data:q,useGlobalEvent:!Pn}});return $e.addEventListener("close",re),Zt(Ce,Ae=>{se.isFunction(ee)&&ee(Ae.data),Ae.keep||$e.close("auto")}),$e.show(W.animationType,W.animationDuration),new sn($e)}let gr={for:{type:String,default:""}},yr=Tr("ul");function Ii(){let _=[];return A.provide(yr,{addHandler(F){_.push(F)},removeHandler(F){_.splice(_.indexOf(F),1)}}),_}var Pi=A.defineComponent({name:"Label",props:gr,styles:[],setup(_,{slots:F}){let q=mn(),W=Ii(),ee=re=>{_.for?I.emit(`uni-label-click-${q}-${_.for}`,re,!0):W.length&&W[0](re,!0)};return()=>A.createVNode("view",{onClick:ee},[F.default&&F.default()])}});function or(_,F){zi(_.id,F),A.watch(()=>_.id,(q,W)=>{$o(W,F,!0),zi(q,F,!0)}),A.onUnmounted(()=>{$o(_.id,F)})}function zi(_,F,q){let W=mn();q&&!_||!se.isPlainObject(F)||Object.keys(F).forEach(ee=>{q?ee.indexOf("@")!==0&&ee.indexOf("uni-")!==0&&I.on(`uni-${ee}-${W}-${_}`,F[ee]):ee.indexOf("uni-")===0?I.on(ee,F[ee]):_&&I.on(`uni-${ee}-${W}-${_}`,F[ee])})}function $o(_,F,q){let W=mn();q&&!_||!se.isPlainObject(F)||Object.keys(F).forEach(ee=>{q?ee.indexOf("@")!==0&&ee.indexOf("uni-")!==0&&I.off(`uni-${ee}-${W}-${_}`,F[ee]):ee.indexOf("uni-")===0?I.off(ee,F[ee]):_&&I.off(`uni-${ee}-${W}-${_}`,F[ee])})}function Ni(_){return Object.keys(_).map(F=>[F,_[F]])}let Wi=["class","style"],Gi=/^on[A-Z]+/,hi=(_={})=>{let{excludeListeners:F=!1,excludeKeys:q=[]}=_,W=A.getCurrentInstance(),ee=A.shallowRef({}),re=A.shallowRef({}),pe=A.shallowRef({}),Ce=q.concat(Wi);return W.attrs=A.reactive(W.attrs),A.watchEffect(()=>{let Me=Ni(W.attrs).reduce(($e,[Ae,ke])=>(Ce.includes(Ae)?$e.exclude[Ae]=ke:Gi.test(Ae)?(F||($e.attrs[Ae]=ke),$e.listeners[Ae]=ke):$e.attrs[Ae]=ke,$e),{exclude:{},attrs:{},listeners:{}});ee.value=Me.attrs,re.value=Me.listeners,pe.value=Me.exclude}),{$attrs:ee,$listeners:re,$excludeAttrs:pe}},Yi={id:{type:String,default:""},hoverClass:{type:String,default:"button-hover"},hoverStartTime:{type:[Number,String],default:20},hoverStayTime:{type:[Number,String],default:70},hoverStopPropagation:{type:Boolean,default:!1},disabled:{type:[Boolean,String],default:!1},formType:{type:String,default:""},openType:{type:String,default:""},loading:{type:[Boolean,String],default:!1},plain:{type:[Boolean,String],default:!1}},Lr=Tr("uf"),Vr=[{ub:{"":{flexDirection:"row",alignItems:"center",justifyContent:"center",position:"relative",paddingLeft:"5",paddingRight:"5",overflow:"hidden",color:"#000000",backgroundColor:"#f8f8f8",borderRadius:"5",borderStyle:"solid",borderWidth:"1",borderColor:"#dbdbdb"}},"ub-t":{"":{color:"#000000",fontSize:"18",textDecoration:"none",lineHeight:"46"}},"ub-d":{"":{backgroundColor:"#f8f8f8"}},"ub-p":{"":{backgroundColor:"#007aff",borderColor:"#0062cc"}},"ub-w":{"":{backgroundColor:"#e64340",borderColor:"#b83633"}},"ub-d-t":{"":{color:"#000000"}},"ub-p-t":{"":{color:"#ffffff"}},"ub-w-t":{"":{color:"#ffffff"}},"ub-d-d":{"":{backgroundColor:"#f7f7f7"}},"ub-p-d":{"":{backgroundColor:"#63acfc",borderColor:"#4f8aca"}},"ub-w-d":{"":{backgroundColor:"#ec8b89",borderColor:"#bd6f6e"}},"ub-d-t-d":{"":{color:"#cccccc"}},"ub-p-t-d":{"":{color:"rgba(255,255,255,0.6)"}},"ub-w-t-d":{"":{color:"rgba(255,255,255,0.6)"}},"ub-d-plain":{"":{borderColor:"#353535",backgroundColor:"rgba(0,0,0,0)"}},"ub-p-plain":{"":{borderColor:"#007aff",backgroundColor:"rgba(0,0,0,0)"}},"ub-w-plain":{"":{borderColor:"#e64340",backgroundColor:"rgba(0,0,0,0)"}},"ub-d-t-plain":{"":{color:"#353535"}},"ub-p-t-plain":{"":{color:"#007aff"}},"ub-w-t-plain":{"":{color:"#e64340"}},"ub-d-d-plain":{"":{borderColor:"#c6c6c6",backgroundColor:"rgba(0,0,0,0)"}},"ub-p-d-plain":{"":{borderColor:"#c6c6c6",backgroundColor:"rgba(0,0,0,0)"}},"ub-w-d-plain":{"":{borderColor:"#c6c6c6",backgroundColor:"rgba(0,0,0,0)"}},"ub-d-t-d-plain":{"":{color:"rgba(0,0,0,0.2)"}},"ub-p-t-d-plain":{"":{color:"rgba(0,0,0,0.2)"}},"ub-w-t-d-plain":{"":{color:"rgba(0,0,0,0.2)"}},"ub-mini":{"":{lineHeight:"30",fontSize:"13",paddingTop:0,paddingRight:"17.5",paddingBottom:0,paddingLeft:"17.5"}},"ub-loading":{"":{width:"18",height:"18",marginRight:"10"}},"ub-d-loading":{"":{color:"rgba(255,255,255,0.6)",backgroundColor:"rgba(0,0,0,0)"}},"ub-p-loading":{"":{color:"rgba(255,255,255,0.6)",backgroundColor:"rgba(0,0,0,0)"}},"ub-w-loading":{"":{color:"rgba(255,255,255,0.6)",backgroundColor:"rgba(0,0,0,0)"}},"ub-d-loading-plain":{"":{color:"#353535"}},"ub-p-loading-plain":{"":{color:"#007aff",backgroundColor:"#0062cc"}},"ub-w-loading-plain":{"":{color:"#e64340",backgroundColor:"rgba(0,0,0,0)"}},"ub-d-hover":{"":{opacity:.8,backgroundColor:"#dedede"}},"ub-p-hover":{"":{opacity:.8,backgroundColor:"#0062cc"}},"ub-w-hover":{"":{opacity:.8,backgroundColor:"#ce3c39"}},"ub-d-t-hover":{"":{color:"rgba(0,0,0,0.6)"}},"ub-p-t-hover":{"":{color:"rgba(255,255,255,0.6)"}},"ub-w-t-hover":{"":{color:"rgba(255,255,255,0.6)"}},"ub-d-hover-plain":{"":{color:"rgba(53,53,53,0.6)",borderColor:"rgba(53,53,53,0.6)",backgroundColor:"rgba(0,0,0,0)"}},"ub-p-hover-plain":{"":{color:"rgba(26,173,25,0.6)",borderColor:"rgba(0,122,255,0.6)",backgroundColor:"rgba(0,0,0,0)"}},"ub-w-hover-plain":{"":{color:"rgba(230,67,64,0.6)",borderColor:"rgba(230,67,64,0.6)",backgroundColor:"rgba(0,0,0,0)"}}}],ar={default:"d",primary:"p",warn:"w"};var Ir=A.defineComponent({inheritAttrs:!1,name:"Button",props:se.extend(Yi,{type:{type:String,default:"default"},size:{type:String,default:"default"}}),styles:Vr,setup(_,{slots:F,attrs:q}){let{$attrs:W,$excludeAttrs:ee,$listeners:re}=hi({excludeListeners:!0}),pe=_.type,Ce=A.ref(null),Me=A.inject(Lr,!1),$e=(gt,ut)=>{let Nt=re.value.onClick||(()=>{});if(_.disabled)return;Nt(gt);let pn=_.formType;if(pn){if(!Me)return;pn==="submit"?Me.submit(gt):pn==="reset"&&Me.reset(gt)}},Ae=gt=>{let ut="ub-"+ar[pe]+gt;return _.disabled&&(ut+="-d"),_.plain&&(ut+="-plain"),_.size==="mini"&&gt==="-t"&&(ut+=" ub-mini"),ut},ke=gt=>{if(_.disabled)return"";let ut="ub-"+ar[pe]+gt+"-hover";return _.plain&&(ut+="-plain"),ut},qe=A.inject(yr,!1);qe&&(qe.addHandler($e),A.onBeforeUnmount(()=>{qe.removeHandler($e)})),or(_,{"label-click":$e});let vt=A.computed(()=>{let gt={};for(let ut in re.value){let Nt=re.value[ut];ut!=="onClick"&&(gt[ut]=Nt)}return gt}),Jt=()=>{if(!F.default)return[];let gt=F.default();return gt.length===1&&gt[0].type===A.Text?[Vt(gt[0].children,{class:"ub-t "+Ae("-t")})]:gt};return()=>{let gt=se.extend({},Ft(_),{hoverClass:ke("")},W.value,ee.value,vt.value);return A.createVNode("view",A.mergeProps({ref:Ce,class:["ub",Ae("")],onClick:$e},gt),[_.loading?A.createVNode("loading-indicator",A.mergeProps({class:["ub-loading",`ub-${ar[pe]}-loading`]},{arrow:"false",animating:"true"}),null):null,...Jt()])}}});let qi={scaleArea:{type:Boolean,default:!1}};function So(_){let F=[];return se.isArray(_)&&_.forEach(q=>{A.isVNode(q)?q.type===A.Fragment?F.push(...So(q.children)):F.push(q):se.isArray(q)&&F.push(...So(q))}),F}function Co(_){let F=Object.create(null);return function(W){return F[W]||(F[W]=_(W))}}let ti=Co(function(_){let F={},q=/;(?![^(]*\))/g,W=/:(.+)/;return _.split(q).forEach(function(ee){if(ee){let re=ee.split(W);re.length>1&&(F[re[0].trim()]=re[1].trim())}}),F}),Qn=_=>new Promise((F,q)=>{if(!_)return F({width:0,height:0,top:0,left:0});C.requireModule("dom").getComponentRect(_,({size:ee})=>{F(ee)})});var pi=A.defineComponent({name:"MovableArea",props:qi,styles:[{"uni-movable-area":{"":{overflow:"hidden",width:"10px",height:"10px"}}}],setup(_,{slots:F}){let q=A.ref(0),W=A.ref(0),ee=A.ref(0),re=A.ref(0),pe=A.ref(!1),Ce=A.ref(null),Me=[],$e=null,Ae=ut=>{$e=ut},ke=()=>Qn(Ce.value).then(({width:ut,height:Nt,top:pn,left:St})=>{q.value=ut,W.value=Nt,ee.value=pn,re.value=St}),qe=()=>{ke().then(()=>{Me.forEach(function(ut){ut.setParent()})})};A.onMounted(()=>{v(()=>{pe.value=!0,qe()},200)});let vt={onPanstart(ut){$e&&$e.touchstart(ut)},onPanmove(ut){ut.stopPropagation(),$e&&$e.touchmove(ut)},onPanend(ut){$e&&$e.touchend(ut),$e=null}},Jt=ut=>{Me.push(ut)},gt=ut=>{let Nt=Me.indexOf(ut);Nt>=0&&Me.splice(Nt,1)};return A.provide("_isMounted",pe),A.provide("parentSize",{width:q,height:W,top:ee,left:re}),A.provide("addMovableViewContext",Jt),A.provide("removeMovableViewContext",gt),A.provide("setTouchMovableViewContext",Ae),()=>{let ut=F.default&&F.default(),Nt=So(ut);return A.createVNode("view",A.mergeProps({ref:Ce,class:"uni-movable-area"},vt),[Nt])}}});function ni(_){let F={};function q(Ae,ke){F[Ae]&&F[Ae](ke)}function W(Ae,ke){F[Ae]=function(qe){se.isFunction(ke)&&(qe.touches=qe.changedTouches,ke(qe)===!1&&qe.stopPropagation())}}let ee=0,re=0,pe=0,Ce=0,Me=function(Ae,ke,qe,vt){if(_({target:Ae.target,currentTarget:Ae.currentTarget,stopPropagation:Ae.stopPropagation.bind(Ae),touches:Ae.touches,changedTouches:Ae.changedTouches,detail:{state:ke,x:qe,y:vt,dx:qe-ee,dy:vt-re,ddx:qe-pe,ddy:vt-Ce,timeStamp:Ae.timeStamp||Date.now()}})===!1)return!1},$e=null;return W("touchstart",function(Ae){if(!$e)return $e=Ae,ee=pe=Ae.touches[0].pageX,re=Ce=Ae.touches[0].pageY,Me(Ae,"start",ee,re)}),W("touchmove",function(Ae){if($e){let ke=Me(Ae,"move",Ae.touches[0].pageX,Ae.touches[0].pageY);return pe=Ae.touches[0].pageX,Ce=Ae.touches[0].pageY,ke}}),W("touchend",function(Ae){if($e)return $e=null,Me(Ae,"end",Ae.changedTouches[0].pageX,Ae.changedTouches[0].pageY)}),{touchstart:function(Ae){q("touchstart",Ae)},touchmove:function(Ae){q("touchmove",Ae)},touchend:function(Ae){q("touchend",Ae)}}}function sr(_,F){return(q,W)=>{_.value&&F(q,gi(q,_.value,W||{}))}}function gi(_,F,q={}){return F=mi(F),{type:_,timeStamp:Date.now(),target:F,currentTarget:F,detail:q}}let vi=En.cacheStringFunction(_=>_.charAt(0).toLowerCase()+_.slice(1));function mi(_){let{offsetLeft:F,offsetTop:q}=_,W=_.attr,ee={};return Object.keys(W||{}).forEach(re=>{re.indexOf("data")===0&&(ee[vi(re.replace("data",""))]=W[re])}),{id:W&&W.id||"",dataset:ee,offsetLeft:F||0,offsetTop:q||0}}function Er(_,F,q){return _>F-q&&_<F+q}function Pr(_,F){return Er(_,0,F)}function Wr(){}Wr.prototype.x=function(_){return Math.sqrt(_)};function Gr(_,F){this._m=_,this._f=1e3*F,this._startTime=0,this._v=0}Gr.prototype.setV=function(_,F){let q=Math.pow(Math.pow(_,2)+Math.pow(F,2),.5);this._x_v=_,this._y_v=F,this._x_a=-this._f*this._x_v/q,this._y_a=-this._f*this._y_v/q,this._t=Math.abs(_/this._x_a)||Math.abs(F/this._y_a),this._lastDt=null,this._startTime=new Date().getTime()},Gr.prototype.setS=function(_,F){this._x_s=_,this._y_s=F},Gr.prototype.s=function(_){_===void 0&&(_=(new Date().getTime()-this._startTime)/1e3),_>this._t&&(_=this._t,this._lastDt=_);let F=this._x_v*_+.5*this._x_a*Math.pow(_,2)+this._x_s,q=this._y_v*_+.5*this._y_a*Math.pow(_,2)+this._y_s;return(this._x_a>0&&F<this._endPositionX||this._x_a<0&&F>this._endPositionX)&&(F=this._endPositionX),(this._y_a>0&&q<this._endPositionY||this._y_a<0&&q>this._endPositionY)&&(q=this._endPositionY),{x:F,y:q}},Gr.prototype.ds=function(_){return _===void 0&&(_=(new Date().getTime()-this._startTime)/1e3),_>this._t&&(_=this._t),{dx:this._x_v+this._x_a*_,dy:this._y_v+this._y_a*_}},Gr.prototype.delta=function(){return{x:-1.5*Math.pow(this._x_v,2)/this._x_a||0,y:-1.5*Math.pow(this._y_v,2)/this._y_a||0}},Gr.prototype.dt=function(){return-this._x_v/this._x_a},Gr.prototype.done=function(){let _=Er(this.s().x,this._endPositionX)||Er(this.s().y,this._endPositionY)||this._lastDt===this._t;return this._lastDt=null,_},Gr.prototype.setEnd=function(_,F){this._endPositionX=_,this._endPositionY=F},Gr.prototype.reconfigure=function(_,F){this._m=_,this._f=1e3*F};function er(_,F,q){this._m=_,this._k=F,this._c=q,this._solution=null,this._endPosition=0,this._startTime=0}er.prototype._solve=function(_,F){let q=this._c,W=this._m,ee=this._k,re=q*q-4*W*ee;if(re===0){let Ae=-q/(2*W),ke=_,qe=F/(Ae*_);return{x:function(vt){return(ke+qe*vt)*Math.pow(Math.E,Ae*vt)},dx:function(vt){let Jt=Math.pow(Math.E,Ae*vt);return Ae*(ke+qe*vt)*Jt+qe*Jt}}}if(re>0){let Ae=(-q-Math.sqrt(re))/(2*W),ke=(-q+Math.sqrt(re))/(2*W),qe=(F-Ae*_)/(ke-Ae),vt=_-qe;return{x:function(Jt){let gt,ut;return Jt===this._t&&(gt=this._powER1T,ut=this._powER2T),this._t=Jt,gt||(gt=this._powER1T=Math.pow(Math.E,Ae*Jt)),ut||(ut=this._powER2T=Math.pow(Math.E,ke*Jt)),vt*gt+qe*ut},dx:function(Jt){let gt,ut;return Jt===this._t&&(gt=this._powER1T,ut=this._powER2T),this._t=Jt,gt||(gt=this._powER1T=Math.pow(Math.E,Ae*Jt)),ut||(ut=this._powER2T=Math.pow(Math.E,ke*Jt)),vt*Ae*gt+qe*ke*ut}}}let pe=Math.sqrt(4*W*ee-q*q)/(2*W),Ce=-q/2*W,Me=_,$e=(F-Ce*_)/pe;return{x:function(Ae){return Math.pow(Math.E,Ce*Ae)*(Me*Math.cos(pe*Ae)+$e*Math.sin(pe*Ae))},dx:function(Ae){let ke=Math.pow(Math.E,Ce*Ae),qe=Math.cos(pe*Ae),vt=Math.sin(pe*Ae);return ke*($e*pe*qe-Me*pe*vt)+Ce*ke*($e*vt+Me*qe)}}},er.prototype.x=function(_){return _===void 0&&(_=(new Date().getTime()-this._startTime)/1e3),this._solution?this._endPosition+this._solution.x(_):0},er.prototype.dx=function(_){return _===void 0&&(_=(new Date().getTime()-this._startTime)/1e3),this._solution?this._solution.dx(_):0},er.prototype.setEnd=function(_,F,q){if(q||(q=new Date().getTime()),_!==this._endPosition||!Pr(F,.1)){F=F||0;let W=this._endPosition;this._solution&&(Pr(F,.1)&&(F=this._solution.dx((q-this._startTime)/1e3)),W=this._solution.x((q-this._startTime)/1e3),Pr(F,.1)&&(F=0),Pr(W,.1)&&(W=0),W+=this._endPosition),this._solution&&Pr(W-_,.1)&&Pr(F,.1)||(this._endPosition=_,this._solution=this._solve(W-this._endPosition,F),this._startTime=q)}},er.prototype.snap=function(_){this._startTime=new Date().getTime(),this._endPosition=_,this._solution={x:function(){return 0},dx:function(){return 0}}},er.prototype.done=function(_){return _||(_=new Date().getTime()),Er(this.x(),this._endPosition,.1)&&Pr(this.dx(),.1)},er.prototype.reconfigure=function(_,F,q){this._m=_,this._k=F,this._c=q,this.done()||(this._solution=this._solve(this.x()-this._endPosition,this.dx()),this._startTime=new Date().getTime())},er.prototype.springConstant=function(){return this._k},er.prototype.damping=function(){return this._c},er.prototype.configuration=function(){function _(q,W){q.reconfigure(1,W,q.damping())}function F(q,W){q.reconfigure(1,q.springConstant(),W)}return[{label:"Spring Constant",read:this.springConstant.bind(this),write:_.bind(this,this),min:100,max:1e3},{label:"Damping",read:this.damping.bind(this),write:F.bind(this,this),min:1,max:500}]};function Ki(_,F,q){this._springX=new er(_,F,q),this._springY=new er(_,F,q),this._springScale=new er(_,F,q),this._startTime=0}Ki.prototype.setEnd=function(_,F,q,W){let ee=new Date().getTime();this._springX.setEnd(_,W,ee),this._springY.setEnd(F,W,ee),this._springScale.setEnd(q,W,ee),this._startTime=ee},Ki.prototype.x=function(){let _=(new Date().getTime()-this._startTime)/1e3;return{x:this._springX.x(_),y:this._springY.x(_),scale:this._springScale.x(_)}},Ki.prototype.done=function(){let _=new Date().getTime();return this._springX.done(_)&&this._springY.done(_)&&this._springScale.done(_)},Ki.prototype.reconfigure=function(_,F,q){this._springX.reconfigure(_,F,q),this._springY.reconfigure(_,F,q),this._springScale.reconfigure(_,F,q)};let Ji={direction:{type:String,default:"none"},inertia:{type:[Boolean,String],default:!1},outOfBounds:{type:[Boolean,String],default:!1},x:{type:[Number,String],default:0},y:{type:[Number,String],default:0},damping:{type:[Number,String],default:20},friction:{type:[Number,String],default:2},disabled:{type:[Boolean,String],default:!1},scale:{type:[Boolean,String],default:!1},scaleMin:{type:[Number,String],default:.5},scaleMax:{type:[Number,String],default:10},scaleValue:{type:[Number,String],default:1},animation:{type:[Boolean,String],default:!0}};function uo(_,F){return+((1e3*_-1e3*F)/1e3).toFixed(1)}function _i(_,F,q){let W={id:0,cancelled:!1},ee=function(pe){pe&&pe.id&&Ho(pe.id),pe&&(pe.cancelled=!0)};function re(pe,Ce,Me,$e){if(!pe||!pe.cancelled){Me(Ce);let Ae=Ce.done();Ae||pe.cancelled||(pe.id=_a(re.bind(null,pe,Ce,Me,$e))),Ae&&$e&&$e(Ce)}}return re(W,_,F,q),{cancel:ee.bind(null,W),model:_}}let Ao=!1;function Uo(_){Ao||(Ao=!0,_a(function(){_(),Ao=!1}))}function _a(_){return v(_,16)}function Ho(_){c(_)}let Zi=C.requireModule("animation");var wn=A.defineComponent({name:"MovableView",props:Ji,emits:["change","scale"],styles:[{"uni-movable-view":{"":{position:"absolute",top:"0px",left:"0px",width:"10px",height:"10px"}}}],setup(_,{emit:F,slots:q}){let W=A.ref(null),ee=sr(W,F),re=A.inject("setTouchMovableViewContext",()=>{}),pe=Sn(_,ee,W,re);return()=>{let Ce={preventGesture:!0};return A.createVNode("view",A.mergeProps({ref:W,onTouchstart:pe,class:"uni-movable-view",style:"transform-origin: center;"},Ce),[q.default&&q.default()])}}});function Sn(_,F,q,W){let ee=A.inject("_isMounted",A.ref(!1)),re=A.inject("parentSize",{width:A.ref(0),height:A.ref(0),top:A.ref(0),left:A.ref(0)}),pe=A.inject("addMovableViewContext",()=>{}),Ce=A.inject("removeMovableViewContext",()=>{}),Me={touchstart:()=>{},touchmove:()=>{},touchend:()=>{}};function $e(Ue){return Number(Ue)||0}function Ae(Ue){return Ue=Number(Ue),isNaN(Ue)?1:Ue}let ke=A.ref($e(_.x)),qe=A.ref($e(_.y)),vt=A.ref(Ae(Number(_.scaleValue))),Jt=A.ref(0),gt=A.ref(0),ut=A.ref(0),Nt=A.ref(0),pn=A.ref(0),St=A.ref(0),ht=null,Lt=null,Rn={x:0,y:0},xn={x:0,y:0},Bn=1,Ln=0,Yt=0,Kn=!1,za,Wa,xo=null,Ga=null,Bo={top:0,left:0,width:0,height:0},Ya=new Wr,Bs=new Wr,An={historyX:[0,0],historyY:[0,0],historyT:[0,0]},Yo=A.computed(()=>{let Ue=Number(_.damping);return isNaN(Ue)?20:Ue}),qo=A.computed(()=>{let Ue=Number(_.friction);return isNaN(Ue)||Ue<=0?2:Ue}),qa=A.computed(()=>{let Ue=Number(_.scaleMin);return isNaN(Ue)?.5:Ue}),Ms=A.computed(()=>{let Ue=Number(_.scaleMax);return isNaN(Ue)?10:Ue}),Ka=A.computed(()=>_.direction==="all"||_.direction==="horizontal"),Di=A.computed(()=>_.direction==="all"||_.direction==="vertical"),ur=new Ki(1,9*Math.pow(Yo.value,2)/40,Yo.value),On=new Gr(1,qo.value);A.watch(()=>_.x,Ue=>{ke.value=$e(Ue)}),A.watch(()=>_.y,Ue=>{qe.value=$e(Ue)}),A.watch(()=>_.scaleValue,Ue=>{vt.value=Ae(Number(Ue))}),A.watch(ke,Ja),A.watch(qe,Aa),A.watch(vt,$r),A.watch(qa,wi),A.watch(Ms,wi);function ro(){Lt&&Lt.cancel(),ht&&ht.cancel()}function Ja(Ue){if(Ka.value){if(Ue+xn.x===Ln)return Ln;ht&&ht.cancel(),Mo(Ue+xn.x,qe.value+xn.y,Bn)}return Ue}function Aa(Ue){if(Di.value){if(Ue+xn.y===Yt)return Yt;ht&&ht.cancel(),Mo(ke.value+xn.x,Ue+xn.y,Bn)}return Ue}function wi(){if(!_.scale)return!1;vo(Bn,!0)}function $r(Ue){return _.scale?(Ue=ai(Ue),vo(Ue,!0),Ue):!1}function Sr(){_.disabled||(ro(),An.historyX=[0,0],An.historyY=[0,0],An.historyT=[0,0],Ka.value&&(za=Ln),Di.value&&(Wa=Yt),xo=null,Ga=null,Kn=!0)}function Fi(Ue){if(!_.disabled&&Kn){let It=Ln,Bt=Yt;if(Ga===null&&(Ga=Math.abs(Ue.detail.dx/Ue.detail.dy)>1?"htouchmove":"vtouchmove"),Ka.value&&(It=Ue.detail.dx+za,An.historyX.shift(),An.historyX.push(It),!Di.value&&xo===null&&(xo=Math.abs(Ue.detail.dx/Ue.detail.dy)<1)),Di.value&&(Bt=Ue.detail.dy+Wa,An.historyY.shift(),An.historyY.push(Bt),!Ka.value&&xo===null&&(xo=Math.abs(Ue.detail.dy/Ue.detail.dx)<1)),An.historyT.shift(),An.historyT.push(Ue.detail.timeStamp),!xo){let Ht="touch";It<ut.value?_.outOfBounds?(Ht="touch-out-of-bounds",It=ut.value-Ya.x(ut.value-It)):It=ut.value:It>pn.value&&(_.outOfBounds?(Ht="touch-out-of-bounds",It=pn.value+Ya.x(It-pn.value)):It=pn.value),Bt<Nt.value?_.outOfBounds?(Ht="touch-out-of-bounds",Bt=Nt.value-Bs.x(Nt.value-Bt)):Bt=Nt.value:Bt>St.value&&(_.outOfBounds?(Ht="touch-out-of-bounds",Bt=St.value+Bs.x(Bt-St.value)):Bt=St.value),Uo(function(){Ci(It,Bt,Bn,Ht)})}}}function ds(){if(!_.disabled&&Kn&&(Kn=!1,!xo&&!Za("out-of-bounds")&&_.inertia)){let Ue=1e3*(An.historyX[1]-An.historyX[0])/(An.historyT[1]-An.historyT[0]),It=1e3*(An.historyY[1]-An.historyY[0])/(An.historyT[1]-An.historyT[0]);On.setV(Ue,It),On.setS(Ln,Yt);let Bt=On.delta().x,Ht=On.delta().y,jt=Bt+Ln,it=Ht+Yt;jt<ut.value?(jt=ut.value,it=Yt+(ut.value-Ln)*Ht/Bt):jt>pn.value&&(jt=pn.value,it=Yt+(pn.value-Ln)*Ht/Bt),it<Nt.value?(it=Nt.value,jt=Ln+(Nt.value-Yt)*Bt/Ht):it>St.value&&(it=St.value,jt=Ln+(St.value-Yt)*Bt/Ht),On.setEnd(jt,it),Lt=_i(On,function(){let fn=On.s(),Br=fn.x,rr=fn.y;Ci(Br,rr,Bn,"friction")},function(){Lt.cancel()})}}function jn(Ue,It){let Bt=!1;return Ue>pn.value?(Ue=pn.value,Bt=!0):Ue<ut.value&&(Ue=ut.value,Bt=!0),It>St.value?(It=St.value,Bt=!0):It<Nt.value&&(It=Nt.value,Bt=!0),{x:Ue,y:It,outOfBounds:Bt}}function Cr(){Rn.x=Bo.left-re.left.value,Rn.y=Bo.top-re.top.value}function hs(Ue){Ue=Ue||Bn,Ue=ai(Ue),gt.value=Bo.height/Bn,Jt.value=Bo.width/Bn;let It=gt.value*Ue,Bt=Jt.value*Ue;xn.x=(Bt-Jt.value)/2,xn.y=(It-gt.value)/2}function Si(){let Ue=0-Rn.x+xn.x,It=re.width.value-Jt.value-Rn.x-xn.x;ut.value=Math.min(Ue,It),pn.value=Math.max(Ue,It);let Bt=0-Rn.y+xn.y,Ht=re.height.value-gt.value-Rn.y-xn.y;Nt.value=Math.min(Bt,Ht),St.value=Math.max(Bt,Ht)}function vo(Ue,It){if(_.scale){Ue=ai(Ue),hs(Ue),Si();let Bt=jn(Ln,Yt),Ht=Bt.x,jt=Bt.y;It?Mo(Ht,jt,Ue,"",!0,!0):Uo(function(){Ci(Ht,jt,Ue,"",!0,!0)})}}function ai(Ue){return Ue=Math.max(.5,qa.value,Ue),Ue=Math.min(10,Ms.value,Ue),Ue}function Mo(Ue,It,Bt,Ht,jt,it){ro(),Ka.value||(Ue=Ln),Di.value||(It=Yt),_.scale||(Bt=Bn);let fn=jn(Ue,It);if(Ue=fn.x,It=fn.y,!_.animation){Ci(Ue,It,Bt,Ht,jt,it);return}ur._springX._solution=null,ur._springY._solution=null,ur._springScale._solution=null,ur._springX._endPosition=Ln,ur._springY._endPosition=Yt,ur._springScale._endPosition=Bn,ur.setEnd(Ue,It,Bt,1),ht=_i(ur,function(){let Br=ur.x(),rr=Br.x,Mr=Br.y,_o=Br.scale;Ci(rr,Mr,_o,Ht,jt,it)},function(){ht.cancel()})}function Za(Ue){let It=jn(Ln,Yt),Bt=It.x,Ht=It.y,jt=It.outOfBounds;return jt&&Mo(Bt,Ht,Bn,Ue),jt}function Ci(Ue,It,Bt,Ht="",jt,it){Ue!==null&&Ue.toString()!=="NaN"&&typeof Ue=="number"||(Ue=Ln||0),It!==null&&It.toString()!=="NaN"&&typeof It=="number"||(It=Yt||0),Ue=Number(Ue.toFixed(1)),It=Number(It.toFixed(1)),Bt=Number(Bt.toFixed(1)),Ln===Ue&&Yt===It||jt||F("change",{x:uo(Ue,xn.x),y:uo(It,xn.y),source:Ht}),_.scale||(Bt=Bn),Bt=ai(Bt),Bt=+Bt.toFixed(3),it&&Bt!==Bn&&F("scale",{x:Ue,y:It,scale:Bt});let fn=`translate(${Ue}px, ${It}px) scale(${Bt})`;Zi.transition(q.value,{styles:{transform:fn},duration:0,delay:0}),Ln=Ue,Yt=It,Bn=Bt}function mo(){return Qn(q.value).then(Ue=>{Bo=Ue})}function Xa(){if(!ee.value)return;ro();let Ue=_.scale?vt.value:1;Cr(),hs(Ue),Si(),Ln=ke.value+xn.x,Yt=qe.value+xn.y;let It=jn(Ln,Yt),Bt=It.x,Ht=It.y;Ci(Bt,Ht,Ue,"",!0)}return A.onMounted(()=>{Me=ni(It=>{switch(It.detail.state){case"start":Sr();break;case"move":Fi(It);break;case"end":ds()}}),v(()=>{mo().then(()=>{Xa()})},100),On.reconfigure(1,qo.value),ur.reconfigure(1,9*Math.pow(Yo.value,2)/40,Yo.value);let Ue={setParent:Xa};pe(Ue),A.onUnmounted(()=>{Ce(Ue)})}),A.onUnmounted(()=>{ro()}),()=>{W(Me)}}let Nn=16,lr={activeColor:En.PRIMARY_COLOR,backgroundColor:"#EBEBEB",activeMode:"backwards"},Oo={percent:{type:[Number,String],default:0,validator(_){return!isNaN(parseFloat(_))}},fontSize:{type:[String,Number],default:Nn},showInfo:{type:[Boolean,String],default:!1},strokeWidth:{type:[Number,String],default:6,validator(_){return!isNaN(parseFloat(_))}},color:{type:String,default:lr.activeColor},activeColor:{type:String,default:lr.activeColor},backgroundColor:{type:String,default:lr.backgroundColor},active:{type:[Boolean,String],default:!1},activeMode:{type:String,default:lr.activeMode},duration:{type:[Number,String],default:30,validator(_){return!isNaN(parseFloat(_))}},borderRadius:{type:[Number,String],default:0}},Dt=[{"uni-progress":{"":{flex:1,flexDirection:"row",alignItems:"center"}},"uni-progress-bar":{"":{flex:1}},"uni-progress-inner-bar":{"":{position:"absolute"}},"uni-progress-info":{"":{marginLeft:"15px"}}}];var Re=A.defineComponent({name:"Progress",props:Oo,styles:Dt,emits:["activeend"],setup(_,{emit:F}){let q=A.ref(null),W=A.ref(null),ee=sr(q,F),re=Xi(_);return A.watch(()=>re.realPercent,(pe,Ce)=>{re.lastPercent=Ce||0,ri(re,_,ee)}),A.onMounted(()=>{v(()=>{Qn(W.value).then(({width:pe})=>{re.progressWidth=pe||0,ri(re,_,ee)})},50)}),()=>{let{showInfo:pe,fontSize:Ce}=_,{outerBarStyle:Me,innerBarStyle:$e,currentPercent:Ae}=re;return A.createVNode("div",{ref:q,class:"uni-progress"},[A.createVNode("div",{ref:W,style:Me,class:"uni-progress-bar"},[A.createVNode("div",{style:$e,class:"uni-progress-inner-bar"},null)]),pe?Vt(Ae+"%",{class:"uni-progress-info",style:{fontSize:Ce}}):null])}}});function Xi(_){let F=A.ref(0),q=A.ref(0),W=A.computed(()=>({backgroundColor:_.backgroundColor,borderRadius:_.borderRadius,height:_.strokeWidth})),ee=A.computed(()=>{let Ce=_.color!==lr.activeColor&&_.activeColor===lr.activeColor?_.color:_.activeColor;return{width:F.value*q.value/100,height:_.strokeWidth,backgroundColor:Ce,borderRadius:_.borderRadius}}),re=A.computed(()=>{let Ce=parseFloat(_.percent);return Ce<0&&(Ce=0),Ce>100&&(Ce=100),Ce});return A.reactive({outerBarStyle:W,innerBarStyle:ee,realPercent:re,currentPercent:F,strokeTimer:0,lastPercent:0,progressWidth:q})}function ri(_,F,q){_.strokeTimer&&clearInterval(_.strokeTimer),F.active?(_.currentPercent=F.activeMode===lr.activeMode?0:_.lastPercent,_.strokeTimer=setInterval(()=>{_.currentPercent+1>_.realPercent?(_.currentPercent=_.realPercent,_.strokeTimer&&clearInterval(_.strokeTimer),q("activeend",{})):_.currentPercent+=1},parseFloat(F.duration))):_.currentPercent=_.realPercent}let ki={value:{type:Array,default(){return[]},validator:function(_){return se.isArray(_)&&_.filter(F=>typeof F=="number").length===_.length}},indicatorStyle:{type:String,default:""},indicatorClass:{type:String,default:""},maskStyle:{type:String,default:""},maskClass:{type:String,default:""}},Qi=se.extend({},ki,{height:{type:[Number,String],default:0}});var Ri=A.defineComponent({name:"PickerView",props:Qi,emits:["change","update:value"],setup(_,{slots:F,emit:q}){let W=A.ref(null),ee=Yr(_),re=sr(W,q),pe=[],Ce=$e=>Array.prototype.indexOf.call(pe,$e),Me=$e=>A.computed({get(){let Ae=Ce($e.vnode);return ee.value[Ae]||0},set(Ae){if(!$e.data._isMounted)return;let ke=Ce($e.vnode);if(ke<0)return;if(ee.value[ke]!==Ae){ee.value[ke]=Ae;let vt=ee.value.map(Jt=>Jt);q("update:value",vt),re("change",{value:vt})}}});return A.provide("getPickerViewColumn",Me),A.provide("pickerViewProps",_),()=>{let $e=F.default&&F.default();pe=So($e);let Ae=_.height?{height:`${parseFloat(_.height)}px`}:{};return A.createVNode("view",A.mergeProps({ref:W,class:"uni-picker-view",style:Ae},{preventGesture:!0}),[A.createVNode("view",{class:"uni-picker-view-wrapper"},[$e])])}},styles:[{"uni-picker-view":{"":{position:"relative"}},"uni-picker-view-wrapper":{"":{display:"flex",flexDirection:"row",position:"absolute",top:0,left:0,right:0,bottom:0,overflow:"hidden"}}}]});function Yr(_){let F=A.reactive([..._.value]),q=A.reactive({value:F});return A.watch(()=>_.value,W=>{q.value.length=W.length,W.forEach((ee,re)=>{ee!==q.value[re]&&q.value.splice(re,1,ee)})}),q}let ia=C.requireModule("dom"),To=C.config.env.platform.toLowerCase()==="android";function Xt(_){return se.extend({},se.isString(_)?ti(_):_)}var ba=A.defineComponent({name:"PickerViewColumn",props:{length:{type:[Number,String],default:0}},data:()=>({_isMounted:!1}),setup(_,{slots:F}){let q=A.getCurrentInstance(),W=A.ref(null),ee=A.ref(null),re=A.ref(null),pe=A.ref(null),Ce=A.inject("pickerViewProps"),$e=A.inject("getPickerViewColumn")(q),Ae=A.computed(()=>Xt(Ce.indicatorStyle)),ke=A.computed(()=>Xt(Ce.maskStyle)),qe=A.ref(0);qe.value=xi(Ae.value);let vt=A.ref(0);vt.value=parseFloat(Ce.height),A.watch(()=>_.length,()=>{v(()=>{gt($e.value,!0,!0)},150)});let Jt,gt=(St,ht=!0,Lt)=>{$e.value===St&&!Lt||(ia.scrollToElement(ee.value,{offset:St*qe.value,animated:ht}),$e.value=St,ht&&(Jt=Date.now()))},ut=St=>{if(Date.now()-Jt<340)return;let ht=St.detail.contentOffset.y,Lt=Math.round(ht/qe.value);ht%qe.value?gt(Lt,!0,!0):$e.value=Lt},Nt=()=>{let St,ht;v(()=>{Promise.all([Qn(W.value).then(({height:Lt})=>{St=vt.value=Lt}),To&&_.length?Qn(re.value).then(({height:Lt})=>{ht=qe.value=Lt/parseFloat(_.length)}):Qn(pe.value).then(({height:Lt})=>{ht=qe.value=Lt})]).then(()=>{St&&ht?v(()=>{q.data._isMounted=!0,gt($e.value,!1,!0)},50):Nt()})},50)};A.onMounted(Nt);let pn=St=>St?To?A.createVNode("div",{ref:re,style:"flex-direction:column;"},[St]):St:null;return()=>{let St=F.default&&F.default(),ht=(vt.value-qe.value)/2,Lt=`${vt.value-ht}px`,Rn={showScrollbar:!1,scrollToBegin:!1,decelerationRate:.3,scrollY:!0};return To||(Rn.scrollTop=$e.value*qe.value),A.createVNode("view",{ref:W,class:"uni-picker-view-column"},[A.createVNode("scroll-view",A.mergeProps({class:"uni-picker-view-group",style:"flex-direction:column;",onScrollend:ut},Rn),[A.createVNode("view",{ref:ee,class:"uni-picker-view-content",style:{paddingTop:`${ht}px`,paddingBottom:`${ht}px`}},[pn(St)])]),A.createVNode("u-scalable",{class:"uni-picker-view-mask",style:ke.value},[A.createVNode("u-scalable",{class:"uni-picker-view-mask uni-picker-view-mask-top",style:{bottom:Lt}},null),A.createVNode("u-scalable",{class:"uni-picker-view-mask uni-picker-view-mask-bottom",style:{top:Lt}},null)]),A.createVNode("u-scalable",{ref:pe,class:"uni-picker-view-indicator",style:se.extend({},Ae.value,{top:`${ht}px`})},null)])}},styles:[{"uni-picker-view-column":{"":{flex:1,position:"relative",alignItems:"stretch",overflow:"hidden"}},"uni-picker-view-mask":{"":{position:"absolute",top:0,left:0,right:0,bottom:0,pointerEvents:"none"}},"uni-picker-view-mask-top":{"":{bottom:0,backgroundImage:"linear-gradient(to bottom,rgba(255, 255, 255, 0.95),rgba(255, 255, 255, 0.6))"}},"uni-picker-view-mask-bottom":{"":{top:0,backgroundImage:"linear-gradient(to top,rgba(255, 255, 255, 0.95),rgba(255, 255, 255, 0.6))"}},"uni-picker-view-group":{"":{position:"absolute",top:0,left:0,right:0,bottom:0}},"uni-picker-view-content":{"":{flexDirection:"column",paddingTop:0,paddingRight:0,paddingBottom:0,paddingLeft:0}},"uni-picker-view-indicator":{"":{position:"absolute",left:0,right:0,top:0,height:"34px",pointerEvents:"none",borderColor:"#e5e5e5",borderTopWidth:"1px",borderBottomWidth:"1px"}}}]});function xi(_){let q=(_.height||_.lineHeight||"").match(/(-?[\d\.]+)px/),W=0;return q&&(W=parseFloat(q[1])),W}let un={SELECTOR:"selector",MULTISELECTOR:"multiSelector",TIME:"time",DATE:"date"},qr={YEAR:"year",MONTH:"month",DAY:"day"};function Bi(_){return _>9?_:`0${_}`}function Yn(_,F){_=String(_||"");let q=new Date;if(F===un.TIME){let W=_.split(":");W.length===2&&q.setHours(parseInt(W[0]),parseInt(W[1]))}else{let W=_.split("-");W.length===3&&q.setFullYear(parseInt(W[0]),parseInt(String(parseFloat(W[1])-1)),parseInt(W[2]))}return q}function Io(_){if(_.mode===un.TIME)return"00:00";if(_.mode===un.DATE){let F=new Date().getFullYear()-100;switch(_.fields){case qr.YEAR:return F;case qr.MONTH:return F+"-01";default:return F+"-01-01"}}return""}function Fa(_){if(_.mode===un.TIME)return"23:59";if(_.mode===un.DATE){let F=new Date().getFullYear()+100;switch(_.fields){case qr.YEAR:return F;case qr.MONTH:return F+"-12";default:return F+"-12-31"}}return""}let oa={name:{type:String,default:""},range:{type:Array,default(){return[]}},rangeKey:{type:String,default:""},value:{type:[Number,String,Array],default:0},mode:{type:String,default:un.SELECTOR,validator(_){return Object.values(un).indexOf(_)>=0}},fields:{type:String,default:""},start:{type:String,default:Io},end:{type:String,default:Fa},disabled:{type:[Boolean,String],default:!1}};var jo=A.defineComponent({name:"Picker",props:oa,emits:["change","cancel","columnchange"],setup(_,{slots:F,emit:q}){let W=A.ref(null),ee=sr(W,q),re=A.ref(null),pe=A.ref(null),Ce=()=>{let gt=_.value;switch(_.mode){case un.MULTISELECTOR:{se.isArray(gt)||(gt=[]),se.isArray(re.value)||(re.value=[]);let ut=re.value.length=Math.max(gt.length,_.range.length);for(let Nt=0;Nt<ut;Nt++){let pn=Number(gt[Nt]),St=Number(re.value[Nt]),ht=isNaN(pn)?isNaN(St)?0:St:pn;re.value.splice(Nt,1,ht<0?0:ht)}}break;case un.TIME:case un.DATE:re.value=String(gt);break;default:{let ut=Number(gt);re.value=ut<0?0:ut;break}}},Me=gt=>{pe.value&&pe.value.sendMessage(gt)},$e=gt=>{let ut={event:"cancel"};pe.value=cn({url:"__uniapppicker",data:gt,style:{titleNView:!1,animationType:"none",animationDuration:0,background:"rgba(0,0,0,0)",popGesture:"none"},onMessage:Nt=>{let pn=Nt.event;if(pn==="created"){Me(gt);return}if(pn==="columnchange"){delete Nt.event,ee(pn,Nt);return}ut=Nt},onClose:()=>{pe.value=null;let Nt=ut.event;delete ut.event,Nt&&ee(Nt,ut)}})},Ae=gt=>{k.nativeUI[_.mode===un.TIME?"pickTime":"pickDate"](ut=>{let Nt=ut.date;ee("change",{value:_.mode===un.TIME?`${Bi(Nt.getHours())}:${Bi(Nt.getMinutes())}`:`${Nt.getFullYear()}-${Bi(Nt.getMonth()+1)}-${Bi(Nt.getDate())}`})},()=>{ee("cancel",{})},_.mode===un.TIME?{time:Yn(_.value,un.TIME)}:{date:Yn(_.value,un.DATE),minDate:Yn(_.start,un.DATE),maxDate:Yn(_.end,un.DATE)})},ke=gt=>{(gt.mode===un.TIME||gt.mode===un.DATE)&&!gt.fields?Ae():(gt.fields=Object.values(qr).includes(gt.fields)?gt.fields:qr.DAY,$e(gt))},qe=gt=>{_.disabled||ke(se.extend({},_,{value:re.value,locale:b.getLocale()}))},vt=A.inject(Lr,!1),Jt={submit:()=>[_.name,re.value],reset:()=>{switch(_.mode){case un.SELECTOR:re.value=0;break;case un.MULTISELECTOR:se.isArray(_.value)&&(re.value=_.value.map(gt=>0));break;case un.DATE:case un.TIME:re.value="";break}}};return vt&&(vt.addField(Jt),A.onBeforeUnmount(()=>vt.removeField(Jt))),Object.keys(_).forEach(gt=>{A.watch(()=>_[gt],ut=>{let Nt={};Nt[gt]=ut,Me(Nt)},{deep:!0})}),A.watch(()=>_.value,Ce,{deep:!0}),Ce(),()=>A.createVNode("view",{ref:W,onClick:qe},[F.default&&F.default()])}});let aa={name:{type:String,default:""},min:{type:[Number,String],default:0},max:{type:[Number,String],default:100},value:{type:[Number,String],default:0},step:{type:[Number,String],default:1},disabled:{type:[Boolean,String],default:!1},color:{type:String,default:"#e9e9e9"},backgroundColor:{type:String,default:"#e9e9e9"},activeColor:{type:String,default:"#007aff"},selectedColor:{type:String,default:"#007aff"},blockColor:{type:String,default:"#ffffff"},blockSize:{type:[Number,String],default:28},showValue:{type:[Boolean,String],default:!1}},ya=[{"uni-slider":{"":{flex:1,flexDirection:"column",marginTop:"12",marginRight:0,marginBottom:"12",marginLeft:0,paddingTop:0,paddingRight:0,paddingBottom:0,paddingLeft:0}},"uni-slider-wrapper":{"":{flexDirection:"row",alignItems:"center",minHeight:"30"}},"uni-slider-tap-area":{"":{position:"relative",flex:1,flexDirection:"column",paddingTop:"15",paddingRight:0,paddingBottom:"15",paddingLeft:0}},"uni-slider-handle-wrapper":{"":{position:"relative",marginTop:0,marginRight:"18",marginBottom:0,marginLeft:"18",height:"2",borderRadius:"5",backgroundColor:"#e9e9e9",transitionProperty:"backgroundColor",transitionDuration:300,transitionTimingFunction:"ease"}},"uni-slider-track":{"":{height:"2",borderRadius:"6",backgroundColor:"#007aff",transitionProperty:"backgroundColor",transitionDuration:300,transitionTimingFunction:"ease"}},"uni-slider-thumb":{"":{position:"absolute",width:"28",height:"28",borderRadius:50,boxShadow:"0 0 4px #ebebeb",transitionProperty:"borderColor",transitionDuration:300,transitionTimingFunction:"ease"}},"uni-slider-step":{"":{position:"absolute",width:100,height:"2",background:"transparent"}},"uni-slider-value":{"":{color:"#888888",fontSize:"14",marginLeft:"14"}}}];var Nr=A.defineComponent({name:"USlider",props:aa,styles:ya,setup(_,{emit:F}){let q=A.ref(null),W=A.ref(null),ee=sr(q,F),re=kr(_),pe=kn(_,re,ee);return cr(_,re),A.watch(()=>_.value,Ce=>{re.sliderValue=Number(Ce)}),A.onMounted(()=>{v(()=>{Qn(q.value).then(({width:Ce})=>{re.sliderWidth=Ce||0,re.sliderValue=Number(_.value)})},100)}),()=>{let{showValue:Ce}=_,{trackStyle:Me,trackActiveStyle:$e,thumbStyle:Ae,sliderValue:ke}=re;return A.createVNode("div",{class:"uni-slider",ref:q},[A.createVNode("div",{class:"uni-slider-wrapper"},[A.createVNode("div",A.mergeProps({class:"uni-slider-tap-area"},pe),[A.createVNode("div",{class:"uni-slider-handle-wrapper",ref:W,style:Me},[A.createVNode("div",{class:"uni-slider-track",style:$e},null)]),A.createVNode("div",{class:"uni-slider-thumb",style:Ae},null)]),Ce?Vt(ke+"",{class:"uni-slider-value"}):null])])}}});function kr(_){let F=A.ref(0),q=A.ref(0),W=()=>_.backgroundColor!=="#e9e9e9"?_.backgroundColor:_.color!=="#007aff"?_.color:"#007aff",ee=()=>_.activeColor!=="#007aff"?_.activeColor:_.selectedColor!=="#e9e9e9"?_.selectedColor:"#e9e9e9",re=()=>{let Ce=Number(_.max),Me=Number(_.min);return(q.value-Me)/(Ce-Me)*F.value};return A.reactive({sliderWidth:F,sliderValue:q,trackStyle:A.computed(()=>({backgroundColor:W()})),trackActiveStyle:A.computed(()=>({backgroundColor:ee(),width:re()})),thumbStyle:A.computed(()=>({width:_.blockSize,height:_.blockSize,marginTop:-_.blockSize/2,left:re(),backgroundColor:_.blockColor}))})}function kn(_,F,q){let W=null;function ee(Ce,Me){_.disabled||(Ce==="move"?(re(Me),q("changing",{value:F.sliderValue})):Ce==="end"&&(re(Me),q("change",{value:F.sliderValue})))}function re(Ce){Ce<0&&(Ce=0),Ce>F.sliderWidth&&(Ce=F.sliderWidth);let Me=Number(_.max),$e=Number(_.min),Ae=Number(_.step),ke=Ce/F.sliderWidth*Me-$e;Ae>0&&ke>Ae&&ke%Ae/Ae!==0&&(ke-=ke%Ae),F.sliderValue=ke+$e}return{onTouchstart(Ce){Ce.changedTouches.length===1&&!W&&(W=Ce,ee("start",Ce.changedTouches[0].pageX))},onTouchmove(Ce){Ce.changedTouches.length===1&&W&&ee("move",Ce.changedTouches[0].pageX)},onTouchend(Ce){Ce.changedTouches.length===1&&W&&(W=null,ee("end",Ce.changedTouches[0].pageX))}}}function cr(_,F){let q=A.inject(Lr,!1),W={submit:()=>{let ee=["",null];return _.name&&(ee[0]=_.name,ee[1]=F.sliderValue),ee},reset:()=>{F.sliderValue=Number(_.value)}};q&&(q.addField(W),A.onUnmounted(()=>{q.removeField(W)}))}let vr={name:{type:String,default:""},checked:{type:[Boolean,String],default:!1},type:{type:String,default:"switch"},id:{type:String,default:""},disabled:{type:[Boolean,String],default:!1},color:{type:String,default:"#007aff"}},eo={switch:"switch",checkbox:"checkbox"},zo={width:52,height:32};var La=A.defineComponent({name:"Switch",props:vr,emits:["change"],setup(_,{emit:F}){let q=A.ref(null),W=A.ref(_.checked),ee=Ea(_,W),re=sr(q,F);A.watch(()=>_.checked,Me=>{W.value=Me});let pe={onChange(Me){W.value=Me.detail.value,re("change",{value:W.value})}},Ce=(Me,$e)=>{_.disabled||(W.value=!W.value,re("change",{value:W.value}))};return ee&&(ee.addHandler(Ce),A.onBeforeUnmount(()=>{ee.removeHandler(Ce)})),or(_,{"label-click":Ce}),()=>{let{color:Me,type:$e}=_;return A.createVNode("div",{ref:q},[$e===eo.switch?A.createVNode("dc-switch",A.mergeProps({dataUncType:"uni-switch"},pe,{checked:W.value,color:Me},{style:zo}),null):null,$e===eo.checkbox?A.createVNode(A.resolveComponent("checkbox"),A.mergeProps({style:{color:Me}},{checked:W.value},pe),null):null])}}});function Ea(_,F){let q=A.inject(Lr,!1),W=A.inject(yr,!1),ee={submit:()=>{let re=["",null];return _.name&&(re[0]=_.name,re[1]=F.value),re},reset:()=>{F.value=!1}};return q&&(q.addField(ee),A.onUnmounted(()=>{q.removeField(ee)})),W}let to={checked:{type:[Boolean,String],default:!1},id:{type:String,default:""},disabled:{type:[Boolean,String],default:!1},color:{type:String,default:"#007aff"},value:{type:String,default:""}},Kr=Tr("ucg"),Mi={name:{type:String,default:""}},Wo=[{"uni-checkbox":{"":{flexDirection:"row",alignItems:"center"}},"uni-checkbox-input":{"":{justifyContent:"center",alignItems:"center",position:"relative",borderWidth:"1",borderColor:"#d1d1d1",borderStyle:"solid",backgroundColor:"#ffffff",borderRadius:"3",width:"22",height:"22"}},"uni-icon":{"":{fontFamily:"unincomponents",fontSize:"16",marginLeft:"2",marginTop:"2",color:"#007aff"}},"uni-checkbox-input-disabled":{"":{backgroundColor:"#e1e1e1"}},"uni-checkbox-input-disabled-before":{"":{color:"#adadad"}},"uni-checkbox-slot":{"":{fontSize:"16",marginLeft:"5"}}}];var ii=A.defineComponent({name:"Checkbox",props:to,styles:Wo,setup(_,{slots:F}){let q=A.ref(null),W=A.ref(_.checked),ee=A.ref(_.value),re=A.computed(()=>_.disabled?"#adadad":_.color),pe=()=>{W.value=!1},Ce=(ke,qe)=>{_.disabled||(W.value=!W.value,Me&&Me.checkboxChange(ke))},{uniCheckGroup:Me,uniLabel:$e}=bi(W,ee,pe);$e&&($e.addHandler(Ce),A.onBeforeUnmount(()=>{$e.removeHandler(Ce)})),or(_,{"label-click":Ce}),A.watch([()=>_.checked,()=>_.value],([ke,qe])=>{W.value=ke,ee.value=qe});let Ae=()=>{if(!F.default)return[];let ke=F.default();return ke.length===1&&ke[0].type===Text?[Vt(ke[0].children,{class:"uni-checkbox-slot"})]:ke};return()=>A.createVNode("div",A.mergeProps({ref:q},{dataUncType:"uni-checkbox"},{onClick:Ce,class:"uni-checkbox"}),[A.createVNode("div",{class:["uni-checkbox-input",{"uni-checkbox-input-disabled":_.disabled}]},[W.value?Vt("\uEA08",{class:"uni-icon",style:{color:re.value}}):null]),...Ae()])}});function bi(_,F,q){let W=A.computed(()=>({checkboxChecked:Boolean(_.value),value:F.value})),ee={reset:q},re=A.inject(Kr,!1);re&&re.addField(W);let pe=A.inject(Lr,!1);pe&&pe.addField(ee);let Ce=A.inject(yr,!1);return A.onBeforeUnmount(()=>{re&&re.removeField(W),pe&&pe.removeField(ee)}),{uniCheckGroup:re,uniForm:pe,uniLabel:Ce}}var tr=A.defineComponent({name:"CheckboxGroup",props:Mi,emits:["change"],setup(_,{slots:F,emit:q}){let W=A.ref(null),ee=sr(W,q);return wr(_,ee),()=>A.createVNode("div",{ref:W,class:"uni-checkbox-group"},[F.default&&F.default()])}});function wr(_,F){let q=[],W=()=>q.reduce((re,pe)=>(pe.value.checkboxChecked&&re.push(pe.value.value),re),new Array);A.provide(Kr,{addField(re){q.push(re)},removeField(re){q.splice(q.indexOf(re),1)},checkboxChange(re){F("change",{value:W()})}});let ee=A.inject(Lr,!1);return ee&&ee.addField({submit:()=>{let re=["",null];return _.name!==""&&(re[0]=_.name,re[1]=W()),re}}),W}let D={checked:{type:[Boolean,String],default:!1},id:{type:String,default:""},disabled:{type:[Boolean,String],default:!1},color:{type:String,default:"#007aff"},value:{type:String,default:""}},ie=Tr("ucg"),be={name:{type:String,default:""}},G=[{"uni-radio":{"":{alignItems:"center",flexDirection:"row"}},"uni-radio-input":{"":{position:"relative",alignItems:"center",justifyContent:"center",marginRight:"5",borderStyle:"solid",borderWidth:"1",borderColor:"#d1d1d1",borderRadius:50,width:"22",height:"22",outline:0}},"uni-radio-input-icon":{"":{fontFamily:"unincomponents",fontSize:"14",color:"#ffffff"}},"uni-radio-input-disabled":{"":{backgroundColor:"#e1e1e1",borderColor:"#d1d1d1",color:"#adadad"}},"uni-radio-slot":{"":{fontSize:"16",marginLeft:"5"}}}];var V=A.defineComponent({name:"Radio",props:D,styles:G,emits:["change"],setup(_,{slots:F}){let q=A.ref(null),W=A.ref(_.checked),ee=A.ref(_.value),re=A.computed(()=>{let qe=_.disabled?"#adadad":_.color;return W.value?{backgroundColor:qe,borderColor:qe}:{borderColor:"#d1d1d1"}}),pe=()=>{W.value=!1},{uniCheckGroup:Ce,uniLabel:Me,field:$e}=J(W,ee,pe),Ae=(qe,vt)=>{_.disabled||(W.value=!W.value,Ce&&Ce.radioChange(qe,$e))};Me&&(Me.addHandler(Ae),A.onBeforeUnmount(()=>{Me.removeHandler(Ae)})),or(_,{"label-click":Ae}),A.watch([()=>_.checked,()=>_.value],([qe,vt])=>{W.value=qe,ee.value=vt});let ke=()=>{if(!F.default)return[];let qe=F.default();return qe.length===1&&qe[0].type===Text?[Vt(qe[0].children,{class:"uni-radio-slot"})]:qe};return()=>{let{disabled:qe}=_;return A.createVNode("div",A.mergeProps({ref:q},{dataUncType:"uni-radio"},{onClick:Ae,class:"uni-radio"}),[A.createVNode("div",{style:re.value,class:["uni-radio-input",{"uni-radio-input-disabled":qe}]},[W.value?Vt("\uEA08",{class:"uni-radio-input-icon"}):null]),...ke()])}}});function J(_,F,q){let W=A.computed({get:()=>({radioChecked:Boolean(_.value),value:F.value}),set:({radioChecked:Me})=>{_.value=Me}}),ee={reset:q},re=A.inject(ie,!1);re&&re.addField(W);let pe=A.inject(Lr,!1);pe&&pe.addField(ee);let Ce=A.inject(yr,!1);return A.onBeforeUnmount(()=>{re&&re.removeField(W),pe&&pe.removeField(ee)}),{uniCheckGroup:re,uniForm:pe,uniLabel:Ce,field:W}}var Z=A.defineComponent({name:"RadioGroup",props:be,emits:["change"],setup(_,{slots:F,emit:q}){let W=A.ref(null),ee=sr(W,q);return ge(_,ee),()=>A.createVNode("div",{ref:W},[F.default&&F.default()])}});function ge(_,F){let q=[];A.onMounted(()=>{Ce(q.length-1)});let W=()=>{var Me;return(Me=q.find($e=>$e.value.radioChecked))==null?void 0:Me.value.value};A.provide(ie,{addField(Me){q.push(Me)},removeField(Me){q.splice(q.indexOf(Me),1)},radioChange(Me,$e){let Ae=q.indexOf($e);Ce(Ae,!0),F("change",{value:W()})}});let ee=A.inject(Lr,!1),re={submit:()=>{let Me=["",null];return _.name!==""&&(Me[0]=_.name,Me[1]=W()),Me}};ee&&(ee.addField(re),A.onBeforeUnmount(()=>{ee.removeField(re)}));function pe(Me,$e){Me.value={radioChecked:$e,value:Me.value.value}}function Ce(Me,$e){q.forEach((Ae,ke)=>{ke!==Me&&$e&&pe(q[ke],!1)})}return q}let zt=["u-input","u-textarea"];var Cn=A.defineComponent({name:"Form",emits:["submit","reset"],setup({},{slots:_,emit:F}){let q=A.ref(null),W=sr(q,F),ee=[],re;return A.provide(Lr,{addField(pe){ee.push(pe)},removeField(pe){ee.splice(ee.indexOf(pe),1)},submit(pe){let Ce={};re&&re(Ce);let Me=ee.reduce(($e,Ae)=>{if(Ae.submit){let[ke,qe]=Ae.submit();ke&&($e[ke]=qe)}return $e},Object.create(null));Object.assign(Ce,Me),W("submit",{value:Ce})},reset(pe){re&&re(),ee.forEach(Ce=>Ce.reset&&Ce.reset()),W("reset",pe)}}),()=>{let pe=_.default&&_.default();return re=_n(pe),A.createVNode("view",{ref:q},[pe])}}});function _n(_){let F=C.requireModule("plus"),q=(W,ee)=>{(ee||_||[]).forEach(function(re){zt.indexOf(String(re.type))>=0&&re.el&&re.el.attr&&re.el.attr.name&&(W?W[re.el.attr.name]=F.getValue(re.el.nodeId):re.el.setValue("")),se.isArray(re.children)&&re.children&&re.children.length&&q(W,re.children)})};return q}let mr={type:{type:String,default:""},size:{type:[String,Number],default:23},color:{type:String,default:""}},qn={success:"#09bb07",info:"#10aeff",warn:"#f76260",waiting:"#10aeff",safe_success:"#09bb07",safe_warn:"#ffbe00",success_circle:"#09bb07",success_no_circle:"#09bb07",waiting_circle:"#10aeff",circle:"#c9c9c9",download:"#09bb07",info_circle:"#09bb07",cancel:"#f43530",search:"#b2b2b2",clear:"#b2b2b2"},Va={success:"\uEA06",info:"\uEA03",warn:"\uEA0B",waiting:"\uEA09",safe_success:"\uEA04",safe_warn:"\uEA05",success_circle:"\uEA07",success_no_circle:"\uEA08",waiting_circle:"\uEA0A",circle:"\uEA01",download:"\uEA02",info_circle:"\uEA0C",cancel:"\uEA0D",search:"\uEA0E",clear:"\uEA0F"},Po=[{"uni-icon":{"":{fontFamily:"unincomponents"}}}];var No=A.defineComponent({name:"Icon",props:mr,styles:Po,setup(_,{}){return()=>Vt(Va[_.type],{class:"uni-icon",style:{color:_.color||qn[_.type],fontSize:_.size}})}});let sa={indicatorDots:{type:[Boolean,String],default:!1},vertical:{type:[Boolean,String],default:!1},autoplay:{type:[Boolean,String],default:!1},circular:{type:[Boolean,String],default:!1},interval:{type:[Number,String],default:5e3},duration:{type:[Number,String],default:500},current:{type:[Number,String],default:0},indicatorColor:{type:String,default:"rgba(0,0,0,.3)"},indicatorActiveColor:{type:String,default:"#000000"},previousMargin:{type:String,default:""},nextMargin:{type:String,default:""},currentItemId:{type:String,default:""},skipHiddenItemLayout:{type:[Boolean,String],default:!1},displayMultipleItems:{type:[Number,String],default:1},disableTouch:{type:[Boolean,String],default:!1}},$a=C.config.env.platform.toLowerCase()==="android",Ua=[{"uni-swiper":{"":{position:"relative",height:"150px"}},"uni-swiper-slider":{"":{position:"absolute",left:0,top:0,right:0,bottom:0}},"uni-swiper-dots":{"":{position:"absolute",left:0,right:0,bottom:"10",height:"10"}}}];var Cs=A.defineComponent({name:"Swiper",props:sa,styles:Ua,emits:["change","transition","animationfinish"],setup(_,{slots:F,emit:q}){let W=A.ref(null),ee=[],re=sr(W,q),pe=la(_),Ce=Go(pe,_,ee,re);return A.watch([()=>_.current,()=>_.currentItemId],([Me,$e])=>{oi(pe,_,ee)}),A.onMounted(()=>{v(()=>{Qn(W.value).then(({width:Me,height:$e})=>{pe.swiperWidth=Me,pe.swiperHeight=$e})},50)}),()=>{let Me=F.default&&F.default(),{indicatorStyle:$e,currentSync:Ae}=pe;return ee=So(Me),A.createVNode("div",{ref:W,class:"uni-swiper"},[A.createVNode("slider",A.mergeProps({class:"uni-swiper-slider"},{autoPlay:_.autoplay,interval:_.interval,index:Ae,keepIndex:!0,showIndicators:_.indicatorDots,infinite:_.circular,vertical:_.vertical,scrollable:!_.disableTouch},Ce),[ee,A.createVNode("indicator",{class:"uni-swiper-dots",style:$e},null)])])}}});function la(_){let F=A.ref(0),q=A.ref(0),W=A.ref(_.current),ee=A.ref("autoplay"),re=A.computed(()=>({itemColor:_.indicatorColor,itemSelectedColor:_.indicatorActiveColor,itemSize:8,opacity:_.indicatorDots?1:0}));return A.reactive({swiperWidth:F,swiperHeight:q,indicatorStyle:re,currentSync:W,currentChangeSource:ee})}function Go(_,F,q,W){let ee=0,re=Ae=>{let ke=Ae.detail,qe=F.vertical,vt=(qe?ke.offsetYRatio:ke.offsetXRatio)||0;if((Ae.drag||Ae.drag)&&(_.currentChangeSource="touch"),vt===0){let Jt=Math.abs(ee);if(Jt===1)return;Jt>.5&&(vt=1)}ee=vt,W("transition",{dx:qe?0:-_.swiperWidth*vt,dy:qe?-_.swiperHeight*vt:0})},pe=Ae=>{let ke=()=>{W("animationfinish",Me()),_.currentChangeSource="autoplay"};$a?ke():v(ke,50)},Ce=Ae=>{se.isString(Ae.detail.source)&&(_.currentChangeSource=Ae.detail.source),_.currentSync=Ae.detail.index,ee=0};function Me(){let Ae=Number(_.currentSync),ke=q[Ae]||{},qe=ke.componentInstance&&ke.componentInstance.itemId||"";return{current:Ae,currentItemId:qe,source:_.currentChangeSource}}return A.watch(()=>_.currentSync,Ae=>{W("change",Me())}),{onScroll:re,onScrollend:pe,onChange:Ce}}function oi(_,F,q){let W=-1;if(F.currentItemId)for(let ee=0,re=q;ee<re.length;ee++){let pe=re[ee].componentInstance;if(pe&&pe.itemId===F.currentItemId){W=ee;break}}W<0&&(W=Math.round(Number(F.current))||0),W=W<0?0:W,_.currentSync!==W&&(_.currentChangeSource="",_.currentSync=W)}let yi={itemId:{type:String,default:""}};var wa=A.defineComponent({name:"SwiperItem",props:yi,setup(_,{slots:F}){return()=>A.createVNode("div",{class:"uni-swiper-item",style:{position:"absolute",left:0,top:0,right:0,bottom:0,overflow:"hidden"}},[F.default&&F.default()])}}),nr=/^<([-A-Za-z0-9_]+)((?:\s+[a-zA-Z_:][-a-zA-Z0-9_:.]*(?:\s*=\s*(?:(?:"[^"]*")|(?:'[^']*')|[^>\s]+))?)*)\s*(\/?)>/,Rr=/^<\/([-A-Za-z0-9_]+)[^>]*>/,ko=/([a-zA-Z_:][-a-zA-Z0-9_:.]*)(?:\s*=\s*(?:(?:"((?:\\.|[^"])*)")|(?:'((?:\\.|[^'])*)')|([^>\s]+)))?/g,ca=Jr("area,base,basefont,br,col,frame,hr,img,input,link,meta,param,embed,command,keygen,source,track,wbr"),xr=Jr("a,address,article,applet,aside,audio,blockquote,button,canvas,center,dd,del,dir,div,dl,dt,fieldset,figcaption,figure,footer,form,frameset,h1,h2,h3,h4,h5,h6,header,hgroup,hr,iframe,isindex,li,map,menu,noframes,noscript,object,ol,output,p,pre,section,script,table,tbody,td,tfoot,th,thead,tr,ul,video"),As=Jr("abbr,acronym,applet,b,basefont,bdo,big,br,button,cite,code,del,dfn,em,font,i,iframe,img,input,ins,kbd,label,map,object,q,s,samp,script,select,small,span,strike,strong,sub,sup,textarea,tt,u,var"),Os=Jr("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr"),Ts=Jr("checked,compact,declare,defer,disabled,ismap,multiple,nohref,noresize,noshade,nowrap,readonly,selected"),Is=Jr("script,style");function Zs(_,F){var q,W,ee,re=[],pe=_;for(re.last=function(){return this[this.length-1]};_;){if(W=!0,!re.last()||!Is[re.last()]){if(_.indexOf("<!--")==0?(q=_.indexOf("-->"),q>=0&&(F.comment&&F.comment(_.substring(4,q)),_=_.substring(q+3),W=!1)):_.indexOf("</")==0?(ee=_.match(Rr),ee&&(_=_.substring(ee[0].length),ee[0].replace(Rr,$e),W=!1)):_.indexOf("<")==0&&(ee=_.match(nr),ee&&(_=_.substring(ee[0].length),ee[0].replace(nr,Me),W=!1)),W){q=_.indexOf("<");var Ce=q<0?_:_.substring(0,q);_=q<0?"":_.substring(q),F.chars&&F.chars(Ce)}}else _=_.replace(new RegExp("([\\s\\S]*?)</"+re.last()+"[^>]*>"),function(Ae,ke){return ke=ke.replace(/<!--([\s\S]*?)-->|<!\[CDATA\[([\s\S]*?)]]>/g,"$1$2"),F.chars&&F.chars(ke),""}),$e("",re.last());if(_==pe)throw"Parse Error: "+_;pe=_}$e();function Me(Ae,ke,qe,vt){if(ke=ke.toLowerCase(),xr[ke])for(;re.last()&&As[re.last()];)$e("",re.last());if(Os[ke]&&re.last()==ke&&$e("",ke),vt=ca[ke]||!!vt,vt||re.push(ke),F.start){var Jt=[];qe.replace(ko,function(gt,ut){var Nt=arguments[2]?arguments[2]:arguments[3]?arguments[3]:arguments[4]?arguments[4]:Ts[ut]?ut:"";Jt.push({name:ut,value:Nt,escaped:Nt.replace(/(^|[^\\])"/g,'$1\\"')})}),F.start&&F.start(ke,Jt,vt)}}function $e(Ae,ke){if(ke)for(var qe=re.length-1;qe>=0&&re[qe]!=ke;qe--);else var qe=0;if(qe>=0){for(var vt=re.length-1;vt>=qe;vt--)F.end&&F.end(re[vt]);re.length=qe}}}function Jr(_){for(var F={},q=_.split(","),W=0;W<q.length;W++)F[q[W]]=!0;return F}function Ei(_){return _.replace(/<\?xml.*\?>\n/,"").replace(/<!doctype.*>\n/,"").replace(/<!DOCTYPE.*>\n/,"")}function Hn(_){return _.reduce(function(F,q){let W=q.value,ee=q.name;return W.match(/ /)&&["style","src"].indexOf(ee)===-1&&(W=W.split(" ")),F[ee]?Array.isArray(F[ee])?F[ee].push(W):F[ee]=[F[ee],W]:F[ee]=W,F},{})}function yl(_){_=Ei(_);let F=[],q={node:"root",children:[]};return Zs(_,{start:function(W,ee,re){let pe={name:W};if(ee.length!==0&&(pe.attrs=Hn(ee)),re){let Ce=F[0]||q;Ce.children||(Ce.children=[]),Ce.children.push(pe)}else F.unshift(pe)},end:function(W){let ee=F.shift();if(ee.name!==W&&console.error("invalid state: mismatch end tag"),F.length===0)q.children.push(ee);else{let re=F[0];re.children||(re.children=[]),re.children.push(ee)}},chars:function(W){let ee={type:"text",text:W};if(F.length===0)q.children.push(ee);else{let re=F[0];re.children||(re.children=[]),re.children.push(ee)}},comment:function(W){let ee={node:"comment",text:W},re=F[0];re.children||(re.children=[]),re.children.push(ee)}}),q.children}let Ha={nodes:{type:[Array,String],default:function(){return[]}}},fo=16;var Xs=A.defineComponent({name:"RichText",props:Ha,setup(_){let F=A.getCurrentInstance();return()=>{let q=_.nodes;return se.isString(q)&&(q=yl(q)),A.createVNode("u-rich-text",{value:Ps(q||[],F.root,{defaultFontSize:fo})},null)}}});function Ps(_,F,q){let W=["span","a","image","img"],ee={blockquote:ke,br:gt,div:ke,dl:ke,h1:vt(2),h2:vt(1.5),h3:vt(1.17),h4:vt(1),h5:vt(.83),h6:vt(.67),hr:ke,ol:ke,p:ke,strong:Jt,table:ke,tbody:ke,tfoot:ke,thead:ke,ul:ke},re=/&(amp|gt|lt|nbsp|quot|apos);/g,pe={amp:"&",gt:">",lt:"<",nbsp:" ",quot:'"',apos:"'"},Ce={type:"span",__type:"break",attr:{value:`
`}},Me={__block:!0,__break:!0,children:[]},$e=null;function Ae(ht){let Lt=Object.create(null);if(ht.attrs){let Rn=(ht.attrs.class||"").split(" ");Object.assign(Lt,A.parseClassList(Rn,F),ti(ht.attrs.style||""))}if(ht.name==="img"||ht.name==="image"){let Rn=ht.attrs;Lt.width=Lt.width||Rn.width,Lt.height=Lt.height||Rn.height}return Lt}function ke(ht){return ht.__block=!0,ht}function qe(ht,Lt){return ht.style&&!ht.style.fontSize&&(ht.style.fontSize=q.defaultFontSize*Lt),ke(Jt(ht))}function vt(ht){return function(Lt){return qe(Lt,ht)}}function Jt(ht){return ht.style&&!ht.style.fontWeight&&(ht.style.fontWeight="bold"),ht}function gt(ht){return ht.__value=" ",ke(ht)}function ut(ht){return ht.replace(re,function(Lt,Rn){return pe[Rn]})}function Nt(ht){let Lt=(ht.name||"").toLowerCase(),Rn=Lt,xn=ee[Lt];W.indexOf(Lt)===-1&&(Lt="span"),Lt==="img"&&(Lt="image");let Bn={type:Lt,__type:Rn,attr:Object.create(null)};return(ht.type==="text"||ht.text)&&(Bn.__value=Bn.attr.value=ut((ht.text||"").trim())),ht.attrs&&Object.keys(ht.attrs).forEach(Ln=>{Ln!=="class"&&Ln!=="style"&&(Bn.attr[Ln]=ht.attrs[Ln])}),Bn.style=Ae(ht),xn&&xn(Bn),(Me.__block||Bn.__block)&&($e||(Me.children.push(Ce),$e=[Me,Ce])),Me=Bn,(Me.__value||Me.type==="image"&&Me.attr.src)&&($e=null),Bn.children=pn(ht.children),Me=Bn,Me.__block&&Me.style.height&&!/^0(px)?$/.test(Me.style.height)&&($e=null),Bn}function pn(ht){return se.isArray(ht)?ht.map(Lt=>Nt(Lt)):[]}let St=pn(_);if($e){let[ht,Lt]=$e,Rn=ht.children,xn=Rn.indexOf(Lt);Rn.splice(xn,1)}return St}let ho={};function Ns(_,F,q){let{adpid:W,width:ee}=_,re=W+"-"+ee,pe=ho[re];if(pe&&pe.length>0){F(pe.splice(0,1)[0]);return}k.ad.getAds(_,Ce=>{let Me=Ce.ads;F(Me.splice(0,1)[0]),ho[re]=pe?pe.concat(Me):Me},Ce=>{q({errCode:Ce.code,errMsg:Ce.message})})}let Sa={adpid:{type:[Number,String],default:""},data:{type:String,default:""},width:{type:String,default:""},channel:{type:String,default:""}},Ro={load:"load",close:"close",error:"error",downloadchange:"downloadchange"};var ks=A.defineComponent({name:"Ad",props:Sa,emits:[Ro.load,Ro.close,Ro.error,Ro.downloadchange],setup(_,{emit:F}){let q=A.ref(null),W=sr(q,F),ee=ja();A.watch(()=>_.adpid,pe=>{Ca(ee,_,W)}),A.watch(()=>_.data,pe=>{ee.data=pe}),A.onMounted(()=>{v(()=>{Qn(q.value).then(({width:pe})=>{ee.width=pe===0?-1:pe,Ca(ee,_,W)})},50)});let re={onDownloadchange(pe){W(Ro.downloadchange,pe)},onDislike(pe){W(Ro.close,pe)}};return()=>A.createVNode("u-ad",A.mergeProps({ref:q},{data:ee.data,rendering:!0},re),null)}});function ja(_){let F=A.ref("");return A.reactive({width:0,data:F})}function Ca(_,F,q){Ns({adpid:F.adpid,width:_.width},W=>{_.data=W,q(Ro.load,{})},W=>{q(Ro.error,W)})}let no={};function po(_,F,q,W,ee){let re=_+"-"+F,pe=no[re];if(pe&&pe.length>0){W(pe.splice(0,1)[0]);return}k.ad.getDrawAds({adpid:String(_),count:3,width:F},Ce=>{let Me=Ce.ads;W(Me.splice(0,1)[0]),no[re]=pe?pe.concat(Me):Me},Ce=>{ee({errCode:Ce.code,errMsg:Ce.message})})}let ua={adpid:{type:[Number,String],default:""},data:{type:String,default:""},width:{type:String,default:""}},go={load:"load",close:"close",error:"error"};var Rs=A.defineComponent({name:"AdDraw",props:ua,emits:[go.load,go.close,go.error],setup(_,{emit:F}){let q=A.ref(null),W=sr(q,F),ee=El();A.watch(()=>_.adpid,pe=>{xs(ee,_,W)}),A.watch(()=>_.data,pe=>{ee.data=pe});let re={onDislike(pe){W(go.close,pe)}};return A.onMounted(()=>{v(()=>{Qn(q.value).then(({width:pe,height:Ce})=>{ee.width=pe===0?-1:pe,ee.height=Ce===0?-1:Ce,xs(ee,_,W)})},50)}),()=>{let{data:pe}=ee;return A.createVNode("u-ad-draw",A.mergeProps({ref:q},{data:pe,rendering:!0},re),null)}}});function El(_){let F=A.ref("");return A.reactive({width:0,height:0,data:F})}function xs(_,F,q){po(F.adpid,_.width,_.height,W=>{_.data=W,q(go.load,{})},W=>{q(go.error,W)})}var Qs={Navigator:ei,Label:Pi,Button:Ir,MovableArea:pi,MovableView:wn,Progress:Re,PickerView:Ri,PickerViewColumn:ba,Picker:jo,USlider:Nr,Switch:La,Checkbox:ii,CheckboxGroup:tr,Radio:V,RadioGroup:Z,Form:Cn,Icon:No,Swiper:Cs,SwiperItem:wa,RichText:Xs,Ad:ks,AdDraw:Rs};return Qs}(B,Ge,At);return tn}function AI(v,c){let{UniShared:b,Vue:T}=c;function B(k,u,I){let Ge=k.$[u];return Ge&&b.invokeArrayFns(Ge,I)}let C=v.setup;return v.inheritAttrs=!1,v.setup=(k,u)=>{let{attrs:{__pageId:I,__pagePath:Ge,__pageQuery:At}}=u,tn=c.__uniRoutes.find(En=>En.meta.route===Ge),A=T.getCurrentInstance(),se=A.proxy;if(tn&&(tn.meta.isSubNVue||OI(se,c,{__pageId:I,__pagePath:Ge})),T.onMounted(()=>{T.nextTick(()=>{B(se,b.ON_READY)}),A.onPageScroll&&se.$el.addEvent("scroll",En=>{En.scrollTop=En.detail.scrollTop,B(se,b.ON_PAGE_SCROLL,En)}),A.onReachBottom&&se.$el.addEvent("scrolltolower",En=>{B(se,b.ON_REACH_BOTTOM,En)})}),T.onBeforeUnmount(()=>{B(se,b.ON_UNLOAD)}),C)return C(At,u)},v}function OI(v,c,{__pageId:b,__pagePath:T}){let B=c.getCurrentPages(),C=B[B.length-1];if(C&&C.__setup)C.__setup(v,C);else{let k="/"+T;return c.__registerPage({url:k,path:k,query:{},openType:"launch",webview:{id:b+""},nvuePageVm:v})}}var Bc={},xg;function Bg(v){xg=v}var Qu;function TI(v){if(Qu)return Qu;let c=new v.Emitter;return Qu={on(b,T){return c.on(b,T)},once(b,T){return c.once(b,T)},off(b,T){return c.off(b,T)},emit(b,...T){return c.emit(b,...T)}},Qu}function II(v){return(c,b,T)=>{let{nvue:B}=b,C=Xu(v,b);b.Vue=C,Bc[c]={instanceId:c,config:B.config,document:B.document,data:T};let{createApp:k}=C;C.createVueApp=C.createApp=(u,I)=>(b.__uniConfig.styles=u.styles||[],k(u,I).use(PI,c,b)),C.createPageApp=(u,I)=>{AI(u,b);let Ge=I.$store;delete I.$store;let At=k(u,I);return Ge&&At.use(Ge),At.use(kI,C,c,b)}}}var PI={install(v,c,b){gu(b).initApp(v),NI(v,c,b)}};function NI(v,c,b){let{mount:T}=v,B=Bc[c];return v.mount=C=>{let k=C==="#app",u=B.app=T(Mg(B.document,{isRoot:k}));return k&&b.__registerApp(u),u},v}var kI={install(v,c,b,T){let{weex:B,plus:C,BroadcastChannel:k,VueShared:u,UniShared:I,getCurrentPages:Ge,setTimeout:At,clearTimeout:tn}=T;v.config.globalProperties.$requireNativePlugin=B.requireModule;let A=CI({uni:xg,Vue:c,weex:B,plus:C,BroadcastChannel:k,UniViewJSBridge:TI(I),VueShared:u,UniShared:I,getCurrentPages:Ge,setTimeout:At,clearTimeout:tn});Object.keys(A).forEach(se=>{v.component(c.hyphenate(se),A[se])}),gu(T).initApp(v),RI(v,b,T)}};function RI(v,c,{nvue:b}){let{config:{compilerOptions:T},mount:B}=v;T.isCustomElement=k=>!!b.supports(`@component/${k}`);let C=Bc[c];return v.mount=k=>{let u=k==="#root",I=C.app=B(Mg(C.document,{isRoot:u}));if(u)try{b.document.taskCenter.send("dom",{action:"createFinish"},[])}catch(Ge){}return I},v}function Mg(v,{isRoot:c}){if(c)return v.documentElement;let b=v.createComment("root");return v.documentElement.appendChild(b),b}function Dg(v){let c=Bc[v];if(c&&c.app&&c.document){try{c.app.$.appContext.app.unmount(),c.document.destroy()}catch(b){}delete c.document,delete c.app}delete Bc[v]}function Fg(v){let c=Bc[v];if(!c||!c.app)return new Error(`refreshInstance: instance ${v} not found!`);c.document.taskCenter.send("dom",{action:"refreshFinish"},[])}function xI(v,c){let{UniShared:b,VueShared:T,VueReactivity:B}=v;var C=function(k,u,I,Ge){"use strict";var At=[];function tn(o){At.push(o)}function A(){At.pop()}function se(o){I.pauseTracking();for(var l=At.length?At[At.length-1].component:null,h=l&&l.appContext.config.warnHandler,m=En(),S=arguments.length,O=new Array(S>1?S-1:0),M=1;M<S;M++)O[M-1]=arguments[M];if(h)Ft(h,l,11,[o+O.join(""),l&&l.proxy,m.map(H=>{var{vnode:ne}=H;return"at <".concat(da(l,ne.type),">")}).join(`
`),m]);else{var Y=["[Vue warn]: ".concat(o),...O];m.length&&Y.push(`
`,...Gn(m)),console.warn(...Y)}I.resetTracking()}function En(){var o=At[At.length-1];if(!o)return[];for(var l=[];o;){var h=l[0];h&&h.vnode===o?h.recurseCount++:l.push({vnode:o,recurseCount:0});var m=o.component&&o.component.parent;o=m&&m.vnode}return l}function Gn(o){var l=[];return o.forEach((h,m)=>{l.push(...m===0?[]:[`
`],...bt(h))}),l}function bt(o){var{vnode:l,recurseCount:h}=o,m=h>0?"... (".concat(h," recursive calls)"):"",S=l.component?l.component.parent==null:!1,O=" at <".concat(da(l.component,l.type,S)),M=">"+m;return l.props?[O,...Q(l.props),M]:[O+M]}function Q(o){var l=[],h=Object.keys(o);return h.slice(0,3).forEach(m=>{l.push(...ae(m,o[m]))}),h.length>3&&l.push(" ..."),l}function ae(o,l,h){return u.isString(l)?(l=JSON.stringify(l),h?l:["".concat(o,"=").concat(l)]):typeof l=="number"||typeof l=="boolean"||l==null?h?l:["".concat(o,"=").concat(l)]:I.isRef(l)?(l=ae(o,I.toRaw(l.value),!0),h?l:["".concat(o,"=Ref<"),l,">"]):u.isFunction(l)?["".concat(o,"=fn").concat(l.name?"<".concat(l.name,">"):"")]:(l=I.toRaw(l),h?l:["".concat(o,"="),l])}var hn={sp:"serverPrefetch hook",bc:"beforeCreate hook",c:"created hook",bm:"beforeMount hook",m:"mounted hook",bu:"beforeUpdate hook",u:"updated",bum:"beforeUnmount hook",um:"unmounted hook",a:"activated hook",da:"deactivated hook",ec:"errorCaptured hook",rtc:"renderTracked hook",rtg:"renderTriggered hook",[0]:"setup function",[1]:"render function",[2]:"watcher getter",[3]:"watcher callback",[4]:"watcher cleanup function",[5]:"native event handler",[6]:"component event handler",[7]:"vnode hook",[8]:"directive hook",[9]:"transition hook",[10]:"app errorHandler",[11]:"app warnHandler",[12]:"ref function",[13]:"async component loader",[14]:"scheduler flush. This is likely a Vue internals bug. Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/core"};function Ft(o,l,h,m){var S;try{S=m?o(...m):o()}catch(O){zr(O,l,h)}return S}function Vt(o,l,h,m){if(u.isFunction(o)){var S=Ft(o,l,h,m);return S&&u.isPromise(S)&&S.catch(Y=>{zr(Y,l,h)}),S}for(var O=[],M=0;M<o.length;M++)O.push(Vt(o[M],l,h,m));return O}function zr(o,l,h){var m=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!0,S=l?l.vnode:null;if(l){for(var O=l.parent,M=l.proxy,Y=hn[h]||h;O;){var H=O.ec;if(H){for(var ne=0;ne<H.length;ne++)if(H[ne](o,M,Y)===!1)return}O=O.parent}var Ne=l.appContext.config.errorHandler;if(Ne){Ft(Ne,null,10,[o,M,Y]);return}}ei(o,h,S,m)}function ei(o,l,h){var m=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!0;{var S=hn[l]||l;if(h&&tn(h),se("Unhandled error".concat(S?" during execution of ".concat(S):"")),h&&A(),m)throw o;console.error(o)}}var Tr=!1,mn=!1,Gt=[],an=0,Pn=[],Un=null,ir=0,Fn=[],Be=null,at=0,yt=Promise.resolve(),Zt=null,sn=null,cn=100;function gr(o){var l=Zt||yt;return o?l.then(this?o.bind(this):o):l}function yr(o){for(var l=an+1,h=Gt.length;l<h;){var m=l+h>>>1,S=hi(Gt[m]);S<o?l=m+1:h=m}return l}function Ii(o){(!Gt.length||!Gt.includes(o,Tr&&o.allowRecurse?an+1:an))&&o!==sn&&(o.id==null?Gt.push(o):Gt.splice(yr(o.id),0,o),Pi())}function Pi(){!Tr&&!mn&&(mn=!0,Zt=yt.then(Yi))}function or(o){var l=Gt.indexOf(o);l>an&&Gt.splice(l,1)}function zi(o,l,h,m){u.isArray(o)?h.push(...o):(!l||!l.includes(o,o.allowRecurse?m+1:m))&&h.push(o),Pi()}function $o(o){zi(o,Un,Pn,ir)}function Ni(o){zi(o,Be,Fn,at)}function Wi(o){var l=arguments.length>1&&arguments[1]!==void 0?arguments[1]:null;if(Pn.length){for(sn=l,Un=[...new Set(Pn)],Pn.length=0,o=o||new Map,ir=0;ir<Un.length;ir++)Lr(o,Un[ir])||Un[ir]();Un=null,ir=0,sn=null,Wi(o,l)}}function Gi(o){if(Wi(),Fn.length){var l=[...new Set(Fn)];if(Fn.length=0,Be){Be.push(...l);return}for(Be=l,o=o||new Map,Be.sort((h,m)=>hi(h)-hi(m)),at=0;at<Be.length;at++)Lr(o,Be[at])||Be[at]();Be=null,at=0}}var hi=o=>o.id==null?1/0:o.id;function Yi(o){mn=!1,Tr=!0,o=o||new Map,Wi(o),Gt.sort((m,S)=>hi(m)-hi(S));var l=m=>Lr(o,m);try{for(an=0;an<Gt.length;an++){var h=Gt[an];if(h&&h.active!==!1){if(l(h))continue;Ft(h,null,14)}}}finally{an=0,Gt.length=0,Gi(o),Tr=!1,Zt=null,(Gt.length||Pn.length||Fn.length)&&Yi(o)}}function Lr(o,l){if(!o.has(l))o.set(l,1);else{var h=o.get(l);if(h>cn){var m=l.ownerInstance,S=m&&gs(m.type);return se("Maximum recursive updates exceeded".concat(S?" in component <".concat(S,">"):"",". ")+"This means you have a reactive effect that is mutating its own dependencies and thus recursively triggering itself. Possible sources include component template, render function, updated hook or watcher source function."),!0}else o.set(l,h+1)}}var Vr=!1,ar=new Set;u.getGlobalThis().__VUE_HMR_RUNTIME__={createRecord:sr(Co),rerender:sr(Qn),reload:sr(pi)};var Ir=new Map;function qi(o){var l=o.type.__hmrId,h=Ir.get(l);h||(Co(l,o.type),h=Ir.get(l)),h.instances.add(o)}function So(o){Ir.get(o.type.__hmrId).instances.delete(o)}function Co(o,l){return Ir.has(o)?!1:(Ir.set(o,{initialDef:ti(l),instances:new Set}),!0)}function ti(o){return Vs(o)?o.__vccOpts:o}function Qn(o,l){var h=Ir.get(o);!h||(h.initialDef.render=l,[...h.instances].forEach(m=>{l&&(m.render=l,ti(m.type).render=l),m.renderCache=[],Vr=!0,m.update(),Vr=!1}))}function pi(o,l){var h=Ir.get(o);if(!!h){l=ti(l),ni(h.initialDef,l);var m=[...h.instances];for(var S of m){var O=ti(S.type);ar.has(O)||(O!==h.initialDef&&ni(O,l),ar.add(O)),S.appContext.optionsCache.delete(S.type),S.ceReload?(ar.add(O),S.ceReload(l.styles),ar.delete(O)):S.parent?(Ii(S.parent.update),S.parent.type.__asyncLoader&&S.parent.ceReload&&S.parent.ceReload(l.styles)):S.appContext.reload?S.appContext.reload():typeof window!="undefined"?window.location.reload():console.warn("[HMR] Root or manually mounted instance modified. Full reload required.")}Ni(()=>{for(var M of m)ar.delete(ti(M.type))})}}function ni(o,l){u.extend(o,l);for(var h in o)h!=="__file"&&!(h in l)&&delete o[h]}function sr(o){return(l,h)=>{try{return o(l,h)}catch(m){console.error(m),console.warn("[HMR] Something went wrong during Vue component hot-reload. Full reload required.")}}}k.devtools=void 0;var gi=[],vi=!1;function mi(o){for(var l=arguments.length,h=new Array(l>1?l-1:0),m=1;m<l;m++)h[m-1]=arguments[m];k.devtools?k.devtools.emit(o,...h):vi||gi.push({event:o,args:h})}function Er(o,l){var h,m;if(k.devtools=o,k.devtools)k.devtools.enabled=!0,gi.forEach(O=>{var{event:M,args:Y}=O;return k.devtools.emit(M,...Y)}),gi=[];else if(typeof window!="undefined"&&window.HTMLElement&&!((m=(h=window.navigator)===null||h===void 0?void 0:h.userAgent)===null||m===void 0?void 0:m.includes("jsdom"))){var S=l.__VUE_DEVTOOLS_HOOK_REPLAY__=l.__VUE_DEVTOOLS_HOOK_REPLAY__||[];S.push(O=>{Er(O,l)}),setTimeout(()=>{k.devtools||(l.__VUE_DEVTOOLS_HOOK_REPLAY__=null,vi=!0,gi=[])},3e3)}else vi=!0,gi=[]}function Pr(o,l){mi("app:init",o,l,{Fragment:Ht,Text:jt,Comment:it,Static:fn})}function Wr(o){mi("app:unmount",o)}var Gr=Ji("component:added"),er=Ji("component:updated"),Ki=Ji("component:removed");function Ji(o){return l=>{mi(o,l.appContext.app,l.uid,l.parent?l.parent.uid:void 0,l)}}var uo=Ao("perf:start"),_i=Ao("perf:end");function Ao(o){return(l,h,m)=>{mi(o,l.appContext.app,l.uid,l,h,m)}}function Uo(o,l,h){mi("component:emit",o.appContext.app,o,l,h)}function _a(o,l){if(!o.isUnmounted){for(var h=o.vnode.props||u.EMPTY_OBJ,m=arguments.length,S=new Array(m>2?m-2:0),O=2;O<m;O++)S[O-2]=arguments[O];{var{emitsOptions:M,propsOptions:[Y]}=o;if(M)if(!(l in M))(!Y||!(u.toHandlerKey(l)in Y))&&se('Component emitted event "'.concat(l,'" but it is neither declared in ')+'the emits option nor as an "'.concat(u.toHandlerKey(l),'" prop.'));else{var H=M[l];if(u.isFunction(H)){var ne=H(...S);ne||se('Invalid event arguments: event validation failed for event "'.concat(l,'".'))}}}var Ne=S,fe=l.startsWith("update:"),ce=fe&&l.slice(7);if(ce&&ce in h){var Fe="".concat(ce==="modelValue"?"model":ce,"Modifiers"),{number:Ve,trim:lt}=h[Fe]||u.EMPTY_OBJ;lt&&(Ne=S.map(nt=>nt.trim())),Ve&&(Ne=S.map(u.toNumber))}Uo(o,l,Ne);{var mt=l.toLowerCase();mt!==l&&h[u.toHandlerKey(mt)]&&se('Event "'.concat(mt,'" is emitted in component ')+"".concat(da(o,o.type),' but the handler is registered for "').concat(l,'". ')+"Note that HTML attributes are case-insensitive and you cannot use v-on to listen to camelCase events when using in-DOM templates. "+'You should probably use "'.concat(u.hyphenate(l),'" instead of "').concat(l,'".'))}var we,de=h[we=u.toHandlerKey(l)]||h[we=u.toHandlerKey(u.camelize(l))];!de&&fe&&(de=h[we=u.toHandlerKey(u.hyphenate(l))]),de&&Vt(de,o,6,Ne);var Se=h[we+"Once"];if(Se){if(!o.emitted)o.emitted={};else if(o.emitted[we])return;o.emitted[we]=!0,Vt(Se,o,6,Ne)}}}function Ho(o,l){var h=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!1,m=l.emitsCache,S=m.get(o);if(S!==void 0)return S;var O=o.emits,M={},Y=!1;if(!u.isFunction(o)){var H=ne=>{var Ne=Ho(ne,l,!0);Ne&&(Y=!0,u.extend(M,Ne))};!h&&l.mixins.length&&l.mixins.forEach(H),o.extends&&H(o.extends),o.mixins&&o.mixins.forEach(H)}return!O&&!Y?(m.set(o,null),null):(u.isArray(O)?O.forEach(ne=>M[ne]=null):u.extend(M,O),m.set(o,M),M)}function Zi(o,l){return!o||!u.isOn(l)?!1:(l=l.slice(2).replace(/Once$/,""),u.hasOwn(o,l[0].toLowerCase()+l.slice(1))||u.hasOwn(o,u.hyphenate(l))||u.hasOwn(o,l))}var wn=null,Sn=null;function Nn(o){var l=wn;return wn=o,Sn=o&&o.type.__scopeId||null,l}function lr(o){Sn=o}function Oo(){Sn=null}var Dt=o=>Re;function Re(o){var l=arguments.length>1&&arguments[1]!==void 0?arguments[1]:wn;if(!l||o._n)return o;var h=function(){h._d&&Ko(-1);var m=Nn(l),S=o(...arguments);return Nn(m),h._d&&Ko(1),er(l),S};return h._n=!0,h._c=!0,h._d=!0,h}var Xi=!1;function ri(){Xi=!0}function ki(o){var{type:l,vnode:h,proxy:m,withProxy:S,props:O,propsOptions:[M],slots:Y,attrs:H,emit:ne,render:Ne,renderCache:fe,data:ce,setupState:Fe,ctx:Ve,inheritAttrs:lt}=o,mt,we,de=Nn(o);Xi=!1;try{if(h.shapeFlag&4){var Se=S||m;mt=io(Ne.call(Se,Se,fe,O,Fe,ce,Ve)),we=H}else{var nt=l;H===O&&ri(),mt=io(nt.length>1?nt(O,{get attrs(){return ri(),H},slots:Y,emit:ne}):nt(O,null)),we=l.props?H:Yr(H)}}catch(K){Br.length=0,zr(K,o,1),mt=Mn(it)}var ze=mt,i=void 0;if(mt.patchFlag>0&&mt.patchFlag&2048&&([ze,i]=Qi(mt)),we&&lt!==!1){var a=Object.keys(we),{shapeFlag:f}=ze;if(a.length){if(f&(1|6))M&&a.some(u.isModelListener)&&(we=ia(we,M)),ze=Li(ze,we);else if(!Xi&&ze.type!==it){for(var p=Object.keys(H),w=[],E=[],N=0,L=p.length;N<L;N++){var R=p[N];u.isOn(R)?u.isModelListener(R)||w.push(R[2].toLowerCase()+R.slice(3)):E.push(R)}E.length&&se("Extraneous non-props attributes ("+"".concat(E.join(", "),") ")+"were passed to component but could not be automatically inherited because component renders fragment or text root nodes."),w.length&&se("Extraneous non-emits event listeners ("+"".concat(w.join(", "),") ")+'were passed to component but could not be automatically inherited because component renders fragment or text root nodes. If the listener is intended to be a component custom event listener only, declare it using the "emits" option.')}}}return h.dirs&&(To(ze)||se("Runtime directive used on component with non-element root node. The directives will not function as intended."),ze=Li(ze),ze.dirs=ze.dirs?ze.dirs.concat(h.dirs):h.dirs),h.transition&&(To(ze)||se("Component inside <Transition> renders non-element root node that cannot be animated."),ze.transition=h.transition),i?i(ze):mt=ze,Nn(de),mt}var Qi=o=>{var l=o.children,h=o.dynamicChildren,m=Ri(l);if(!m)return[o,void 0];var S=l.indexOf(m),O=h?h.indexOf(m):-1,M=Y=>{l[S]=Y,h&&(O>-1?h[O]=Y:Y.patchFlag>0&&(o.dynamicChildren=[...h,Y]))};return[io(m),M]};function Ri(o){for(var l,h=0;h<o.length;h++){var m=o[h];if(bo(m)){if(m.type!==it||m.children==="v-if"){if(l)return;l=m}}else return}return l}var Yr=o=>{var l;for(var h in o)(h==="class"||h==="style"||u.isOn(h))&&((l||(l={}))[h]=o[h]);return l},ia=(o,l)=>{var h={};for(var m in o)(!u.isModelListener(m)||!(m.slice(9)in l))&&(h[m]=o[m]);return h},To=o=>o.shapeFlag&(6|1)||o.type===it;function Xt(o,l,h){var{props:m,children:S,component:O}=o,{props:M,children:Y,patchFlag:H}=l,ne=O.emitsOptions;if((S||Y)&&Vr||l.dirs||l.transition)return!0;if(h&&H>=0){if(H&1024)return!0;if(H&16)return m?ba(m,M,ne):!!M;if(H&8)for(var Ne=l.dynamicProps,fe=0;fe<Ne.length;fe++){var ce=Ne[fe];if(M[ce]!==m[ce]&&!Zi(ne,ce))return!0}}else return(S||Y)&&(!Y||!Y.$stable)?!0:m===M?!1:m?M?ba(m,M,ne):!0:!!M;return!1}function ba(o,l,h){var m=Object.keys(l);if(m.length!==Object.keys(o).length)return!0;for(var S=0;S<m.length;S++){var O=m[S];if(l[O]!==o[O]&&!Zi(h,O))return!0}return!1}function xi(o,l){for(var{vnode:h,parent:m}=o;m&&m.subTree===h;)(h=m.vnode).el=l,m=m.parent}var un=o=>o.__isSuspense,qr={name:"Suspense",__isSuspense:!0,process(o,l,h,m,S,O,M,Y,H,ne){o==null?Io(l,h,m,S,O,M,Y,H,ne):Fa(o,l,h,m,S,M,Y,H,ne)},hydrate:aa,create:jo,normalize:ya},Bi=qr;function Yn(o,l){var h=o.props&&o.props[l];u.isFunction(h)&&h()}function Io(o,l,h,m,S,O,M,Y,H){var{p:ne,o:{createElement:Ne}}=H,fe=Ne("div"),ce=o.suspense=jo(o,S,m,l,fe,h,O,M,Y,H);ne(null,ce.pendingBranch=o.ssContent,fe,null,m,ce,O,M),ce.deps>0?(Yn(o,"onPending"),Yn(o,"onFallback"),ne(null,o.ssFallback,l,h,m,null,O,M),kn(ce,o.ssFallback)):ce.resolve()}function Fa(o,l,h,m,S,O,M,Y,H){var{p:ne,um:Ne,o:{createElement:fe}}=H,ce=l.suspense=o.suspense;ce.vnode=l,l.el=o.el;var Fe=l.ssContent,Ve=l.ssFallback,{activeBranch:lt,pendingBranch:mt,isInFallback:we,isHydrating:de}=ce;if(mt)ce.pendingBranch=Fe,fr(Fe,mt)?(ne(mt,Fe,ce.hiddenContainer,null,S,ce,O,M,Y),ce.deps<=0?ce.resolve():we&&(ne(lt,Ve,h,m,S,null,O,M,Y),kn(ce,Ve))):(ce.pendingId++,de?(ce.isHydrating=!1,ce.activeBranch=mt):Ne(mt,S,ce),ce.deps=0,ce.effects.length=0,ce.hiddenContainer=fe("div"),we?(ne(null,Fe,ce.hiddenContainer,null,S,ce,O,M,Y),ce.deps<=0?ce.resolve():(ne(lt,Ve,h,m,S,null,O,M,Y),kn(ce,Ve))):lt&&fr(Fe,lt)?(ne(lt,Fe,h,m,S,ce,O,M,Y),ce.resolve(!0)):(ne(null,Fe,ce.hiddenContainer,null,S,ce,O,M,Y),ce.deps<=0&&ce.resolve()));else if(lt&&fr(Fe,lt))ne(lt,Fe,h,m,S,ce,O,M,Y),kn(ce,Fe);else if(Yn(l,"onPending"),ce.pendingBranch=Fe,ce.pendingId++,ne(null,Fe,ce.hiddenContainer,null,S,ce,O,M,Y),ce.deps<=0)ce.resolve();else{var{timeout:Se,pendingId:nt}=ce;Se>0?setTimeout(()=>{ce.pendingId===nt&&ce.fallback(Ve)},Se):Se===0&&ce.fallback(Ve)}}var oa=!1;function jo(o,l,h,m,S,O,M,Y,H,ne){var Ne=arguments.length>10&&arguments[10]!==void 0?arguments[10]:!1;oa||(oa=!0,console[console.info?"info":"log"]("<Suspense> is an experimental feature and its API will likely change."));var{p:fe,m:ce,um:Fe,n:Ve,o:{parentNode:lt,remove:mt}}=ne,we=u.toNumber(o.props&&o.props.timeout),de={vnode:o,parent:l,parentComponent:h,isSVG:M,container:m,hiddenContainer:S,anchor:O,deps:0,pendingId:0,timeout:typeof we=="number"?we:-1,activeBranch:null,pendingBranch:null,isInFallback:!0,isHydrating:Ne,isUnmounted:!1,effects:[],resolve(){var Se=arguments.length>0&&arguments[0]!==void 0?arguments[0]:!1;{if(!Se&&!de.pendingBranch)throw new Error("suspense.resolve() is called without a pending branch.");if(de.isUnmounted)throw new Error("suspense.resolve() is called on an already unmounted suspense boundary.")}var{vnode:nt,activeBranch:ze,pendingBranch:i,pendingId:a,effects:f,parentComponent:p,container:w}=de;if(de.isHydrating)de.isHydrating=!1;else if(!Se){var E=ze&&i.transition&&i.transition.mode==="out-in";E&&(ze.transition.afterLeave=()=>{a===de.pendingId&&ce(i,w,N,0)});var{anchor:N}=de;ze&&(N=Ve(ze),Fe(ze,p,de,!0)),E||ce(i,w,N,0)}kn(de,i),de.pendingBranch=null,de.isInFallback=!1;for(var L=de.parent,R=!1;L;){if(L.pendingBranch){L.effects.push(...f),R=!0;break}L=L.parent}R||Ni(f),de.effects=[],Yn(nt,"onResolve")},fallback(Se){if(!!de.pendingBranch){var{vnode:nt,activeBranch:ze,parentComponent:i,container:a,isSVG:f}=de;Yn(nt,"onFallback");var p=Ve(ze),w=()=>{!de.isInFallback||(fe(null,Se,a,p,i,null,f,Y,H),kn(de,Se))},E=Se.transition&&Se.transition.mode==="out-in";E&&(ze.transition.afterLeave=w),de.isInFallback=!0,Fe(ze,i,null,!0),E||w()}},move(Se,nt,ze){de.activeBranch&&ce(de.activeBranch,Se,nt,ze),de.container=Se},next(){return de.activeBranch&&Ve(de.activeBranch)},registerDep(Se,nt){var ze=!!de.pendingBranch;ze&&de.deps++;var i=Se.vnode.el;Se.asyncDep.catch(a=>{zr(a,Se,0)}).then(a=>{if(!(Se.isUnmounted||de.isUnmounted||de.pendingId!==Se.suspenseId)){Se.asyncResolved=!0;var{vnode:f}=Se;tn(f),Il(Se,a,!1),i&&(f.el=i);var p=!i&&Se.subTree.el;nt(Se,f,lt(i||Se.subTree.el),i?null:Ve(Se.subTree),de,M,H),p&&mt(p),xi(Se,f.el),A(),ze&&--de.deps===0&&de.resolve()}})},unmount(Se,nt){de.isUnmounted=!0,de.activeBranch&&Fe(de.activeBranch,h,Se,nt),de.pendingBranch&&Fe(de.pendingBranch,h,Se,nt)}};return de}function aa(o,l,h,m,S,O,M,Y,H){var ne=l.suspense=jo(l,m,h,o.parentNode,c.createElement("div"),null,S,O,M,Y,!0),Ne=H(o,ne.pendingBranch=l.ssContent,h,ne,O,M);return ne.deps===0&&ne.resolve(),Ne}function ya(o){var{shapeFlag:l,children:h}=o,m=l&32;o.ssContent=Nr(m?h.default:h),o.ssFallback=m?Nr(h.fallback):Mn(it)}function Nr(o){var l;if(u.isFunction(o)){var h=Oa&&o._c;h&&(o._d=!1,Mr()),o=o(),h&&(o._d=!0,l=rr,_o())}if(u.isArray(o)){var m=Ri(o);m||se("<Suspense> slots expect a single root node."),o=m}return o=io(o),l&&!o.dynamicChildren&&(o.dynamicChildren=l.filter(S=>S!==o)),o}function kr(o,l){l&&l.pendingBranch?u.isArray(o)?l.effects.push(...o):l.effects.push(o):Ni(o)}function kn(o,l){o.activeBranch=l;var{vnode:h,parentComponent:m}=o,S=h.el=l.el;m&&m.subTree===h&&(m.vnode.el=S,xi(m,S))}function cr(o,l){if(!Jn)se("provide() can only be used inside setup().");else{var h=Jn.provides,m=Jn.parent&&Jn.parent.provides;m===h&&(h=Jn.provides=Object.create(m)),h[o]=l,Jn.type.mpType==="app"&&Jn.appContext.app.provide(o,l)}}function vr(o,l){var h=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!1,m=Jn||wn;if(m){var S=m.parent==null?m.vnode.appContext&&m.vnode.appContext.provides:m.parent.provides;if(S&&o in S)return S[o];if(arguments.length>1)return h&&u.isFunction(l)?l.call(m.proxy):l;se('injection "'.concat(String(o),'" not found.'))}else se("inject() can only be used inside setup() or functional components.")}function eo(o,l){return Kr(o,null,l)}function zo(o,l){return Kr(o,null,Object.assign(Object.assign({},l),{flush:"post"}))}function La(o,l){return Kr(o,null,Object.assign(Object.assign({},l),{flush:"sync"}))}var Ea={};function to(o,l,h){return u.isFunction(l)||se("`watch(fn, options?)` signature has been moved to a separate API. Use `watchEffect(fn, options?)` instead. `watch` now only supports `watch(source, cb, options?) signature."),Kr(o,l,h)}function Kr(o,l){var{immediate:h,deep:m,flush:S,onTrack:O,onTrigger:M}=arguments.length>2&&arguments[2]!==void 0?arguments[2]:u.EMPTY_OBJ;l||(h!==void 0&&se('watch() "immediate" option is only respected when using the watch(source, callback, options?) signature.'),m!==void 0&&se('watch() "deep" option is only respected when using the watch(source, callback, options?) signature.'));var Y=Se=>{se("Invalid watch source: ",Se,"A watch source can only be a getter/effect function, a ref, a reactive object, or an array of these types.")},H=Jn,ne,Ne=!1,fe=!1;if(I.isRef(o)?(ne=()=>o.value,Ne=I.isShallow(o)):I.isReactive(o)?(ne=()=>o,m=!0):u.isArray(o)?(fe=!0,Ne=o.some(Se=>I.isReactive(Se)||I.isShallow(Se)),ne=()=>o.map(Se=>{if(I.isRef(Se))return Se.value;if(I.isReactive(Se))return ii(Se);if(u.isFunction(Se))return Ft(Se,H,2);Y(Se)})):u.isFunction(o)?l?ne=()=>Ft(o,H,2):ne=()=>{if(!(H&&H.isUnmounted))return Fe&&Fe(),Vt(o,H,3,[Ve])}:(ne=u.NOOP,Y(o)),l&&m){var ce=ne;ne=()=>ii(ce())}var Fe,Ve=Se=>{Fe=de.onStop=()=>{Ft(Se,H,4)}};if(k.isInSSRComponentSetup)return Ve=u.NOOP,l?h&&Vt(l,H,3,[ne(),fe?[]:void 0,Ve]):ne(),u.NOOP;var lt=fe?[]:Ea,mt=()=>{if(!!de.active)if(l){var Se=de.run();(m||Ne||(fe?Se.some((nt,ze)=>u.hasChanged(nt,lt[ze])):u.hasChanged(Se,lt)))&&(Fe&&Fe(),Vt(l,H,3,[Se,lt===Ea?void 0:lt,Ve]),lt=Se)}else de.run()};mt.allowRecurse=!!l;var we;S==="sync"?we=mt:S==="post"?we=()=>jn(mt,H&&H.suspense):we=()=>$o(mt);var de=new I.ReactiveEffect(ne,we);return de.onTrack=O,de.onTrigger=M,l?h?mt():lt=de.run():S==="post"?jn(de.run.bind(de),H&&H.suspense):de.run(),()=>{de.stop(),H&&H.scope&&u.remove(H.scope.effects,de)}}function Mi(o,l,h){var m=this.proxy,S=u.isString(o)?o.includes(".")?Wo(m,o):()=>m[o]:o.bind(m,m),O;u.isFunction(l)?O=l:(O=l.handler,h=l);var M=Jn;ci(this);var Y=Kr(S,O.bind(m),h);return M?ci(M):Zr(),Y}function Wo(o,l){var h=l.split(".");return()=>{for(var m=o,S=0;S<h.length&&m;S++)m=m[h[S]];return m}}function ii(o,l){if(!u.isObject(o)||o.__v_skip||(l=l||new Set,l.has(o)))return o;if(l.add(o),I.isRef(o))ii(o.value,l);else if(u.isArray(o))for(var h=0;h<o.length;h++)ii(o[h],l);else if(u.isSet(o)||u.isMap(o))o.forEach(S=>{ii(S,l)});else if(u.isPlainObject(o))for(var m in o)ii(o[m],l);return o}function bi(){var o={isMounted:!1,isLeaving:!1,isUnmounting:!1,leavingVNodes:new Map};return wa(()=>{o.isMounted=!0}),ko(()=>{o.isUnmounting=!0}),o}var tr=[Function,Array],wr={name:"BaseTransition",props:{mode:String,appear:Boolean,persisted:Boolean,onBeforeEnter:tr,onEnter:tr,onAfterEnter:tr,onEnterCancelled:tr,onBeforeLeave:tr,onLeave:tr,onAfterLeave:tr,onLeaveCancelled:tr,onBeforeAppear:tr,onAppear:tr,onAfterAppear:tr,onAppearCancelled:tr},setup(o,l){var{slots:h}=l,m=In(),S=bi(),O;return()=>{var M=h.default&&Z(h.default(),!0);if(!(!M||!M.length)){var Y=M[0];if(M.length>1){var H=!1;for(var ne of M)if(ne.type!==it){if(H){se("<transition> can only be used on a single element or component. Use <transition-group> for lists.");break}Y=ne,H=!0}}var Ne=I.toRaw(o),{mode:fe}=Ne;if(fe&&fe!=="in-out"&&fe!=="out-in"&&fe!=="default"&&se("invalid <transition> mode: ".concat(fe)),S.isLeaving)return G(Y);var ce=V(Y);if(!ce)return G(Y);var Fe=be(ce,Ne,S,m);J(ce,Fe);var Ve=m.subTree,lt=Ve&&V(Ve),mt=!1,{getTransitionKey:we}=ce.type;if(we){var de=we();O===void 0?O=de:de!==O&&(O=de,mt=!0)}if(lt&&lt.type!==it&&(!fr(ce,lt)||mt)){var Se=be(lt,Ne,S,m);if(J(lt,Se),fe==="out-in")return S.isLeaving=!0,Se.afterLeave=()=>{S.isLeaving=!1,m.update()},G(Y);fe==="in-out"&&ce.type!==it&&(Se.delayLeave=(nt,ze,i)=>{var a=ie(S,lt);a[String(lt.key)]=lt,nt._leaveCb=()=>{ze(),nt._leaveCb=void 0,delete Fe.delayedLeave},Fe.delayedLeave=i})}return Y}}}},D=wr;function ie(o,l){var{leavingVNodes:h}=o,m=h.get(l.type);return m||(m=Object.create(null),h.set(l.type,m)),m}function be(o,l,h,m){var{appear:S,mode:O,persisted:M=!1,onBeforeEnter:Y,onEnter:H,onAfterEnter:ne,onEnterCancelled:Ne,onBeforeLeave:fe,onLeave:ce,onAfterLeave:Fe,onLeaveCancelled:Ve,onBeforeAppear:lt,onAppear:mt,onAfterAppear:we,onAppearCancelled:de}=l,Se=String(o.key),nt=ie(h,o),ze=(f,p)=>{f&&Vt(f,m,9,p)},i=(f,p)=>{var w=p[1];ze(f,p),u.isArray(f)?f.every(E=>E.length<=1)&&w():f.length<=1&&w()},a={mode:O,persisted:M,beforeEnter(f){var p=Y;if(!h.isMounted)if(S)p=lt||Y;else return;f._leaveCb&&f._leaveCb(!0);var w=nt[Se];w&&fr(o,w)&&w.el._leaveCb&&w.el._leaveCb(),ze(p,[f])},enter(f){var p=H,w=ne,E=Ne;if(!h.isMounted)if(S)p=mt||H,w=we||ne,E=de||Ne;else return;var N=!1,L=f._enterCb=R=>{N||(N=!0,R?ze(E,[f]):ze(w,[f]),a.delayedLeave&&a.delayedLeave(),f._enterCb=void 0)};p?i(p,[f,L]):L()},leave(f,p){var w=String(o.key);if(f._enterCb&&f._enterCb(!0),h.isUnmounting)return p();ze(fe,[f]);var E=!1,N=f._leaveCb=L=>{E||(E=!0,p(),L?ze(Ve,[f]):ze(Fe,[f]),f._leaveCb=void 0,nt[w]===o&&delete nt[w])};nt[w]=o,ce?i(ce,[f,N]):N()},clone(f){return be(f,l,h,m)}};return a}function G(o){if(mr(o))return o=Li(o),o.children=null,o}function V(o){return mr(o)?o.children?o.children[0]:void 0:o}function J(o,l){o.shapeFlag&6&&o.component?J(o.component.subTree,l):o.shapeFlag&128?(o.ssContent.transition=l.clone(o.ssContent),o.ssFallback.transition=l.clone(o.ssFallback)):o.transition=l}function Z(o){for(var l=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!1,h=arguments.length>2?arguments[2]:void 0,m=[],S=0,O=0;O<o.length;O++){var M=o[O],Y=h==null?M.key:String(h)+String(M.key!=null?M.key:O);M.type===Ht?(M.patchFlag&128&&S++,m=m.concat(Z(M.children,l,Y))):(l||M.type!==it)&&m.push(Y!=null?Li(M,{key:Y}):M)}if(S>1)for(var H=0;H<m.length;H++)m[H].patchFlag=-2;return m}function ge(o){return u.isFunction(o)?{setup:o,name:o.name}:o}var zt=o=>!!o.type.__asyncLoader;function Cn(o){u.isFunction(o)&&(o={loader:o});var{loader:l,loadingComponent:h,errorComponent:m,delay:S=200,timeout:O,suspensible:M=!0,onError:Y}=o,H=null,ne,Ne=0,fe=()=>(Ne++,H=null,ce()),ce=()=>{var Fe;return H||(Fe=H=l().catch(Ve=>{if(Ve=Ve instanceof Error?Ve:new Error(String(Ve)),Y)return new Promise((lt,mt)=>{var we=()=>lt(fe()),de=()=>mt(Ve);Y(Ve,we,de,Ne+1)});throw Ve}).then(Ve=>{if(Fe!==H&&H)return H;if(Ve||se("Async component loader resolved to undefined. If you are using retry(), make sure to return its return value."),Ve&&(Ve.__esModule||Ve[Symbol.toStringTag]==="Module")&&(Ve=Ve.default),Ve&&!u.isObject(Ve)&&!u.isFunction(Ve))throw new Error("Invalid async component load result: ".concat(Ve));return ne=Ve,Ve}))};return ge({name:"AsyncComponentWrapper",__asyncLoader:ce,get __asyncResolved(){return ne},setup(){var Fe=Jn;if(ne)return()=>_n(ne,Fe);var Ve=de=>{H=null,zr(de,Fe,13,!m)};if(M&&Fe.suspense||k.isInSSRComponentSetup)return ce().then(de=>()=>_n(de,Fe)).catch(de=>(Ve(de),()=>m?Mn(m,{error:de}):null));var lt=I.ref(!1),mt=I.ref(),we=I.ref(!!S);return S&&setTimeout(()=>{we.value=!1},S),O!=null&&setTimeout(()=>{if(!lt.value&&!mt.value){var de=new Error("Async component timed out after ".concat(O,"ms."));Ve(de),mt.value=de}},O),ce().then(()=>{lt.value=!0,Fe.parent&&mr(Fe.parent.vnode)&&Ii(Fe.parent.update)}).catch(de=>{Ve(de),mt.value=de}),()=>{if(lt.value&&ne)return _n(ne,Fe);if(mt.value&&m)return Mn(m,{error:mt.value});if(h&&!we.value)return Mn(h)}}})}function _n(o,l){var{vnode:{ref:h,props:m,children:S,shapeFlag:O},parent:M}=l,Y=Mn(o,m,S);return Y.ref=h,Y}var mr=o=>o.type.__isKeepAlive,qn={name:"KeepAlive",__isKeepAlive:!0,props:{include:[String,RegExp,Array],exclude:[String,RegExp,Array],max:[String,Number]},setup(o,l){var{slots:h}=l,m=In(),S=m.ctx;if(!S.renderer)return()=>{var Se=h.default&&h.default();return Se&&Se.length===1?Se[0]:Se};var O=new Map,M=new Set,Y=null;m.__v_cache=O;var H=m.suspense,{renderer:{p:ne,m:Ne,um:fe,o:{createElement:ce}}}=S,Fe=ce("div");S.activate=(Se,nt,ze,i,a)=>{var f=Se.component;Ne(Se,nt,ze,0,H),ne(f.vnode,Se,nt,ze,f,H,i,Se.slotScopeIds,a),jn(()=>{f.isDeactivated=!1,f.a&&u.invokeArrayFns(f.a);var p=Se.props&&Se.props.onVnodeMounted;p&&Dr(p,f.parent,Se)},H),Gr(f)},S.deactivate=Se=>{var nt=Se.component;Ne(Se,Fe,null,1,H),jn(()=>{nt.da&&u.invokeArrayFns(nt.da);var ze=Se.props&&Se.props.onVnodeUnmounted;ze&&Dr(ze,nt.parent,Se),nt.isDeactivated=!0},H),Gr(nt)};function Ve(Se){Cs(Se),fe(Se,m,H,!0)}function lt(Se){O.forEach((nt,ze)=>{var i=gs(nt.type);i&&(!Se||!Se(i))&&mt(ze)})}function mt(Se){var nt=O.get(Se);!Y||nt.type!==Y.type?Ve(nt):Y&&Cs(Y),O.delete(Se),M.delete(Se)}to(()=>[o.include,o.exclude],Se=>{var[nt,ze]=Se;nt&&lt(i=>Po(nt,i)),ze&&lt(i=>!Po(ze,i))},{flush:"post",deep:!0});var we=null,de=()=>{we!=null&&O.set(we,la(m.subTree))};return wa(de),Rr(de),ko(()=>{O.forEach(Se=>{var{subTree:nt,suspense:ze}=m,i=la(nt);if(Se.type===i.type){Cs(i);var a=i.component.da;a&&jn(a,ze);return}Ve(Se)})}),()=>{if(we=null,!h.default)return null;var Se=h.default(),nt=Se[0];if(Se.length>1)return se("KeepAlive should contain exactly one component child."),Y=null,Se;if(!bo(nt)||!(nt.shapeFlag&4)&&!(nt.shapeFlag&128))return Y=null,nt;var ze=la(nt),i=ze.type,a=gs(zt(ze)?ze.type.__asyncResolved||{}:i),{include:f,exclude:p,max:w}=o;if(f&&(!a||!Po(f,a))||p&&a&&Po(p,a))return Y=ze,nt;var E=ze.key==null?i:ze.key,N=O.get(E);return ze.el&&(ze=Li(ze),nt.shapeFlag&128&&(nt.ssContent=ze)),we=E,N?(ze.el=N.el,ze.component=N.component,ze.transition&&J(ze,ze.transition),ze.shapeFlag|=512,M.delete(E),M.add(E)):(M.add(E),w&&M.size>parseInt(w,10)&&mt(M.values().next().value)),ze.shapeFlag|=256,Y=ze,un(nt.type)?nt:ze}}},Va=qn;function Po(o,l){return u.isArray(o)?o.some(h=>Po(h,l)):u.isString(o)?o.split(",").includes(l):o.test?o.test(l):!1}function No(o,l){$a(o,"a",l)}function sa(o,l){$a(o,"da",l)}function $a(o,l){var h=arguments.length>2&&arguments[2]!==void 0?arguments[2]:Jn,m=o.__wdc||(o.__wdc=()=>{for(var O=h;O;){if(O.isDeactivated)return;O=O.parent}return o()});if(Go(l,m,h),h)for(var S=h.parent;S&&S.parent;)mr(S.parent.vnode)&&Ua(m,l,h,S),S=S.parent}function Ua(o,l,h,m){var S=Go(l,o,m,!0);ca(()=>{u.remove(m[l],S)},h)}function Cs(o){var l=o.shapeFlag;l&256&&(l-=256),l&512&&(l-=512),o.shapeFlag=l}function la(o){return o.shapeFlag&128?o.ssContent:o}function Go(o,l){var h=arguments.length>2&&arguments[2]!==void 0?arguments[2]:Jn,m=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1;if(h){if(Ge.isRootHook(o)&&h!==h.root&&(h=h.root,Ge.isRootImmediateHook(o))){var S=h.proxy;Vt(l.bind(S),h,o,Ge.ON_LOAD===o?[S.$page.options]:[])}var O=h[o]||(h[o]=[]),M=l.__weh||(l.__weh=function(){if(!h.isUnmounted){I.pauseTracking(),ci(h);for(var H=arguments.length,ne=new Array(H),Ne=0;Ne<H;Ne++)ne[Ne]=arguments[Ne];var fe=Vt(l,h,o,ne);return Zr(),I.resetTracking(),fe}});return m?O.unshift(M):O.push(M),M}else{var Y=u.toHandlerKey((hn[o]||o.replace(/^on/,"")).replace(/ hook$/,""));se("".concat(Y," is called when there is no active component instance to be ")+"associated with. Lifecycle injection APIs can only be used during execution of setup(). If you are using async setup(), make sure to register lifecycle hooks before the first await statement.")}}var oi=o=>function(l){var h=arguments.length>1&&arguments[1]!==void 0?arguments[1]:Jn;return(!k.isInSSRComponentSetup||o==="sp")&&Go(o,l,h)},yi=oi("bm"),wa=oi("m"),nr=oi("bu"),Rr=oi("u"),ko=oi("bum"),ca=oi("um"),xr=oi("sp"),As=oi("rtg"),Os=oi("rtc");function Ts(o){var l=arguments.length>1&&arguments[1]!==void 0?arguments[1]:Jn;Go("ec",o,l)}function Is(o){u.isBuiltInDirective(o)&&se("Do not use built-in directive ids as custom directive id: "+o)}function Zs(o,l){var h=wn;if(h===null)return se("withDirectives can only be used inside render functions."),o;for(var m=rs(h)||h.proxy,S=o.dirs||(o.dirs=[]),O=0;O<l.length;O++){var[M,Y,H,ne=u.EMPTY_OBJ]=l[O];u.isFunction(M)&&(M={mounted:M,updated:M}),M.deep&&ii(Y),S.push({dir:M,instance:m,value:Y,oldValue:void 0,arg:H,modifiers:ne})}return o}function Jr(o,l,h,m){for(var S=o.dirs,O=l&&l.dirs,M=0;M<S.length;M++){var Y=S[M];O&&(Y.oldValue=O[M].value);var H=Y.dir[m];H&&(I.pauseTracking(),Vt(H,h,8,[o.el,Y,o,l]),I.resetTracking())}}var Ei="components",Hn="directives";function yl(o,l){return Ps(Ei,o,!0,l)||o}var Ha=Symbol();function fo(o){return u.isString(o)?Ps(Ei,o,!1)||o:o||Ha}function Xs(o){return Ps(Hn,o)}function Ps(o,l){var h=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!0,m=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1,S=wn||Jn;if(S){var O=S.type;if(o===Ei){var M=gs(O,!1);if(M&&(M===l||M===u.camelize(l)||M===u.capitalize(u.camelize(l))))return O}var Y=ho(S[o]||O[o],l)||ho(S.appContext[o],l);if(!Y&&m)return O;if(h&&!Y){var H=o===Ei?`
If this is a native custom element, make sure to exclude it from component resolution via compilerOptions.isCustomElement.`:"";se("Failed to resolve ".concat(o.slice(0,-1),": ").concat(l).concat(H))}return Y}else se("resolve".concat(u.capitalize(o.slice(0,-1))," ")+"can only be used in render() or setup().")}function ho(o,l){return o&&(o[l]||o[u.camelize(l)]||o[u.capitalize(u.camelize(l))])}function Ns(o,l,h,m){var S,O=h&&h[m];if(u.isArray(o)||u.isString(o)){S=new Array(o.length);for(var M=0,Y=o.length;M<Y;M++)S[M]=l(o[M],M,void 0,O&&O[M])}else if(typeof o=="number"){Number.isInteger(o)||se("The v-for range expect an integer value but got ".concat(o,".")),S=new Array(o);for(var H=0;H<o;H++)S[H]=l(H+1,H,void 0,O&&O[H])}else if(u.isObject(o))if(o[Symbol.iterator])S=Array.from(o,(Fe,Ve)=>l(Fe,Ve,void 0,O&&O[Ve]));else{var ne=Object.keys(o);S=new Array(ne.length);for(var Ne=0,fe=ne.length;Ne<fe;Ne++){var ce=ne[Ne];S[Ne]=l(o[ce],ce,Ne,O&&O[Ne])}}else S=[];return h&&(h[m]=S),S}function Sa(o,l){for(var h=0;h<l.length;h++){var m=l[h];if(u.isArray(m))for(var S=0;S<m.length;S++)o[m[S].name]=m[S].fn;else m&&(o[m.name]=m.fn)}return o}function Ro(o,l){var h=arguments.length>2&&arguments[2]!==void 0?arguments[2]:{},m=arguments.length>3?arguments[3]:void 0,S=arguments.length>4?arguments[4]:void 0;if(wn.isCE||wn.parent&&zt(wn.parent)&&wn.parent.isCE)return Mn("slot",l==="default"?null:{name:l},m&&m());var O=o[l];O&&O.length>1&&(se("SSR-optimized slot function detected in a non-SSR-optimized render function. You need to mark this component with $dynamic-slots in the parent template."),O=()=>[]),O&&O._c&&(O._d=!1),Mr();var M=O&&ks(O(h)),Y=wl(Ht,{key:h.key||"_".concat(l)},M||(m?m():[]),M&&o._===1?64:-2);return!S&&Y.scopeId&&(Y.slotScopeIds=[Y.scopeId+"-s"]),O&&O._c&&(O._d=!0),Y}function ks(o){return o.some(l=>bo(l)?!(l.type===it||l.type===Ht&&!ks(l.children)):!0)?o:null}function ja(o){var l={};if(!u.isObject(o))return se("v-on with no argument expects an object value."),l;for(var h in o)l[u.toHandlerKey(h)]=o[h];return l}var Ca=o=>o?Xr(o)?rs(o)||o.proxy:Ca(o.parent):null,no=u.extend(Object.create(null),{$:o=>o,$el:o=>o.vnode.el,$data:o=>o.data,$props:o=>I.shallowReadonly(o.props),$attrs:o=>I.shallowReadonly(o.attrs),$slots:o=>I.shallowReadonly(o.slots),$refs:o=>I.shallowReadonly(o.refs),$parent:o=>Ca(o.parent),$root:o=>Ca(o.root),$emit:o=>o.emit,$options:o=>re(o),$forceUpdate:o=>o.f||(o.f=()=>Ii(o.update)),$nextTick:o=>o.n||(o.n=gr.bind(o.proxy)),$watch:o=>Mi.bind(o)}),po=o=>o==="_"||o==="$",ua={get(o,l){var{_:h}=o,{ctx:m,setupState:S,data:O,props:M,accessCache:Y,type:H,appContext:ne}=h;if(l==="__isVue")return!0;if(S!==u.EMPTY_OBJ&&S.__isScriptSetup&&u.hasOwn(S,l))return S[l];var Ne;if(l[0]!=="$"){var fe=Y[l];if(fe!==void 0)switch(fe){case 1:return S[l];case 2:return O[l];case 4:return m[l];case 3:return M[l]}else{if(S!==u.EMPTY_OBJ&&u.hasOwn(S,l))return Y[l]=1,S[l];if(O!==u.EMPTY_OBJ&&u.hasOwn(O,l))return Y[l]=2,O[l];if((Ne=h.propsOptions[0])&&u.hasOwn(Ne,l))return Y[l]=3,M[l];if(m!==u.EMPTY_OBJ&&u.hasOwn(m,l))return Y[l]=4,m[l];_&&(Y[l]=0)}}var ce=no[l],Fe,Ve;if(ce)return l==="$attrs"&&(I.track(h,"get",l),ri()),ce(h);if((Fe=H.__cssModules)&&(Fe=Fe[l]))return Fe;if(m!==u.EMPTY_OBJ&&u.hasOwn(m,l))return Y[l]=4,m[l];if(Ve=ne.config.globalProperties,u.hasOwn(Ve,l))return Ve[l];wn&&(!u.isString(l)||l.indexOf("__v")!==0)&&(O!==u.EMPTY_OBJ&&po(l[0])&&u.hasOwn(O,l)?se("Property ".concat(JSON.stringify(l)," must be accessed via $data because it starts with a reserved ")+'character ("$" or "_") and is not proxied on the render context.'):h===wn&&se("Property ".concat(JSON.stringify(l)," was accessed during render ")+"but is not defined on instance."))},set(o,l,h){var{_:m}=o,{data:S,setupState:O,ctx:M}=m;return O!==u.EMPTY_OBJ&&u.hasOwn(O,l)?(O[l]=h,!0):S!==u.EMPTY_OBJ&&u.hasOwn(S,l)?(S[l]=h,!0):u.hasOwn(m.props,l)?(se('Attempting to mutate prop "'.concat(l,'". Props are readonly.'),m),!1):l[0]==="$"&&l.slice(1)in m?(se('Attempting to mutate public property "'.concat(l,'". ')+"Properties starting with $ are reserved and readonly.",m),!1):(l in m.appContext.config.globalProperties?Object.defineProperty(M,l,{enumerable:!0,configurable:!0,value:h}):M[l]=h,!0)},has(o,l){var{_:{data:h,setupState:m,accessCache:S,ctx:O,appContext:M,propsOptions:Y}}=o,H;return!!S[l]||h!==u.EMPTY_OBJ&&u.hasOwn(h,l)||m!==u.EMPTY_OBJ&&u.hasOwn(m,l)||(H=Y[0])&&u.hasOwn(H,l)||u.hasOwn(O,l)||u.hasOwn(no,l)||u.hasOwn(M.config.globalProperties,l)},defineProperty(o,l,h){return h.get!=null?o._.accessCache[l]=0:u.hasOwn(h,"value")&&this.set(o,l,h.value,null),Reflect.defineProperty(o,l,h)}};ua.ownKeys=o=>(se("Avoid app logic that relies on enumerating keys on a component instance. The keys will be empty in production mode to avoid performance overhead."),Reflect.ownKeys(o));var go=u.extend({},ua,{get(o,l){if(l!==Symbol.unscopables)return ua.get(o,l,o)},has(o,l){var h=l[0]!=="_"&&!u.isGloballyWhitelisted(l);return!h&&ua.has(o,l)&&se("Property ".concat(JSON.stringify(l)," should not start with _ which is a reserved prefix for Vue internals.")),h}});function Rs(o){var l={};return Object.defineProperty(l,"_",{configurable:!0,enumerable:!1,get:()=>o}),Object.keys(no).forEach(h=>{Object.defineProperty(l,h,{configurable:!0,enumerable:!1,get:()=>no[h](o),set:u.NOOP})}),l}function El(o){var{ctx:l,propsOptions:[h]}=o;h&&Object.keys(h).forEach(m=>{Object.defineProperty(l,m,{enumerable:!0,configurable:!0,get:()=>o.props[m],set:u.NOOP})})}function xs(o){var{ctx:l,setupState:h}=o;Object.keys(I.toRaw(h)).forEach(m=>{if(!h.__isScriptSetup){if(po(m[0])){se("setup() return property ".concat(JSON.stringify(m),' should not start with "$" or "_" ')+"which are reserved prefixes for Vue internals.");return}Object.defineProperty(l,m,{enumerable:!0,configurable:!0,get:()=>h[m],set:u.NOOP})}})}function Qs(){var o=Object.create(null);return(l,h)=>{o[h]?se("".concat(l,' property "').concat(h,'" is already defined in ').concat(o[h],".")):o[h]=l}}var _=!0;function F(o){var l=re(o),h=o.proxy,m=o.ctx;_=!1,l.beforeCreate&&W(l.beforeCreate,o,"bc");var{data:S,computed:O,methods:M,watch:Y,provide:H,inject:ne,created:Ne,beforeMount:fe,mounted:ce,beforeUpdate:Fe,updated:Ve,activated:lt,deactivated:mt,beforeDestroy:we,beforeUnmount:de,destroyed:Se,unmounted:nt,render:ze,renderTracked:i,renderTriggered:a,errorCaptured:f,serverPrefetch:p,expose:w,inheritAttrs:E,components:N,directives:L,filters:R}=l,K=Qs();{var[ue]=o.propsOptions;if(ue)for(var oe in ue)K("Props",oe)}if(ne&&q(ne,m,K,o.appContext.config.unwrapInjectedRef),M)for(var te in M){var Ee=M[te];u.isFunction(Ee)?(Object.defineProperty(m,te,{value:Ee.bind(h),configurable:!0,enumerable:!0,writable:!0}),K("Methods",te)):se('Method "'.concat(te,'" has type "').concat(typeof Ee,'" in the component definition. ')+"Did you reference the function correctly?")}if(S&&function(){u.isFunction(S)||se("The data option must be a function. Plain object usage is no longer supported.");var Oe=S.call(h,h);if(u.isPromise(Oe)&&se("data() returned a Promise - note data() cannot be async; If you intend to perform data fetching before component renders, use async setup() + <Suspense>."),!u.isObject(Oe))se("data() should return an object.");else{o.data=I.reactive(Oe);{var ot=function(Ye){K("Data",Ye),po(Ye[0])||Object.defineProperty(m,Ye,{configurable:!0,enumerable:!0,get:()=>Oe[Ye],set:u.NOOP})};for(var dt in Oe)ot(dt)}}}(),_=!0,O){var He=function(Oe){var ot=O[Oe],dt=u.isFunction(ot)?ot.bind(h,h):u.isFunction(ot.get)?ot.get.bind(h,h):u.NOOP;dt===u.NOOP&&se('Computed property "'.concat(Oe,'" has no getter.'));var Ye=!u.isFunction(ot)&&u.isFunction(ot.set)?ot.set.bind(h):()=>{se('Write operation failed: computed property "'.concat(Oe,'" is readonly.'))},Ot=xl({get:dt,set:Ye});Object.defineProperty(m,Oe,{enumerable:!0,configurable:!0,get:()=>Ot.value,set:Tt=>Ot.value=Tt}),K("Computed",Oe)};for(var rt in O)He(rt)}if(Y)for(var ft in Y)ee(Y[ft],m,h,ft);if(H){var ve=u.isFunction(H)?H.call(h):H;Reflect.ownKeys(ve).forEach(Oe=>{cr(Oe,ve[Oe])})}Ne&&W(Ne,o,"c");function le(Oe,ot){u.isArray(ot)?ot.forEach(dt=>Oe(dt.bind(h))):ot&&Oe(ot.bind(h))}if(le(yi,fe),le(wa,ce),le(nr,Fe),le(Rr,Ve),le(No,lt),le(sa,mt),le(Ts,f),le(Os,i),le(As,a),le(ko,de),le(ca,nt),le(xr,p),u.isArray(w))if(w.length){var me=o.exposed||(o.exposed={});w.forEach(Oe=>{Object.defineProperty(me,Oe,{get:()=>h[Oe],set:ot=>h[Oe]=ot})})}else o.exposed||(o.exposed={});ze&&o.render===u.NOOP&&(o.render=ze),E!=null&&(o.inheritAttrs=E),N&&(o.components=N),L&&(o.directives=L);var Ze=o.appContext.config.globalProperties.$applyOptions;Ze&&Ze(l,o,h)}function q(o,l){var h=arguments.length>2&&arguments[2]!==void 0?arguments[2]:u.NOOP,m=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1;u.isArray(o)&&(o=Ae(o));var S=function(M){var Y=o[M],H=void 0;u.isObject(Y)?"default"in Y?H=vr(Y.from||M,Y.default,!0):H=vr(Y.from||M):H=vr(Y),I.isRef(H)?m?Object.defineProperty(l,M,{enumerable:!0,configurable:!0,get:()=>H.value,set:ne=>H.value=ne}):(se('injected property "'.concat(M,'" is a ref and will be auto-unwrapped ')+"and no longer needs `.value` in the next minor release. To opt-in to the new behavior now, set `app.config.unwrapInjectedRef = true` (this config is temporary and will not be needed in the future.)"),l[M]=H):l[M]=H,h("Inject",M)};for(var O in o)S(O)}function W(o,l,h){Vt(u.isArray(o)?o.map(m=>m.bind(l.proxy)):o.bind(l.proxy),l,h)}function ee(o,l,h,m){var S=m.includes(".")?Wo(h,m):()=>h[m];if(u.isString(o)){var O=l[o];u.isFunction(O)?to(S,O):se('Invalid watch handler specified by key "'.concat(o,'"'),O)}else if(u.isFunction(o))to(S,o.bind(h));else if(u.isObject(o))if(u.isArray(o))o.forEach(Y=>ee(Y,l,h,m));else{var M=u.isFunction(o.handler)?o.handler.bind(h):l[o.handler];u.isFunction(M)?to(S,M,o):se('Invalid watch handler specified by key "'.concat(o.handler,'"'),M)}else se('Invalid watch option: "'.concat(m,'"'),o)}function re(o){var l=o.type,{mixins:h,extends:m}=l,{mixins:S,optionsCache:O,config:{optionMergeStrategies:M}}=o.appContext,Y=O.get(l),H;return Y?H=Y:!S.length&&!h&&!m?H=l:(H={},S.length&&S.forEach(ne=>pe(H,ne,M,!0)),pe(H,l,M)),O.set(l,H),H}function pe(o,l,h){var m=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1,{mixins:S,extends:O}=l;O&&pe(o,O,h,!0),S&&S.forEach(H=>pe(o,H,h,!0));for(var M in l)if(m&&M==="expose")se('"expose" option is ignored when declared in mixins or extends. It should only be declared in the base component itself.');else{var Y=Ce[M]||h&&h[M];o[M]=Y?Y(o[M],l[M]):l[M]}return o}var Ce={data:Me,props:qe,emits:qe,methods:qe,computed:qe,beforeCreate:ke,created:ke,beforeMount:ke,mounted:ke,beforeUpdate:ke,updated:ke,beforeDestroy:ke,beforeUnmount:ke,destroyed:ke,unmounted:ke,activated:ke,deactivated:ke,errorCaptured:ke,serverPrefetch:ke,components:qe,directives:qe,watch:vt,provide:Me,inject:$e};function Me(o,l){return l?o?function(){return u.extend(u.isFunction(o)?o.call(this,this):o,u.isFunction(l)?l.call(this,this):l)}:l:o}function $e(o,l){return qe(Ae(o),Ae(l))}function Ae(o){if(u.isArray(o)){for(var l={},h=0;h<o.length;h++)l[o[h]]=o[h];return l}return o}function ke(o,l){return o?[...new Set([].concat(o,l))]:l}function qe(o,l){return o?u.extend(u.extend(Object.create(null),o),l):l}function vt(o,l){if(!o)return l;if(!l)return o;var h=u.extend(Object.create(null),o);for(var m in l)h[m]=ke(o[m],l[m]);return h}function Jt(o,l,h){var m=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1,S={},O={};u.def(O,Fs,1),o.propsDefaults=Object.create(null),ut(o,l,S,O);for(var M in o.propsOptions[0])M in S||(S[M]=void 0);xn(l||{},S,o),h?o.props=m?S:I.shallowReactive(S):o.type.props?o.props=S:o.props=O,o.attrs=O}function gt(o,l,h,m){var{props:S,attrs:O,vnode:{patchFlag:M}}=o,Y=I.toRaw(S),[H]=o.propsOptions,ne=!1;if(!(o.type.__hmrId||o.parent&&o.parent.type.__hmrId)&&(m||M>0)&&!(M&16)){if(M&8)for(var Ne=o.vnode.dynamicProps,fe=0;fe<Ne.length;fe++){var ce=Ne[fe];if(!Zi(o.emitsOptions,ce)){var Fe=l[ce];if(H)if(u.hasOwn(O,ce))Fe!==O[ce]&&(O[ce]=Fe,ne=!0);else{var Ve=u.camelize(ce);S[Ve]=Nt(H,Y,Ve,Fe,o,!1)}else Fe!==O[ce]&&(O[ce]=Fe,ne=!0)}}}else{ut(o,l,S,O)&&(ne=!0);var lt;for(var mt in Y)(!l||!u.hasOwn(l,mt)&&((lt=u.hyphenate(mt))===mt||!u.hasOwn(l,lt)))&&(H?h&&(h[mt]!==void 0||h[lt]!==void 0)&&(S[mt]=Nt(H,Y,mt,void 0,o,!0)):delete S[mt]);if(O!==Y)for(var we in O)(!l||!u.hasOwn(l,we)&&!0)&&(delete O[we],ne=!0)}ne&&I.trigger(o,"set","$attrs"),xn(l||{},S,o)}function ut(o,l,h,m){var[S,O]=o.propsOptions,M=!1,Y;if(l){for(var H in l)if(!u.isReservedProp(H)){var ne=l[H],Ne=void 0;S&&u.hasOwn(S,Ne=u.camelize(H))?!O||!O.includes(Ne)?h[Ne]=ne:(Y||(Y={}))[Ne]=ne:Zi(o.emitsOptions,H)||(!(H in m)||ne!==m[H])&&(m[H]=ne,M=!0)}}if(O)for(var fe=I.toRaw(h),ce=Y||u.EMPTY_OBJ,Fe=0;Fe<O.length;Fe++){var Ve=O[Fe];h[Ve]=Nt(S,fe,Ve,ce[Ve],o,!u.hasOwn(ce,Ve))}return M}function Nt(o,l,h,m,S,O){var M=o[h];if(M!=null){var Y=u.hasOwn(M,"default");if(Y&&m===void 0){var H=M.default;if(M.type!==Function&&u.isFunction(H)){var{propsDefaults:ne}=S;h in ne?m=ne[h]:(ci(S),m=ne[h]=H.call(null,l),Zr())}else m=H}M[0]&&(O&&!Y?m=!1:M[1]&&(m===""||m===u.hyphenate(h))&&(m=!0))}return m}function pn(o,l){var h=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!1,m=l.propsCache,S=m.get(o);if(S)return S;var O=o.props,M={},Y=[],H=!1;if(!u.isFunction(o)){var ne=Se=>{H=!0;var[nt,ze]=pn(Se,l,!0);u.extend(M,nt),ze&&Y.push(...ze)};!h&&l.mixins.length&&l.mixins.forEach(ne),o.extends&&ne(o.extends),o.mixins&&o.mixins.forEach(ne)}if(!O&&!H)return m.set(o,u.EMPTY_ARR),u.EMPTY_ARR;if(u.isArray(O))for(var Ne=0;Ne<O.length;Ne++){u.isString(O[Ne])||se("props must be strings when using array syntax.",O[Ne]);var fe=u.camelize(O[Ne]);St(fe)&&(M[fe]=u.EMPTY_OBJ)}else if(O){u.isObject(O)||se("invalid props options",O);for(var ce in O){var Fe=u.camelize(ce);if(St(Fe)){var Ve=O[ce],lt=M[Fe]=u.isArray(Ve)||u.isFunction(Ve)?{type:Ve}:Ve;if(lt){var mt=Rn(Boolean,lt.type),we=Rn(String,lt.type);lt[0]=mt>-1,lt[1]=we<0||mt<we,(mt>-1||u.hasOwn(lt,"default"))&&Y.push(Fe)}}}}var de=[M,Y];return m.set(o,de),de}function St(o){return o[0]!=="$"?!0:(se('Invalid prop name: "'.concat(o,'" is a reserved property.')),!1)}function ht(o){var l=o&&o.toString().match(/^\s*function (\w+)/);return l?l[1]:o===null?"null":""}function Lt(o,l){return ht(o)===ht(l)}function Rn(o,l){return u.isArray(l)?l.findIndex(h=>Lt(h,o)):u.isFunction(l)&&Lt(l,o)?0:-1}function xn(o,l,h){var m=I.toRaw(l),S=h.propsOptions[0];for(var O in S){var M=S[O];M!=null&&Bn(O,m[O],M,!u.hasOwn(o,O)&&!u.hasOwn(o,u.hyphenate(O)))}}function Bn(o,l,h,m){var{type:S,required:O,validator:M}=h;if(O&&m){se('Missing required prop: "'+o+'"');return}if(!(l==null&&!h.required)){if(S!=null&&S!==!0){for(var Y=!1,H=u.isArray(S)?S:[S],ne=[],Ne=0;Ne<H.length&&!Y;Ne++){var{valid:fe,expectedType:ce}=Yt(l,H[Ne]);ne.push(ce||""),Y=fe}if(!Y){se(Kn(o,l,ne));return}}M&&!M(l)&&se('Invalid prop: custom validator check failed for prop "'+o+'".')}}var Ln=u.makeMap("String,Number,Boolean,Function,Symbol,BigInt");function Yt(o,l){var h,m=ht(l);if(Ln(m)){var S=typeof o;h=S===m.toLowerCase(),!h&&S==="object"&&(h=o instanceof l)}else m==="Object"?h=u.isObject(o):m==="Array"?h=u.isArray(o):m==="null"?h=o===null:h=o instanceof l;return{valid:h,expectedType:m}}function Kn(o,l,h){var m='Invalid prop: type check failed for prop "'.concat(o,'".')+" Expected ".concat(h.map(u.capitalize).join(" | ")),S=h[0],O=u.toRawType(l),M=za(l,S),Y=za(l,O);return h.length===1&&Wa(S)&&!xo(S,O)&&(m+=" with value ".concat(M)),m+=", got ".concat(O," "),Wa(O)&&(m+="with value ".concat(Y,".")),m}function za(o,l){return l==="String"?'"'.concat(o,'"'):l==="Number"?"".concat(Number(o)):"".concat(o)}function Wa(o){var l=["string","number","boolean"];return l.some(h=>o.toLowerCase()===h)}function xo(){for(var o=arguments.length,l=new Array(o),h=0;h<o;h++)l[h]=arguments[h];return l.some(m=>m.toLowerCase()==="boolean")}var Ga=o=>o[0]==="_"||o==="$stable",Bo=o=>u.isArray(o)?o.map(io):[io(o)],Ya=(o,l,h)=>{if(l._n)return l;var m=Re(function(){return Jn&&se('Slot "'.concat(o,'" invoked outside of the render function: ')+"this will not track dependencies used in the slot. Invoke the slot function inside the render function instead."),Bo(l(...arguments))},h);return m._c=!1,m},Bs=(o,l,h)=>{var m=o._ctx;for(var S in o)if(!Ga(S)){var O=o[S];u.isFunction(O)?l[S]=Ya(S,O,m):O!=null&&function(){se('Non-function value encountered for slot "'.concat(S,'". ')+"Prefer function slots for better performance.");var M=Bo(O);l[S]=()=>M}()}},An=(o,l)=>{mr(o.vnode)||se("Non-function value encountered for default slot. Prefer function slots for better performance.");var h=Bo(l);o.slots.default=()=>h},Yo=(o,l)=>{if(o.vnode.shapeFlag&32){var h=l._;h?(o.slots=I.toRaw(l),u.def(l,"_",h)):Bs(l,o.slots={})}else o.slots={},l&&An(o,l);u.def(o.slots,Fs,1)},qo=(o,l,h)=>{var{vnode:m,slots:S}=o,O=!0,M=u.EMPTY_OBJ;if(m.shapeFlag&32){var Y=l._;Y?Vr?u.extend(S,l):h&&Y===1?O=!1:(u.extend(S,l),!h&&Y===1&&delete S._):(O=!l.$stable,Bs(l,S)),M=l}else l&&(An(o,l),M={default:1});if(O)for(var H in S)!Ga(H)&&!(H in M)&&delete S[H]};function qa(){return{app:null,config:{isNativeTag:u.NO,performance:!1,globalProperties:{},optionMergeStrategies:{},errorHandler:void 0,warnHandler:void 0,compilerOptions:{}},mixins:[],components:{},directives:{},provides:Object.create(null),optionsCache:new WeakMap,propsCache:new WeakMap,emitsCache:new WeakMap}}var Ms=0;function Ka(o,l){return function(m){var S=arguments.length>1&&arguments[1]!==void 0?arguments[1]:null;u.isFunction(m)||(m=Object.assign({},m)),S!=null&&!u.isObject(S)&&(se("root props passed to app.mount() must be an object."),S=null);var O=qa(),M=new Set,Y=!1,H=O.app={_uid:Ms++,_component:m,_props:S,_container:null,_context:O,_instance:null,version:rl,get config(){return O.config},set config(ne){se("app.config cannot be replaced. Modify individual options instead.")},use(ne){for(var Ne=arguments.length,fe=new Array(Ne>1?Ne-1:0),ce=1;ce<Ne;ce++)fe[ce-1]=arguments[ce];return M.has(ne)?se("Plugin has already been applied to target app."):ne&&u.isFunction(ne.install)?(M.add(ne),ne.install(H,...fe)):u.isFunction(ne)?(M.add(ne),ne(H,...fe)):se('A plugin must either be a function or an object with an "install" function.'),H},mixin(ne){return O.mixins.includes(ne)?se("Mixin has already been applied to target app"+(ne.name?": ".concat(ne.name):"")):O.mixins.push(ne),H},component(ne,Ne){return ts(ne,O.config),Ne?(O.components[ne]&&se('Component "'.concat(ne,'" has already been registered in target app.')),O.components[ne]=Ne,H):O.components[ne]},directive(ne,Ne){return Is(ne),Ne?(O.directives[ne]&&se('Directive "'.concat(ne,'" has already been registered in target app.')),O.directives[ne]=Ne,H):O.directives[ne]},mount(ne,Ne,fe){if(Y)se("App has already been mounted.\nIf you want to remount the same app, move your app creation logic into a factory function and create fresh app instances for each mount - e.g. `const createMyApp = () => createApp(App)`");else{ne.__vue_app__&&se("There is already an app instance mounted on the host container.\n If you want to mount another app on the same host container, you need to unmount the previous app by calling `app.unmount()` first.");var ce=Mn(m,S);return ce.appContext=O,O.reload=()=>{o(Li(ce),ne,fe)},Ne&&l?l(ce,ne):o(ce,ne,fe),Y=!0,H._container=ne,ne.__vue_app__=H,H._instance=ce.component,Pr(H,rl),rs(ce.component)||ce.component.proxy}},unmount(){Y?(o(null,H._container),H._instance=null,Wr(H),delete H._container.__vue_app__):se("Cannot unmount an app that is not mounted.")},provide(ne,Ne){return ne in O.provides&&se('App already provides property with key "'.concat(String(ne),'". ')+"It will be overwritten with the new value."),O.provides[ne]=Ne,H}};return H}}function Di(o,l,h,m){var S=arguments.length>4&&arguments[4]!==void 0?arguments[4]:!1;if(u.isArray(o)){o.forEach((lt,mt)=>Di(lt,l&&(u.isArray(l)?l[mt]:l),h,m,S));return}if(!(zt(m)&&!S)){var O=m.shapeFlag&4?rs(m.component)||m.component.proxy:m.el,M=S?null:O,{i:Y,r:H}=o;if(!Y){se("Missing ref owner context. ref cannot be used on hoisted vnodes. A vnode with ref must be created inside the render function.");return}var ne=l&&l.r,Ne=Y.refs===u.EMPTY_OBJ?Y.refs={}:Y.refs,fe=Y.setupState;if(ne!=null&&ne!==H&&(u.isString(ne)?(Ne[ne]=null,u.hasOwn(fe,ne)&&(fe[ne]=null)):I.isRef(ne)&&(ne.value=null)),u.isFunction(H))Ft(H,Y,12,[M,Ne]);else{var ce=u.isString(H),Fe=I.isRef(H);if(ce||Fe){var Ve=()=>{if(o.f){var lt=ce?Ne[H]:H.value;S?u.isArray(lt)&&u.remove(lt,O):u.isArray(lt)?lt.includes(O)||lt.push(O):ce?(Ne[H]=[O],u.hasOwn(fe,H)&&(fe[H]=Ne[H])):(H.value=[O],o.k&&(Ne[o.k]=H.value))}else ce?(Ne[H]=M,u.hasOwn(fe,H)&&(fe[H]=M)):Fe?(H.value=M,o.k&&(Ne[o.k]=M)):se("Invalid template ref type:",H,"(".concat(typeof H,")"))};M?(Ve.id=-1,jn(Ve,h)):Ve()}else se("Invalid template ref type:",H,"(".concat(typeof H,")"))}}}var ur=!1,On=o=>/svg/.test(o.namespaceURI)&&o.tagName!=="foreignObject",ro=o=>o.nodeType===8;function Ja(o){var{mt:l,p:h,o:{patchProp:m,createText:S,nextSibling:O,parentNode:M,remove:Y,insert:H,createComment:ne}}=o,Ne=(we,de)=>{if(!de.hasChildNodes()){se("Attempting to hydrate existing markup but container is empty. Performing full mount instead."),h(null,we,de),Gi(),de._vnode=we;return}ur=!1,fe(de.firstChild,we,null,null,null),Gi(),de._vnode=we,ur&&console.error("Hydration completed but contains mismatches.")},fe=function(we,de,Se,nt,ze){var i=arguments.length>5&&arguments[5]!==void 0?arguments[5]:!1,a=ro(we)&&we.data==="[",f=()=>lt(we,de,Se,nt,ze,a),{type:p,ref:w,shapeFlag:E,patchFlag:N}=de,L=we.nodeType;de.el=we,N===-2&&(i=!1,de.dynamicChildren=null);var R=null;switch(p){case jt:L!==3?de.children===""?(H(de.el=S(""),M(we),we),R=we):R=f():(we.data!==de.children&&(ur=!0,se("Hydration text mismatch:"+`
- Client: `.concat(JSON.stringify(we.data))+`
- Server: `.concat(JSON.stringify(de.children))),we.data=de.children),R=O(we));break;case it:L!==8||a?R=f():R=O(we);break;case fn:if(L!==1&&L!==3)R=f();else{R=we;for(var K=!de.children.length,ue=0;ue<de.staticCount;ue++)K&&(de.children+=R.nodeType===1?R.outerHTML:R.data),ue===de.staticCount-1&&(de.anchor=R),R=O(R);return R}break;case Ht:a?R=Ve(we,de,Se,nt,ze,i):R=f();break;default:if(E&1)L!==1||de.type.toLowerCase()!==we.tagName.toLowerCase()?R=f():R=ce(we,de,Se,nt,ze,i);else if(E&6){de.slotScopeIds=ze;var oe=M(we);if(l(de,oe,null,Se,nt,On(oe),i),R=a?mt(we):O(we),R&&ro(R)&&R.data==="teleport end"&&(R=O(R)),zt(de)){var te;a?(te=Mn(Ht),te.anchor=R?R.previousSibling:oe.lastChild):te=we.nodeType===3?es(""):Mn("div"),te.el=we,de.component.subTree=te}}else E&64?L!==8?R=f():R=de.type.hydrate(we,de,Se,nt,ze,i,o,Fe):E&128?R=de.type.hydrate(we,de,Se,nt,On(M(we)),ze,i,o,fe):se("Invalid HostVNode type:",p,"(".concat(typeof p,")"))}return w!=null&&Di(w,null,nt,de),R},ce=(we,de,Se,nt,ze,i)=>{i=i||!!de.dynamicChildren;var{type:a,props:f,patchFlag:p,shapeFlag:w,dirs:E}=de,N=a==="input"&&E||a==="option";{if(E&&Jr(de,null,Se,"created"),f)if(N||!i||p&(16|32))for(var L in f)(N&&L.endsWith("value")||u.isOn(L)&&!u.isReservedProp(L))&&m(we,L,null,f[L],!1,void 0,Se);else f.onClick&&m(we,"onClick",null,f.onClick,!1,void 0,Se);var R;if((R=f&&f.onVnodeBeforeMount)&&Dr(R,Se,de),E&&Jr(de,null,Se,"beforeMount"),((R=f&&f.onVnodeMounted)||E)&&kr(()=>{R&&Dr(R,Se,de),E&&Jr(de,null,Se,"mounted")},nt),w&16&&!(f&&(f.innerHTML||f.textContent)))for(var K=Fe(we.firstChild,de,we,Se,nt,ze,i),ue=!1;K;){ur=!0,ue||(se("Hydration children mismatch in <".concat(de.type,">: ")+"server rendered element contains more child nodes than client vdom."),ue=!0);var oe=K;K=K.nextSibling,Y(oe)}else w&8&&we.textContent!==de.children&&(ur=!0,se("Hydration text content mismatch in <".concat(de.type,`>:
`)+"- Client: ".concat(we.textContent,`
`)+"- Server: ".concat(de.children)),we.textContent=de.children)}return we.nextSibling},Fe=(we,de,Se,nt,ze,i,a)=>{a=a||!!de.dynamicChildren;for(var f=de.children,p=f.length,w=!1,E=0;E<p;E++){var N=a?f[E]:f[E]=io(f[E]);if(we)we=fe(we,N,nt,ze,i,a);else{if(N.type===jt&&!N.children)continue;ur=!0,w||(se("Hydration children mismatch in <".concat(Se.tagName.toLowerCase(),">: ")+"server rendered element contains fewer child nodes than client vdom."),w=!0),h(null,N,Se,null,nt,ze,On(Se),i)}}return we},Ve=(we,de,Se,nt,ze,i)=>{var{slotScopeIds:a}=de;a&&(ze=ze?ze.concat(a):a);var f=M(we),p=Fe(O(we),de,f,Se,nt,ze,i);return p&&ro(p)&&p.data==="]"?O(de.anchor=p):(ur=!0,H(de.anchor=ne("]"),f,p),p)},lt=(we,de,Se,nt,ze,i)=>{if(ur=!0,se(`Hydration node mismatch:
- Client vnode:`,de.type,`
- Server rendered DOM:`,we,we.nodeType===3?"(text)":ro(we)&&we.data==="["?"(start of fragment)":""),de.el=null,i)for(var a=mt(we);;){var f=O(we);if(f&&f!==a)Y(f);else break}var p=O(we),w=M(we);return Y(we),h(null,de,w,p,Se,nt,On(w),ze),p},mt=we=>{for(var de=0;we;)if(we=O(we),we&&ro(we)&&(we.data==="["&&de++,we.data==="]")){if(de===0)return O(we);de--}return we};return[Ne,fe]}var Aa,wi;function $r(o,l){o.appContext.config.performance&&Fi()&&wi.mark("vue-".concat(l,"-").concat(o.uid)),uo(o,l,Fi()?wi.now():Date.now())}function Sr(o,l){if(o.appContext.config.performance&&Fi()){var h="vue-".concat(l,"-").concat(o.uid),m=h+":end";wi.mark(m),wi.measure("<".concat(da(o,o.type),"> ").concat(l),h,m),wi.clearMarks(h),wi.clearMarks(m)}_i(o,l,Fi()?wi.now():Date.now())}function Fi(){return Aa!==void 0||(typeof window!="undefined"&&window.performance?(Aa=!0,wi=window.performance):Aa=!1),Aa}function ds(){var o=[];if(o.length){var l=o.length>1;console.warn("Feature flag".concat(l?"s":""," ").concat(o.join(", ")," ").concat(l?"are":"is"," not explicitly defined. You are running the esm-bundler build of Vue, ")+`which expects these compile-time feature flags to be globally injected via the bundler config in order to get better tree-shaking in the production bundle.

For more details, see https://link.vuejs.org/feature-flags.`)}}var jn=kr;function Cr(o){return Si(o)}function hs(o){return Si(o,Ja)}function Si(o,l){ds();var h=u.getGlobalThis();h.__VUE__=!0,Er(h.__VUE_DEVTOOLS_GLOBAL_HOOK__,h);var{insert:m,remove:S,patchProp:O,forcePatchProp:M,createElement:Y,createText:H,createComment:ne,setText:Ne,setElementText:fe,parentNode:ce,nextSibling:Fe,setScopeId:Ve=u.NOOP,cloneNode:lt,insertStaticContent:mt}=o,we=function(x,U,he){var Ie=arguments.length>3&&arguments[3]!==void 0?arguments[3]:null,Pe=arguments.length>4&&arguments[4]!==void 0?arguments[4]:null,Je=arguments.length>5&&arguments[5]!==void 0?arguments[5]:null,ct=arguments.length>6&&arguments[6]!==void 0?arguments[6]:!1,Xe=arguments.length>7&&arguments[7]!==void 0?arguments[7]:null,tt=arguments.length>8&&arguments[8]!==void 0?arguments[8]:Vr?!1:!!U.dynamicChildren;if(x!==U){x&&!fr(x,U)&&(Ie=Ye(x),me(x,Pe,Je,!0),x=null),U.patchFlag===-2&&(tt=!1,U.dynamicChildren=null);var{type:We,ref:Ct,shapeFlag:pt}=U;switch(We){case jt:de(x,U,he,Ie);break;case it:Se(x,U,he,Ie);break;case fn:x==null?nt(U,he,Ie,ct):ze(x,U,he,ct);break;case Ht:K(x,U,he,Ie,Pe,Je,ct,Xe,tt);break;default:pt&1?f(x,U,he,Ie,Pe,Je,ct,Xe,tt):pt&6?ue(x,U,he,Ie,Pe,Je,ct,Xe,tt):pt&64||pt&128?We.process(x,U,he,Ie,Pe,Je,ct,Xe,tt,Tt):se("Invalid VNode type:",We,"(".concat(typeof We,")"))}Ct!=null&&Pe&&Di(Ct,x&&x.ref,Je,U||x,!U)}},de=(x,U,he,Ie)=>{if(x==null)m(U.el=H(U.children),he,Ie);else{var Pe=U.el=x.el;U.children!==x.children&&Ne(Pe,U.children)}},Se=(x,U,he,Ie)=>{x==null?m(U.el=ne(U.children||""),he,Ie):U.el=x.el},nt=(x,U,he,Ie)=>{[x.el,x.anchor]=mt(x.children,U,he,Ie,x.el,x.anchor)},ze=(x,U,he,Ie)=>{if(U.children!==x.children){var Pe=Fe(x.anchor);a(x),[U.el,U.anchor]=mt(U.children,he,Pe,Ie)}else U.el=x.el,U.anchor=x.anchor},i=(x,U,he)=>{for(var{el:Ie,anchor:Pe}=x,Je;Ie&&Ie!==Pe;)Je=Fe(Ie),m(Ie,U,he),Ie=Je;m(Pe,U,he)},a=x=>{for(var{el:U,anchor:he}=x,Ie;U&&U!==he;)Ie=Fe(U),S(U),U=Ie;S(he)},f=(x,U,he,Ie,Pe,Je,ct,Xe,tt)=>{ct=ct||U.type==="svg",x==null?p(U,he,Ie,Pe,Je,ct,Xe,tt):N(x,U,Pe,Je,ct,Xe,tt)},p=(x,U,he,Ie,Pe,Je,ct,Xe)=>{var tt,We,{type:Ct,props:pt,shapeFlag:Pt,transition:en,patchFlag:nn,dirs:Wt}=x;{if(tt=x.el=Y(x.type,Je,pt&&pt.is,pt),Pt&8?fe(tt,x.children):Pt&16&&E(x.children,tt,null,Ie,Pe,Je&&Ct!=="foreignObject",ct,Xe),Wt&&Jr(x,null,Ie,"created"),pt){for(var gn in pt)gn!=="value"&&!u.isReservedProp(gn)&&O(tt,gn,null,pt[gn],Je,x.children,Ie,Pe,dt,x.hostInstance);"value"in pt&&O(tt,"value",null,pt.value,!1,[],Ie,null,void 0,x.hostInstance),(We=pt.onVnodeBeforeMount)&&Dr(We,Ie,x)}w(tt,x,x.scopeId,ct,Ie)}Object.defineProperty(tt,"__vnode",{value:x,enumerable:!1}),Object.defineProperty(tt,"__vueParentComponent",{value:Ie,enumerable:!1}),Wt&&Jr(x,null,Ie,"beforeMount");var Wn=(!Pe||Pe&&!Pe.pendingBranch)&&en&&!en.persisted;Wn&&en.beforeEnter(tt),m(tt,U,he),((We=pt&&pt.onVnodeMounted)||Wn||Wt)&&jn(()=>{We&&Dr(We,Ie,x),Wn&&en.enter(tt),Wt&&Jr(x,null,Ie,"mounted")},Pe)},w=(x,U,he,Ie,Pe)=>{if(he&&Ve(x,he),Ie)for(var Je=0;Je<Ie.length;Je++)Ve(x,Ie[Je]);if(Pe){var ct=Pe.subTree;if(ct.patchFlag>0&&ct.patchFlag&2048&&(ct=Ri(ct.children)||ct),U===ct){var Xe=Pe.vnode;w(x,Xe,Xe.scopeId,Xe.slotScopeIds,Pe.parent)}}},E=function(x,U,he,Ie,Pe,Je,ct,Xe){for(var tt=arguments.length>8&&arguments[8]!==void 0?arguments[8]:0,We=tt;We<x.length;We++){var Ct=x[We]=Xe?Tn(x[We]):io(x[We]);we(null,Ct,U,he,Ie,Pe,Je,ct,Xe)}},N=(x,U,he,Ie,Pe,Je,ct)=>{var Xe=U.el=x.el,{patchFlag:tt,dynamicChildren:We,dirs:Ct}=U;tt|=x.patchFlag&16;var pt=x.props||u.EMPTY_OBJ,Pt=U.props||u.EMPTY_OBJ,en;he&&vo(he,!1),(en=Pt.onVnodeBeforeUpdate)&&Dr(en,he,U,x),Ct&&Jr(U,x,he,"beforeUpdate"),he&&vo(he,!0),Vr&&(tt=0,ct=!1,We=null);var nn=Pe&&U.type!=="foreignObject";if(We?(L(x.dynamicChildren,We,Xe,he,Ie,nn,Je),he&&he.type.__hmrId&&ai(x,U)):ct||rt(x,U,Xe,null,he,Ie,nn,Je,!1),tt>0){if(tt&16)R(Xe,U,pt,Pt,he,Ie,Pe);else if(tt&2&&pt.class!==Pt.class&&O(Xe,"class",null,Pt.class,Pe,[],he,null,void 0,U.hostInstance),tt&4&&O(Xe,"style",pt.style,Pt.style,Pe,[],he,null,void 0,U.hostInstance),tt&8)for(var Wt=U.dynamicProps,gn=0;gn<Wt.length;gn++){var Wn=Wt[gn],Vo=pt[Wn],ui=Pt[Wn];(ui!==Vo||Wn==="value"||M&&M(Xe,Wn))&&O(Xe,Wn,Vo,ui,Pe,x.children,he,Ie,dt,U.hostInstance)}tt&1&&x.children!==U.children&&fe(Xe,U.children)}else!ct&&We==null&&R(Xe,U,pt,Pt,he,Ie,Pe);((en=Pt.onVnodeUpdated)||Ct)&&jn(()=>{en&&Dr(en,he,U,x),Ct&&Jr(U,x,he,"updated")},Ie)},L=(x,U,he,Ie,Pe,Je,ct)=>{for(var Xe=0;Xe<U.length;Xe++){var tt=x[Xe],We=U[Xe],Ct=tt.el&&(tt.type===Ht||!fr(tt,We)||tt.shapeFlag&(6|64))?ce(tt.el):he;we(tt,We,Ct,null,Ie,Pe,Je,ct,!0)}},R=(x,U,he,Ie,Pe,Je,ct)=>{if(he!==Ie){for(var Xe in Ie)if(!u.isReservedProp(Xe)){var tt=Ie[Xe],We=he[Xe];(tt!==We&&Xe!=="value"||M&&M(x,Xe))&&O(x,Xe,We,tt,ct,U.children,Pe,Je,dt,U.hostInstance)}if(he!==u.EMPTY_OBJ)for(var Ct in he)!u.isReservedProp(Ct)&&!(Ct in Ie)&&O(x,Ct,he[Ct],null,ct,U.children,Pe,Je,dt,U.hostInstance);"value"in Ie&&O(x,"value",he.value,Ie.value,!1,[],Pe,null,void 0,U.hostInstance)}},K=(x,U,he,Ie,Pe,Je,ct,Xe,tt)=>{var We=U.el=x?x.el:H(""),Ct=U.anchor=x?x.anchor:H(""),{patchFlag:pt,dynamicChildren:Pt,slotScopeIds:en}=U;(Vr||pt&2048)&&(pt=0,tt=!1,Pt=null),en&&(Xe=Xe?Xe.concat(en):en),x==null?(m(We,he,Ie),m(Ct,he,Ie),E(U.children,he,Ct,Pe,Je,ct,Xe,tt)):pt>0&&pt&64&&Pt&&x.dynamicChildren?(L(x.dynamicChildren,Pt,he,Pe,Je,ct,Xe),Pe&&Pe.type.__hmrId?ai(x,U):(U.key!=null||Pe&&U===Pe.subTree)&&ai(x,U,!0)):rt(x,U,he,Ct,Pe,Je,ct,Xe,tt)},ue=(x,U,he,Ie,Pe,Je,ct,Xe,tt)=>{U.slotScopeIds=Xe,x==null?U.shapeFlag&512?Pe.ctx.activate(U,he,Ie,ct,tt):oe(U,he,Ie,Pe,Je,ct,tt):te(x,U,tt)},oe=(x,U,he,Ie,Pe,Je,ct)=>{var Xe=x.component=Ol(x,Ie,Pe);if(Xe.type.__hmrId&&qi(Xe),tn(x),$r(Xe,"mount"),mr(x)&&(Xe.ctx.renderer=Tt),$r(Xe,"init"),Fo(Xe),Sr(Xe,"init"),Xe.asyncDep){if(Pe&&Pe.registerDep(Xe,Ee),!x.el){var tt=Xe.subTree=Mn(it);Se(null,tt,U,he)}return}Ee(Xe,x,U,he,Pe,Je,ct),A(),Sr(Xe,"mount")},te=(x,U,he)=>{var Ie=U.component=x.component;if(Xt(x,U,he))if(Ie.asyncDep&&!Ie.asyncResolved){tn(U),He(Ie,U,he),A();return}else Ie.next=U,or(Ie.update),Ie.update();else U.el=x.el,Ie.vnode=U},Ee=(x,U,he,Ie,Pe,Je,ct)=>{var Xe=()=>{if(x.isMounted){var{next:hr,bu:Ba,u:j,parent:X,vnode:ye}=x,De=hr,xe;tn(hr||x.vnode),vo(x,!1),hr?(hr.el=ye.el,He(x,hr,ct)):hr=ye,Ba&&u.invokeArrayFns(Ba),(xe=hr.props&&hr.props.onVnodeBeforeUpdate)&&Dr(xe,X,hr,ye),vo(x,!0),$r(x,"render");var Qe=ki(x);Sr(x,"render");var st=x.subTree;x.subTree=Qe,$r(x,"patch"),we(st,Qe,ce(st.el),Ye(st),x,Pe,Je),Sr(x,"patch"),hr.el=Qe.el,De===null&&xi(x,Qe.el),j&&jn(j,Pe),(xe=hr.props&&hr.props.onVnodeUpdated)&&jn(()=>Dr(xe,X,hr,ye),Pe),er(x),A()}else{var Ct,{el:pt,props:Pt}=U,{bm:en,m:nn,parent:Wt}=x,gn=zt(U);if(vo(x,!1),en&&u.invokeArrayFns(en),!gn&&(Ct=Pt&&Pt.onVnodeBeforeMount)&&Dr(Ct,Wt,U),vo(x,!0),pt&&$t){var Wn=()=>{$r(x,"render"),x.subTree=ki(x),Sr(x,"render"),$r(x,"hydrate"),$t(pt,x.subTree,x,Pe,null),Sr(x,"hydrate")};gn?U.type.__asyncLoader().then(()=>!x.isUnmounted&&Wn()):Wn()}else{$r(x,"render");var Vo=x.subTree=ki(x);Sr(x,"render"),$r(x,"patch"),we(null,Vo,he,Ie,x,Pe,Je),Sr(x,"patch"),U.el=Vo.el}if(nn&&jn(nn,Pe),!gn&&(Ct=Pt&&Pt.onVnodeMounted)){var ui=U;jn(()=>Dr(Ct,Wt,ui),Pe)}(U.shapeFlag&256||Wt&&zt(Wt.vnode)&&Wt.vnode.shapeFlag&256)&&x.a&&jn(x.a,Pe),x.isMounted=!0,Gr(x),U=he=Ie=null}},tt=x.effect=new I.ReactiveEffect(Xe,()=>Ii(We),x.scope),We=x.update=()=>tt.run();We.id=x.uid,vo(x,!0),tt.onTrack=x.rtc?Ct=>u.invokeArrayFns(x.rtc,Ct):void 0,tt.onTrigger=x.rtg?Ct=>u.invokeArrayFns(x.rtg,Ct):void 0,We.ownerInstance=x,We()},He=(x,U,he)=>{U.component=x;var Ie=x.vnode.props;x.vnode=U,x.next=null,gt(x,U.props,Ie,he),qo(x,U.children,he),I.pauseTracking(),Wi(void 0,x.update),I.resetTracking()},rt=function(x,U,he,Ie,Pe,Je,ct,Xe){var tt=arguments.length>8&&arguments[8]!==void 0?arguments[8]:!1,We=x&&x.children,Ct=x?x.shapeFlag:0,pt=U.children,{patchFlag:Pt,shapeFlag:en}=U;if(Pt>0){if(Pt&128){ve(We,pt,he,Ie,Pe,Je,ct,Xe,tt);return}else if(Pt&256){ft(We,pt,he,Ie,Pe,Je,ct,Xe,tt);return}}en&8?(Ct&16&&dt(We,Pe,Je),pt!==We&&fe(he,pt)):Ct&16?en&16?ve(We,pt,he,Ie,Pe,Je,ct,Xe,tt):dt(We,Pe,Je,!0):(Ct&8&&fe(he,""),en&16&&E(pt,he,Ie,Pe,Je,ct,Xe,tt))},ft=(x,U,he,Ie,Pe,Je,ct,Xe,tt)=>{x=x||u.EMPTY_ARR,U=U||u.EMPTY_ARR;var We=x.length,Ct=U.length,pt=Math.min(We,Ct),Pt;for(Pt=0;Pt<pt;Pt++){var en=U[Pt]=tt?Tn(U[Pt]):io(U[Pt]);we(x[Pt],en,he,null,Pe,Je,ct,Xe,tt)}We>Ct?dt(x,Pe,Je,!0,!1,pt):E(U,he,Ie,Pe,Je,ct,Xe,tt,pt)},ve=(x,U,he,Ie,Pe,Je,ct,Xe,tt)=>{for(var We=0,Ct=U.length,pt=x.length-1,Pt=Ct-1;We<=pt&&We<=Pt;){var en=x[We],nn=U[We]=tt?Tn(U[We]):io(U[We]);if(fr(en,nn))we(en,nn,he,null,Pe,Je,ct,Xe,tt);else break;We++}for(;We<=pt&&We<=Pt;){var Wt=x[pt],gn=U[Pt]=tt?Tn(U[Pt]):io(U[Pt]);if(fr(Wt,gn))we(Wt,gn,he,null,Pe,Je,ct,Xe,tt);else break;pt--,Pt--}if(We>pt){if(We<=Pt)for(var Wn=Pt+1,Vo=Wn<Ct?U[Wn].el:Ie;We<=Pt;)we(null,U[We]=tt?Tn(U[We]):io(U[We]),he,Vo,Pe,Je,ct,Xe,tt),We++}else if(We>Pt)for(;We<=pt;)me(x[We],Pe,Je,!0),We++;else{var ui=We,hr=We,Ba=new Map;for(We=hr;We<=Pt;We++){var j=U[We]=tt?Tn(U[We]):io(U[We]);j.key!=null&&(Ba.has(j.key)&&se("Duplicate keys found during update:",JSON.stringify(j.key),"Make sure keys are unique."),Ba.set(j.key,We))}var X,ye=0,De=Pt-hr+1,xe=!1,Qe=0,st=new Array(De);for(We=0;We<De;We++)st[We]=0;for(We=ui;We<=pt;We++){var Ke=x[We];if(ye>=De){me(Ke,Pe,Je,!0);continue}var et=void 0;if(Ke.key!=null)et=Ba.get(Ke.key);else for(X=hr;X<=Pt;X++)if(st[X-hr]===0&&fr(Ke,U[X])){et=X;break}et===void 0?me(Ke,Pe,Je,!0):(st[et-hr]=We+1,et>=Qe?Qe=et:xe=!0,we(Ke,U[et],he,null,Pe,Je,ct,Xe,tt),ye++)}var je=xe?Mo(st):u.EMPTY_ARR;for(X=je.length-1,We=De-1;We>=0;We--){var Rt=hr+We,Mt=U[Rt],xt=Rt+1<Ct?U[Rt+1].el:Ie;st[We]===0?we(null,Mt,he,xt,Pe,Je,ct,Xe,tt):xe&&(X<0||We!==je[X]?le(Mt,he,xt,2):X--)}}},le=function(x,U,he,Ie){var Pe=arguments.length>4&&arguments[4]!==void 0?arguments[4]:null,{el:Je,type:ct,transition:Xe,children:tt,shapeFlag:We}=x;if(We&6){le(x.component.subTree,U,he,Ie);return}if(We&128){x.suspense.move(U,he,Ie);return}if(We&64){ct.move(x,U,he,Tt);return}if(ct===Ht){m(Je,U,he);for(var Ct=0;Ct<tt.length;Ct++)le(tt[Ct],U,he,Ie);m(x.anchor,U,he);return}if(ct===fn){i(x,U,he);return}var pt=Ie!==2&&We&1&&Xe;if(pt)if(Ie===0)Xe.beforeEnter(Je),m(Je,U,he),jn(()=>Xe.enter(Je),Pe);else{var{leave:Pt,delayLeave:en,afterLeave:nn}=Xe,Wt=()=>m(Je,U,he),gn=()=>{Pt(Je,()=>{Wt(),nn&&nn()})};en?en(Je,Wt,gn):gn()}else m(Je,U,he)},me=function(x,U,he){var Ie=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1,Pe=arguments.length>4&&arguments[4]!==void 0?arguments[4]:!1,{type:Je,props:ct,ref:Xe,children:tt,dynamicChildren:We,shapeFlag:Ct,patchFlag:pt,dirs:Pt}=x;if(Xe!=null&&Di(Xe,null,he,x,!0),Ct&256){U.ctx.deactivate(x);return}var en=Ct&1&&Pt,nn=!zt(x),Wt;if(nn&&(Wt=ct&&ct.onVnodeBeforeUnmount)&&Dr(Wt,U,x),Ct&6)ot(x.component,he,Ie);else{if(Ct&128){x.suspense.unmount(he,Ie);return}en&&Jr(x,null,U,"beforeUnmount"),Ct&64?x.type.remove(x,U,he,Pe,Tt,Ie):We&&(Je!==Ht||pt>0&&pt&64)?dt(We,U,he,!1,!0):(Je===Ht&&pt&(128|256)||!Pe&&Ct&16)&&dt(tt,U,he),Ie&&Ze(x)}(nn&&(Wt=ct&&ct.onVnodeUnmounted)||en)&&jn(()=>{Wt&&Dr(Wt,U,x),en&&Jr(x,null,U,"unmounted")},he)},Ze=x=>{var{type:U,el:he,anchor:Ie,transition:Pe}=x;if(U===Ht){x.patchFlag>0&&x.patchFlag&2048&&Pe&&!Pe.persisted?x.children.forEach(We=>{We.type===it?S(We.el):Ze(We)}):Oe(he,Ie);return}if(U===fn){a(x);return}var Je=()=>{S(he),Pe&&!Pe.persisted&&Pe.afterLeave&&Pe.afterLeave()};if(x.shapeFlag&1&&Pe&&!Pe.persisted){var{leave:ct,delayLeave:Xe}=Pe,tt=()=>ct(he,Je);Xe?Xe(x.el,Je,tt):tt()}else Je()},Oe=(x,U)=>{for(var he;x!==U;)he=Fe(x),S(x),x=he;S(U)},ot=(x,U,he)=>{x.type.__hmrId&&So(x);var{bum:Ie,scope:Pe,update:Je,subTree:ct,um:Xe}=x;Ie&&u.invokeArrayFns(Ie),Pe.stop(),Je&&(Je.active=!1,me(ct,x,U,he)),Xe&&jn(Xe,U),jn(()=>{x.isUnmounted=!0},U),U&&U.pendingBranch&&!U.isUnmounted&&x.asyncDep&&!x.asyncResolved&&x.suspenseId===U.pendingId&&(U.deps--,U.deps===0&&U.resolve()),Ki(x)},dt=function(x,U,he){for(var Ie=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1,Pe=arguments.length>4&&arguments[4]!==void 0?arguments[4]:!1,Je=arguments.length>5&&arguments[5]!==void 0?arguments[5]:0,ct=Je;ct<x.length;ct++)me(x[ct],U,he,Ie,Pe)},Ye=x=>x.shapeFlag&6?Ye(x.component.subTree):x.shapeFlag&128?x.suspense.next():Fe(x.anchor||x.el),Ot=(x,U,he)=>{x==null?U._vnode&&me(U._vnode,null,null,!0):we(U._vnode||null,x,U,null,null,null,he),Gi(),U._vnode=x},Tt={p:we,um:me,m:le,r:Ze,mt:oe,mc:E,pc:rt,pbc:L,n:Ye,o},wt,$t;return l&&([wt,$t]=l(Tt)),{render:Ot,hydrate:wt,createApp:Ka(Ot,wt)}}function vo(o,l){var{effect:h,update:m}=o;h.allowRecurse=m.allowRecurse=l}function ai(o,l){var h=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!1,m=o.children,S=l.children;if(u.isArray(m)&&u.isArray(S))for(var O=0;O<m.length;O++){var M=m[O],Y=S[O];Y.shapeFlag&1&&!Y.dynamicChildren&&((Y.patchFlag<=0||Y.patchFlag===32)&&(Y=S[O]=Tn(S[O]),Y.el=M.el),h||ai(M,Y)),Y.type===it&&!Y.el&&(Y.el=M.el)}}function Mo(o){var l=o.slice(),h=[0],m,S,O,M,Y,H=o.length;for(m=0;m<H;m++){var ne=o[m];if(ne!==0){if(S=h[h.length-1],o[S]<ne){l[m]=S,h.push(m);continue}for(O=0,M=h.length-1;O<M;)Y=O+M>>1,o[h[Y]]<ne?O=Y+1:M=Y;ne<o[h[O]]&&(O>0&&(l[m]=h[O-1]),h[O]=m)}}for(O=h.length,M=h[O-1];O-- >0;)h[O]=M,M=l[M];return h}var Za=o=>o.__isTeleport,Ci=o=>o&&(o.disabled||o.disabled===""),mo=o=>typeof SVGElement!="undefined"&&o instanceof SVGElement,Xa=(o,l)=>{var h=o&&o.to;if(u.isString(h))if(l){var m=l(h);return m||se('Failed to locate Teleport target with selector "'.concat(h,'". ')+"Note the target element must exist before the component is mounted - i.e. the target cannot be rendered by the component itself, and ideally should be outside of the entire Vue component tree."),m}else return se("Current renderer does not support string target for Teleports. (missing querySelector renderer option)"),null;else return!h&&!Ci(o)&&se("Invalid Teleport target: ".concat(h)),h},Ds={__isTeleport:!0,process(o,l,h,m,S,O,M,Y,H,ne){var{mc:Ne,pc:fe,pbc:ce,o:{insert:Fe,querySelector:Ve,createText:lt,createComment:mt}}=ne,we=Ci(l.props),{shapeFlag:de,children:Se,dynamicChildren:nt}=l;if(Vr&&(H=!1,nt=null),o==null){var ze=l.el=mt("teleport start"),i=l.anchor=mt("teleport end");Fe(ze,h,m),Fe(i,h,m);var a=l.target=Xa(l.props,Ve),f=l.targetAnchor=lt("");a?(Fe(f,a),M=M||mo(a)):we||se("Invalid Teleport target on mount:",a,"(".concat(typeof a,")"));var p=(oe,te)=>{de&16&&Ne(Se,oe,te,S,O,M,Y,H)};we?p(h,i):a&&p(a,f)}else{l.el=o.el;var w=l.anchor=o.anchor,E=l.target=o.target,N=l.targetAnchor=o.targetAnchor,L=Ci(o.props),R=L?h:E,K=L?w:N;if(M=M||mo(E),nt?(ce(o.dynamicChildren,nt,R,S,O,M,Y),ai(o,l,!0)):H||fe(o,l,R,K,S,O,M,Y,!1),we)L||Ue(l,h,w,ne,1);else if((l.props&&l.props.to)!==(o.props&&o.props.to)){var ue=l.target=Xa(l.props,Ve);ue?Ue(l,ue,null,ne,0):se("Invalid Teleport target on update:",E,"(".concat(typeof E,")"))}else L&&Ue(l,E,N,ne,1)}},remove(o,l,h,m,S,O){var{um:M,o:{remove:Y}}=S,{shapeFlag:H,children:ne,anchor:Ne,targetAnchor:fe,target:ce,props:Fe}=o;if(ce&&Y(fe),(O||!Ci(Fe))&&(Y(Ne),H&16))for(var Ve=0;Ve<ne.length;Ve++){var lt=ne[Ve];M(lt,l,h,!0,!!lt.dynamicChildren)}},move:Ue,hydrate:It};function Ue(o,l,h,m){var{o:{insert:S},m:O}=m,M=arguments.length>4&&arguments[4]!==void 0?arguments[4]:2;M===0&&S(o.targetAnchor,l,h);var{el:Y,anchor:H,shapeFlag:ne,children:Ne,props:fe}=o,ce=M===2;if(ce&&S(Y,l,h),(!ce||Ci(fe))&&ne&16)for(var Fe=0;Fe<Ne.length;Fe++)O(Ne[Fe],l,h,2);ce&&S(H,l,h)}function It(o,l,h,m,S,O,M,Y){var{o:{nextSibling:H,parentNode:ne,querySelector:Ne}}=M,fe=l.target=Xa(l.props,Ne);if(fe){var ce=fe._lpa||fe.firstChild;if(l.shapeFlag&16)if(Ci(l.props))l.anchor=Y(H(o),l,ne(o),h,m,S,O),l.targetAnchor=ce;else{l.anchor=H(o);for(var Fe=ce;Fe;)if(Fe=H(Fe),Fe&&Fe.nodeType===8&&Fe.data==="teleport anchor"){l.targetAnchor=Fe,fe._lpa=l.targetAnchor&&H(l.targetAnchor);break}Y(ce,l,fe,h,m,S,O)}}return l.anchor&&H(l.anchor)}var Bt=Ds,Ht=Symbol("Fragment"),jt=Symbol("Text"),it=Symbol("Comment"),fn=Symbol("Static"),Br=[],rr=null;function Mr(){var o=arguments.length>0&&arguments[0]!==void 0?arguments[0]:!1;Br.push(rr=o?null:[])}function _o(){Br.pop(),rr=Br[Br.length-1]||null}var Oa=1;function Ko(o){Oa+=o}function el(o){return o.dynamicChildren=Oa>0?rr||u.EMPTY_ARR:null,_o(),Oa>0&&rr&&rr.push(o),o}function nc(o,l,h,m,S,O){return el(ps(o,l,h,m,S,O,!0))}function wl(o,l,h,m,S){return el(Mn(o,l,h,m,S,!0))}function bo(o){return o?o.__v_isVNode===!0:!1}function fr(o,l){return l.shapeFlag&6&&ar.has(l.type)?!1:o.type===l.type&&o.key===l.key}var si;function Ta(o){si=o}var Sl=function(){for(var o=arguments.length,l=new Array(o),h=0;h<o;h++)l[h]=arguments[h];return zn(...si?si(l,wn):l)},Fs="__vInternal",Do=o=>{var{key:l}=o;return l!=null?l:null},Qa=o=>{var{ref:l,ref_key:h,ref_for:m}=o;return l!=null?u.isString(l)||I.isRef(l)||u.isFunction(l)?{i:wn,r:l,k:h,f:!!m}:l:null};function ps(o){var l=arguments.length>1&&arguments[1]!==void 0?arguments[1]:null,h=arguments.length>2&&arguments[2]!==void 0?arguments[2]:null,m=arguments.length>3&&arguments[3]!==void 0?arguments[3]:0,S=arguments.length>4&&arguments[4]!==void 0?arguments[4]:null,O=arguments.length>5&&arguments[5]!==void 0?arguments[5]:o===Ht?0:1,M=arguments.length>6&&arguments[6]!==void 0?arguments[6]:!1,Y=arguments.length>7&&arguments[7]!==void 0?arguments[7]:!1,H={__v_isVNode:!0,__v_skip:!0,type:o,props:l,key:l&&Do(l),ref:l&&Qa(l),scopeId:Sn,slotScopeIds:null,children:h,component:null,suspense:null,ssContent:null,ssFallback:null,dirs:null,transition:null,el:null,anchor:null,target:null,targetAnchor:null,staticCount:0,shapeFlag:O,patchFlag:m,dynamicProps:S,dynamicChildren:null,appContext:null,hostInstance:wn};return Y?(Vi(H,h),O&128&&o.normalize(H)):h&&(H.shapeFlag|=u.isString(h)?8:16),H.key!==H.key&&se("VNode created with invalid key (NaN). VNode type:",H.type),Oa>0&&!M&&rr&&(H.patchFlag>0||O&6)&&H.patchFlag!==32&&rr.push(H),H}var Mn=Sl;function zn(o){var l=arguments.length>1&&arguments[1]!==void 0?arguments[1]:null,h=arguments.length>2&&arguments[2]!==void 0?arguments[2]:null,m=arguments.length>3&&arguments[3]!==void 0?arguments[3]:0,S=arguments.length>4&&arguments[4]!==void 0?arguments[4]:null,O=arguments.length>5&&arguments[5]!==void 0?arguments[5]:!1;if((!o||o===Ha)&&(o||se("Invalid vnode type when creating vnode: ".concat(o,".")),o=it),bo(o)){var M=Li(o,l,!0);return h&&Vi(M,h),Oa>0&&!O&&rr&&(M.shapeFlag&6?rr[rr.indexOf(o)]=M:rr.push(M)),M.patchFlag|=-2,M}if(Vs(o)&&(o=o.__vccOpts),l){l=Cl(l);var{class:Y,style:H}=l;Y&&!u.isString(Y)&&(l.class=u.normalizeClass(Y)),u.isObject(H)&&(I.isProxy(H)&&!u.isArray(H)&&(H=u.extend({},H)),l.style=u.normalizeStyle(H))}var ne=u.isString(o)?1:un(o)?128:Za(o)?64:u.isObject(o)?4:u.isFunction(o)?2:0;return ne&4&&I.isProxy(o)&&(o=I.toRaw(o),se("Vue received a Component which was made a reactive object. This can lead to unnecessary performance overhead, and should be avoided by marking the component with `markRaw` or using `shallowRef` instead of `ref`.",`
Component that was made reactive: `,o)),ps(o,l,h,m,S,ne,O,!0)}function Cl(o){return o?I.isProxy(o)||Fs in o?u.extend({},o):o:null}function Li(o,l){var h=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!1,{props:m,ref:S,patchFlag:O,children:M}=o,Y=l?Ia(m||{},l):m,H={__v_isVNode:!0,__v_skip:!0,type:o.type,props:Y,key:Y&&Do(Y),ref:l&&l.ref?h&&S?u.isArray(S)?S.concat(Qa(l)):[S,Qa(l)]:Qa(l):S,scopeId:o.scopeId,slotScopeIds:o.slotScopeIds,children:O===-1&&u.isArray(M)?M.map(Ai):M,target:o.target,targetAnchor:o.targetAnchor,staticCount:o.staticCount,shapeFlag:o.shapeFlag,patchFlag:l&&o.type!==Ht?O===-1?16:O|16:O,dynamicProps:o.dynamicProps,dynamicChildren:o.dynamicChildren,appContext:o.appContext,hostInstance:o.hostInstance,dirs:o.dirs,transition:o.transition,component:o.component,suspense:o.suspense,ssContent:o.ssContent&&Li(o.ssContent),ssFallback:o.ssFallback&&Li(o.ssFallback),el:o.el,anchor:o.anchor};return H}function Ai(o){var l=Li(o);return u.isArray(o.children)&&(l.children=o.children.map(Ai)),l}function es(){var o=arguments.length>0&&arguments[0]!==void 0?arguments[0]:" ",l=arguments.length>1&&arguments[1]!==void 0?arguments[1]:0;return Mn(jt,null,o,l)}function Al(o,l){var h=Mn(fn,null,o);return h.staticCount=l,h}function rc(){var o=arguments.length>0&&arguments[0]!==void 0?arguments[0]:"",l=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!1;return l?(Mr(),wl(it,null,o)):Mn(it,null,o)}function io(o){return o==null||typeof o=="boolean"?Mn(it):u.isArray(o)?Mn(Ht,null,o.slice()):typeof o=="object"?Tn(o):Mn(jt,null,String(o))}function Tn(o){return o.el===null||o.memo?o:Li(o)}function Vi(o,l){var h=0,{shapeFlag:m}=o;if(l==null)l=null;else if(u.isArray(l))h=16;else if(typeof l=="object")if(m&(1|64)){var S=l.default;S&&(S._c&&(S._d=!1),Vi(o,S()),S._c&&(S._d=!0));return}else{h=32;var O=l._;!O&&!(Fs in l)?l._ctx=wn:O===3&&wn&&(wn.slots._===1?l._=1:(l._=2,o.patchFlag|=1024))}else u.isFunction(l)?(l={default:l,_ctx:wn},h=32):(l=String(l),m&64?(h=16,l=[es(l)]):h=8);o.children=l,o.shapeFlag|=h}function Ia(){for(var o={},l=0;l<arguments.length;l++){var h=l<0||arguments.length<=l?void 0:arguments[l];for(var m in h)if(m==="class")o.class!==h.class&&(o.class=u.normalizeClass([o.class,h.class]));else if(m==="style")o.style=u.normalizeStyle([o.style,h.style]);else if(u.isOn(m)){var S=o[m],O=h[m];O&&S!==O&&!(u.isArray(S)&&S.includes(O))&&(o[m]=S?[].concat(S,O):O)}else m!==""&&(o[m]=h[m])}return o}function Dr(o,l,h){var m=arguments.length>3&&arguments[3]!==void 0?arguments[3]:null;Vt(o,l,7,[h,m])}var li=qa(),tl=0;function Ol(o,l,h){var m=o.type,S=(l?l.appContext:o.appContext)||li,O={uid:tl++,vnode:o,type:m,parent:l,appContext:S,root:null,next:null,subTree:null,effect:null,update:null,scope:new I.EffectScope(!0),render:null,proxy:null,exposed:null,exposeProxy:null,withProxy:null,provides:l?l.provides:Object.create(S.provides),accessCache:null,renderCache:[],components:null,directives:null,propsOptions:pn(m,S),emitsOptions:Ho(m,S),emit:null,emitted:null,propsDefaults:u.EMPTY_OBJ,inheritAttrs:m.inheritAttrs,ctx:u.EMPTY_OBJ,data:u.EMPTY_OBJ,props:u.EMPTY_OBJ,attrs:u.EMPTY_OBJ,slots:u.EMPTY_OBJ,refs:u.EMPTY_OBJ,setupState:u.EMPTY_OBJ,setupContext:null,suspense:h,suspenseId:h?h.pendingId:0,asyncDep:null,asyncResolved:!1,isMounted:!1,isUnmounted:!1,isDeactivated:!1,bc:null,c:null,bm:null,m:null,bu:null,u:null,um:null,bum:null,da:null,a:null,rtg:null,rtc:null,ec:null,sp:null};return O.ctx=Rs(O),O.root=l?l.root:O,O.emit=_a.bind(null,O),o.ce&&o.ce(O),O}var Jn=null,In=()=>Jn||wn,ci=o=>{Jn=o,o.scope.on()},Zr=()=>{Jn&&Jn.scope.off(),Jn=null},fa=u.makeMap("slot,component");function ts(o,l){var h=l.isNativeTag||u.NO;(fa(o)||h(o))&&se("Do not use built-in or reserved HTML elements as component id: "+o)}function Xr(o){return o.vnode.shapeFlag&4}k.isInSSRComponentSetup=!1;function Fo(o){var l=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!1;k.isInSSRComponentSetup=l;var{props:h,children:m}=o.vnode,S=Xr(o);Jt(o,h,S,l),Yo(o,m);var O=S?Tl(o,l):void 0;return k.isInSSRComponentSetup=!1,O}function Tl(o,l){var h,m=o.type;{if(m.name&&ts(m.name,o.appContext.config),m.components)for(var S=Object.keys(m.components),O=0;O<S.length;O++)ts(S[O],o.appContext.config);if(m.directives)for(var M=Object.keys(m.directives),Y=0;Y<M.length;Y++)Is(M[Y]);m.compilerOptions&&Nl()&&se('"compilerOptions" is only supported when using a build of Vue that includes the runtime compiler. Since you are using a runtime-only build, the options should be passed via your build tool config instead.')}o.accessCache=Object.create(null),o.proxy=I.markRaw(new Proxy(o.ctx,ua)),El(o);var{setup:H}=m;if(H){var ne=o.setupContext=H.length>1?kl(o):null;ci(o),I.pauseTracking();var Ne=Ft(H,o,0,[I.shallowReadonly(o.props),ne]);if(I.resetTracking(),Zr(),u.isPromise(Ne)){if(Ne.then(Zr,Zr),l)return Ne.then(ce=>{Il(o,ce,l)}).catch(ce=>{zr(ce,o,0)});if(o.asyncDep=Ne,!o.suspense){var fe=(h=m.name)!==null&&h!==void 0?h:"Anonymous";se("Component <".concat(fe,">: setup function returned a promise, but no ")+"<Suspense> boundary was found in the parent component tree. A component with async setup() must be nested in a <Suspense> in order to be rendered.")}}else Il(o,Ne,l)}else nl(o,l)}function Il(o,l,h){u.isFunction(l)?o.type.__ssrInlineRender?o.ssrRender=l:o.render=l:u.isObject(l)?(bo(l)&&se("setup() should not return VNodes directly - return a render function instead."),o.devtoolsRawSetupState=l,o.setupState=I.proxyRefs(l),xs(o)):l!==void 0&&se("setup() should return an object. Received: ".concat(l===null?"null":typeof l)),nl(o,h)}var ns,Pa;function Pl(o){ns=o,Pa=l=>{l.render._rc&&(l.withProxy=new Proxy(l.ctx,go))}}var Nl=()=>!ns;function nl(o,l,h){var m=o.type;if(!o.render){if(!l&&ns&&!m.render){var S=m.template;if(S){$r(o,"compile");var{isCustomElement:O,compilerOptions:M}=o.appContext.config,{delimiters:Y,compilerOptions:H}=m,ne=u.extend(u.extend({isCustomElement:O,delimiters:Y},M),H);m.render=ns(S,ne),Sr(o,"compile")}}o.render=m.render||u.NOOP,Pa&&Pa(o)}ci(o),I.pauseTracking(),F(o),I.resetTracking(),Zr(),!m.render&&o.render===u.NOOP&&!l&&(!ns&&m.template?se('Component provided template option but runtime compilation is not supported in this build of Vue. Configure your bundler to alias "vue" to "vue/dist/vue.esm-bundler.js".'):se("Component is missing template or render function."))}function ic(o){return new Proxy(o.attrs,{get(l,h){return ri(),I.track(o,"get","$attrs"),l[h]},set(){return se("setupContext.attrs is readonly."),!1},deleteProperty(){return se("setupContext.attrs is readonly."),!1}})}function kl(o){var l=m=>{o.exposed&&se("expose() should be called only once per setup()."),o.exposed=m||{}},h;return Object.freeze({get attrs(){return h||(h=ic(o))},get slots(){return I.shallowReadonly(o.slots)},get emit(){return function(m){for(var S=arguments.length,O=new Array(S>1?S-1:0),M=1;M<S;M++)O[M-1]=arguments[M];return o.emit(m,...O)}},expose:l})}function rs(o){if(o.exposed)return o.exposeProxy||(o.exposeProxy=new Proxy(I.proxyRefs(I.markRaw(o.exposed)),{get(l,h){if(h in l)return l[h];if(h in no)return no[h](o)}}))}var Ls=/(?:^|[-_])(\w)/g,Rl=o=>o.replace(Ls,l=>l.toUpperCase()).replace(/[-_]/g,"");function gs(o){var l=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!0;return u.isFunction(o)?o.displayName||o.name:o.name||l&&o.__name}function da(o,l){var h=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!1,m=gs(l);if(!m&&l.__file){var S=l.__file.match(/([^/\\]+)\.\w+$/);S&&(m=S[1])}if(!m&&o&&o.parent){var O=M=>{for(var Y in M)if(M[Y]===l)return Y};m=O(o.components||o.parent.type.components)||O(o.appContext.components)}return m?Rl(m):h?"App":"Anonymous"}function Vs(o){return u.isFunction(o)&&"__vccOpts"in o}var xl=(o,l)=>I.computed(o,l,k.isInSSRComponentSetup),$s=o=>se("".concat(o,"() is a compiler-hint helper that is only usable inside ")+"<script setup> of a single file component. Its arguments should be compiled away and passing it at runtime has no effect.");function Us(){return $s("defineProps"),null}function $c(){return $s("defineEmits"),null}function oc(o){$s("defineExpose")}function Uc(o,l){return $s("withDefaults"),null}function Hc(){return ac().slots}function jc(){return ac().attrs}function ac(){var o=In();return o||se("useContext() called without active instance."),o.setupContext||(o.setupContext=kl(o))}function sc(o,l){var h=u.isArray(o)?o.reduce((O,M)=>(O[M]={},O),{}):o;for(var m in l){var S=h[m];S?u.isArray(S)||u.isFunction(S)?h[m]={type:S,default:l[m]}:S.default=l[m]:S===null?h[m]={default:l[m]}:se('props default key "'.concat(m,'" has no corresponding declaration.'))}return h}function zc(o,l){var h={},m=function(O){l.includes(O)||Object.defineProperty(h,O,{enumerable:!0,get:()=>o[O]})};for(var S in o)m(S);return h}function Wc(o){var l=In();l||se("withAsyncContext called without active current instance. This is likely a bug.");var h=o();return Zr(),u.isPromise(h)&&(h=h.catch(m=>{throw ci(l),m})),[h,()=>ci(l)]}function Gc(o,l,h){var m=arguments.length;return m===2?u.isObject(l)&&!u.isArray(l)?bo(l)?Mn(o,null,[l]):Mn(o,l):Mn(o,null,l):(m>3?h=Array.prototype.slice.call(arguments,2):m===3&&bo(h)&&(h=[h]),Mn(o,l,h))}var Bl=Symbol("ssrContext"),lc=()=>{{var o=vr(Bl);return o||se("Server rendering context not provided. Make sure to only call useSSRContext() conditionally in the server build."),o}};function Ml(o){return!!(o&&o.__v_isShallow)}function Dl(){if(typeof window=="undefined")return;var o={style:"color:#3ba776"},l={style:"color:#0b1bc9"},h={style:"color:#b62e24"},m={style:"color:#9d288c"},S={header(fe){return u.isObject(fe)?fe.__isVue?["div",o,"VueInstance"]:I.isRef(fe)?["div",{},["span",o,Ne(fe)],"<",Y(fe.value),">"]:I.isReactive(fe)?["div",{},["span",o,Ml(fe)?"ShallowReactive":"Reactive"],"<",Y(fe),">".concat(I.isReadonly(fe)?" (readonly)":"")]:I.isReadonly(fe)?["div",{},["span",o,Ml(fe)?"ShallowReadonly":"Readonly"],"<",Y(fe),">"]:null:null},hasBody(fe){return fe&&fe.__isVue},body(fe){if(fe&&fe.__isVue)return["div",{},...O(fe.$)]}};function O(fe){var ce=[];fe.type.props&&fe.props&&ce.push(M("props",I.toRaw(fe.props))),fe.setupState!==u.EMPTY_OBJ&&ce.push(M("setup",fe.setupState)),fe.data!==u.EMPTY_OBJ&&ce.push(M("data",I.toRaw(fe.data)));var Fe=H(fe,"computed");Fe&&ce.push(M("computed",Fe));var Ve=H(fe,"inject");return Ve&&ce.push(M("injected",Ve)),ce.push(["div",{},["span",{style:m.style+";opacity:0.66"},"$ (internal): "],["object",{object:fe}]]),ce}function M(fe,ce){return ce=u.extend({},ce),Object.keys(ce).length?["div",{style:"line-height:1.25em;margin-bottom:0.6em"},["div",{style:"color:#476582"},fe],["div",{style:"padding-left:1.25em"},...Object.keys(ce).map(Fe=>["div",{},["span",m,Fe+": "],Y(ce[Fe],!1)])]]:["span",{}]}function Y(fe){var ce=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!0;return typeof fe=="number"?["span",l,fe]:typeof fe=="string"?["span",h,JSON.stringify(fe)]:typeof fe=="boolean"?["span",m,fe]:u.isObject(fe)?["object",{object:ce?I.toRaw(fe):fe}]:["span",h,String(fe)]}function H(fe,ce){var Fe=fe.type;if(!u.isFunction(Fe)){var Ve={};for(var lt in fe.ctx)ne(Fe,lt,ce)&&(Ve[lt]=fe.ctx[lt]);return Ve}}function ne(fe,ce,Fe){var Ve=fe[Fe];if(u.isArray(Ve)&&Ve.includes(ce)||u.isObject(Ve)&&ce in Ve||fe.extends&&ne(fe.extends,ce,Fe)||fe.mixins&&fe.mixins.some(lt=>ne(lt,ce,Fe)))return!0}function Ne(fe){return Ml(fe)?"ShallowRef":fe.effect?"ComputedRef":"Ref"}window.devtoolsFormatters?window.devtoolsFormatters.push(S):window.devtoolsFormatters=[S]}function Yc(o,l,h,m){var S=h[m];if(S&&cc(S,o))return S;var O=l();return O.memo=o.slice(),h[m]=O}function cc(o,l){var h=o.memo;if(h.length!=l.length)return!1;for(var m=0;m<h.length;m++)if(u.hasChanged(h[m],l[m]))return!1;return Oa>0&&rr&&rr.push(o),!0}var rl="3.2.37",Fl=null,yo=null,Hs={insert:(o,l,h)=>h?l.insertBefore(o,h):l.appendChild(o),remove:o=>{var l=o.parentNode;l&&l.removeChild(o)},createElement:o=>c.createElement(o),createText:o=>c.createText(o),createComment:o=>c.createComment(o),setText:(o,l)=>{o.setAttr("value",l)},setElementText:(o,l)=>{o.setAttr("value",l)},parentNode:o=>o.parentNode,nextSibling:o=>o.nextSibling};function dr(o){return Object.keys(o)}function ha(o){var l={};return u.isArray(o)&&o.forEach(h=>{dr(h).forEach(m=>{var S=h[m],O=l[m]||(l[m]={});dr(S).forEach(M=>{var Y=S[M],H=O[M]||(O[M]={});dr(Y).forEach(ne=>{ne[0]==="!"?(H[ne]=Y[ne],delete H[ne.slice(1)]):u.hasOwn(H,"!"+ne)||(H[ne]=Y[ne])})})})}),l}function Jo(o,l){var h=l&&l.classList;return h&&h.includes(o)}var uc=/[+~> ]$/,il="parentNode",Zo="previousSibling";function Ll(o,l){for(var h=o.split("."),m=h.length-1;m>0;m--){var S=h[m],O=S[S.length-1],M=S.replace(uc,"");if(O==="~"||O===" "){for(var Y=O==="~"?Zo:il;l&&(l=l[Y],!Jo(M,l)););if(!l)return!1}else if(O===">"?l=l&&l[il]:O==="+"&&(l=l&&l[Zo]),!Jo(M,l))return!1}return!0}var Xo=1e3;function fc(o,l,h){var{styles:m,weights:S}=o;dr(l).forEach(O=>{if(!(O&&h&&!Ll(O,h))){var M=O.split(".").length,Y=l[O];dr(Y).forEach(H=>{var ne=Y[H],Ne=H[0]==="!";Ne&&(H=H.slice(1));var fe=S[H]||0,ce=M+(Ne?Xo:0);ce>=fe&&(S[H]=ce,m[H]=ne)})}})}function oo(o,l){var h=arguments.length>2&&arguments[2]!==void 0?arguments[2]:null,m={styles:{},weights:{}};return o.forEach(S=>{var O=l[S];O&&fc(m,O,h)}),m.styles}function dc(o){return oo(o.classList,o.styleSheet,o)}function ol(o,l){var h=arguments.length>2&&arguments[2]!==void 0?arguments[2]:null;return oo(o,hc(l),h)}function hc(o){var{type:l,appContext:h}=o,m=l;if(!m.__styles)if(h&&u.isArray(h.provides.__globalStyles)&&(h.provides.__globalStyles=ha(h.provides.__globalStyles)),m.mpType==="page"&&h)m.__styles=h.provides.__globalStyles;else{var S=[];h&&S.push(h.provides.__globalStyles),u.isArray(m.styles)&&m.styles.forEach(O=>S.push(O)),m.__styles=ha(S)}return m.__styles}function pc(o,l,h){var m=arguments.length>3&&arguments[3]!==void 0?arguments[3]:null;m&&([l,h]=Na(o,l,h,m)),o.setAttr(l,h)}var vs="hoverClass",gc="placeholderClass",vc="placeholderStyle",qc="indicatorClass",Kc="indicatorStyle",al="maskClass",Vl="maskStyle",mc={view:{class:[vs],style:[]},button:{class:[vs],style:[]},navigator:{class:[vs],style:[]},"u-input":{class:[gc],style:[vc]},"u-textarea":{class:[gc],style:[vc]},"picker-view":{class:[qc,al],style:[Kc,Vl]}};function Na(o,l,h,m){if(!h)return[l,h];var S=mc[o.type];if(S){var O=u.camelize(l);if(S.class.indexOf(O)>-1)return[O,ol([h],m,o)];if(S.style.indexOf(l)>-1)return u.isString(h)?[O,u.parseStringStyle(h)]:[O,u.normalizeStyle(h)]}return[l,h]}function js(o,l,h){var m=arguments.length>3&&arguments[3]!==void 0?arguments[3]:null;if(!!m){var S=h?h.split(" "):[];o.setClassList(S),o.setStyleSheet(hc(m))}}function $l(o,l,h,m){o.addEvent(l,h)}function sl(o,l){o.removeEvent(l)}function Jc(o,l,h,m){var S=arguments.length>4&&arguments[4]!==void 0?arguments[4]:null,O=o._vei||(o._vei={}),M=O[l];if(m&&M)M.value=m;else{var[Y,H]=bc(l);if(m){var ne=O[l]=dn(m,S);$l(o,Y,ne)}else M&&(sl(o,Y),O[l]=void 0)}}var ka=/(?:Once|Passive|Capture)$/;function _c(o){return o==="on-post-message"?"onPostMessage":o}function bc(o){var l;if(ka.test(o)){l={};for(var h;h=o.match(ka);)o=o.slice(0,o.length-h[0].length),l[h[0].toLowerCase()]=!0}return o=o.slice(2),[_c(u.hyphenate(o)),l]}function dn(o,l){var h=S=>{Vt(h.value,l,5,[S])};h.value=o;var m=new Set;return u.isArray(h.value)?h.value.forEach(S=>{S.modifiers&&S.modifiers.forEach(O=>{m.add(O)})}):(h.value.modifiers&&h.value.modifiers.forEach(S=>{m.add(S)}),Qo(h,l)),h.modifiers=[...m],h}function Qo(o,l){if(!!l){var{$wxsModules:h}=l;if(!!h){var m=o.value.toString();!h.find(S=>m.indexOf("."+S+".")>-1)||(o.wxsEvent=o.value())}}}function Lo(o,l,h){if(!!h){u.isString(h)&&(h=u.parseStringStyle(h));var m={},S=l&&!u.isString(l);if(S){for(var O in l)h[O]==null&&(m[u.camelize(O)]="");for(var M in h){var Y=h[M];Y!==l[M]&&(m[u.camelize(M)]=Y)}}else for(var H in h)m[u.camelize(H)]=h[H];o.setStyles(m)}}var pa=["u-input","u-textarea"],ea=function(o,l,h,m){var S=arguments.length>6?arguments[6]:void 0,O=arguments.length>9?arguments[9]:void 0;l==="class"?js(o,h,m,O||S):l==="style"?Lo(o,h,m):u.isOn(l)?u.isModelListener(l)||Jc(o,l,h,m,S):l==="modelValue"&&pa.includes(o.type)?o.setAttrs({modelValue:m,value:m}):pc(o,l,m,S)};function ll(){var o=arguments.length>0&&arguments[0]!==void 0?arguments[0]:"$style";{var l=In();if(!l)return se("useCssModule must be called inside setup()"),u.EMPTY_OBJ;var h=l.type.__cssModules;if(!h)return se("Current instance does not have CSS modules injected."),u.EMPTY_OBJ;var m=h[o];return m||(se('Current instance does not have CSS module named "'.concat(o,'".')),u.EMPTY_OBJ)}}function cl(o){var l=In();if(!l){se("useCssVars is called without current active component instance.");return}var h=()=>is(l.subTree,o(l.proxy));wa(()=>eo(h,{flush:"post"})),Rr(h)}function is(o,l){if(o.shapeFlag&128){var h=o.suspense;o=h.activeBranch,h.pendingBranch&&!h.isHydrating&&h.effects.push(()=>{is(h.activeBranch,l)})}for(;o.component;)o=o.component.subTree;if(o.shapeFlag&1&&o.el){var m=o.el.style;for(var S in l)m.setProperty("--".concat(S),l[S])}else o.type===Ht&&o.children.forEach(O=>is(O,l))}var zs=["ctrl","shift","alt","meta"],Ra={stop:o=>o.stopPropagation(),prevent:o=>o.preventDefault(),self:o=>o.target!==o.currentTarget,ctrl:o=>!o.ctrlKey,shift:o=>!o.shiftKey,alt:o=>!o.altKey,meta:o=>!o.metaKey,left:o=>"button"in o&&o.button!==0,middle:o=>"button"in o&&o.button!==1,right:o=>"button"in o&&o.button!==2,exact:(o,l)=>zs.some(h=>o["".concat(h,"Key")]&&!l.includes(h))},ms=(o,l)=>function(h){for(var m=0;m<l.length;m++){var S=Ra[l[m]];if(S&&S(h,l))return}for(var O=arguments.length,M=new Array(O>1?O-1:0),Y=1;Y<O;Y++)M[Y-1]=arguments[Y];return o(h,...M)},Ar=(o,l)=>h=>{if("key"in h){var m=u.hyphenate(h.key);if(l.some(S=>S===m))return o(h)}},_s=u.extend({patchProp:ea},Hs),ga;function os(){return ga||(ga=Cr(_s))}var Zc=function(){os().render(...arguments)},xa=function(){var o=os().createApp(...arguments),{mount:l}=o;return o.mount=h=>l(h),o};return Object.defineProperty(k,"camelize",{enumerable:!0,get:function(){return u.camelize}}),Object.defineProperty(k,"capitalize",{enumerable:!0,get:function(){return u.capitalize}}),Object.defineProperty(k,"hyphenate",{enumerable:!0,get:function(){return u.hyphenate}}),Object.defineProperty(k,"normalizeClass",{enumerable:!0,get:function(){return u.normalizeClass}}),Object.defineProperty(k,"normalizeProps",{enumerable:!0,get:function(){return u.normalizeProps}}),Object.defineProperty(k,"normalizeStyle",{enumerable:!0,get:function(){return u.normalizeStyle}}),Object.defineProperty(k,"toDisplayString",{enumerable:!0,get:function(){return u.toDisplayString}}),Object.defineProperty(k,"toHandlerKey",{enumerable:!0,get:function(){return u.toHandlerKey}}),Object.defineProperty(k,"EffectScope",{enumerable:!0,get:function(){return I.EffectScope}}),Object.defineProperty(k,"ReactiveEffect",{enumerable:!0,get:function(){return I.ReactiveEffect}}),Object.defineProperty(k,"customRef",{enumerable:!0,get:function(){return I.customRef}}),Object.defineProperty(k,"effect",{enumerable:!0,get:function(){return I.effect}}),Object.defineProperty(k,"effectScope",{enumerable:!0,get:function(){return I.effectScope}}),Object.defineProperty(k,"getCurrentScope",{enumerable:!0,get:function(){return I.getCurrentScope}}),Object.defineProperty(k,"isProxy",{enumerable:!0,get:function(){return I.isProxy}}),Object.defineProperty(k,"isReactive",{enumerable:!0,get:function(){return I.isReactive}}),Object.defineProperty(k,"isReadonly",{enumerable:!0,get:function(){return I.isReadonly}}),Object.defineProperty(k,"isRef",{enumerable:!0,get:function(){return I.isRef}}),Object.defineProperty(k,"isShallow",{enumerable:!0,get:function(){return I.isShallow}}),Object.defineProperty(k,"markRaw",{enumerable:!0,get:function(){return I.markRaw}}),Object.defineProperty(k,"onScopeDispose",{enumerable:!0,get:function(){return I.onScopeDispose}}),Object.defineProperty(k,"proxyRefs",{enumerable:!0,get:function(){return I.proxyRefs}}),Object.defineProperty(k,"reactive",{enumerable:!0,get:function(){return I.reactive}}),Object.defineProperty(k,"readonly",{enumerable:!0,get:function(){return I.readonly}}),Object.defineProperty(k,"ref",{enumerable:!0,get:function(){return I.ref}}),Object.defineProperty(k,"shallowReactive",{enumerable:!0,get:function(){return I.shallowReactive}}),Object.defineProperty(k,"shallowReadonly",{enumerable:!0,get:function(){return I.shallowReadonly}}),Object.defineProperty(k,"shallowRef",{enumerable:!0,get:function(){return I.shallowRef}}),Object.defineProperty(k,"stop",{enumerable:!0,get:function(){return I.stop}}),Object.defineProperty(k,"toRaw",{enumerable:!0,get:function(){return I.toRaw}}),Object.defineProperty(k,"toRef",{enumerable:!0,get:function(){return I.toRef}}),Object.defineProperty(k,"toRefs",{enumerable:!0,get:function(){return I.toRefs}}),Object.defineProperty(k,"triggerRef",{enumerable:!0,get:function(){return I.triggerRef}}),Object.defineProperty(k,"unref",{enumerable:!0,get:function(){return I.unref}}),k.BaseTransition=D,k.Comment=it,k.Fragment=Ht,k.KeepAlive=Va,k.Static=fn,k.Suspense=Bi,k.Teleport=Bt,k.Text=jt,k.callWithAsyncErrorHandling=Vt,k.callWithErrorHandling=Ft,k.cloneVNode=Li,k.compatUtils=yo,k.computed=xl,k.createApp=xa,k.createBlock=wl,k.createCommentVNode=rc,k.createElementBlock=nc,k.createElementVNode=ps,k.createHydrationRenderer=hs,k.createPropsRestProxy=zc,k.createRenderer=Cr,k.createSlots=Sa,k.createStaticVNode=Al,k.createTextVNode=es,k.createVNode=Mn,k.defineAsyncComponent=Cn,k.defineComponent=ge,k.defineEmits=$c,k.defineExpose=oc,k.defineProps=Us,k.getCurrentInstance=In,k.getTransitionRawChildren=Z,k.guardReactiveProps=Cl,k.h=Gc,k.handleError=zr,k.initCustomFormatter=Dl,k.inject=vr,k.injectHook=Go,k.isMemoSame=cc,k.isRuntimeOnly=Nl,k.isVNode=bo,k.mergeDefaults=sc,k.mergeProps=Ia,k.nextTick=gr,k.onActivated=No,k.onBeforeMount=yi,k.onBeforeUnmount=ko,k.onBeforeUpdate=nr,k.onDeactivated=sa,k.onErrorCaptured=Ts,k.onMounted=wa,k.onRenderTracked=Os,k.onRenderTriggered=As,k.onServerPrefetch=xr,k.onUnmounted=ca,k.onUpdated=Rr,k.openBlock=Mr,k.parseClassList=ol,k.parseClassStyles=dc,k.popScopeId=Oo,k.provide=cr,k.pushScopeId=lr,k.queuePostFlushCb=Ni,k.registerRuntimeCompiler=Pl,k.render=Zc,k.renderList=Ns,k.renderSlot=Ro,k.resolveComponent=yl,k.resolveDirective=Xs,k.resolveDynamicComponent=fo,k.resolveFilter=Fl,k.resolveTransitionHooks=be,k.setBlockTracking=Ko,k.setDevtoolsHook=Er,k.setTransitionHooks=J,k.ssrContextKey=Bl,k.toHandlers=ja,k.transformVNodeArgs=Ta,k.useAttrs=jc,k.useCssModule=ll,k.useCssStyles=ha,k.useCssVars=cl,k.useSSRContext=lc,k.useSlots=Hc,k.useTransitionState=bi,k.version=rl,k.warn=se,k.watch=to,k.watchEffect=eo,k.watchPostEffect=zo,k.watchSyncEffect=La,k.withAsyncContext=Wc,k.withCtx=Re,k.withDefaults=Uc,k.withDirectives=Zs,k.withKeys=Ar,k.withMemo=Yc,k.withModifiers=ms,k.withScopeId=Dt,Object.defineProperty(k,"__esModule",{value:!0}),k}({},T,B,b);return C.__TYPE__="nvue",C}var Lg=II(xI);var vu={};SI(vu,{EMPTY_ARR:()=>GI,EMPTY_OBJ:()=>WI,NO:()=>qI,NOOP:()=>YI,camelize:()=>sP,capitalize:()=>tf,def:()=>dP,extend:()=>di,getGlobalThis:()=>pP,hasChanged:()=>uP,hasOwn:()=>ql,hyphenate:()=>Qf,invokeArrayFns:()=>fP,isArray:()=>Hi,isBuiltInDirective:()=>oP,isFunction:()=>$n,isGloballyWhitelisted:()=>DI,isHTMLTag:()=>HI,isIntegerKey:()=>rP,isMap:()=>Ug,isModelListener:()=>ZI,isObject:()=>Dc,isOn:()=>JI,isPlainObject:()=>Fc,isPromise:()=>tP,isReservedProp:()=>iP,isSVGTag:()=>jI,isSet:()=>Hg,isString:()=>ji,isSymbol:()=>eP,makeMap:()=>Mc,normalizeClass:()=>Xf,normalizeProps:()=>VI,normalizeStyle:()=>Zf,parseStringStyle:()=>Vg,remove:()=>XI,toDisplayString:()=>zI,toHandlerKey:()=>cP,toNumber:()=>hP,toRawType:()=>nP,toTypeString:()=>qs});function Mc(v,c){let b=Object.create(null),T=v.split(",");for(let B=0;B<T.length;B++)b[T[B]]=!0;return c?B=>!!b[B.toLowerCase()]:B=>!!b[B]}var MI="Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt",DI=Mc(MI);function Zf(v){if(Hi(v)){let c={};for(let b=0;b<v.length;b++){let T=v[b],B=ji(T)?Vg(T):Zf(T);if(B)for(let C in B)c[C]=B[C]}return c}else{if(ji(v))return v;if(Dc(v))return v}}var FI=/;(?![^(]*\))/g,LI=/:(.+)/;function Vg(v){let c={};return v.split(FI).forEach(b=>{if(b){let T=b.split(LI);T.length>1&&(c[T[0].trim()]=T[1].trim())}}),c}function Xf(v){let c="";if(ji(v))c=v;else if(Hi(v))for(let b=0;b<v.length;b++){let T=Xf(v[b]);T&&(c+=T+" ")}else if(Dc(v))for(let b in v)v[b]&&(c+=b+" ");return c.trim()}function VI(v){if(!v)return null;let{class:c,style:b}=v;return c&&!ji(c)&&(v.class=Xf(c)),b&&(v.style=Zf(b)),v}var $I="html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,summary,template,blockquote,iframe,tfoot",UI="svg,animate,animateMotion,animateTransform,circle,clipPath,color-profile,defs,desc,discard,ellipse,feBlend,feColorMatrix,feComponentTransfer,feComposite,feConvolveMatrix,feDiffuseLighting,feDisplacementMap,feDistanceLight,feDropShadow,feFlood,feFuncA,feFuncB,feFuncG,feFuncR,feGaussianBlur,feImage,feMerge,feMergeNode,feMorphology,feOffset,fePointLight,feSpecularLighting,feSpotLight,feTile,feTurbulence,filter,foreignObject,g,hatch,hatchpath,image,line,linearGradient,marker,mask,mesh,meshgradient,meshpatch,meshrow,metadata,mpath,path,pattern,polygon,polyline,radialGradient,rect,set,solidcolor,stop,switch,symbol,text,textPath,title,tspan,unknown,use,view",HI=Mc($I),jI=Mc(UI),zI=v=>ji(v)?v:v==null?"":Hi(v)||Dc(v)&&(v.toString===jg||!$n(v.toString))?JSON.stringify(v,$g,2):String(v),$g=(v,c)=>c&&c.__v_isRef?$g(v,c.value):Ug(c)?{[`Map(${c.size})`]:[...c.entries()].reduce((b,[T,B])=>(b[`${T} =>`]=B,b),{})}:Hg(c)?{[`Set(${c.size})`]:[...c.values()]}:Dc(c)&&!Hi(c)&&!Fc(c)?String(c):c,WI={},GI=[],YI=()=>{},qI=()=>!1,KI=/^on[^a-z]/,JI=v=>KI.test(v),ZI=v=>v.startsWith("onUpdate:"),di=Object.assign,XI=(v,c)=>{let b=v.indexOf(c);b>-1&&v.splice(b,1)},QI=Object.prototype.hasOwnProperty,ql=(v,c)=>QI.call(v,c),Hi=Array.isArray,Ug=v=>qs(v)==="[object Map]",Hg=v=>qs(v)==="[object Set]",$n=v=>typeof v=="function",ji=v=>typeof v=="string",eP=v=>typeof v=="symbol",Dc=v=>v!==null&&typeof v=="object",tP=v=>Dc(v)&&$n(v.then)&&$n(v.catch),jg=Object.prototype.toString,qs=v=>jg.call(v),nP=v=>qs(v).slice(8,-1),Fc=v=>qs(v)==="[object Object]",rP=v=>ji(v)&&v!=="NaN"&&v[0]!=="-"&&""+parseInt(v,10)===v,iP=Mc(",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted"),oP=Mc("bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text,memo"),ef=v=>{let c=Object.create(null);return b=>c[b]||(c[b]=v(b))},aP=/-(\w)/g,sP=ef(v=>v.replace(aP,(c,b)=>b?b.toUpperCase():"")),lP=/\B([A-Z])/g,Qf=ef(v=>v.replace(lP,"-$1").toLowerCase()),tf=ef(v=>v.charAt(0).toUpperCase()+v.slice(1)),cP=ef(v=>v?`on${tf(v)}`:""),uP=(v,c)=>!Object.is(v,c),fP=(v,c)=>{for(let b=0;b<v.length;b++)v[b](c)},dP=(v,c,b)=>{Object.defineProperty(v,c,{configurable:!0,enumerable:!1,value:b})},hP=v=>{let c=parseFloat(v);return isNaN(c)?v:c},zg,pP=()=>zg||(zg=typeof globalThis!="undefined"?globalThis:typeof self!="undefined"?self:typeof window!="undefined"?window:typeof global!="undefined"?global:{});function Wg(v){var c=function(b,T){"use strict";function B(D,...ie){console.warn(`[Vue warn] ${D}`,...ie)}let C;class k{constructor(ie=!1){this.active=!0,this.effects=[],this.cleanups=[],!ie&&C&&(this.parent=C,this.index=(C.scopes||(C.scopes=[])).push(this)-1)}run(ie){if(this.active){let be=C;try{return C=this,ie()}finally{C=be}}}on(){C=this}off(){C=this.parent}stop(ie){if(this.active){let be,G;for(be=0,G=this.effects.length;be<G;be++)this.effects[be].stop();for(be=0,G=this.cleanups.length;be<G;be++)this.cleanups[be]();if(this.scopes)for(be=0,G=this.scopes.length;be<G;be++)this.scopes[be].stop(!0);if(this.parent&&!ie){let V=this.parent.scopes.pop();V&&V!==this&&(this.parent.scopes[this.index]=V,V.index=this.index)}this.active=!1}}}function u(D){return new k(D)}function I(D,ie=C){ie&&ie.active&&ie.effects.push(D)}function Ge(){return C}function At(D){C&&C.cleanups.push(D)}let tn=D=>{let ie=new Set(D);return ie.w=0,ie.n=0,ie},A=D=>(D.w&ae)>0,se=D=>(D.n&ae)>0,En=({deps:D})=>{if(D.length)for(let ie=0;ie<D.length;ie++)D[ie].w|=ae},Gn=D=>{let{deps:ie}=D;if(ie.length){let be=0;for(let G=0;G<ie.length;G++){let V=ie[G];A(V)&&!se(V)?V.delete(D):ie[be++]=V,V.w&=~ae,V.n&=~ae}ie.length=be}},bt=new WeakMap,Q=0,ae=1,hn=30,Ft,Vt=Symbol(""),zr=Symbol("");class ei{constructor(ie,be=null,G){this.fn=ie,this.scheduler=be,this.active=!0,this.deps=[],this.parent=void 0,I(this,G)}run(){if(!this.active)return this.fn();let ie=Ft,be=an;for(;ie;){if(ie===this)return;ie=ie.parent}try{return this.parent=Ft,Ft=this,an=!0,ae=1<<++Q,Q<=hn?En(this):Tr(this),this.fn()}finally{Q<=hn&&Gn(this),ae=1<<--Q,Ft=this.parent,an=be,this.parent=void 0,this.deferStop&&this.stop()}}stop(){Ft===this?this.deferStop=!0:this.active&&(Tr(this),this.onStop&&this.onStop(),this.active=!1)}}function Tr(D){let{deps:ie}=D;if(ie.length){for(let be=0;be<ie.length;be++)ie[be].delete(D);ie.length=0}}function mn(D,ie){D.effect&&(D=D.effect.fn);let be=new ei(D);ie&&(T.extend(be,ie),ie.scope&&I(be,ie.scope)),(!ie||!ie.lazy)&&be.run();let G=be.run.bind(be);return G.effect=be,G}function Gt(D){D.effect.stop()}let an=!0,Pn=[];function Un(){Pn.push(an),an=!1}function ir(){Pn.push(an),an=!0}function Fn(){let D=Pn.pop();an=D===void 0?!0:D}function Be(D,ie,be){if(an&&Ft){let G=bt.get(D);G||bt.set(D,G=new Map);let V=G.get(be);V||G.set(be,V=tn()),at(V,void 0)}}function at(D,ie){let be=!1;Q<=hn?se(D)||(D.n|=ae,be=!A(D)):be=!D.has(Ft),be&&(D.add(Ft),Ft.deps.push(D))}function yt(D,ie,be,G,V,J){let Z=bt.get(D);if(!Z)return;let ge=[];if(ie==="clear")ge=[...Z.values()];else if(be==="length"&&T.isArray(D))Z.forEach((Cn,_n)=>{(_n==="length"||_n>=G)&&ge.push(Cn)});else switch(be!==void 0&&ge.push(Z.get(be)),ie){case"add":T.isArray(D)?T.isIntegerKey(be)&&ge.push(Z.get("length")):(ge.push(Z.get(Vt)),T.isMap(D)&&ge.push(Z.get(zr)));break;case"delete":T.isArray(D)||(ge.push(Z.get(Vt)),T.isMap(D)&&ge.push(Z.get(zr)));break;case"set":T.isMap(D)&&ge.push(Z.get(Vt));break}let zt=void 0;if(ge.length===1)ge[0]&&Zt(ge[0]);else{let Cn=[];for(let _n of ge)_n&&Cn.push(..._n);Zt(tn(Cn))}}function Zt(D,ie){let be=T.isArray(D)?D:[...D];for(let G of be)G.computed&&sn(G,ie);for(let G of be)G.computed||sn(G,ie)}function sn(D,ie){(D!==Ft||D.allowRecurse)&&(D.scheduler?D.scheduler():D.run())}let cn=T.makeMap("__proto__,__v_isRef,__isVue"),gr=new Set(Object.getOwnPropertyNames(Symbol).filter(D=>D!=="arguments"&&D!=="caller").map(D=>Symbol[D]).filter(T.isSymbol)),yr=Ni(),Ii=Ni(!1,!0),Pi=Ni(!0),or=Ni(!0,!0),zi=$o();function $o(){let D={};return["includes","indexOf","lastIndexOf"].forEach(ie=>{D[ie]=function(...be){let G=Xt(this);for(let J=0,Z=this.length;J<Z;J++)Be(G,"get",J+"");let V=G[ie](...be);return V===-1||V===!1?G[ie](...be.map(Xt)):V}}),["push","pop","shift","unshift","splice"].forEach(ie=>{D[ie]=function(...be){Un();let G=Xt(this)[ie].apply(this,be);return Fn(),G}}),D}function Ni(D=!1,ie=!1){return function(G,V,J){if(V==="__v_isReactive")return!D;if(V==="__v_isReadonly")return D;if(V==="__v_isShallow")return ie;if(V==="__v_raw"&&J===(D?ie?lr:Nn:ie?Sn:wn).get(G))return G;let Z=T.isArray(G);if(!D&&Z&&T.hasOwn(zi,V))return Reflect.get(zi,V,J);let ge=Reflect.get(G,V,J);return(T.isSymbol(V)?gr.has(V):cn(V))||(D||Be(G,"get",V),ie)?ge:Yn(ge)?Z&&T.isIntegerKey(V)?ge:ge.value:T.isObject(ge)?D?ri(ge):Re(ge):ge}}let Wi=hi(),Gi=hi(!0);function hi(D=!1){return function(be,G,V,J){let Z=be[G];if(Yr(Z)&&Yn(Z)&&!Yn(V))return!1;if(!D&&!Yr(V)&&(ia(V)||(V=Xt(V),Z=Xt(Z)),!T.isArray(be)&&Yn(Z)&&!Yn(V)))return Z.value=V,!0;let ge=T.isArray(be)&&T.isIntegerKey(G)?Number(G)<be.length:T.hasOwn(be,G),zt=Reflect.set(be,G,V,J);return be===Xt(J)&&(ge?T.hasChanged(V,Z)&&yt(be,"set",G,V,Z):yt(be,"add",G,V)),zt}}function Yi(D,ie){let be=T.hasOwn(D,ie),G=D[ie],V=Reflect.deleteProperty(D,ie);return V&&be&&yt(D,"delete",ie,void 0,G),V}function Lr(D,ie){let be=Reflect.has(D,ie);return(!T.isSymbol(ie)||!gr.has(ie))&&Be(D,"has",ie),be}function Vr(D){return Be(D,"iterate",T.isArray(D)?"length":Vt),Reflect.ownKeys(D)}let ar={get:yr,set:Wi,deleteProperty:Yi,has:Lr,ownKeys:Vr},Ir={get:Pi,set(D,ie){return!0},deleteProperty(D,ie){return!0}},qi=T.extend({},ar,{get:Ii,set:Gi}),So=T.extend({},Ir,{get:or}),Co=D=>D,ti=D=>Reflect.getPrototypeOf(D);function Qn(D,ie,be=!1,G=!1){D=D.__v_raw;let V=Xt(D),J=Xt(ie);be||(ie!==J&&Be(V,"get",ie),Be(V,"get",J));let{has:Z}=ti(V),ge=G?Co:be?un:xi;if(Z.call(V,ie))return ge(D.get(ie));if(Z.call(V,J))return ge(D.get(J));D!==V&&D.get(ie)}function pi(D,ie=!1){let be=this.__v_raw,G=Xt(be),V=Xt(D);return ie||(D!==V&&Be(G,"has",D),Be(G,"has",V)),D===V?be.has(D):be.has(D)||be.has(V)}function ni(D,ie=!1){return D=D.__v_raw,!ie&&Be(Xt(D),"iterate",Vt),Reflect.get(D,"size",D)}function sr(D){D=Xt(D);let ie=Xt(this);return ti(ie).has.call(ie,D)||(ie.add(D),yt(ie,"add",D,D)),this}function gi(D,ie){ie=Xt(ie);let be=Xt(this),{has:G,get:V}=ti(be),J=G.call(be,D);J||(D=Xt(D),J=G.call(be,D));let Z=V.call(be,D);return be.set(D,ie),J?T.hasChanged(ie,Z)&&yt(be,"set",D,ie,Z):yt(be,"add",D,ie),this}function vi(D){let ie=Xt(this),{has:be,get:G}=ti(ie),V=be.call(ie,D);V||(D=Xt(D),V=be.call(ie,D));let J=G?G.call(ie,D):void 0,Z=ie.delete(D);return V&&yt(ie,"delete",D,void 0,J),Z}function mi(){let D=Xt(this),ie=D.size!==0,be=void 0,G=D.clear();return ie&&yt(D,"clear",void 0,void 0,be),G}function Er(D,ie){return function(G,V){let J=this,Z=J.__v_raw,ge=Xt(Z),zt=ie?Co:D?un:xi;return!D&&Be(ge,"iterate",Vt),Z.forEach((Cn,_n)=>G.call(V,zt(Cn),zt(_n),J))}}function Pr(D,ie,be){return function(...G){let V=this.__v_raw,J=Xt(V),Z=T.isMap(J),ge=D==="entries"||D===Symbol.iterator&&Z,zt=D==="keys"&&Z,Cn=V[D](...G),_n=be?Co:ie?un:xi;return!ie&&Be(J,"iterate",zt?zr:Vt),{next(){let{value:mr,done:qn}=Cn.next();return qn?{value:mr,done:qn}:{value:ge?[_n(mr[0]),_n(mr[1])]:_n(mr),done:qn}},[Symbol.iterator](){return this}}}}function Wr(D){return function(...ie){return D==="delete"?!1:this}}function Gr(){let D={get(J){return Qn(this,J)},get size(){return ni(this)},has:pi,add:sr,set:gi,delete:vi,clear:mi,forEach:Er(!1,!1)},ie={get(J){return Qn(this,J,!1,!0)},get size(){return ni(this)},has:pi,add:sr,set:gi,delete:vi,clear:mi,forEach:Er(!1,!0)},be={get(J){return Qn(this,J,!0)},get size(){return ni(this,!0)},has(J){return pi.call(this,J,!0)},add:Wr("add"),set:Wr("set"),delete:Wr("delete"),clear:Wr("clear"),forEach:Er(!0,!1)},G={get(J){return Qn(this,J,!0,!0)},get size(){return ni(this,!0)},has(J){return pi.call(this,J,!0)},add:Wr("add"),set:Wr("set"),delete:Wr("delete"),clear:Wr("clear"),forEach:Er(!0,!0)};return["keys","values","entries",Symbol.iterator].forEach(J=>{D[J]=Pr(J,!1,!1),be[J]=Pr(J,!0,!1),ie[J]=Pr(J,!1,!0),G[J]=Pr(J,!0,!0)}),[D,be,ie,G]}let[er,Ki,Ji,uo]=Gr();function _i(D,ie){let be=ie?D?uo:Ji:D?Ki:er;return(G,V,J)=>V==="__v_isReactive"?!D:V==="__v_isReadonly"?D:V==="__v_raw"?G:Reflect.get(T.hasOwn(be,V)&&V in G?be:G,V,J)}let Ao={get:_i(!1,!1)},Uo={get:_i(!1,!0)},_a={get:_i(!0,!1)},Ho={get:_i(!0,!0)};function Zi(D,ie,be){let G=Xt(be);if(G!==be&&ie.call(D,G)){let V=T.toRawType(D);console.warn(`Reactive ${V} contains both the raw and reactive versions of the same object${V==="Map"?" as keys":""}, which can lead to inconsistencies. Avoid differentiating between the raw and reactive versions of an object and only use the reactive version if possible.`)}}let wn=new WeakMap,Sn=new WeakMap,Nn=new WeakMap,lr=new WeakMap;function Oo(D){switch(D){case"Object":case"Array":return 1;case"Map":case"Set":case"WeakMap":case"WeakSet":return 2;default:return 0}}function Dt(D){return D.__v_skip||!Object.isExtensible(D)?0:Oo(T.toRawType(D))}function Re(D){return Yr(D)?D:Qi(D,!1,ar,Ao,wn)}function Xi(D){return Qi(D,!1,qi,Uo,Sn)}function ri(D){return Qi(D,!0,Ir,_a,Nn)}function ki(D){return Qi(D,!0,So,Ho,lr)}function Qi(D,ie,be,G,V){if(!T.isObject(D)||D.__v_raw&&!(ie&&D.__v_isReactive))return D;let J=V.get(D);if(J)return J;let Z=Dt(D);if(Z===0)return D;let ge=new Proxy(D,Z===2?G:be);return V.set(D,ge),ge}function Ri(D){return Yr(D)?Ri(D.__v_raw):!!(D&&D.__v_isReactive)}function Yr(D){return!!(D&&D.__v_isReadonly)}function ia(D){return!!(D&&D.__v_isShallow)}function To(D){return Ri(D)||Yr(D)}function Xt(D){let ie=D&&D.__v_raw;return ie?Xt(ie):D}function ba(D){return T.def(D,"__v_skip",!0),D}let xi=D=>T.isObject(D)?Re(D):D,un=D=>T.isObject(D)?ri(D):D;function qr(D){an&&Ft&&(D=Xt(D),at(D.dep||(D.dep=tn())))}function Bi(D,ie){D=Xt(D),D.dep&&Zt(D.dep)}function Yn(D){return!!(D&&D.__v_isRef===!0)}function Io(D){return oa(D,!1)}function Fa(D){return oa(D,!0)}function oa(D,ie){return Yn(D)?D:new jo(D,ie)}class jo{constructor(ie,be){this.__v_isShallow=be,this.dep=void 0,this.__v_isRef=!0,this._rawValue=be?ie:Xt(ie),this._value=be?ie:xi(ie)}get value(){return qr(this),this._value}set value(ie){ie=this.__v_isShallow?ie:Xt(ie),T.hasChanged(ie,this._rawValue)&&(this._rawValue=ie,this._value=this.__v_isShallow?ie:xi(ie),Bi(this,ie))}}function aa(D){Bi(D,void 0)}function ya(D){return Yn(D)?D.value:D}let Nr={get:(D,ie,be)=>ya(Reflect.get(D,ie,be)),set:(D,ie,be,G)=>{let V=D[ie];return Yn(V)&&!Yn(be)?(V.value=be,!0):Reflect.set(D,ie,be,G)}};function kr(D){return Ri(D)?D:new Proxy(D,Nr)}class kn{constructor(ie){this.dep=void 0,this.__v_isRef=!0;let{get:be,set:G}=ie(()=>qr(this),()=>Bi(this));this._get=be,this._set=G}get value(){return this._get()}set value(ie){this._set(ie)}}function cr(D){return new kn(D)}function vr(D){let ie=T.isArray(D)?new Array(D.length):{};for(let be in D)ie[be]=zo(D,be);return ie}class eo{constructor(ie,be,G){this._object=ie,this._key=be,this._defaultValue=G,this.__v_isRef=!0}get value(){let ie=this._object[this._key];return ie===void 0?this._defaultValue:ie}set value(ie){this._object[this._key]=ie}}function zo(D,ie,be){let G=D[ie];return Yn(G)?G:new eo(D,ie,be)}class La{constructor(ie,be,G,V){this._setter=be,this.dep=void 0,this.__v_isRef=!0,this._dirty=!0,this.effect=new ei(ie,()=>{this._dirty||(this._dirty=!0,Bi(this))}),this.effect.computed=this,this.effect.active=this._cacheable=!V,this.__v_isReadonly=G}get value(){let ie=Xt(this);return qr(ie),(ie._dirty||!ie._cacheable)&&(ie._dirty=!1,ie._value=ie.effect.run()),ie._value}set value(ie){this._setter(ie)}}function Ea(D,ie,be=!1){let G,V,J=T.isFunction(D);return J?(G=D,V=T.NOOP):(G=D.get,V=D.set),new La(G,V,J||!V,be)}var to;let Kr=Promise.resolve(),Mi=[],Wo=!1,ii=D=>{Mi.push(D),Wo||(Wo=!0,Kr.then(bi))},bi=()=>{for(let D=0;D<Mi.length;D++)Mi[D]();Mi.length=0,Wo=!1};class tr{constructor(ie){this.dep=void 0,this._dirty=!0,this.__v_isRef=!0,this[to]=!0;let be,G=!1,V=!1;this.effect=new ei(ie,J=>{if(this.dep){if(J)be=this._value,G=!0;else if(!V){let Z=G?be:this._value;V=!0,G=!1,ii(()=>{this.effect.active&&this._get()!==Z&&Bi(this),V=!1})}for(let Z of this.dep)Z.computed instanceof tr&&Z.scheduler(!0)}this._dirty=!0}),this.effect.computed=this}_get(){return this._dirty?(this._dirty=!1,this._value=this.effect.run()):this._value}get value(){return qr(this),Xt(this)._get()}}to="__v_isReadonly";function wr(D){return new tr(D)}return b.EffectScope=k,b.ITERATE_KEY=Vt,b.ReactiveEffect=ei,b.computed=Ea,b.customRef=cr,b.deferredComputed=wr,b.effect=mn,b.effectScope=u,b.enableTracking=ir,b.getCurrentScope=Ge,b.isProxy=To,b.isReactive=Ri,b.isReadonly=Yr,b.isRef=Yn,b.isShallow=ia,b.markRaw=ba,b.onScopeDispose=At,b.pauseTracking=Un,b.proxyRefs=kr,b.reactive=Re,b.readonly=ri,b.ref=Io,b.resetTracking=Fn,b.shallowReactive=Xi,b.shallowReadonly=ki,b.shallowRef=Fa,b.stop=Gt,b.toRaw=Xt,b.toRef=zo,b.toRefs=vr,b.track=Be,b.trigger=yt,b.triggerRef=aa,b.unref=ya,Object.defineProperty(b,"__esModule",{value:!0}),b}({},v);return c}function Gg(v){var c=function(b){"use strict";let T=`
`,B=44,C=50,k=50,u=["%","%"],I="#007aff",Ge="#f7f7f7",At=/^([a-z-]+:)?\/\//i,tn=/^data:.*,.*/,A="WEB_INVOKE_APPSERVICE",se="wxs://",En="json://",Gn="wxsModules",bt="renderjsModules",Q="onShow",ae="onHide",hn="onLaunch",Ft="onError",Vt="onThemeChange",zr="onKeyboardHeightChange",ei="onPageNotFound",Tr="onUnhandledRejection",mn="onLoad",Gt="onReady",an="onUnload",Pn="onInit",Un="onSaveExitState",ir="onResize",Fn="onBackPress",Be="onPageScroll",at="onTabItemTap",yt="onReachBottom",Zt="onPullDownRefresh",sn="onShareTimeline",cn="onAddToFavorites",gr="onShareAppMessage",yr="onNavigationBarButtonTap",Ii="onNavigationBarSearchInputClicked",Pi="onNavigationBarSearchInputChanged",or="onNavigationBarSearchInputConfirmed",zi="onNavigationBarSearchInputFocusChanged",$o="onAppEnterForeground",Ni="onAppEnterBackground",Wi="onWxsInvokeCallMethod";function Gi(G){return!!G.appContext}function hi(G){return G&&(Gi(G)?G.proxy:G)}function Yi(G){return G.nodeType===1}function Lr(G){let{vnode:V}=G;if(Yi(V.el))return V.el;let{subTree:J}=G;if(J.shapeFlag&16){let Z=J.children.find(ge=>ge.el&&Yi(ge.el));if(Z)return Z.el}return V.el}let Vr=0;function ar(G,...V){let J=Date.now(),Z=Vr?J-Vr:0;return Vr=J,`[${J}][${Z}ms][${G}]\uFF1A${V.map(ge=>JSON.stringify(ge)).join(" ")}`}function Ir(G){let V=Object.create(null);return J=>V[J]||(V[J]=G(J))}function qi(G){return Ir(G)}function So(G=""){return(""+G).replace(/[^\x00-\xff]/g,"**").length}function Co(G){return G.indexOf("/")===0}function ti(G){return Co(G)?G:"/"+G}function Qn(G){return Co(G)?G.slice(1):G}let pi=(G,V)=>{let J;for(let Z=0;Z<G.length;Z++)J=G[Z](V);return J};function ni(G,V=null){let J;return(...Z)=>(G&&(J=G.apply(V,Z),G=null),J)}function sr(G,V){G=G||{},b.isString(V)&&(V={errMsg:V}),/:ok$/.test(V.errMsg)?b.isFunction(G.success)&&G.success(V):b.isFunction(G.fail)&&G.fail(V),b.isFunction(G.complete)&&G.complete(V)}function gi(G){let V={};return b.isPlainObject(G)&&Object.keys(G).sort().forEach(J=>{let Z=J;V[Z]=G[Z]}),Object.keys(V)?V:G}let vi=encodeURIComponent;function mi(G,V=vi){let J=G?Object.keys(G).map(Z=>{let ge=G[Z];return typeof ge===void 0||ge===null?ge="":b.isPlainObject(ge)&&(ge=JSON.stringify(ge)),V(Z)+"="+V(ge)}).filter(Z=>Z.length>0).join("&"):null;return J?`?${J}`:""}function Er(G){try{return decodeURIComponent(""+G)}catch(V){}return""+G}let Pr=/\+/g;function Wr(G){let V={};if(G===""||G==="?")return V;let Z=(G[0]==="?"?G.slice(1):G).split("&");for(let ge=0;ge<Z.length;++ge){let zt=Z[ge].replace(Pr," "),Cn=zt.indexOf("="),_n=Er(Cn<0?zt:zt.slice(0,Cn)),mr=Cn<0?null:Er(zt.slice(Cn+1));if(_n in V){let qn=V[_n];b.isArray(qn)||(qn=V[_n]=[qn]),qn.push(mr)}else V[_n]=mr}return V}function Gr(G){let[V,J]=G.split("?",2);return{path:V,query:Wr(J||"")}}function er(G){let V={};return G&&Object.keys(G).forEach(J=>{J.indexOf("data-")===0&&(V[J.replace("data-","")]=G[J])}),V}class Ki extends Error{constructor(V){super(V);this.name="DOMException"}}function Ji(G,V){return V&&(V.capture&&(G+="Capture"),V.once&&(G+="Once"),V.passive&&(G+="Passive")),`on${b.capitalize(b.camelize(G))}`}class uo{constructor(V,J){this.defaultPrevented=!1,this.timeStamp=Date.now(),this._stop=!1,this._end=!1,this.type=V,this.bubbles=!!J.bubbles,this.cancelable=!!J.cancelable}preventDefault(){this.defaultPrevented=!0}stopImmediatePropagation(){this._end=this._stop=!0}stopPropagation(){this._stop=!0}}function _i(G){if(G instanceof uo)return G;let[V]=_a(G.type),J=new uo(V,{bubbles:!1,cancelable:!1});return b.extend(J,G),J}class Ao{constructor(){this.listeners=Object.create(null)}dispatchEvent(V){let J=this.listeners[V.type];if(!J)return!1;let Z=_i(V),ge=J.length;for(let zt=0;zt<ge&&(J[zt].call(this,Z),!Z._end);zt++);return Z.cancelable&&Z.defaultPrevented}addEventListener(V,J,Z){V=Ji(V,Z),(this.listeners[V]||(this.listeners[V]=[])).push(J)}removeEventListener(V,J,Z){V=Ji(V,Z);let ge=this.listeners[V];if(!ge)return;let zt=ge.indexOf(J);zt>-1&&ge.splice(zt,1)}}let Uo=/(?:Once|Passive|Capture)$/;function _a(G){let V;if(Uo.test(G)){V={};let J;for(;J=G.match(Uo);)G=G.slice(0,G.length-J[0].length),V[J[0].toLowerCase()]=!0}return[b.hyphenate(G.slice(2)),V]}let Ho=(()=>({stop:1,prevent:1<<1,self:1<<2}))();function Zi(G){let V=0;return G.includes("stop")&&(V|=Ho.stop),G.includes("prevent")&&(V|=Ho.prevent),G.includes("self")&&(V|=Ho.self),V}let wn=0,Sn=1,Nn=3,lr=8;function Oo(G,V){let{parentNode:J}=G;if(!J)return null;let{childNodes:Z}=J;return Z[Z.indexOf(G)+(V==="n"?1:-1)]||null}function Dt(G){let{parentNode:V}=G;V&&V.removeChild(G)}function Re(G){!G.nodeId&&G.pageNode&&(G.nodeId=G.pageNode.genId())}class Xi extends Ao{constructor(V,J,Z){super();if(this.pageNode=null,this.parentNode=null,this._text=null,Z){let{pageNode:ge}=Z;ge&&(this.pageNode=ge,this.nodeId=ge.genId(),!ge.isUnmounted&&ge.onCreate(this,J))}this.nodeType=V,this.nodeName=J,this.childNodes=[]}get firstChild(){return this.childNodes[0]||null}get lastChild(){let{childNodes:V}=this,J=V.length;return J?V[J-1]:null}get nextSibling(){return Oo(this,"n")}get nodeValue(){return null}set nodeValue(V){}get textContent(){return this._text||""}set textContent(V){this._text=V,this.pageNode&&!this.pageNode.isUnmounted&&this.pageNode.onTextContent(this,V)}get parentElement(){let{parentNode:V}=this;return V&&V.nodeType===Sn?V:null}get previousSibling(){return Oo(this,"p")}appendChild(V){return this.insertBefore(V,null)}cloneNode(V){let J=b.extend(Object.create(Object.getPrototypeOf(this)),this),{attributes:Z}=J;return Z&&(J.attributes=b.extend({},Z)),V&&(J.childNodes=J.childNodes.map(ge=>ge.cloneNode(!0))),J}insertBefore(V,J){Dt(V),V.pageNode=this.pageNode,V.parentNode=this,Re(V);let{childNodes:Z}=this;if(J){let ge=Z.indexOf(J);if(ge===-1)throw new Ki("Failed to execute 'insertBefore' on 'Node': The node before which the new node is to be inserted is not a child of this node.");Z.splice(ge,0,V)}else Z.push(V);return this.pageNode&&!this.pageNode.isUnmounted?this.pageNode.onInsertBefore(this,V,J):V}removeChild(V){let{childNodes:J}=this,Z=J.indexOf(V);if(Z===-1)throw new Ki("Failed to execute 'removeChild' on 'Node': The node to be removed is not a child of this node.");return V.parentNode=null,J.splice(Z,1),this.pageNode&&!this.pageNode.isUnmounted?this.pageNode.onRemoveChild(V):V}}let ri="class",ki="style",Qi=".vOwnerId",Ri=".vRenderjs";class Yr extends Xi{constructor(V,J,Z){super(V,J,Z);this.attributes=Object.create(null),this.style=null,this.vShow=null,this._html=null}get className(){return this.attributes[ri]||""}set className(V){this.setAttribute(ri,V)}get innerHTML(){return""}set innerHTML(V){this._html=V}addEventListener(V,J,Z){super.addEventListener(V,J,Z),this.pageNode&&!this.pageNode.isUnmounted&&(J.wxsEvent?this.pageNode.onAddWxsEvent(this,Ji(V,Z),J.wxsEvent,Zi(J.modifiers||[])):this.pageNode.onAddEvent(this,Ji(V,Z),Zi(J.modifiers||[])))}removeEventListener(V,J,Z){super.removeEventListener(V,J,Z),this.pageNode&&!this.pageNode.isUnmounted&&this.pageNode.onRemoveEvent(this,Ji(V,Z))}getAttribute(V){return V===ki?this.style:this.attributes[V]}removeAttribute(V){V==ki?this.style=null:delete this.attributes[V],this.pageNode&&!this.pageNode.isUnmounted&&this.pageNode.onRemoveAttribute(this,V)}setAttribute(V,J){V===ki?this.style=J:this.attributes[V]=J,this.pageNode&&!this.pageNode.isUnmounted&&this.pageNode.onSetAttribute(this,V,J)}toJSON({attr:V,normalize:J}={}){let{attributes:Z,style:ge,listeners:zt,_text:Cn}=this,_n={};Object.keys(Z).length&&(_n.a=J?J(Z):Z);let mr=Object.keys(zt);if(mr.length){let qn,Va={};mr.forEach(Po=>{let No=zt[Po];if(No.length){let{wxsEvent:sa,modifiers:$a}=No[0],Ua=Zi($a||[]);sa?(qn||(qn={}),qn[Po]=[J?J(sa):sa,Ua]):Va[Po]=Ua}}),_n.e=J?J(Va,!1):Va,qn&&(_n.w=J?J(qn,!1):qn)}return ge!==null&&(_n.s=J?J(ge):ge),V||(_n.i=this.nodeId,_n.n=this.nodeName),Cn!==null&&(_n.t=J?J(Cn):Cn),_n}}class ia extends Xi{constructor(V,J){super(lr,"#comment",J);this._text=""}toJSON(V={}){return V.attr?{}:{i:this.nodeId}}}class To extends Yr{constructor(V,J){super(Sn,V.toUpperCase(),J);this.tagName=this.nodeName}}class Xt extends To{get value(){return this.getAttribute("value")}set value(V){this.setAttribute("value",V)}}class ba extends Xt{}class xi extends Yr{constructor(V,J){super(Nn,"#text",J);this._text=V}get nodeValue(){return this._text||""}set nodeValue(V){this._text=V,this.pageNode&&!this.pageNode.isUnmounted&&this.pageNode.onNodeValue(this,V)}}let un={AD:["data"],"AD-DRAW":["data"],"LIVE-PLAYER":["picture-in-picture-mode"],MAP:["markers","polyline","circles","controls","include-points","polygons"],PICKER:["range","value"],"PICKER-VIEW":["value"],"RICH-TEXT":["nodes"],VIDEO:["danmu-list","header"],"WEB-VIEW":["webview-styles"]},qr=["animation"],Bi=(G,V)=>{if(qr.indexOf(V)>-1)return!0;let J=un[G.nodeName];return!!(J&&J.indexOf(V)>-1)},Yn=1,Io=2,Fa=3,oa=4,jo=5,aa=6,ya=7,Nr=8,kr=9,kn=10,cr=12,vr=15,eo=20;function zo(G,V,{clearTimeout:J,setTimeout:Z}){let ge,zt=function(){J(ge),ge=Z(()=>G.apply(this,arguments),V)};return zt.cancel=function(){J(ge)},zt}class La{constructor(V,J){this.id=V,this.listener={},this.emitCache={},J&&Object.keys(J).forEach(Z=>{this.on(Z,J[Z])})}emit(V,...J){let Z=this.listener[V];if(!Z)return(this.emitCache[V]||(this.emitCache[V]=[])).push(J);Z.forEach(ge=>{ge.fn.apply(ge.fn,J)}),this.listener[V]=Z.filter(ge=>ge.type!=="once")}on(V,J){this._addListener(V,"on",J),this._clearCache(V)}once(V,J){this._addListener(V,"once",J),this._clearCache(V)}off(V,J){let Z=this.listener[V];if(!!Z)if(J)for(let ge=0;ge<Z.length;)Z[ge].fn===J&&(Z.splice(ge,1),ge--),ge++;else delete this.listener[V]}_clearCache(V){let J=this.emitCache[V];if(J)for(;J.length>0;)this.emit.apply(this,[V,...J.shift()])}_addListener(V,J,Z){(this.listener[V]||(this.listener[V]=[])).push({fn:Z,type:J})}}let Ea=[Pn,mn,Q,ae,an,Fn,Be,at,yt,Zt,sn,gr,cn,Un,yr,Ii,Pi,or,zi],to=[mn,Q];function Kr(G){return to.indexOf(G)>-1}function Mi(G){return Ea.indexOf(G)>-1}let Wo=[Q,ae,hn,Ft,Vt,ei,Tr,Pn,mn,Gt,an,ir,Fn,Be,at,yt,Zt,sn,cn,gr,Un,yr,Ii,Pi,or,zi],ii,bi=[];function tr(G){if(ii)return G(ii);bi.push(G)}function wr(G){ii=G,bi.forEach(V=>V(G))}let D=function(){};D.prototype={on:function(G,V,J){var Z=this.e||(this.e={});return(Z[G]||(Z[G]=[])).push({fn:V,ctx:J}),this},once:function(G,V,J){var Z=this;function ge(){Z.off(G,ge),V.apply(J,arguments)}return ge._=V,this.on(G,ge,J)},emit:function(G){var V=[].slice.call(arguments,1),J=((this.e||(this.e={}))[G]||[]).slice(),Z=0,ge=J.length;for(Z;Z<ge;Z++)J[Z].fn.apply(J[Z].ctx,V);return this},off:function(G,V){var J=this.e||(this.e={}),Z=J[G],ge=[];if(Z&&V)for(var zt=0,Cn=Z.length;zt<Cn;zt++)Z[zt].fn!==V&&Z[zt].fn._!==V&&ge.push(Z[zt]);return ge.length?J[G]=ge:delete J[G],this}};var ie=D,be={invokeArrayFns:pi,ON_LOAD:mn,ON_SHOW:Q,LINEFEED:T,RENDERJS_MODULES:bt,WXS_PROTOCOL:se,formatLog:ar,WXS_MODULES:Gn,ON_ERROR:Ft,UniLifecycleHooks:Wo,invokeCreateVueAppHook:wr,parseNVueDataset:er,once:ni,I18N_JSON_DELIMITERS:u,Emitter:ie,addLeadingSlash:ti,resolveComponentInstance:hi,removeLeadingSlash:Qn,ON_RESIZE:ir,ON_APP_ENTER_FOREGROUND:$o,ON_APP_ENTER_BACKGROUND:Ni,ON_HIDE:ae,ON_PAGE_SCROLL:Be,ON_REACH_BOTTOM:yt,SCHEME_RE:At,DATA_RE:tn,cacheStringFunction:qi,parseQuery:Wr,callOptions:sr,ON_UNHANDLE_REJECTION:Tr,ON_PAGE_NOT_FOUND:ei,PRIMARY_COLOR:I,getLen:So,TABBAR_HEIGHT:C,NAVBAR_HEIGHT:B,sortObject:gi,ON_THEME_CHANGE:Vt,ON_KEYBOARD_HEIGHT_CHANGE:zr,BACKGROUND_COLOR:Ge,ON_NAVIGATION_BAR_BUTTON_TAP:yr,stringifyQuery:mi,debounce:zo,ON_PULL_DOWN_REFRESH:Zt,ON_NAVIGATION_BAR_SEARCH_INPUT_CHANGED:Pi,ON_NAVIGATION_BAR_SEARCH_INPUT_CONFIRMED:or,ON_NAVIGATION_BAR_SEARCH_INPUT_CLICKED:Ii,ON_NAVIGATION_BAR_SEARCH_INPUT_FOCUS_CHANGED:zi,ON_BACK_PRESS:Fn,UniNode:Xi,NODE_TYPE_PAGE:wn,ACTION_TYPE_PAGE_CREATE:Yn,ACTION_TYPE_PAGE_CREATED:Io,ACTION_TYPE_PAGE_SCROLL:vr,ACTION_TYPE_INSERT:oa,ACTION_TYPE_CREATE:Fa,ACTION_TYPE_REMOVE:jo,ACTION_TYPE_ADD_EVENT:Nr,ACTION_TYPE_ADD_WXS_EVENT:cr,ACTION_TYPE_REMOVE_EVENT:kr,ACTION_TYPE_SET_ATTRIBUTE:aa,ACTION_TYPE_REMOVE_ATTRIBUTE:ya,ACTION_TYPE_SET_TEXT:kn,ON_READY:Gt,ON_UNLOAD:an,EventChannel:La,ON_REACH_BOTTOM_DISTANCE:k,parseUrl:Gr,onCreateVueApp:tr,ON_TAB_ITEM_TAP:at,ON_LAUNCH:hn,ACTION_TYPE_EVENT:eo,createUniEvent:_i,ON_WXS_INVOKE_CALL_METHOD:Wi,WEB_INVOKE_APPSERVICE:A,isRootHook:Mi,isRootImmediateHook:Kr,UniInputElement:Xt,UniTextAreaElement:ba,UniElement:To,UniTextNode:xi,UniCommentNode:ia,forcePatchProp:Bi,resolveOwnerEl:Lr,ATTR_V_OWNER_ID:Qi,ATTR_V_RENDERJS:Ri,JSON_PROTOCOL:En};return be}(v);return c}var gP=1;function Yg(){return(gP++).toString()}var ed=v=>v&&JSON.parse(JSON.stringify(v))||v;function mu(v){let c=qs(v);return c.substring(8,c.length-1)}function td(v){if(!$n(btoa))return"";let c=Array.prototype.map.call(new Uint8Array(v),b=>String.fromCharCode(b)).join("");return btoa(c)}function _u(v){if(!v||typeof v!="object")return!0;for(let c in v)if(ql(v,c))return!1;return!0}var nf=["off","error","warn","info","log","debug"],rf={};function qg(){nf.forEach(v=>{let c=nf.indexOf(v);rf[v]={},nf.forEach(b=>{nf.indexOf(b)<=c&&(rf[v][b]=!0)})})}function Xn(v){let c=global.WXEnvironment&&global.WXEnvironment.logLevel||"log";return rf[c]&&rf[c][v]}function co(v){global.nativeLog("wxInteractionAnalyzer: [jsfm]"+v,"__DEBUG")}function Kg(v,c,b){return`${c}@${b}#${v}`}var of=class{constructor(c){this.instanceId=String(c),this.lastCallbackId=0,this.callbacks={},this.hooks={}}add(c){return this.lastCallbackId++,this.callbacks[this.lastCallbackId]=c,this.lastCallbackId}remove(c){let b=this.callbacks[c];return delete this.callbacks[c],b}registerHook(c,b,T,B){let C=Kg(c,b,T);this.hooks[C]&&console.warn(`[JS Framework] Override an existing component hook "${C}".`),this.hooks[C]=B}triggerHook(c,b,T,B){let C=Kg(c,b,T),k=this.hooks[C];if(!$n(k))return console.error(`[JS Framework] Invalid hook function type (${typeof k}) on "${C}".`),null;let u=null;try{u=k.apply(null,B||[])}catch(I){throw console.error(`[JS Framework] Failed to execute the hook function on "${C}".`),I}return u}consume(c,b,T){let B=this.callbacks[c];if((typeof T=="undefined"||T===!1)&&delete this.callbacks[c],$n(B))try{return B.call(null,b,T)}catch(C){throw console.error(`[JS Framework] Failed to execute the callback function:
 ${C.toString()}`),C}return new Error(`invalid callback id "${c}"`)}close(){this.callbacks={},this.hooks={}}};var af={};function Jg(v,c){v&&(af[v]=c)}function Ks(v){return af[v]}function Zg(v){delete af[v]}function jr(v){if(v){let c=af[v];if(c&&c.taskCenter)return c.taskCenter}return null}function vP(v){v.calcClassList&&v.calcClassList()}function nd(v,c,b){let{documentElement:T}=v;if(T.pureChildren.length>0||c.parentNode)return;let B=T.children,C=b?B.indexOf(b):-1;C<0?B.push(c):B.splice(C,0,c),c.nodeType===1?(c.role==="body"?(c.docId=v.id,c.ownerDocument=v,c.parentNode=T,Kl(c,T)):(c.children.forEach(k=>{k.parentNode=c}),rd(v,c),Kl(c,T),delete v.nodeMap[c.nodeId]),T.pureChildren.push(c),mP(v,c)):(c.parentNode=T,v.nodeMap[c.ref]=c)}function mP(v,c){let b=c.toJSON();v&&v.taskCenter&&$n(v.taskCenter.send)&&v.taskCenter.send("dom",{action:"createBody"},[b])}function rd(v,c){c.role="body",c.depth=1,delete v.nodeMap[c.nodeId],c.ref="_root",v.nodeMap._root=c,v.body=c}function Kl(v,c){v.parentNode=c,vP(v),c.docId&&(v.docId=c.docId,v.ownerDocument=c.ownerDocument,v.ownerDocument.nodeMap[v.nodeId]=v,v.depth=c.depth+1),v.children.forEach(b=>{Kl(b,v)})}function id(v){for(;v;){if(v.nodeType===1)return v;v=v.nextSibling}}function od(v){for(;v;){if(v.nodeType===1)return v;v=v.previousSibling}}function Jl(v,c,b,T=!1){b<0&&(b=0);let B=c[b-1],C=c[b];return c.splice(b,0,v),T&&(B&&(B.nextSibling=v),v.previousSibling=B,v.nextSibling=C,C&&(C.previousSibling=v)),b}function Zl(v,c,b,T=!1){let B=c.indexOf(v);if(B<0)return-1;if(T){let I=c[B-1],Ge=c[B+1];I&&(I.nextSibling=Ge),Ge&&(Ge.previousSibling=I)}c.splice(B,1);let C=b;B<=b&&(C=b-1);let k=c[C-1],u=c[C];return c.splice(C,0,v),T&&(k&&(k.nextSibling=v),v.previousSibling=k,v.nextSibling=u,u&&(u.previousSibling=v)),B===C?-1:b}function ad(v,c,b=!1){let T=c.indexOf(v);if(!(T<0)){if(b){let B=c[T-1],C=c[T+1];B&&(B.nextSibling=C),C&&(C.previousSibling=B)}c.splice(T,1)}}var Xl=class{constructor(){this.depth=0;this.nodeId=Yg(),this.ref=this.nodeId,this.children=[],this.pureChildren=[],this.parentNode=null,this.nextSibling=null,this.previousSibling=null}destroy(){let c=Ks(this.docId);c&&(delete this.docId,delete c.nodeMap[this.nodeId]),this.children.forEach(b=>{b.destroy()})}};var Xg={};function sd(v,c){if(!Hi(c)||!c.length)return;class b extends wo{}c.forEach(T=>{b.prototype[T]=function(...B){let C=jr(this.docId);if(C)return C.send("component",{ref:this.ref,component:v,method:T},B)}}),Xg[v]=b}function Qg(v){return Xg[v]}function Fr(v,c,b,T,B){return{type:"decl",prop:v,value:c+(b?" !important":""),raws:T,source:B}}var _P="backgroundColor",bP="backgroundImage",yP=v=>{let{value:c,important:b,raws:T,source:B}=v;return/^#?\S+$/.test(c)||/^rgba?(.+)$/.test(c)?[Fr(_P,c,b,T,B)]:/^linear-gradient(.+)$/.test(c)?[Fr(bP,c,b,T,B)]:[v]},EP="Width",wP="Style",SP="Color",bu=v=>{let{prop:c,value:b,important:T,raws:B,source:C}=v,k=b.replace(/\s*,\s*/g,",").split(/\s+/),u=[/^[\d\.]+\S*$/,/^(solid|dashed|dotted)$/,/\S+/].map(I=>{let Ge=k.findIndex(At=>I.test(At));return Ge<0?null:k.splice(Ge,1)[0]});return k.length?[v]:[Fr(c+EP,(u[0]||"0").trim(),T,B,C),Fr(c+wP,(u[1]||"solid").trim(),T,B,C),Fr(c+SP,(u[2]||"#000000").trim(),T,B,C)]},CP="borderTop",AP="borderRight",OP="borderBottom",TP="borderLeft",ld=v=>{let{prop:c,value:b,important:T,raws:B,source:C}=v,k=Qf(c).split("-")[1];k=tf(k);let u=b.replace(/\s*,\s*/g,",").split(/\s+/);switch(u.length){case 1:return[v];case 2:u.push(u[0],u[1]);break;case 3:u.push(u[1]);break}return[Fr(CP+k,u[0],T,B,C),Fr(AP+k,u[1],T,B,C),Fr(OP+k,u[2],T,B,C),Fr(TP+k,u[3],T,B,C)]},IP="borderTopLeftRadius",PP="borderTopRightRadius",NP="borderBottomRightRadius",kP="borderBottomLeftRadius",RP=v=>{let{value:c,important:b,raws:T,source:B}=v,C=c.split(/\s+/);if(c.includes("/"))return[v];switch(C.length){case 1:return[v];case 2:C.push(C[0],C[1]);break;case 3:C.push(C[1]);break}return[Fr(IP,C[0],b,T,B),Fr(PP,C[1],b,T,B),Fr(NP,C[2],b,T,B),Fr(kP,C[3],b,T,B)]},xP=ld,BP=ld,MP="flexDirection",DP="flexWrap",FP=v=>{let{value:c,important:b,raws:T,source:B}=v,C=c.split(/\s+/),k=[/^(column|column-reverse|row|row-reverse)$/,/^(nowrap|wrap|wrap-reverse)$/].map(u=>{let I=C.findIndex(Ge=>u.test(Ge));return I<0?null:C.splice(I,1)[0]});return C.length?[v]:[Fr(MP,k[0]||"column",b,T,B),Fr(DP,k[1]||"nowrap",b,T,B)]},LP="Top",VP="Right",$P="Bottom",UP="Left",ev=v=>c=>{let{value:b,important:T,raws:B,source:C}=c,k=b.split(/\s+/);switch(k.length){case 1:k.push(k[0],k[0],k[0]);break;case 2:k.push(k[0],k[1]);break;case 3:k.push(k[1]);break}return[Fr(v+LP,k[0],T,B,C),Fr(v+VP,k[1],T,B,C),Fr(v+$P,k[2],T,B,C),Fr(v+UP,k[3],T,B,C)]},HP=ev("margin"),jP=ev("padding"),zP="transitionProperty",WP="transitionDuration",GP="transitionTimingFunction",YP="transitionDelay",qP=v=>{let c=/^(\S*)?\s*(\d*\.?\d+(?:ms|s)?)?\s*(\S*)?\s*(\d*\.?\d+(?:ms|s)?)?$/,{value:b,important:T,raws:B,source:C}=v,k=[],u=b.match(c);return u&&(u[1]&&k.push(Fr(zP,u[1],T,B,C)),u[2]&&k.push(Fr(WP,u[2],T,B,C)),u[3]&&k.push(Fr(GP,u[3],T,B,C)),u[4]&&k.push(Fr(YP,u[4],T,B,C))),k},tv={transition:qP,margin:HP,padding:jP,border:bu,background:yP};di(tv,{borderTop:bu,borderRight:bu,borderBottom:bu,borderLeft:bu,borderStyle:xP,borderWidth:BP,borderColor:ld,borderRadius:RP,flexFlow:FP});var nv=Symbol("expanded"),rv={postcssPlugin:"nvue:expand",Declaration(v){if(v[nv])return;let c=tv[v.prop];if(c){let b=c(v);b.length===1&&b[0]===v||v.replaceWith(b)}v[nv]=!0}};var KP=rv.Declaration;function cd(v,c){let b=di({replaceWith(B){T=B}},JP(v,c)),T=[b];return KP(b),T}function JP(v,c){let b=c+"";return b.includes("!important")?{prop:v,value:b.replace(/\s*!important/,""),important:!0}:{prop:v,value:b,important:!1}}var ZP="view",XP=["click","longpress","touchstart","touchmove","touchend","panstart","panmove","panend","horizontalpan","verticalpan","swipe"];function ud(v,c){let b=Ks(v);b.nodeMap[c.nodeId]=c}var fd;function iv(v){fd||(fd=v)}var wo=class extends Xl{constructor(c=ZP,b={},T){super();let B=Qg(c);if(B&&!T)return new B(c,b,!0);this.nodeType=1,this.type=c,this.attr=b.attr||{},this.style=b.style||{},this.classStyle=b.classStyle||{},this.classList=b.classList||[],this.styleSheet=b.styleSheet||{},this.event={}}appendChild(c){if(!(c.parentNode&&c.parentNode!==this)){if(c.parentNode){if(Xn("debug")&&co(`[appendChild](${this.docId},${c.type},${c.ref}) Move <${c.type}> to ${this.children.length} of <${this.type}> (${this.ref}).`),Zl(c,this.children,this.children.length,!0),c.nodeType===1){let b=Zl(c,this.pureChildren,this.pureChildren.length),T=jr(this.docId);if(T&&b>=0)return T.send("dom",{action:"moveElement"},[c.ref,this.ref,b])}}else if(Xn("debug")&&co(`[appendChild](${this.docId},${c.type},${c.ref}) Append <${c.type}> to <${this.type}> (${this.ref}).`),Kl(c,this),Jl(c,this.children,this.children.length,!0),this.docId&&ud(this.docId,c),c.nodeType===1){Jl(c,this.pureChildren,this.pureChildren.length);let b=jr(this.docId);if(b)return b.send("dom",{action:"addElement"},[this.ref,c.toJSON(),-1])}}}insertBefore(c,b){if(!(c.parentNode&&c.parentNode!==this)&&!(c===b||c.nextSibling&&c.nextSibling===b)){if(c.parentNode){if(Zl(c,this.children,this.children.indexOf(b),!0),c.nodeType===1){let T=id(b),B=Zl(c,this.pureChildren,T?this.pureChildren.indexOf(T):this.pureChildren.length),C=jr(this.docId);if(C&&B>=0)return C.send("dom",{action:"moveElement"},[c.ref,this.ref,B])}}else if(Xn("debug")&&co(`[insertBefore](${this.docId},${c.type},${c.ref}) Insert <${c.type}> to <${this.type}> (${this.ref}), before (${b.ref}).`),Kl(c,this),Jl(c,this.children,this.children.indexOf(b),!0),this.docId&&ud(this.docId,c),c.nodeType===1){let T=id(b),B=Jl(c,this.pureChildren,T?this.pureChildren.indexOf(T):this.pureChildren.length),C=jr(this.docId);if(C)return C.send("dom",{action:"addElement"},[this.ref,c.toJSON(),B])}}}insertAfter(c,b){if(!(c.parentNode&&c.parentNode!==this)&&!(c===b||c.previousSibling&&c.previousSibling===b)){if(c.parentNode){if(Zl(c,this.children,this.children.indexOf(b)+1,!0),c.nodeType===1){let T=Zl(c,this.pureChildren,this.pureChildren.indexOf(od(b))+1),B=jr(this.docId);if(B&&T>=0)return B.send("dom",{action:"moveElement"},[c.ref,this.ref,T])}}else if(Xn("debug")&&co(`[insertAfter](${this.docId},${c.type},${c.ref}) Insert <${c.type}> to <${this.type}> (${this.ref}), after (${b.ref}).`),Kl(c,this),Jl(c,this.children,this.children.indexOf(b)+1,!0),this.docId&&ud(this.docId,c),c.nodeType===1){let T=Jl(c,this.pureChildren,this.pureChildren.indexOf(od(b))+1),B=jr(this.docId);if(B)return B.send("dom",{action:"addElement"},[this.ref,c.toJSON(),T])}}}removeChild(c,b){if(c.parentNode&&(ad(c,this.children,!0),c.nodeType===1)){Xn("debug")&&co(`[removeChild](${this.docId},${c.type},${c.ref}) Remove <${c.type}> from <${this.type}> (${this.ref}).`),ad(c,this.pureChildren);let T=jr(this.docId);T&&T.send("dom",{action:"removeElement"},[c.ref])}b||c.destroy()}clear(){let c=jr(this.docId);c&&this.pureChildren.forEach(b=>{c.send("dom",{action:"removeElement"},[b.ref])}),this.children.forEach(b=>{b.destroy()}),this.children.length=0,this.pureChildren.length=0}setAttr(c,b,T){if(this.attr[c]===b&&T!==!1)return;this.attr[c]=b;let B=jr(this.docId);!T&&B&&B.send("dom",{action:"updateAttrs"},[this.ref,{[c]:b}])}setAttrs(c,b){if(_u(c))return;let T={};for(let B in c)this.attr[B]!==c[B]&&(this.attr[B]=c[B],T[B]=c[B]);if(!_u(T)){let B=jr(this.docId);!b&&B&&B.send("dom",{action:"updateAttrs"},[this.ref,T])}}setStyle(c,b,T){cd(c,b).forEach(({prop:B,value:C})=>{if(this.style[B]===C&&T!==!1)return;this.style[B]=C;let k=jr(this.docId);!T&&k&&k.send("dom",{action:"updateStyle"},[this.ref,{[B]:C}])})}setStyles(c,b){if(_u(c))return;let T={};for(let B in c)cd(B,c[B]).forEach(({prop:C,value:k})=>{this.style[C]!==k&&(this.style[C]=k,T[C]=k)});if(!_u(T)){let B=jr(this.docId);!b&&B&&B.send("dom",{action:"updateStyle"},[this.ref,T])}}setClassStyle(c){for(let T in this.classStyle)this.classStyle[T]="";di(this.classStyle,c);let b=jr(this.docId);b&&b.send("dom",{action:"updateStyle"},[this.ref,this.toStyle()])}setClassList(c){c.length===this.classList.length&&c.filter(b=>!this.classList.includes(b)).length===0||(this.classList=c,this.parentNode&&this.calcClassList())}calcClassList(){this.setClassStyle(fd(this))}setStyleSheet(c){this.styleSheet=c}addEvent(c,b,T){if(this.event||(this.event={}),!this.event[c]){Xn("debug")&&co(`[addEvent](${this.docId},${this.type},${this.ref}) Add "${c}" event on <${this.type}> (${this.ref}).`),this.event[c]={handler:b,params:T};let B=jr(this.docId);B&&B.send("dom",{action:"addEvent"},[this.ref,c])}}removeEvent(c){if(this.event&&this.event[c]){Xn("debug")&&co(`[removeEvent](${this.docId},${this.type},${this.ref}) Remove "${c}" event on <${this.type}> (${this.ref}).`),delete this.event[c];let b=jr(this.docId);b&&b.send("dom",{action:"removeEvent"},[this.ref,c])}}fireEvent(c,b,T,B){let C=null,k=!1,u=this.event[c];if(u&&b){Xn("debug")&&co(`[fireEvent](${this.docId},${this.type},${this.ref}) Fire "${c}" event on <${this.type}> (${this.ref}).`);let I=u.handler;b.stopPropagation=()=>{k=!0},b.preventDefault=()=>{};try{B&&B.params?C=I.call(this,...B.params,b):C=I.call(this,b)}catch(Ge){throw console.error(`[JS Framework] Failed to invoke the event handler of "${c}" on ${this.type} (${this.ref}):
 ${Ge.toString()}`),Ge}}return!k&&T&&XP.indexOf(c)!==-1&&this.parentNode&&this.parentNode.fireEvent&&(b.currentTarget=this.parentNode,this.parentNode.fireEvent(c,b,T)),C}toStyle(){return di({},this.classStyle,this.style)}toJSON(c=!1){let b={ref:this.ref.toString(),type:this.type,attr:this.attr,style:this.toStyle()},T=[];for(let B in this.event){let{params:C}=this.event[B];C?T.push({type:B,params:C}):T.push(B)}return T.length&&(b.event=T),!c&&this.pureChildren.length&&(b.children=this.pureChildren.map(B=>B.toJSON())),b}toString(){return"<"+this.type+" attr="+JSON.stringify(this.attr)+" style="+JSON.stringify(this.toStyle())+">"+this.pureChildren.map(c=>c.toString()).join("")+"</"+this.type+">"}};function ov(v){let c=v&&v.__v_raw;return c?ov(c):v}function av(v){let c=mu(v);switch(c){case"Undefined":case"Null":return"";case"RegExp":return v.toString();case"Date":return v.toISOString();case"Number":case"String":case"Boolean":case"Array":case"Object":return ov(v);case"ArrayBuffer":return{"@type":"binary",dataType:c,base64:td(v)};case"Int8Array":case"Uint8Array":case"Uint8ClampedArray":case"Int16Array":case"Uint16Array":case"Int32Array":case"Uint32Array":case"Float32Array":case"Float64Array":return{"@type":"binary",dataType:c,base64:td(v.buffer)};default:return JSON.stringify(v)}}var sf=function(){},Lc=class{constructor(c,b){Object.defineProperty(this,"instanceId",{enumerable:!0,value:String(c)}),Object.defineProperty(this,"callbackManager",{enumerable:!0,value:new of(c)}),sf=b||function(){}}callback(c,b,T){return this.callbackManager.consume(c,b,T)}registerHook(c,b,T,B){return this.callbackManager.registerHook(c,b,T,B)}triggerHook(c,b,T,B){return this.callbackManager.triggerHook(c,b,T,B)}updateData(c,b,T){this.send("module",{module:"dom",method:"updateComponentData"},[c,b,T])}destroyCallback(){return this.callbackManager.close()}normalize(c,b=!1){let T=mu(c);if(c&&c instanceof wo)return c.ref;if(c&&c.$el instanceof wo)return c.$el.ref;if(T==="Function")return this.callbackManager.add(c).toString();if(b){if(T==="Object"){let B={};for(let C in c)B[C]=this.normalize(c[C],!0);return B}if(T==="Array")return c.map(B=>this.normalize(B,!0))}return c&&c.ref&&c["[[VirtualElement]]"]?c.ref:av(c)}send(c,b,T,B){let{action:C,component:k,ref:u,module:I,method:Ge}=b;switch(T=T.map(At=>this.normalize(At,c!=="module")),mu(B)==="Object"&&(B=this.normalize(B,!0)),c){case"dom":return Xn("debug")&&co(`[task](${this.instanceId},${c},${C}) ${JSON.stringify(T)}`),this[C](this.instanceId,T);case"component":return this.componentHandler(this.instanceId,u,Ge,T,di({component:k},B));default:return Xn("debug")&&co(`[task](${this.instanceId},${I},${Ge}) ${JSON.stringify(T)}`),this.moduleHandler(this.instanceId,I,Ge,T,B)}}callDOM(c,b){return this[c](this.instanceId,b)}callComponent(c,b,T,B){return this.componentHandler(this.instanceId,c,b,T,B)}callModule(c,b,T,B){return this.moduleHandler(this.instanceId,c,b,T,B)}};function sv(){let v={createFinish:global.callCreateFinish,updateFinish:global.callUpdateFinish,refreshFinish:global.callRefreshFinish,createBody:global.callCreateBody,addElement:global.callAddElement,removeElement:global.callRemoveElement,moveElement:global.callMoveElement,updateAttrs:global.callUpdateAttrs,updateStyle:global.callUpdateStyle,addEvent:global.callAddEvent,removeEvent:global.callRemoveEvent,__updateComponentData:global.__updateComponentData},c=Lc.prototype;for(let b in v){let T=v[b];c[b]=T?(B,C)=>T(B,...C):(B,C)=>sf(B,[{module:"dom",method:b,args:C}],"-1")}c.componentHandler=global.callNativeComponent||((b,T,B,C,k)=>sf(b,[{component:k.component,ref:T,method:B,args:C}])),c.moduleHandler=global.callNativeModule||((b,T,B,C)=>sf(b,[{module:T,method:B,args:C}]))}function QP(v,c,b,T,B,C){let k=v.getRef(c);if(k)return v.fireEvent(k,b,T,B,C);if(T)return T._nodeId=c,v.fireEvent(v.getRef("_documentElement"),b,T,B,C)}function eN(v,c,b,T){return v.taskCenter.callback(c,b,T)}function tN(v,c,b,T,B){if(!v||!v.taskCenter)return console.error(`[JS Framework] Can't find "document" or "taskCenter".`),null;let C=null;try{C=v.taskCenter.triggerHook(c,b,T,B)}catch(k){throw console.error(`[JS Framework] Failed to trigger the "${b}@${T}" hook on ${c}.`),k}return C}function dd(v,c){let b=Ks(v);if(!b)return new Error(`[JS Framework] Failed to receiveTasks, instance (${v}) is not available.`);if(Hi(c))return c.map(T=>{switch(T.method){case"callback":return eN(b,...T.args);case"fireEventSync":case"fireEvent":return QP(b,...T.args);case"componentHook":return tN(b,...T.args)}})}var ml={};function lv(v={}){for(let c in v)ql(ml,c)||(ml[c]={}),!!Hi(v[c])&&v[c].forEach(b=>{ji(b)?ml[c][b]=!0:Fc(b)&&ji(b.name)&&(ml[c][b.name]=b.args||[])})}function lf(v,c){return ji(c)?!!(ml[v]&&ml[v][c]):!!ml[v]}function cv(v){return ml[v]}var hd={};function uv(v){!Hi(v)||v.forEach(c=>{!c||(ji(c)?hd[c]=!0:Fc(c)&&ji(c.type)&&(hd[c.type]=c,sd(c.type,c.methods)))})}function pd(v){return!!hd[v]}var _l=[];function cf(v,c){gd(v)?console.warn(`Service "${v}" has been registered already!`):(c=di({},c),_l.push({name:v,options:c}))}function uf(v){_l.some((c,b)=>{if(c.name===v)return _l.splice(b,1),!0})}function gd(v){return nN(v)>=0}function nN(v){return _l.map(c=>c.name).indexOf(v)}function rN(v){return c=>{let b=Xu(v,c),{createApp:T}=b;b.createVueApp=b.createApp=(B,C)=>T(B,C).use(iN,c),c.Vue=b}}var iN={install(v,c){oN(v,c),gu(c).initApp(v)}};function oN(v,c){let{mount:b}=v;v.mount=T=>{let B=b(T);return T==="#app"&&c.__registerApp(B),B}}function aN(v){let{UniShared:c,VueShared:b,VueReactivity:T}=v;var B=function(C,k,u,I){"use strict";var Ge=[];function At(i){Ge.push(i)}function tn(){Ge.pop()}function A(i){I.pauseTracking();for(var a=Ge.length?Ge[Ge.length-1].component:null,f=a&&a.appContext.config.warnHandler,p=se(),w=arguments.length,E=new Array(w>1?w-1:0),N=1;N<w;N++)E[N-1]=arguments[N];if(f)hn(f,a,11,[i+E.join(""),a&&a.proxy,p.map(R=>{var{vnode:K}=R;return"at <".concat(Vs(a,K.type),">")}).join(`
`),p]);else{var L=["[Vue warn]: ".concat(i),...E];p.length&&L.push(`
`,...En(p)),console.warn(...L)}I.resetTracking()}function se(){var i=Ge[Ge.length-1];if(!i)return[];for(var a=[];i;){var f=a[0];f&&f.vnode===i?f.recurseCount++:a.push({vnode:i,recurseCount:0});var p=i.component&&i.component.parent;i=p&&p.vnode}return a}function En(i){var a=[];return i.forEach((f,p)=>{a.push(...p===0?[]:[`
`],...Gn(f))}),a}function Gn(i){var{vnode:a,recurseCount:f}=i,p=f>0?"... (".concat(f," recursive calls)"):"",w=a.component?a.component.parent==null:!1,E=" at <".concat(Vs(a.component,a.type,w)),N=">"+p;return a.props?[E,...bt(a.props),N]:[E+N]}function bt(i){var a=[],f=Object.keys(i);return f.slice(0,3).forEach(p=>{a.push(...Q(p,i[p]))}),f.length>3&&a.push(" ..."),a}function Q(i,a,f){return u.isString(a)?(a=JSON.stringify(a),f?a:["".concat(i,"=").concat(a)]):typeof a=="number"||typeof a=="boolean"||a==null?f?a:["".concat(i,"=").concat(a)]:I.isRef(a)?(a=Q(i,I.toRaw(a.value),!0),f?a:["".concat(i,"=Ref<"),a,">"]):u.isFunction(a)?["".concat(i,"=fn").concat(a.name?"<".concat(a.name,">"):"")]:(a=I.toRaw(a),f?a:["".concat(i,"="),a])}var ae={sp:"serverPrefetch hook",bc:"beforeCreate hook",c:"created hook",bm:"beforeMount hook",m:"mounted hook",bu:"beforeUpdate hook",u:"updated",bum:"beforeUnmount hook",um:"unmounted hook",a:"activated hook",da:"deactivated hook",ec:"errorCaptured hook",rtc:"renderTracked hook",rtg:"renderTriggered hook",[0]:"setup function",[1]:"render function",[2]:"watcher getter",[3]:"watcher callback",[4]:"watcher cleanup function",[5]:"native event handler",[6]:"component event handler",[7]:"vnode hook",[8]:"directive hook",[9]:"transition hook",[10]:"app errorHandler",[11]:"app warnHandler",[12]:"ref function",[13]:"async component loader",[14]:"scheduler flush. This is likely a Vue internals bug. Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/core"};function hn(i,a,f,p){var w;try{w=p?i(...p):i()}catch(E){Vt(E,a,f)}return w}function Ft(i,a,f,p){if(u.isFunction(i)){var w=hn(i,a,f,p);return w&&u.isPromise(w)&&w.catch(L=>{Vt(L,a,f)}),w}for(var E=[],N=0;N<i.length;N++)E.push(Ft(i[N],a,f,p));return E}function Vt(i,a,f){var p=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!0,w=a?a.vnode:null;if(a){for(var E=a.parent,N=a.proxy,L=ae[f]||f;E;){var R=E.ec;if(R){for(var K=0;K<R.length;K++)if(R[K](i,N,L)===!1)return}E=E.parent}var ue=a.appContext.config.errorHandler;if(ue){hn(ue,null,10,[i,N,L]);return}}zr(i,f,w,p)}function zr(i,a,f){var p=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!0;{var w=ae[a]||a;f&&At(f),A("Unhandled error".concat(w?" during execution of ".concat(w):"")),f&&tn(),console.error(i)}}var ei=!1,Tr=!1,mn=[],Gt=0,an=[],Pn=null,Un=0,ir=[],Fn=null,Be=0,at={then(i){setTimeout(()=>i(),0)}},yt=C.platform==="iOS",Zt=yt?at:Promise.resolve(),sn=null,cn=null,gr=100;function yr(i){var a=sn||Zt;return i?a.then(this?i.bind(this):i):a}function Ii(i){for(var a=Gt+1,f=mn.length;a<f;){var p=a+f>>>1,w=Yi(mn[p]);w<i?a=p+1:f=p}return a}function Pi(i){(!mn.length||!mn.includes(i,ei&&i.allowRecurse?Gt+1:Gt))&&i!==cn&&(i.id==null?mn.push(i):mn.splice(Ii(i.id),0,i),or())}function or(){!ei&&!Tr&&(Tr=!0,sn=Zt.then(Lr))}function zi(i){var a=mn.indexOf(i);a>Gt&&mn.splice(a,1)}function $o(i,a,f,p){u.isArray(i)?f.push(...i):(!a||!a.includes(i,i.allowRecurse?p+1:p))&&f.push(i),or()}function Ni(i){$o(i,Pn,an,Un)}function Wi(i){$o(i,Fn,ir,Be)}function Gi(i){var a=arguments.length>1&&arguments[1]!==void 0?arguments[1]:null;if(an.length){for(cn=a,Pn=[...new Set(an)],an.length=0,i=i||new Map,Un=0;Un<Pn.length;Un++)Vr(i,Pn[Un])||Pn[Un]();Pn=null,Un=0,cn=null,Gi(i,a)}}function hi(i){if(Gi(),ir.length){var a=[...new Set(ir)];if(ir.length=0,Fn){Fn.push(...a);return}for(Fn=a,i=i||new Map,Fn.sort((f,p)=>Yi(f)-Yi(p)),Be=0;Be<Fn.length;Be++)Vr(i,Fn[Be])||Fn[Be]();Fn=null,Be=0}}var Yi=i=>i.id==null?1/0:i.id;function Lr(i){Tr=!1,ei=!0,i=i||new Map,Gi(i),mn.sort((p,w)=>Yi(p)-Yi(w));var a=p=>Vr(i,p);try{for(Gt=0;Gt<mn.length;Gt++){var f=mn[Gt];if(f&&f.active!==!1){if(a(f))continue;hn(f,null,14)}}}finally{Gt=0,mn.length=0,hi(i),ei=!1,sn=null,(mn.length||an.length||ir.length)&&Lr(i)}}function Vr(i,a){if(!i.has(a))i.set(a,1);else{var f=i.get(a);if(f>gr){var p=a.ownerInstance,w=p&&da(p.type);return A("Maximum recursive updates exceeded".concat(w?" in component <".concat(w,">"):"",". ")+"This means you have a reactive effect that is mutating its own dependencies and thus recursively triggering itself. Possible sources include component template, render function, updated hook or watcher source function."),!0}else i.set(a,f+1)}}var ar=!1,Ir=new Set;u.getGlobalThis().__VUE_HMR_RUNTIME__={createRecord:gi(ti),rerender:gi(pi),reload:gi(ni)};var qi=new Map;function So(i){var a=i.type.__hmrId,f=qi.get(a);f||(ti(a,i.type),f=qi.get(a)),f.instances.add(i)}function Co(i){qi.get(i.type.__hmrId).instances.delete(i)}function ti(i,a){return qi.has(i)?!1:(qi.set(i,{initialDef:Qn(a),instances:new Set}),!0)}function Qn(i){return xl(i)?i.__vccOpts:i}function pi(i,a){var f=qi.get(i);!f||(f.initialDef.render=a,[...f.instances].forEach(p=>{a&&(p.render=a,Qn(p.type).render=a),p.renderCache=[],ar=!0,p.update(),ar=!1}))}function ni(i,a){var f=qi.get(i);if(!!f){a=Qn(a),sr(f.initialDef,a);var p=[...f.instances];for(var w of p){var E=Qn(w.type);Ir.has(E)||(E!==f.initialDef&&sr(E,a),Ir.add(E)),w.appContext.optionsCache.delete(w.type),w.ceReload?(Ir.add(E),w.ceReload(a.styles),Ir.delete(E)):w.parent?(Pi(w.parent.update),w.parent.type.__asyncLoader&&w.parent.ceReload&&w.parent.ceReload(a.styles)):w.appContext.reload?w.appContext.reload():typeof window!="undefined"?window.location.reload():console.warn("[HMR] Root or manually mounted instance modified. Full reload required.")}Wi(()=>{for(var N of p)Ir.delete(Qn(N.type))})}}function sr(i,a){u.extend(i,a);for(var f in i)f!=="__file"&&!(f in a)&&delete i[f]}function gi(i){return(a,f)=>{try{return i(a,f)}catch(p){console.error(p),console.warn("[HMR] Something went wrong during Vue component hot-reload. Full reload required.")}}}C.devtools=void 0;var vi=[],mi=!1;function Er(i){for(var a=arguments.length,f=new Array(a>1?a-1:0),p=1;p<a;p++)f[p-1]=arguments[p];C.devtools?C.devtools.emit(i,...f):mi||vi.push({event:i,args:f})}function Pr(i,a){var f,p;if(C.devtools=i,C.devtools)C.devtools.enabled=!0,vi.forEach(E=>{var{event:N,args:L}=E;return C.devtools.emit(N,...L)}),vi=[];else if(typeof window!="undefined"&&window.HTMLElement&&!((p=(f=window.navigator)===null||f===void 0?void 0:f.userAgent)===null||p===void 0?void 0:p.includes("jsdom"))){var w=a.__VUE_DEVTOOLS_HOOK_REPLAY__=a.__VUE_DEVTOOLS_HOOK_REPLAY__||[];w.push(E=>{Pr(E,a)}),setTimeout(()=>{C.devtools||(a.__VUE_DEVTOOLS_HOOK_REPLAY__=null,mi=!0,vi=[])},3e3)}else mi=!0,vi=[]}function Wr(i,a){Er("app:init",i,a,{Fragment:jt,Text:it,Comment:fn,Static:Br})}function Gr(i){Er("app:unmount",i)}var er=uo("component:added"),Ki=uo("component:updated"),Ji=uo("component:removed");function uo(i){return a=>{Er(i,a.appContext.app,a.uid,a.parent?a.parent.uid:void 0,a)}}var _i=Uo("perf:start"),Ao=Uo("perf:end");function Uo(i){return(a,f,p)=>{Er(i,a.appContext.app,a.uid,a,f,p)}}function _a(i,a,f){Er("component:emit",i.appContext.app,i,a,f)}function Ho(i,a){if(!i.isUnmounted){for(var f=i.vnode.props||u.EMPTY_OBJ,p=arguments.length,w=new Array(p>2?p-2:0),E=2;E<p;E++)w[E-2]=arguments[E];{var{emitsOptions:N,propsOptions:[L]}=i;if(N)if(!(a in N))(!L||!(u.toHandlerKey(a)in L))&&A('Component emitted event "'.concat(a,'" but it is neither declared in ')+'the emits option nor as an "'.concat(u.toHandlerKey(a),'" prop.'));else{var R=N[a];if(u.isFunction(R)){var K=R(...w);K||A('Invalid event arguments: event validation failed for event "'.concat(a,'".'))}}}var ue=w,oe=a.startsWith("update:"),te=oe&&a.slice(7);if(te&&te in f){var Ee="".concat(te==="modelValue"?"model":te,"Modifiers"),{number:He,trim:rt}=f[Ee]||u.EMPTY_OBJ;rt&&(ue=w.map(Ze=>Ze.trim())),He&&(ue=w.map(u.toNumber))}_a(i,a,ue);{var ft=a.toLowerCase();ft!==a&&f[u.toHandlerKey(ft)]&&A('Event "'.concat(ft,'" is emitted in component ')+"".concat(Vs(i,i.type),' but the handler is registered for "').concat(a,'". ')+"Note that HTML attributes are case-insensitive and you cannot use v-on to listen to camelCase events when using in-DOM templates. "+'You should probably use "'.concat(u.hyphenate(a),'" instead of "').concat(a,'".'))}var ve,le=f[ve=u.toHandlerKey(a)]||f[ve=u.toHandlerKey(u.camelize(a))];!le&&oe&&(le=f[ve=u.toHandlerKey(u.hyphenate(a))]),le&&Ft(le,i,6,ue);var me=f[ve+"Once"];if(me){if(!i.emitted)i.emitted={};else if(i.emitted[ve])return;i.emitted[ve]=!0,Ft(me,i,6,ue)}}}function Zi(i,a){var f=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!1,p=a.emitsCache,w=p.get(i);if(w!==void 0)return w;var E=i.emits,N={},L=!1;if(!u.isFunction(i)){var R=K=>{var ue=Zi(K,a,!0);ue&&(L=!0,u.extend(N,ue))};!f&&a.mixins.length&&a.mixins.forEach(R),i.extends&&R(i.extends),i.mixins&&i.mixins.forEach(R)}return!E&&!L?(p.set(i,null),null):(u.isArray(E)?E.forEach(K=>N[K]=null):u.extend(N,E),p.set(i,N),N)}function wn(i,a){return!i||!u.isOn(a)?!1:(a=a.slice(2).replace(/Once$/,""),u.hasOwn(i,a[0].toLowerCase()+a.slice(1))||u.hasOwn(i,u.hyphenate(a))||u.hasOwn(i,a))}var Sn=null,Nn=null;function lr(i){var a=Sn;return Sn=i,Nn=i&&i.type.__scopeId||null,a}function Oo(i){Nn=i}function Dt(){Nn=null}var Re=i=>Xi;function Xi(i){var a=arguments.length>1&&arguments[1]!==void 0?arguments[1]:Sn;if(!a||i._n)return i;var f=function(){f._d&&el(-1);var p=lr(a),w=i(...arguments);return lr(p),f._d&&el(1),Ki(a),w};return f._n=!0,f._c=!0,f._d=!0,f}var ri=!1;function ki(){ri=!0}function Qi(i){var{type:a,vnode:f,proxy:p,withProxy:w,props:E,propsOptions:[N],slots:L,attrs:R,emit:K,render:ue,renderCache:oe,data:te,setupState:Ee,ctx:He,inheritAttrs:rt}=i,ft,ve,le=lr(i);ri=!1;try{if(f.shapeFlag&4){var me=w||p;ft=Tn(ue.call(me,me,oe,E,Ee,te,He)),ve=R}else{var Ze=a;R===E&&ki(),ft=Tn(Ze.length>1?Ze(E,{get attrs(){return ki(),R},slots:L,emit:K}):Ze(E,null)),ve=a.props?R:ia(R)}}catch(he){rr.length=0,Vt(he,i,1),ft=zn(fn)}var Oe=ft,ot=void 0;if(ft.patchFlag>0&&ft.patchFlag&2048&&([Oe,ot]=Ri(ft)),ve&&rt!==!1){var dt=Object.keys(ve),{shapeFlag:Ye}=Oe;if(dt.length){if(Ye&(1|6))N&&dt.some(u.isModelListener)&&(ve=To(ve,N)),Oe=Ai(Oe,ve);else if(!ri&&Oe.type!==fn){for(var Ot=Object.keys(R),Tt=[],wt=[],$t=0,x=Ot.length;$t<x;$t++){var U=Ot[$t];u.isOn(U)?u.isModelListener(U)||Tt.push(U[2].toLowerCase()+U.slice(3)):wt.push(U)}wt.length&&A("Extraneous non-props attributes ("+"".concat(wt.join(", "),") ")+"were passed to component but could not be automatically inherited because component renders fragment or text root nodes."),Tt.length&&A("Extraneous non-emits event listeners ("+"".concat(Tt.join(", "),") ")+'were passed to component but could not be automatically inherited because component renders fragment or text root nodes. If the listener is intended to be a component custom event listener only, declare it using the "emits" option.')}}}return f.dirs&&(Xt(Oe)||A("Runtime directive used on component with non-element root node. The directives will not function as intended."),Oe=Ai(Oe),Oe.dirs=Oe.dirs?Oe.dirs.concat(f.dirs):f.dirs),f.transition&&(Xt(Oe)||A("Component inside <Transition> renders non-element root node that cannot be animated."),Oe.transition=f.transition),ot?ot(Oe):ft=Oe,lr(le),ft}var Ri=i=>{var a=i.children,f=i.dynamicChildren,p=Yr(a);if(!p)return[i,void 0];var w=a.indexOf(p),E=f?f.indexOf(p):-1,N=L=>{a[w]=L,f&&(E>-1?f[E]=L:L.patchFlag>0&&(i.dynamicChildren=[...f,L]))};return[Tn(p),N]};function Yr(i){for(var a,f=0;f<i.length;f++){var p=i[f];if(fr(p)){if(p.type!==fn||p.children==="v-if"){if(a)return;a=p}}else return}return a}var ia=i=>{var a;for(var f in i)(f==="class"||f==="style"||u.isOn(f))&&((a||(a={}))[f]=i[f]);return a},To=(i,a)=>{var f={};for(var p in i)(!u.isModelListener(p)||!(p.slice(9)in a))&&(f[p]=i[p]);return f},Xt=i=>i.shapeFlag&(6|1)||i.type===fn;function ba(i,a,f){var{props:p,children:w,component:E}=i,{props:N,children:L,patchFlag:R}=a,K=E.emitsOptions;if((w||L)&&ar||a.dirs||a.transition)return!0;if(f&&R>=0){if(R&1024)return!0;if(R&16)return p?xi(p,N,K):!!N;if(R&8)for(var ue=a.dynamicProps,oe=0;oe<ue.length;oe++){var te=ue[oe];if(N[te]!==p[te]&&!wn(K,te))return!0}}else return(w||L)&&(!L||!L.$stable)?!0:p===N?!1:p?N?xi(p,N,K):!0:!!N;return!1}function xi(i,a,f){var p=Object.keys(a);if(p.length!==Object.keys(i).length)return!0;for(var w=0;w<p.length;w++){var E=p[w];if(a[E]!==i[E]&&!wn(f,E))return!0}return!1}function un(i,a){for(var{vnode:f,parent:p}=i;p&&p.subTree===f;)(f=p.vnode).el=a,p=p.parent}var qr=i=>i.__isSuspense,Bi={name:"Suspense",__isSuspense:!0,process(i,a,f,p,w,E,N,L,R,K){i==null?Fa(a,f,p,w,E,N,L,R,K):oa(i,a,f,p,w,N,L,R,K)},hydrate:ya,create:aa,normalize:Nr},Yn=Bi;function Io(i,a){var f=i.props&&i.props[a];u.isFunction(f)&&f()}function Fa(i,a,f,p,w,E,N,L,R){var{p:K,o:{createElement:ue}}=R,oe=ue("div",a),te=i.suspense=aa(i,w,p,a,oe,f,E,N,L,R);K(null,te.pendingBranch=i.ssContent,oe,null,p,te,E,N),te.deps>0?(Io(i,"onPending"),Io(i,"onFallback"),K(null,i.ssFallback,a,f,p,null,E,N),cr(te,i.ssFallback)):te.resolve()}function oa(i,a,f,p,w,E,N,L,R){var{p:K,um:ue,o:{createElement:oe}}=R,te=a.suspense=i.suspense;te.vnode=a,a.el=i.el;var Ee=a.ssContent,He=a.ssFallback,{activeBranch:rt,pendingBranch:ft,isInFallback:ve,isHydrating:le}=te;if(ft)te.pendingBranch=Ee,si(Ee,ft)?(K(ft,Ee,te.hiddenContainer,null,w,te,E,N,L),te.deps<=0?te.resolve():ve&&(K(rt,He,f,p,w,null,E,N,L),cr(te,He))):(te.pendingId++,le?(te.isHydrating=!1,te.activeBranch=ft):ue(ft,w,te),te.deps=0,te.effects.length=0,te.hiddenContainer=oe("div",f),ve?(K(null,Ee,te.hiddenContainer,null,w,te,E,N,L),te.deps<=0?te.resolve():(K(rt,He,f,p,w,null,E,N,L),cr(te,He))):rt&&si(Ee,rt)?(K(rt,Ee,f,p,w,te,E,N,L),te.resolve(!0)):(K(null,Ee,te.hiddenContainer,null,w,te,E,N,L),te.deps<=0&&te.resolve()));else if(rt&&si(Ee,rt))K(rt,Ee,f,p,w,te,E,N,L),cr(te,Ee);else if(Io(a,"onPending"),te.pendingBranch=Ee,te.pendingId++,K(null,Ee,te.hiddenContainer,null,w,te,E,N,L),te.deps<=0)te.resolve();else{var{timeout:me,pendingId:Ze}=te;me>0?setTimeout(()=>{te.pendingId===Ze&&te.fallback(He)},me):me===0&&te.fallback(He)}}var jo=!1;function aa(i,a,f,p,w,E,N,L,R,K){var ue=arguments.length>10&&arguments[10]!==void 0?arguments[10]:!1;jo||(jo=!0,console[console.info?"info":"log"]("<Suspense> is an experimental feature and its API will likely change."));var{p:oe,m:te,um:Ee,n:He,o:{parentNode:rt,remove:ft}}=K,ve=u.toNumber(i.props&&i.props.timeout),le={vnode:i,parent:a,parentComponent:f,isSVG:N,container:p,hiddenContainer:w,anchor:E,deps:0,pendingId:0,timeout:typeof ve=="number"?ve:-1,activeBranch:null,pendingBranch:null,isInFallback:!0,isHydrating:ue,isUnmounted:!1,effects:[],resolve(){var me=arguments.length>0&&arguments[0]!==void 0?arguments[0]:!1;{if(!me&&!le.pendingBranch)throw new Error("suspense.resolve() is called without a pending branch.");if(le.isUnmounted)throw new Error("suspense.resolve() is called on an already unmounted suspense boundary.")}var{vnode:Ze,activeBranch:Oe,pendingBranch:ot,pendingId:dt,effects:Ye,parentComponent:Ot,container:Tt}=le;if(le.isHydrating)le.isHydrating=!1;else if(!me){var wt=Oe&&ot.transition&&ot.transition.mode==="out-in";wt&&(Oe.transition.afterLeave=()=>{dt===le.pendingId&&te(ot,Tt,$t,0)});var{anchor:$t}=le;Oe&&($t=He(Oe),Ee(Oe,Ot,le,!0)),wt||te(ot,Tt,$t,0)}cr(le,ot),le.pendingBranch=null,le.isInFallback=!1;for(var x=le.parent,U=!1;x;){if(x.pendingBranch){x.effects.push(...Ye),U=!0;break}x=x.parent}U||Wi(Ye),le.effects=[],Io(Ze,"onResolve")},fallback(me){if(!!le.pendingBranch){var{vnode:Ze,activeBranch:Oe,parentComponent:ot,container:dt,isSVG:Ye}=le;Io(Ze,"onFallback");var Ot=He(Oe),Tt=()=>{!le.isInFallback||(oe(null,me,dt,Ot,ot,null,Ye,L,R),cr(le,me))},wt=me.transition&&me.transition.mode==="out-in";wt&&(Oe.transition.afterLeave=Tt),le.isInFallback=!0,Ee(Oe,ot,null,!0),wt||Tt()}},move(me,Ze,Oe){le.activeBranch&&te(le.activeBranch,me,Ze,Oe),le.container=me},next(){return le.activeBranch&&He(le.activeBranch)},registerDep(me,Ze){var Oe=!!le.pendingBranch;Oe&&le.deps++;var ot=me.vnode.el;me.asyncDep.catch(dt=>{Vt(dt,me,0)}).then(dt=>{if(!(me.isUnmounted||le.isUnmounted||le.pendingId!==me.suspenseId)){me.asyncResolved=!0;var{vnode:Ye}=me;At(Ye),ns(me,dt,!1),ot&&(Ye.el=ot);var Ot=!ot&&me.subTree.el;Ze(me,Ye,rt(ot||me.subTree.el),ot?null:He(me.subTree),le,N,R),Ot&&ft(Ot),un(me,Ye.el),tn(),Oe&&--le.deps===0&&le.resolve()}})},unmount(me,Ze){le.isUnmounted=!0,le.activeBranch&&Ee(le.activeBranch,f,me,Ze),le.pendingBranch&&Ee(le.pendingBranch,f,me,Ze)}};return le}function ya(i,a,f,p,w,E,N,L,R){var K=a.suspense=aa(a,p,f,i.parentNode,document.createElement("div"),null,w,E,N,L,!0),ue=R(i,K.pendingBranch=a.ssContent,f,K,E,N);return K.deps===0&&K.resolve(),ue}function Nr(i){var{shapeFlag:a,children:f}=i,p=a&32;i.ssContent=kr(p?f.default:f),i.ssFallback=p?kr(f.fallback):zn(fn)}function kr(i){var a;if(u.isFunction(i)){var f=Ko&&i._c;f&&(i._d=!1,_o()),i=i(),f&&(i._d=!0,a=Mr,Oa())}if(u.isArray(i)){var p=Yr(i);p||A("<Suspense> slots expect a single root node."),i=p}return i=Tn(i),a&&!i.dynamicChildren&&(i.dynamicChildren=a.filter(w=>w!==i)),i}function kn(i,a){a&&a.pendingBranch?u.isArray(i)?a.effects.push(...i):a.effects.push(i):Wi(i)}function cr(i,a){i.activeBranch=a;var{vnode:f,parentComponent:p}=i,w=f.el=a.el;p&&p.subTree===f&&(p.vnode.el=w,un(p,w))}function vr(i,a){if(!In)A("provide() can only be used inside setup().");else{var f=In.provides,p=In.parent&&In.parent.provides;p===f&&(f=In.provides=Object.create(p)),f[i]=a,In.type.mpType==="app"&&In.appContext.app.provide(i,a)}}function eo(i,a){var f=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!1,p=In||Sn;if(p){var w=p.parent==null?p.vnode.appContext&&p.vnode.appContext.provides:p.parent.provides;if(w&&i in w)return w[i];if(arguments.length>1)return f&&u.isFunction(a)?a.call(p.proxy):a;A('injection "'.concat(String(i),'" not found.'))}else A("inject() can only be used inside setup() or functional components.")}function zo(i,a){return Mi(i,null,a)}function La(i,a){return Mi(i,null,Object.assign(Object.assign({},a),{flush:"post"}))}function Ea(i,a){return Mi(i,null,Object.assign(Object.assign({},a),{flush:"sync"}))}var to={};function Kr(i,a,f){return u.isFunction(a)||A("`watch(fn, options?)` signature has been moved to a separate API. Use `watchEffect(fn, options?)` instead. `watch` now only supports `watch(source, cb, options?) signature."),Mi(i,a,f)}function Mi(i,a){var{immediate:f,deep:p,flush:w,onTrack:E,onTrigger:N}=arguments.length>2&&arguments[2]!==void 0?arguments[2]:u.EMPTY_OBJ;a||(f!==void 0&&A('watch() "immediate" option is only respected when using the watch(source, callback, options?) signature.'),p!==void 0&&A('watch() "deep" option is only respected when using the watch(source, callback, options?) signature.'));var L=me=>{A("Invalid watch source: ",me,"A watch source can only be a getter/effect function, a ref, a reactive object, or an array of these types.")},R=In,K,ue=!1,oe=!1;if(I.isRef(i)?(K=()=>i.value,ue=I.isShallow(i)):I.isReactive(i)?(K=()=>i,p=!0):u.isArray(i)?(oe=!0,ue=i.some(me=>I.isReactive(me)||I.isShallow(me)),K=()=>i.map(me=>{if(I.isRef(me))return me.value;if(I.isReactive(me))return bi(me);if(u.isFunction(me))return hn(me,R,2);L(me)})):u.isFunction(i)?a?K=()=>hn(i,R,2):K=()=>{if(!(R&&R.isUnmounted))return Ee&&Ee(),Ft(i,R,3,[He])}:(K=u.NOOP,L(i)),a&&p){var te=K;K=()=>bi(te())}var Ee,He=me=>{Ee=le.onStop=()=>{hn(me,R,4)}};if(C.isInSSRComponentSetup)return He=u.NOOP,a?f&&Ft(a,R,3,[K(),oe?[]:void 0,He]):K(),u.NOOP;var rt=oe?[]:to,ft=()=>{if(!!le.active)if(a){var me=le.run();(p||ue||(oe?me.some((Ze,Oe)=>u.hasChanged(Ze,rt[Oe])):u.hasChanged(me,rt)))&&(Ee&&Ee(),Ft(a,R,3,[me,rt===to?void 0:rt,He]),rt=me)}else le.run()};ft.allowRecurse=!!a;var ve;w==="sync"?ve=ft:w==="post"?ve=()=>Cr(ft,R&&R.suspense):ve=()=>Ni(ft);var le=new I.ReactiveEffect(K,ve);return le.onTrack=E,le.onTrigger=N,a?f?ft():rt=le.run():w==="post"?Cr(le.run.bind(le),R&&R.suspense):le.run(),()=>{le.stop(),R&&R.scope&&u.remove(R.scope.effects,le)}}function Wo(i,a,f){var p=this.proxy,w=u.isString(i)?i.includes(".")?ii(p,i):()=>p[i]:i.bind(p,p),E;u.isFunction(a)?E=a:(E=a.handler,f=a);var N=In;Zr(this);var L=Mi(w,E.bind(p),f);return N?Zr(N):fa(),L}function ii(i,a){var f=a.split(".");return()=>{for(var p=i,w=0;w<f.length&&p;w++)p=p[f[w]];return p}}function bi(i,a){if(!u.isObject(i)||i.__v_skip||(a=a||new Set,a.has(i)))return i;if(a.add(i),I.isRef(i))bi(i.value,a);else if(u.isArray(i))for(var f=0;f<i.length;f++)bi(i[f],a);else if(u.isSet(i)||u.isMap(i))i.forEach(w=>{bi(w,a)});else if(u.isPlainObject(i))for(var p in i)bi(i[p],a);return i}function tr(){var i={isMounted:!1,isLeaving:!1,isUnmounting:!1,leavingVNodes:new Map};return nr(()=>{i.isMounted=!0}),ca(()=>{i.isUnmounting=!0}),i}var wr=[Function,Array],D={name:"BaseTransition",props:{mode:String,appear:Boolean,persisted:Boolean,onBeforeEnter:wr,onEnter:wr,onAfterEnter:wr,onEnterCancelled:wr,onBeforeLeave:wr,onLeave:wr,onAfterLeave:wr,onLeaveCancelled:wr,onBeforeAppear:wr,onAppear:wr,onAfterAppear:wr,onAppearCancelled:wr},setup(i,a){var{slots:f}=a,p=ci(),w=tr(),E;return()=>{var N=f.default&&ge(f.default(),!0);if(!(!N||!N.length)){var L=N[0];if(N.length>1){var R=!1;for(var K of N)if(K.type!==fn){if(R){A("<transition> can only be used on a single element or component. Use <transition-group> for lists.");break}L=K,R=!0}}var ue=I.toRaw(i),{mode:oe}=ue;if(oe&&oe!=="in-out"&&oe!=="out-in"&&oe!=="default"&&A("invalid <transition> mode: ".concat(oe)),w.isLeaving)return V(L);var te=J(L);if(!te)return V(L);var Ee=G(te,ue,w,p);Z(te,Ee);var He=p.subTree,rt=He&&J(He),ft=!1,{getTransitionKey:ve}=te.type;if(ve){var le=ve();E===void 0?E=le:le!==E&&(E=le,ft=!0)}if(rt&&rt.type!==fn&&(!si(te,rt)||ft)){var me=G(rt,ue,w,p);if(Z(rt,me),oe==="out-in")return w.isLeaving=!0,me.afterLeave=()=>{w.isLeaving=!1,p.update()},V(L);oe==="in-out"&&te.type!==fn&&(me.delayLeave=(Ze,Oe,ot)=>{var dt=be(w,rt);dt[String(rt.key)]=rt,Ze._leaveCb=()=>{Oe(),Ze._leaveCb=void 0,delete Ee.delayedLeave},Ee.delayedLeave=ot})}return L}}}},ie=D;function be(i,a){var{leavingVNodes:f}=i,p=f.get(a.type);return p||(p=Object.create(null),f.set(a.type,p)),p}function G(i,a,f,p){var{appear:w,mode:E,persisted:N=!1,onBeforeEnter:L,onEnter:R,onAfterEnter:K,onEnterCancelled:ue,onBeforeLeave:oe,onLeave:te,onAfterLeave:Ee,onLeaveCancelled:He,onBeforeAppear:rt,onAppear:ft,onAfterAppear:ve,onAppearCancelled:le}=a,me=String(i.key),Ze=be(f,i),Oe=(Ye,Ot)=>{Ye&&Ft(Ye,p,9,Ot)},ot=(Ye,Ot)=>{var Tt=Ot[1];Oe(Ye,Ot),u.isArray(Ye)?Ye.every(wt=>wt.length<=1)&&Tt():Ye.length<=1&&Tt()},dt={mode:E,persisted:N,beforeEnter(Ye){var Ot=L;if(!f.isMounted)if(w)Ot=rt||L;else return;Ye._leaveCb&&Ye._leaveCb(!0);var Tt=Ze[me];Tt&&si(i,Tt)&&Tt.el._leaveCb&&Tt.el._leaveCb(),Oe(Ot,[Ye])},enter(Ye){var Ot=R,Tt=K,wt=ue;if(!f.isMounted)if(w)Ot=ft||R,Tt=ve||K,wt=le||ue;else return;var $t=!1,x=Ye._enterCb=U=>{$t||($t=!0,U?Oe(wt,[Ye]):Oe(Tt,[Ye]),dt.delayedLeave&&dt.delayedLeave(),Ye._enterCb=void 0)};Ot?ot(Ot,[Ye,x]):x()},leave(Ye,Ot){var Tt=String(i.key);if(Ye._enterCb&&Ye._enterCb(!0),f.isUnmounting)return Ot();Oe(oe,[Ye]);var wt=!1,$t=Ye._leaveCb=x=>{wt||(wt=!0,Ot(),x?Oe(He,[Ye]):Oe(Ee,[Ye]),Ye._leaveCb=void 0,Ze[Tt]===i&&delete Ze[Tt])};Ze[Tt]=i,te?ot(te,[Ye,$t]):$t()},clone(Ye){return G(Ye,a,f,p)}};return dt}function V(i){if(qn(i))return i=Ai(i),i.children=null,i}function J(i){return qn(i)?i.children?i.children[0]:void 0:i}function Z(i,a){i.shapeFlag&6&&i.component?Z(i.component.subTree,a):i.shapeFlag&128?(i.ssContent.transition=a.clone(i.ssContent),i.ssFallback.transition=a.clone(i.ssFallback)):i.transition=a}function ge(i){for(var a=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!1,f=arguments.length>2?arguments[2]:void 0,p=[],w=0,E=0;E<i.length;E++){var N=i[E],L=f==null?N.key:String(f)+String(N.key!=null?N.key:E);N.type===jt?(N.patchFlag&128&&w++,p=p.concat(ge(N.children,a,L))):(a||N.type!==fn)&&p.push(L!=null?Ai(N,{key:L}):N)}if(w>1)for(var R=0;R<p.length;R++)p[R].patchFlag=-2;return p}function zt(i){return u.isFunction(i)?{setup:i,name:i.name}:i}var Cn=i=>!!i.type.__asyncLoader;function _n(i){u.isFunction(i)&&(i={loader:i});var{loader:a,loadingComponent:f,errorComponent:p,delay:w=200,timeout:E,suspensible:N=!0,onError:L}=i,R=null,K,ue=0,oe=()=>(ue++,R=null,te()),te=()=>{var Ee;return R||(Ee=R=a().catch(He=>{if(He=He instanceof Error?He:new Error(String(He)),L)return new Promise((rt,ft)=>{var ve=()=>rt(oe()),le=()=>ft(He);L(He,ve,le,ue+1)});throw He}).then(He=>{if(Ee!==R&&R)return R;if(He||A("Async component loader resolved to undefined. If you are using retry(), make sure to return its return value."),He&&(He.__esModule||He[Symbol.toStringTag]==="Module")&&(He=He.default),He&&!u.isObject(He)&&!u.isFunction(He))throw new Error("Invalid async component load result: ".concat(He));return K=He,He}))};return zt({name:"AsyncComponentWrapper",__asyncLoader:te,get __asyncResolved(){return K},setup(){var Ee=In;if(K)return()=>mr(K,Ee);var He=le=>{R=null,Vt(le,Ee,13,!p)};if(N&&Ee.suspense||C.isInSSRComponentSetup)return te().then(le=>()=>mr(le,Ee)).catch(le=>(He(le),()=>p?zn(p,{error:le}):null));var rt=I.ref(!1),ft=I.ref(),ve=I.ref(!!w);return w&&setTimeout(()=>{ve.value=!1},w),E!=null&&setTimeout(()=>{if(!rt.value&&!ft.value){var le=new Error("Async component timed out after ".concat(E,"ms."));He(le),ft.value=le}},E),te().then(()=>{rt.value=!0,Ee.parent&&qn(Ee.parent.vnode)&&Pi(Ee.parent.update)}).catch(le=>{He(le),ft.value=le}),()=>{if(rt.value&&K)return mr(K,Ee);if(ft.value&&p)return zn(p,{error:ft.value});if(f&&!ve.value)return zn(f)}}})}function mr(i,a){var{vnode:{ref:f,props:p,children:w,shapeFlag:E},parent:N}=a,L=zn(i,p,w);return L.ref=f,L}var qn=i=>i.type.__isKeepAlive,Va={name:"KeepAlive",__isKeepAlive:!0,props:{include:[String,RegExp,Array],exclude:[String,RegExp,Array],max:[String,Number]},setup(i,a){var{slots:f}=a,p=ci(),w=p.ctx;if(!w.renderer)return()=>{var me=f.default&&f.default();return me&&me.length===1?me[0]:me};var E=new Map,N=new Set,L=null;p.__v_cache=E;var R=p.suspense,{renderer:{p:K,m:ue,um:oe,o:{createElement:te}}}=w,Ee=te("div",null);w.activate=(me,Ze,Oe,ot,dt)=>{var Ye=me.component;ue(me,Ze,Oe,0,R),K(Ye.vnode,me,Ze,Oe,Ye,R,ot,me.slotScopeIds,dt),Cr(()=>{Ye.isDeactivated=!1,Ye.a&&u.invokeArrayFns(Ye.a);var Ot=me.props&&me.props.onVnodeMounted;Ot&&li(Ot,Ye.parent,me)},R),er(Ye)},w.deactivate=me=>{var Ze=me.component;ue(me,Ee,null,1,R),Cr(()=>{Ze.da&&u.invokeArrayFns(Ze.da);var Oe=me.props&&me.props.onVnodeUnmounted;Oe&&li(Oe,Ze.parent,me),Ze.isDeactivated=!0},R),er(Ze)};function He(me){la(me),oe(me,p,R,!0)}function rt(me){E.forEach((Ze,Oe)=>{var ot=da(Ze.type);ot&&(!me||!me(ot))&&ft(Oe)})}function ft(me){var Ze=E.get(me);!L||Ze.type!==L.type?He(Ze):L&&la(L),E.delete(me),N.delete(me)}Kr(()=>[i.include,i.exclude],me=>{var[Ze,Oe]=me;Ze&&rt(ot=>No(Ze,ot)),Oe&&rt(ot=>!No(Oe,ot))},{flush:"post",deep:!0});var ve=null,le=()=>{ve!=null&&E.set(ve,Go(p.subTree))};return nr(le),ko(le),ca(()=>{E.forEach(me=>{var{subTree:Ze,suspense:Oe}=p,ot=Go(Ze);if(me.type===ot.type){la(ot);var dt=ot.component.da;dt&&Cr(dt,Oe);return}He(me)})}),()=>{if(ve=null,!f.default)return null;var me=f.default(),Ze=me[0];if(me.length>1)return A("KeepAlive should contain exactly one component child."),L=null,me;if(!fr(Ze)||!(Ze.shapeFlag&4)&&!(Ze.shapeFlag&128))return L=null,Ze;var Oe=Go(Ze),ot=Oe.type,dt=da(Cn(Oe)?Oe.type.__asyncResolved||{}:ot),{include:Ye,exclude:Ot,max:Tt}=i;if(Ye&&(!dt||!No(Ye,dt))||Ot&&dt&&No(Ot,dt))return L=Oe,Ze;var wt=Oe.key==null?ot:Oe.key,$t=E.get(wt);return Oe.el&&(Oe=Ai(Oe),Ze.shapeFlag&128&&(Ze.ssContent=Oe)),ve=wt,$t?(Oe.el=$t.el,Oe.component=$t.component,Oe.transition&&Z(Oe,Oe.transition),Oe.shapeFlag|=512,N.delete(wt),N.add(wt)):(N.add(wt),Tt&&N.size>parseInt(Tt,10)&&ft(N.values().next().value)),Oe.shapeFlag|=256,L=Oe,qr(Ze.type)?Ze:Oe}}},Po=Va;function No(i,a){return u.isArray(i)?i.some(f=>No(f,a)):u.isString(i)?i.split(",").includes(a):i.test?i.test(a):!1}function sa(i,a){Ua(i,"a",a)}function $a(i,a){Ua(i,"da",a)}function Ua(i,a){var f=arguments.length>2&&arguments[2]!==void 0?arguments[2]:In,p=i.__wdc||(i.__wdc=()=>{for(var E=f;E;){if(E.isDeactivated)return;E=E.parent}return i()});if(oi(a,p,f),f)for(var w=f.parent;w&&w.parent;)qn(w.parent.vnode)&&Cs(p,a,f,w),w=w.parent}function Cs(i,a,f,p){var w=oi(a,i,p,!0);xr(()=>{u.remove(p[a],w)},f)}function la(i){var a=i.shapeFlag;a&256&&(a-=256),a&512&&(a-=512),i.shapeFlag=a}function Go(i){return i.shapeFlag&128?i.ssContent:i}function oi(i,a){var f=arguments.length>2&&arguments[2]!==void 0?arguments[2]:In,p=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1;if(f){if(k.isRootHook(i)&&f!==f.root&&(f=f.root,k.isRootImmediateHook(i))){var w=f.proxy;Ft(a.bind(w),f,i,k.ON_LOAD===i?[w.$page.options]:[])}var{__page_container__:E}=f.root.vnode;E&&E.onInjectHook(i);var N=f[i]||(f[i]=[]),L=a.__weh||(a.__weh=function(){if(!f.isUnmounted){I.pauseTracking(),Zr(f);for(var K=arguments.length,ue=new Array(K),oe=0;oe<K;oe++)ue[oe]=arguments[oe];var te=Ft(a,f,i,ue);return fa(),I.resetTracking(),te}});return p?N.unshift(L):N.push(L),L}else{var R=u.toHandlerKey((ae[i]||i.replace(/^on/,"")).replace(/ hook$/,""));A("".concat(R," is called when there is no active component instance to be ")+"associated with. Lifecycle injection APIs can only be used during execution of setup(). If you are using async setup(), make sure to register lifecycle hooks before the first await statement.")}}var yi=i=>function(a){var f=arguments.length>1&&arguments[1]!==void 0?arguments[1]:In;return(!C.isInSSRComponentSetup||i==="sp")&&oi(i,a,f)},wa=yi("bm"),nr=yi("m"),Rr=yi("bu"),ko=yi("u"),ca=yi("bum"),xr=yi("um"),As=yi("sp"),Os=yi("rtg"),Ts=yi("rtc");function Is(i){var a=arguments.length>1&&arguments[1]!==void 0?arguments[1]:In;oi("ec",i,a)}function Zs(i){u.isBuiltInDirective(i)&&A("Do not use built-in directive ids as custom directive id: "+i)}function Jr(i,a){var f=Sn;if(f===null)return A("withDirectives can only be used inside render functions."),i;for(var p=Ls(f)||f.proxy,w=i.dirs||(i.dirs=[]),E=0;E<a.length;E++){var[N,L,R,K=u.EMPTY_OBJ]=a[E];u.isFunction(N)&&(N={mounted:N,updated:N}),N.deep&&bi(L),w.push({dir:N,instance:p,value:L,oldValue:void 0,arg:R,modifiers:K})}return i}function Ei(i,a,f,p){for(var w=i.dirs,E=a&&a.dirs,N=0;N<w.length;N++){var L=w[N];E&&(L.oldValue=E[N].value);var R=L.dir[p];R&&(I.pauseTracking(),Ft(R,f,8,[i.el,L,i,a]),I.resetTracking())}}var Hn="components",yl="directives";function Ha(i,a){return ho(Hn,i,!0,a)||i}var fo=Symbol();function Xs(i){return u.isString(i)?ho(Hn,i,!1)||i:i||fo}function Ps(i){return ho(yl,i)}function ho(i,a){var f=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!0,p=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1,w=Sn||In;if(w){var E=w.type;if(i===Hn){var N=da(E,!1);if(N&&(N===a||N===u.camelize(a)||N===u.capitalize(u.camelize(a))))return E}var L=Ns(w[i]||E[i],a)||Ns(w.appContext[i],a);if(!L&&p)return E;if(f&&!L){var R=i===Hn?`
If this is a native custom element, make sure to exclude it from component resolution via compilerOptions.isCustomElement.`:"";A("Failed to resolve ".concat(i.slice(0,-1),": ").concat(a).concat(R))}return L}else A("resolve".concat(u.capitalize(i.slice(0,-1))," ")+"can only be used in render() or setup().")}function Ns(i,a){return i&&(i[a]||i[u.camelize(a)]||i[u.capitalize(u.camelize(a))])}function Sa(i,a,f,p){var w,E=f&&f[p];if(u.isArray(i)||u.isString(i)){w=new Array(i.length);for(var N=0,L=i.length;N<L;N++)w[N]=a(i[N],N,void 0,E&&E[N])}else if(typeof i=="number"){Number.isInteger(i)||A("The v-for range expect an integer value but got ".concat(i,".")),w=new Array(i);for(var R=0;R<i;R++)w[R]=a(R+1,R,void 0,E&&E[R])}else if(u.isObject(i))if(i[Symbol.iterator])w=Array.from(i,(Ee,He)=>a(Ee,He,void 0,E&&E[He]));else{var K=Object.keys(i);w=new Array(K.length);for(var ue=0,oe=K.length;ue<oe;ue++){var te=K[ue];w[ue]=a(i[te],te,ue,E&&E[ue])}}else w=[];return f&&(f[p]=w),w}function Ro(i,a){for(var f=0;f<a.length;f++){var p=a[f];if(u.isArray(p))for(var w=0;w<p.length;w++)i[p[w].name]=p[w].fn;else p&&(i[p.name]=p.fn)}return i}function ks(i,a){var f=arguments.length>2&&arguments[2]!==void 0?arguments[2]:{},p=arguments.length>3?arguments[3]:void 0,w=arguments.length>4?arguments[4]:void 0;if(Sn.isCE||Sn.parent&&Cn(Sn.parent)&&Sn.parent.isCE)return zn("slot",a==="default"?null:{name:a},p&&p());var E=i[a];E&&E.length>1&&(A("SSR-optimized slot function detected in a non-SSR-optimized render function. You need to mark this component with $dynamic-slots in the parent template."),E=()=>[]),E&&E._c&&(E._d=!1),_o();var N=E&&ja(E(f)),L=bo(jt,{key:f.key||"_".concat(a)},N||(p?p():[]),N&&i._===1?64:-2);return!w&&L.scopeId&&(L.slotScopeIds=[L.scopeId+"-s"]),E&&E._c&&(E._d=!0),L}function ja(i){return i.some(a=>fr(a)?!(a.type===fn||a.type===jt&&!ja(a.children)):!0)?i:null}function Ca(i){var a={};if(!u.isObject(i))return A("v-on with no argument expects an object value."),a;for(var f in i)a[u.toHandlerKey(f)]=i[f];return a}var no=i=>i?Fo(i)?Ls(i)||i.proxy:no(i.parent):null,po=u.extend(Object.create(null),{$:i=>i,$el:i=>i.vnode.el,$data:i=>i.data,$props:i=>I.shallowReadonly(i.props),$attrs:i=>I.shallowReadonly(i.attrs),$slots:i=>I.shallowReadonly(i.slots),$refs:i=>I.shallowReadonly(i.refs),$parent:i=>no(i.parent),$root:i=>no(i.root),$emit:i=>i.emit,$options:i=>pe(i),$forceUpdate:i=>i.f||(i.f=()=>Pi(i.update)),$nextTick:i=>i.n||(i.n=yr.bind(i.proxy)),$watch:i=>Wo.bind(i)}),ua=i=>i==="_"||i==="$",go={get(i,a){var{_:f}=i,{ctx:p,setupState:w,data:E,props:N,accessCache:L,type:R,appContext:K}=f;if(a==="__isVue")return!0;if(w!==u.EMPTY_OBJ&&w.__isScriptSetup&&u.hasOwn(w,a))return w[a];var ue;if(a[0]!=="$"){var oe=L[a];if(oe!==void 0)switch(oe){case 1:return w[a];case 2:return E[a];case 4:return p[a];case 3:return N[a]}else{if(w!==u.EMPTY_OBJ&&u.hasOwn(w,a))return L[a]=1,w[a];if(E!==u.EMPTY_OBJ&&u.hasOwn(E,a))return L[a]=2,E[a];if((ue=f.propsOptions[0])&&u.hasOwn(ue,a))return L[a]=3,N[a];if(p!==u.EMPTY_OBJ&&u.hasOwn(p,a))return L[a]=4,p[a];F&&(L[a]=0)}}var te=po[a],Ee,He;if(te)return a==="$attrs"&&(I.track(f,"get",a),ki()),te(f);if((Ee=R.__cssModules)&&(Ee=Ee[a]))return Ee;if(p!==u.EMPTY_OBJ&&u.hasOwn(p,a))return L[a]=4,p[a];if(He=K.config.globalProperties,u.hasOwn(He,a))return He[a];Sn&&(!u.isString(a)||a.indexOf("__v")!==0)&&(E!==u.EMPTY_OBJ&&ua(a[0])&&u.hasOwn(E,a)?A("Property ".concat(JSON.stringify(a)," must be accessed via $data because it starts with a reserved ")+'character ("$" or "_") and is not proxied on the render context.'):f===Sn&&A("Property ".concat(JSON.stringify(a)," was accessed during render ")+"but is not defined on instance."))},set(i,a,f){var{_:p}=i,{data:w,setupState:E,ctx:N}=p;return E!==u.EMPTY_OBJ&&u.hasOwn(E,a)?(E[a]=f,!0):w!==u.EMPTY_OBJ&&u.hasOwn(w,a)?(w[a]=f,!0):u.hasOwn(p.props,a)?(A('Attempting to mutate prop "'.concat(a,'". Props are readonly.'),p),!1):a[0]==="$"&&a.slice(1)in p?(A('Attempting to mutate public property "'.concat(a,'". ')+"Properties starting with $ are reserved and readonly.",p),!1):(a in p.appContext.config.globalProperties?Object.defineProperty(N,a,{enumerable:!0,configurable:!0,value:f}):N[a]=f,!0)},has(i,a){var{_:{data:f,setupState:p,accessCache:w,ctx:E,appContext:N,propsOptions:L}}=i,R;return!!w[a]||f!==u.EMPTY_OBJ&&u.hasOwn(f,a)||p!==u.EMPTY_OBJ&&u.hasOwn(p,a)||(R=L[0])&&u.hasOwn(R,a)||u.hasOwn(E,a)||u.hasOwn(po,a)||u.hasOwn(N.config.globalProperties,a)},defineProperty(i,a,f){return f.get!=null?i._.accessCache[a]=0:u.hasOwn(f,"value")&&this.set(i,a,f.value,null),Reflect.defineProperty(i,a,f)}};go.ownKeys=i=>(A("Avoid app logic that relies on enumerating keys on a component instance. The keys will be empty in production mode to avoid performance overhead."),Reflect.ownKeys(i));var Rs=u.extend({},go,{get(i,a){if(a!==Symbol.unscopables)return go.get(i,a,i)},has(i,a){var f=a[0]!=="_"&&!u.isGloballyWhitelisted(a);return!f&&go.has(i,a)&&A("Property ".concat(JSON.stringify(a)," should not start with _ which is a reserved prefix for Vue internals.")),f}});function El(i){var a={};return Object.defineProperty(a,"_",{configurable:!0,enumerable:!1,get:()=>i}),Object.keys(po).forEach(f=>{Object.defineProperty(a,f,{configurable:!0,enumerable:!1,get:()=>po[f](i),set:u.NOOP})}),a}function xs(i){var{ctx:a,propsOptions:[f]}=i;f&&Object.keys(f).forEach(p=>{Object.defineProperty(a,p,{enumerable:!0,configurable:!0,get:()=>i.props[p],set:u.NOOP})})}function Qs(i){var{ctx:a,setupState:f}=i;Object.keys(I.toRaw(f)).forEach(p=>{if(!f.__isScriptSetup){if(ua(p[0])){A("setup() return property ".concat(JSON.stringify(p),' should not start with "$" or "_" ')+"which are reserved prefixes for Vue internals.");return}Object.defineProperty(a,p,{enumerable:!0,configurable:!0,get:()=>f[p],set:u.NOOP})}})}function _(){var i=Object.create(null);return(a,f)=>{i[f]?A("".concat(a,' property "').concat(f,'" is already defined in ').concat(i[f],".")):i[f]=a}}var F=!0;function q(i){var a=pe(i),f=i.proxy,p=i.ctx;F=!1,a.beforeCreate&&ee(a.beforeCreate,i,"bc");var{data:w,computed:E,methods:N,watch:L,provide:R,inject:K,created:ue,beforeMount:oe,mounted:te,beforeUpdate:Ee,updated:He,activated:rt,deactivated:ft,beforeDestroy:ve,beforeUnmount:le,destroyed:me,unmounted:Ze,render:Oe,renderTracked:ot,renderTriggered:dt,errorCaptured:Ye,serverPrefetch:Ot,expose:Tt,inheritAttrs:wt,components:$t,directives:x,filters:U}=a,he=_();{var[Ie]=i.propsOptions;if(Ie)for(var Pe in Ie)he("Props",Pe)}if(K&&W(K,p,he,i.appContext.config.unwrapInjectedRef),N)for(var Je in N){var ct=N[Je];u.isFunction(ct)?(Object.defineProperty(p,Je,{value:ct.bind(f),configurable:!0,enumerable:!0,writable:!0}),he("Methods",Je)):A('Method "'.concat(Je,'" has type "').concat(typeof ct,'" in the component definition. ')+"Did you reference the function correctly?")}if(w&&function(){u.isFunction(w)||A("The data option must be a function. Plain object usage is no longer supported.");var nn=w.call(f,f);if(u.isPromise(nn)&&A("data() returned a Promise - note data() cannot be async; If you intend to perform data fetching before component renders, use async setup() + <Suspense>."),!u.isObject(nn))A("data() should return an object.");else{i.data=I.reactive(nn);{var Wt=function(Wn){he("Data",Wn),ua(Wn[0])||Object.defineProperty(p,Wn,{configurable:!0,enumerable:!0,get:()=>nn[Wn],set:u.NOOP})};for(var gn in nn)Wt(gn)}}}(),F=!0,E){var Xe=function(nn){var Wt=E[nn],gn=u.isFunction(Wt)?Wt.bind(f,f):u.isFunction(Wt.get)?Wt.get.bind(f,f):u.NOOP;gn===u.NOOP&&A('Computed property "'.concat(nn,'" has no getter.'));var Wn=!u.isFunction(Wt)&&u.isFunction(Wt.set)?Wt.set.bind(f):()=>{A('Write operation failed: computed property "'.concat(nn,'" is readonly.'))},Vo=$s({get:gn,set:Wn});Object.defineProperty(p,nn,{enumerable:!0,configurable:!0,get:()=>Vo.value,set:ui=>Vo.value=ui}),he("Computed",nn)};for(var tt in E)Xe(tt)}if(L)for(var We in L)re(L[We],p,f,We);if(R){var Ct=u.isFunction(R)?R.call(f):R;Reflect.ownKeys(Ct).forEach(nn=>{vr(nn,Ct[nn])})}ue&&ee(ue,i,"c");function pt(nn,Wt){u.isArray(Wt)?Wt.forEach(gn=>nn(gn.bind(f))):Wt&&nn(Wt.bind(f))}if(pt(wa,oe),pt(nr,te),pt(Rr,Ee),pt(ko,He),pt(sa,rt),pt($a,ft),pt(Is,Ye),pt(Ts,ot),pt(Os,dt),pt(ca,le),pt(xr,Ze),pt(As,Ot),u.isArray(Tt))if(Tt.length){var Pt=i.exposed||(i.exposed={});Tt.forEach(nn=>{Object.defineProperty(Pt,nn,{get:()=>f[nn],set:Wt=>f[nn]=Wt})})}else i.exposed||(i.exposed={});Oe&&i.render===u.NOOP&&(i.render=Oe),wt!=null&&(i.inheritAttrs=wt),$t&&(i.components=$t),x&&(i.directives=x);var en=i.appContext.config.globalProperties.$applyOptions;en&&en(a,i,f)}function W(i,a){var f=arguments.length>2&&arguments[2]!==void 0?arguments[2]:u.NOOP,p=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1;u.isArray(i)&&(i=ke(i));var w=function(N){var L=i[N],R=void 0;u.isObject(L)?"default"in L?R=eo(L.from||N,L.default,!0):R=eo(L.from||N):R=eo(L),I.isRef(R)?p?Object.defineProperty(a,N,{enumerable:!0,configurable:!0,get:()=>R.value,set:K=>R.value=K}):(A('injected property "'.concat(N,'" is a ref and will be auto-unwrapped ')+"and no longer needs `.value` in the next minor release. To opt-in to the new behavior now, set `app.config.unwrapInjectedRef = true` (this config is temporary and will not be needed in the future.)"),a[N]=R):a[N]=R,f("Inject",N)};for(var E in i)w(E)}function ee(i,a,f){Ft(u.isArray(i)?i.map(p=>p.bind(a.proxy)):i.bind(a.proxy),a,f)}function re(i,a,f,p){var w=p.includes(".")?ii(f,p):()=>f[p];if(u.isString(i)){var E=a[i];u.isFunction(E)?Kr(w,E):A('Invalid watch handler specified by key "'.concat(i,'"'),E)}else if(u.isFunction(i))Kr(w,i.bind(f));else if(u.isObject(i))if(u.isArray(i))i.forEach(L=>re(L,a,f,p));else{var N=u.isFunction(i.handler)?i.handler.bind(f):a[i.handler];u.isFunction(N)?Kr(w,N,i):A('Invalid watch handler specified by key "'.concat(i.handler,'"'),N)}else A('Invalid watch option: "'.concat(p,'"'),i)}function pe(i){var a=i.type,{mixins:f,extends:p}=a,{mixins:w,optionsCache:E,config:{optionMergeStrategies:N}}=i.appContext,L=E.get(a),R;return L?R=L:!w.length&&!f&&!p?R=a:(R={},w.length&&w.forEach(K=>Ce(R,K,N,!0)),Ce(R,a,N)),E.set(a,R),R}function Ce(i,a,f){var p=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1,{mixins:w,extends:E}=a;E&&Ce(i,E,f,!0),w&&w.forEach(R=>Ce(i,R,f,!0));for(var N in a)if(p&&N==="expose")A('"expose" option is ignored when declared in mixins or extends. It should only be declared in the base component itself.');else{var L=Me[N]||f&&f[N];i[N]=L?L(i[N],a[N]):a[N]}return i}var Me={data:$e,props:vt,emits:vt,methods:vt,computed:vt,beforeCreate:qe,created:qe,beforeMount:qe,mounted:qe,beforeUpdate:qe,updated:qe,beforeDestroy:qe,beforeUnmount:qe,destroyed:qe,unmounted:qe,activated:qe,deactivated:qe,errorCaptured:qe,serverPrefetch:qe,components:vt,directives:vt,watch:Jt,provide:$e,inject:Ae};function $e(i,a){return a?i?function(){return u.extend(u.isFunction(i)?i.call(this,this):i,u.isFunction(a)?a.call(this,this):a)}:a:i}function Ae(i,a){return vt(ke(i),ke(a))}function ke(i){if(u.isArray(i)){for(var a={},f=0;f<i.length;f++)a[i[f]]=i[f];return a}return i}function qe(i,a){return i?[...new Set([].concat(i,a))]:a}function vt(i,a){return i?u.extend(u.extend(Object.create(null),i),a):a}function Jt(i,a){if(!i)return a;if(!a)return i;var f=u.extend(Object.create(null),i);for(var p in a)f[p]=qe(i[p],a[p]);return f}function gt(i,a,f){var p=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1,w={},E={};u.def(E,Do,1),i.propsDefaults=Object.create(null),Nt(i,a,w,E);for(var N in i.propsOptions[0])N in w||(w[N]=void 0);Bn(a||{},w,i),f?i.props=p?w:I.shallowReactive(w):i.type.props?i.props=w:i.props=E,i.attrs=E}function ut(i,a,f,p){var{props:w,attrs:E,vnode:{patchFlag:N}}=i,L=I.toRaw(w),[R]=i.propsOptions,K=!1;if(!(i.type.__hmrId||i.parent&&i.parent.type.__hmrId)&&(p||N>0)&&!(N&16)){if(N&8)for(var ue=i.vnode.dynamicProps,oe=0;oe<ue.length;oe++){var te=ue[oe];if(!wn(i.emitsOptions,te)){var Ee=a[te];if(R)if(u.hasOwn(E,te))Ee!==E[te]&&(E[te]=Ee,K=!0);else{var He=u.camelize(te);w[He]=pn(R,L,He,Ee,i,!1)}else Ee!==E[te]&&(E[te]=Ee,K=!0)}}}else{Nt(i,a,w,E)&&(K=!0);var rt;for(var ft in L)(!a||!u.hasOwn(a,ft)&&((rt=u.hyphenate(ft))===ft||!u.hasOwn(a,rt)))&&(R?f&&(f[ft]!==void 0||f[rt]!==void 0)&&(w[ft]=pn(R,L,ft,void 0,i,!0)):delete w[ft]);if(E!==L)for(var ve in E)(!a||!u.hasOwn(a,ve)&&!0)&&(delete E[ve],K=!0)}K&&I.trigger(i,"set","$attrs"),Bn(a||{},w,i)}function Nt(i,a,f,p){var[w,E]=i.propsOptions,N=!1,L;if(a){for(var R in a)if(!u.isReservedProp(R)){var K=a[R],ue=void 0;w&&u.hasOwn(w,ue=u.camelize(R))?!E||!E.includes(ue)?f[ue]=K:(L||(L={}))[ue]=K:wn(i.emitsOptions,R)||(!(R in p)||K!==p[R])&&(p[R]=K,N=!0)}}if(E)for(var oe=I.toRaw(f),te=L||u.EMPTY_OBJ,Ee=0;Ee<E.length;Ee++){var He=E[Ee];f[He]=pn(w,oe,He,te[He],i,!u.hasOwn(te,He))}return N}function pn(i,a,f,p,w,E){var N=i[f];if(N!=null){var L=u.hasOwn(N,"default");if(L&&p===void 0){var R=N.default;if(N.type!==Function&&u.isFunction(R)){var{propsDefaults:K}=w;f in K?p=K[f]:(Zr(w),p=K[f]=R.call(null,a),fa())}else p=R}N[0]&&(E&&!L?p=!1:N[1]&&(p===""||p===u.hyphenate(f))&&(p=!0))}return p}function St(i,a){var f=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!1,p=a.propsCache,w=p.get(i);if(w)return w;var E=i.props,N={},L=[],R=!1;if(!u.isFunction(i)){var K=me=>{R=!0;var[Ze,Oe]=St(me,a,!0);u.extend(N,Ze),Oe&&L.push(...Oe)};!f&&a.mixins.length&&a.mixins.forEach(K),i.extends&&K(i.extends),i.mixins&&i.mixins.forEach(K)}if(!E&&!R)return p.set(i,u.EMPTY_ARR),u.EMPTY_ARR;if(u.isArray(E))for(var ue=0;ue<E.length;ue++){u.isString(E[ue])||A("props must be strings when using array syntax.",E[ue]);var oe=u.camelize(E[ue]);ht(oe)&&(N[oe]=u.EMPTY_OBJ)}else if(E){u.isObject(E)||A("invalid props options",E);for(var te in E){var Ee=u.camelize(te);if(ht(Ee)){var He=E[te],rt=N[Ee]=u.isArray(He)||u.isFunction(He)?{type:He}:He;if(rt){var ft=xn(Boolean,rt.type),ve=xn(String,rt.type);rt[0]=ft>-1,rt[1]=ve<0||ft<ve,(ft>-1||u.hasOwn(rt,"default"))&&L.push(Ee)}}}}var le=[N,L];return p.set(i,le),le}function ht(i){return i[0]!=="$"?!0:(A('Invalid prop name: "'.concat(i,'" is a reserved property.')),!1)}function Lt(i){var a=i&&i.toString().match(/^\s*function (\w+)/);return a?a[1]:i===null?"null":""}function Rn(i,a){return Lt(i)===Lt(a)}function xn(i,a){return u.isArray(a)?a.findIndex(f=>Rn(f,i)):u.isFunction(a)&&Rn(a,i)?0:-1}function Bn(i,a,f){var p=I.toRaw(a),w=f.propsOptions[0];for(var E in w){var N=w[E];N!=null&&Ln(E,p[E],N,!u.hasOwn(i,E)&&!u.hasOwn(i,u.hyphenate(E)))}}function Ln(i,a,f,p){var{type:w,required:E,validator:N}=f;if(E&&p){A('Missing required prop: "'+i+'"');return}if(!(a==null&&!f.required)){if(w!=null&&w!==!0){for(var L=!1,R=u.isArray(w)?w:[w],K=[],ue=0;ue<R.length&&!L;ue++){var{valid:oe,expectedType:te}=Kn(a,R[ue]);K.push(te||""),L=oe}if(!L){A(za(i,a,K));return}}N&&!N(a)&&A('Invalid prop: custom validator check failed for prop "'+i+'".')}}var Yt=u.makeMap("String,Number,Boolean,Function,Symbol,BigInt");function Kn(i,a){var f,p=Lt(a);if(Yt(p)){var w=typeof i;f=w===p.toLowerCase(),!f&&w==="object"&&(f=i instanceof a)}else p==="Object"?f=u.isObject(i):p==="Array"?f=u.isArray(i):p==="null"?f=i===null:f=i instanceof a;return{valid:f,expectedType:p}}function za(i,a,f){var p='Invalid prop: type check failed for prop "'.concat(i,'".')+" Expected ".concat(f.map(u.capitalize).join(" | ")),w=f[0],E=u.toRawType(a),N=Wa(a,w),L=Wa(a,E);return f.length===1&&xo(w)&&!Ga(w,E)&&(p+=" with value ".concat(N)),p+=", got ".concat(E," "),xo(E)&&(p+="with value ".concat(L,".")),p}function Wa(i,a){return a==="String"?'"'.concat(i,'"'):a==="Number"?"".concat(Number(i)):"".concat(i)}function xo(i){var a=["string","number","boolean"];return a.some(f=>i.toLowerCase()===f)}function Ga(){for(var i=arguments.length,a=new Array(i),f=0;f<i;f++)a[f]=arguments[f];return a.some(p=>p.toLowerCase()==="boolean")}var Bo=i=>i[0]==="_"||i==="$stable",Ya=i=>u.isArray(i)?i.map(Tn):[Tn(i)],Bs=(i,a,f)=>{if(a._n)return a;var p=Xi(function(){return In&&A('Slot "'.concat(i,'" invoked outside of the render function: ')+"this will not track dependencies used in the slot. Invoke the slot function inside the render function instead."),Ya(a(...arguments))},f);return p._c=!1,p},An=(i,a,f)=>{var p=i._ctx;for(var w in i)if(!Bo(w)){var E=i[w];u.isFunction(E)?a[w]=Bs(w,E,p):E!=null&&function(){A('Non-function value encountered for slot "'.concat(w,'". ')+"Prefer function slots for better performance.");var N=Ya(E);a[w]=()=>N}()}},Yo=(i,a)=>{qn(i.vnode)||A("Non-function value encountered for default slot. Prefer function slots for better performance.");var f=Ya(a);i.slots.default=()=>f},qo=(i,a)=>{if(i.vnode.shapeFlag&32){var f=a._;f?(i.slots=I.toRaw(a),u.def(a,"_",f)):An(a,i.slots={})}else i.slots={},a&&Yo(i,a);u.def(i.slots,Do,1)},qa=(i,a,f)=>{var{vnode:p,slots:w}=i,E=!0,N=u.EMPTY_OBJ;if(p.shapeFlag&32){var L=a._;L?ar?u.extend(w,a):f&&L===1?E=!1:(u.extend(w,a),!f&&L===1&&delete w._):(E=!a.$stable,An(a,w)),N=a}else a&&(Yo(i,a),N={default:1});if(E)for(var R in w)!Bo(R)&&!(R in N)&&delete w[R]};function Ms(){return{app:null,config:{isNativeTag:u.NO,performance:!1,globalProperties:{},optionMergeStrategies:{},errorHandler:void 0,warnHandler:void 0,compilerOptions:{}},mixins:[],components:{},directives:{},provides:Object.create(null),optionsCache:new WeakMap,propsCache:new WeakMap,emitsCache:new WeakMap}}var Ka=0;function Di(i,a){return function(p){var w=arguments.length>1&&arguments[1]!==void 0?arguments[1]:null;u.isFunction(p)||(p=Object.assign({},p)),w!=null&&!u.isObject(w)&&(A("root props passed to app.mount() must be an object."),w=null);var E=Ms(),N=new Set,L=!1,R=E.app={_uid:Ka++,_component:p,_props:w,_container:null,_context:E,_instance:null,version:Fl,get config(){return E.config},set config(K){A("app.config cannot be replaced. Modify individual options instead.")},use(K){for(var ue=arguments.length,oe=new Array(ue>1?ue-1:0),te=1;te<ue;te++)oe[te-1]=arguments[te];return N.has(K)?A("Plugin has already been applied to target app."):K&&u.isFunction(K.install)?(N.add(K),K.install(R,...oe)):u.isFunction(K)?(N.add(K),K(R,...oe)):A('A plugin must either be a function or an object with an "install" function.'),R},mixin(K){return E.mixins.includes(K)?A("Mixin has already been applied to target app"+(K.name?": ".concat(K.name):"")):E.mixins.push(K),R},component(K,ue){return Xr(K,E.config),ue?(E.components[K]&&A('Component "'.concat(K,'" has already been registered in target app.')),E.components[K]=ue,R):E.components[K]},directive(K,ue){return Zs(K),ue?(E.directives[K]&&A('Directive "'.concat(K,'" has already been registered in target app.')),E.directives[K]=ue,R):E.directives[K]},mount(K,ue,oe){if(L)A("App has already been mounted.\nIf you want to remount the same app, move your app creation logic into a factory function and create fresh app instances for each mount - e.g. `const createMyApp = () => createApp(App)`");else{K.__vue_app__&&A("There is already an app instance mounted on the host container.\n If you want to mount another app on the same host container, you need to unmount the previous app by calling `app.unmount()` first.");var te=zn(p,w);return te.appContext=E,E.reload=()=>{i(Ai(te),K,oe)},ue&&a?a(te,K):i(te,K,oe),L=!0,R._container=K,K.__vue_app__=R,R._instance=te.component,Wr(R,Fl),Ls(te.component)||te.component.proxy}},unmount(){L?(i(null,R._container),R._instance=null,Gr(R),delete R._container.__vue_app__):A("Cannot unmount an app that is not mounted.")},provide(K,ue){return K in E.provides&&A('App already provides property with key "'.concat(String(K),'". ')+"It will be overwritten with the new value."),E.provides[K]=ue,R}};return R}}function ur(i,a,f,p){var w=arguments.length>4&&arguments[4]!==void 0?arguments[4]:!1;if(u.isArray(i)){i.forEach((rt,ft)=>ur(rt,a&&(u.isArray(a)?a[ft]:a),f,p,w));return}if(!(Cn(p)&&!w)){var E=p.shapeFlag&4?Ls(p.component)||p.component.proxy:p.el,N=w?null:E,{i:L,r:R}=i;if(!L){A("Missing ref owner context. ref cannot be used on hoisted vnodes. A vnode with ref must be created inside the render function.");return}var K=a&&a.r,ue=L.refs===u.EMPTY_OBJ?L.refs={}:L.refs,oe=L.setupState;if(K!=null&&K!==R&&(u.isString(K)?(ue[K]=null,u.hasOwn(oe,K)&&(oe[K]=null)):I.isRef(K)&&(K.value=null)),u.isFunction(R))hn(R,L,12,[N,ue]);else{var te=u.isString(R),Ee=I.isRef(R);if(te||Ee){var He=()=>{if(i.f){var rt=te?ue[R]:R.value;w?u.isArray(rt)&&u.remove(rt,E):u.isArray(rt)?rt.includes(E)||rt.push(E):te?(ue[R]=[E],u.hasOwn(oe,R)&&(oe[R]=ue[R])):(R.value=[E],i.k&&(ue[i.k]=R.value))}else te?(ue[R]=N,u.hasOwn(oe,R)&&(oe[R]=N)):Ee?(R.value=N,i.k&&(ue[i.k]=N)):A("Invalid template ref type:",R,"(".concat(typeof R,")"))};N?(He.id=-1,Cr(He,f)):He()}else A("Invalid template ref type:",R,"(".concat(typeof R,")"))}}}var On=!1,ro=i=>/svg/.test(i.namespaceURI)&&i.tagName!=="foreignObject",Ja=i=>i.nodeType===8;function Aa(i){var{mt:a,p:f,o:{patchProp:p,createText:w,nextSibling:E,parentNode:N,remove:L,insert:R,createComment:K}}=i,ue=(ve,le)=>{if(!le.hasChildNodes()){A("Attempting to hydrate existing markup but container is empty. Performing full mount instead."),f(null,ve,le),hi(),le._vnode=ve;return}On=!1,oe(le.firstChild,ve,null,null,null),hi(),le._vnode=ve,On&&console.error("Hydration completed but contains mismatches.")},oe=function(ve,le,me,Ze,Oe){var ot=arguments.length>5&&arguments[5]!==void 0?arguments[5]:!1,dt=Ja(ve)&&ve.data==="[",Ye=()=>rt(ve,le,me,Ze,Oe,dt),{type:Ot,ref:Tt,shapeFlag:wt,patchFlag:$t}=le,x=ve.nodeType;le.el=ve,$t===-2&&(ot=!1,le.dynamicChildren=null);var U=null;switch(Ot){case it:x!==3?le.children===""?(R(le.el=w("",ve.parentNode),N(ve),ve),U=ve):U=Ye():(ve.data!==le.children&&(On=!0,A("Hydration text mismatch:"+`
- Client: `.concat(JSON.stringify(ve.data))+`
- Server: `.concat(JSON.stringify(le.children))),ve.data=le.children),U=E(ve));break;case fn:x!==8||dt?U=Ye():U=E(ve);break;case Br:if(x!==1&&x!==3)U=Ye();else{U=ve;for(var he=!le.children.length,Ie=0;Ie<le.staticCount;Ie++)he&&(le.children+=U.nodeType===1?U.outerHTML:U.data),Ie===le.staticCount-1&&(le.anchor=U),U=E(U);return U}break;case jt:dt?U=He(ve,le,me,Ze,Oe,ot):U=Ye();break;default:if(wt&1)x!==1||le.type.toLowerCase()!==ve.tagName.toLowerCase()?U=Ye():U=te(ve,le,me,Ze,Oe,ot);else if(wt&6){le.slotScopeIds=Oe;var Pe=N(ve);if(a(le,Pe,null,me,Ze,ro(Pe),ot),U=dt?ft(ve):E(ve),U&&Ja(U)&&U.data==="teleport end"&&(U=E(U)),Cn(le)){var Je;dt?(Je=zn(jt),Je.anchor=U?U.previousSibling:Pe.lastChild):Je=ve.nodeType===3?Al(""):zn("div"),Je.el=ve,le.component.subTree=Je}}else wt&64?x!==8?U=Ye():U=le.type.hydrate(ve,le,me,Ze,Oe,ot,i,Ee):wt&128?U=le.type.hydrate(ve,le,me,Ze,ro(N(ve)),Oe,ot,i,oe):A("Invalid HostVNode type:",Ot,"(".concat(typeof Ot,")"))}return Tt!=null&&ur(Tt,null,Ze,le),U},te=(ve,le,me,Ze,Oe,ot)=>{ot=ot||!!le.dynamicChildren;var{type:dt,props:Ye,patchFlag:Ot,shapeFlag:Tt,dirs:wt}=le,$t=dt==="input"&&wt||dt==="option";{if(wt&&Ei(le,null,me,"created"),Ye)if($t||!ot||Ot&(16|32))for(var x in Ye)($t&&x.endsWith("value")||u.isOn(x)&&!u.isReservedProp(x))&&p(ve,x,null,Ye[x],!1,void 0,me);else Ye.onClick&&p(ve,"onClick",null,Ye.onClick,!1,void 0,me);var U;if((U=Ye&&Ye.onVnodeBeforeMount)&&li(U,me,le),wt&&Ei(le,null,me,"beforeMount"),((U=Ye&&Ye.onVnodeMounted)||wt)&&kn(()=>{U&&li(U,me,le),wt&&Ei(le,null,me,"mounted")},Ze),Tt&16&&!(Ye&&(Ye.innerHTML||Ye.textContent)))for(var he=Ee(ve.firstChild,le,ve,me,Ze,Oe,ot),Ie=!1;he;){On=!0,Ie||(A("Hydration children mismatch in <".concat(le.type,">: ")+"server rendered element contains more child nodes than client vdom."),Ie=!0);var Pe=he;he=he.nextSibling,L(Pe)}else Tt&8&&ve.textContent!==le.children&&(On=!0,A("Hydration text content mismatch in <".concat(le.type,`>:
`)+"- Client: ".concat(ve.textContent,`
`)+"- Server: ".concat(le.children)),ve.textContent=le.children)}return ve.nextSibling},Ee=(ve,le,me,Ze,Oe,ot,dt)=>{dt=dt||!!le.dynamicChildren;for(var Ye=le.children,Ot=Ye.length,Tt=!1,wt=0;wt<Ot;wt++){var $t=dt?Ye[wt]:Ye[wt]=Tn(Ye[wt]);if(ve)ve=oe(ve,$t,Ze,Oe,ot,dt);else{if($t.type===it&&!$t.children)continue;On=!0,Tt||(A("Hydration children mismatch in <".concat(me.tagName.toLowerCase(),">: ")+"server rendered element contains fewer child nodes than client vdom."),Tt=!0),f(null,$t,me,null,Ze,Oe,ro(me),ot)}}return ve},He=(ve,le,me,Ze,Oe,ot)=>{var{slotScopeIds:dt}=le;dt&&(Oe=Oe?Oe.concat(dt):dt);var Ye=N(ve),Ot=Ee(E(ve),le,Ye,me,Ze,Oe,ot);return Ot&&Ja(Ot)&&Ot.data==="]"?E(le.anchor=Ot):(On=!0,R(le.anchor=K("]",Ye),Ye,Ot),Ot)},rt=(ve,le,me,Ze,Oe,ot)=>{if(On=!0,A(`Hydration node mismatch:
- Client vnode:`,le.type,`
- Server rendered DOM:`,ve,ve.nodeType===3?"(text)":Ja(ve)&&ve.data==="["?"(start of fragment)":""),le.el=null,ot)for(var dt=ft(ve);;){var Ye=E(ve);if(Ye&&Ye!==dt)L(Ye);else break}var Ot=E(ve),Tt=N(ve);return L(ve),f(null,le,Tt,Ot,me,Ze,ro(Tt),Oe),Ot},ft=ve=>{for(var le=0;ve;)if(ve=E(ve),ve&&Ja(ve)&&(ve.data==="["&&le++,ve.data==="]")){if(le===0)return E(ve);le--}return ve};return[ue,oe]}var wi,$r;function Sr(i,a){i.appContext.config.performance&&ds()&&$r.mark("vue-".concat(a,"-").concat(i.uid)),_i(i,a,ds()?$r.now():Date.now())}function Fi(i,a){if(i.appContext.config.performance&&ds()){var f="vue-".concat(a,"-").concat(i.uid),p=f+":end";$r.mark(p),$r.measure("<".concat(Vs(i,i.type),"> ").concat(a),f,p),$r.clearMarks(f),$r.clearMarks(p)}Ao(i,a,ds()?$r.now():Date.now())}function ds(){return wi!==void 0||(typeof window!="undefined"&&window.performance?(wi=!0,$r=window.performance):wi=!1),wi}function jn(){var i=[];if(i.length){var a=i.length>1;console.warn("Feature flag".concat(a?"s":""," ").concat(i.join(", ")," ").concat(a?"are":"is"," not explicitly defined. You are running the esm-bundler build of Vue, ")+`which expects these compile-time feature flags to be globally injected via the bundler config in order to get better tree-shaking in the production bundle.

For more details, see https://link.vuejs.org/feature-flags.`)}}var Cr=kn;function hs(i){return vo(i)}function Si(i){return vo(i,Aa)}function vo(i,a){jn();var f=u.getGlobalThis();f.__VUE__=!0,Pr(f.__VUE_DEVTOOLS_GLOBAL_HOOK__,f);var{insert:p,remove:w,patchProp:E,forcePatchProp:N,createElement:L,createText:R,createComment:K,setText:ue,setElementText:oe,parentNode:te,nextSibling:Ee,setScopeId:He=u.NOOP,cloneNode:rt,insertStaticContent:ft}=i,ve=function(j,X,ye){var De=arguments.length>3&&arguments[3]!==void 0?arguments[3]:null,xe=arguments.length>4&&arguments[4]!==void 0?arguments[4]:null,Qe=arguments.length>5&&arguments[5]!==void 0?arguments[5]:null,st=arguments.length>6&&arguments[6]!==void 0?arguments[6]:!1,Ke=arguments.length>7&&arguments[7]!==void 0?arguments[7]:null,et=arguments.length>8&&arguments[8]!==void 0?arguments[8]:ar?!1:!!X.dynamicChildren;if(j!==X){j&&!si(j,X)&&(De=Wn(j),Pt(j,xe,Qe,!0),j=null),X.patchFlag===-2&&(et=!1,X.dynamicChildren=null);var{type:je,ref:Rt,shapeFlag:Mt}=X;switch(je){case it:le(j,X,ye,De);break;case fn:me(j,X,ye,De);break;case Br:j==null?Ze(X,ye,De,st):Oe(j,X,ye,st);break;case jt:he(j,X,ye,De,xe,Qe,st,Ke,et);break;default:Mt&1?Ye(j,X,ye,De,xe,Qe,st,Ke,et):Mt&6?Ie(j,X,ye,De,xe,Qe,st,Ke,et):Mt&64||Mt&128?je.process(j,X,ye,De,xe,Qe,st,Ke,et,ui):A("Invalid VNode type:",je,"(".concat(typeof je,")"))}Rt!=null&&xe&&ur(Rt,j&&j.ref,Qe,X||j,!X)}},le=(j,X,ye,De)=>{if(j==null)p(X.el=R(X.children,ye),ye,De);else{var xe=X.el=j.el;X.children!==j.children&&ue(xe,X.children)}},me=(j,X,ye,De)=>{j==null?p(X.el=K(X.children||"",ye),ye,De):X.el=j.el},Ze=(j,X,ye,De)=>{[j.el,j.anchor]=ft(j.children,X,ye,De,j.el,j.anchor)},Oe=(j,X,ye,De)=>{if(X.children!==j.children){var xe=Ee(j.anchor);dt(j),[X.el,X.anchor]=ft(X.children,ye,xe,De)}else X.el=j.el,X.anchor=j.anchor},ot=(j,X,ye)=>{for(var{el:De,anchor:xe}=j,Qe;De&&De!==xe;)Qe=Ee(De),p(De,X,ye),De=Qe;p(xe,X,ye)},dt=j=>{for(var{el:X,anchor:ye}=j,De;X&&X!==ye;)De=Ee(X),w(X),X=De;w(ye)},Ye=(j,X,ye,De,xe,Qe,st,Ke,et)=>{st=st||X.type==="svg",j==null?Ot(X,ye,De,xe,Qe,st,Ke,et):$t(j,X,xe,Qe,st,Ke,et)},Ot=(j,X,ye,De,xe,Qe,st,Ke)=>{var et,je,{type:Rt,props:Mt,shapeFlag:xt,transition:bn,patchFlag:$i,dirs:Zn}=j;{if(et=j.el=L(j.type,X),xt&8?oe(et,j.children):xt&16&&wt(j.children,et,null,De,xe,Qe&&Rt!=="foreignObject",st,Ke),Zn&&Ei(j,null,De,"created"),Mt){for(var Qr in Mt)Qr!=="value"&&!u.isReservedProp(Qr)&&E(et,Qr,null,Mt[Qr],Qe,j.children,De,xe,gn);"value"in Mt&&E(et,"value",null,Mt.value),(je=Mt.onVnodeBeforeMount)&&li(je,De,j)}Tt(et,j,j.scopeId,st,De)}Object.defineProperty(et,"__vnode",{value:j,enumerable:!1}),Object.defineProperty(et,"__vueParentComponent",{value:De,enumerable:!1}),Zn&&Ei(j,null,De,"beforeMount");var ao=(!xe||xe&&!xe.pendingBranch)&&bn&&!bn.persisted;ao&&bn.beforeEnter(et),p(et,X,ye),((je=Mt&&Mt.onVnodeMounted)||ao||Zn)&&Cr(()=>{je&&li(je,De,j),ao&&bn.enter(et),Zn&&Ei(j,null,De,"mounted")},xe)},Tt=(j,X,ye,De,xe)=>{if(ye&&He(j,ye),De)for(var Qe=0;Qe<De.length;Qe++)He(j,De[Qe]);if(xe){var st=xe.subTree;if(st.patchFlag>0&&st.patchFlag&2048&&(st=Yr(st.children)||st),X===st){var Ke=xe.vnode;Tt(j,Ke,Ke.scopeId,Ke.slotScopeIds,xe.parent)}}},wt=function(j,X,ye,De,xe,Qe,st,Ke){for(var et=arguments.length>8&&arguments[8]!==void 0?arguments[8]:0,je=et;je<j.length;je++){var Rt=j[je]=Ke?Vi(j[je]):Tn(j[je]);ve(null,Rt,X,ye,De,xe,Qe,st,Ke)}},$t=(j,X,ye,De,xe,Qe,st)=>{var Ke=X.el=j.el,{patchFlag:et,dynamicChildren:je,dirs:Rt}=X;et|=j.patchFlag&16;var Mt=j.props||u.EMPTY_OBJ,xt=X.props||u.EMPTY_OBJ,bn;ye&&ai(ye,!1),(bn=xt.onVnodeBeforeUpdate)&&li(bn,ye,X,j),Rt&&Ei(X,j,ye,"beforeUpdate"),ye&&ai(ye,!0),ar&&(et=0,st=!1,je=null);var $i=xe&&X.type!=="foreignObject";if(je?(x(j.dynamicChildren,je,Ke,ye,De,$i,Qe),ye&&ye.type.__hmrId&&Mo(j,X)):st||tt(j,X,Ke,null,ye,De,$i,Qe,!1),et>0){if(et&16)U(Ke,X,Mt,xt,ye,De,xe);else if(et&2&&Mt.class!==xt.class&&E(Ke,"class",null,xt.class,xe),et&4&&E(Ke,"style",Mt.style,xt.style,xe),et&8)for(var Zn=X.dynamicProps,Qr=0;Qr<Zn.length;Qr++){var ao=Zn[Qr],Ma=Mt[ao],ta=xt[ao];(ta!==Ma||ao==="value"||N&&N(Ke,ao))&&E(Ke,ao,Ma,ta,xe,j.children,ye,De,gn)}et&1&&j.children!==X.children&&oe(Ke,X.children)}else!st&&je==null&&U(Ke,X,Mt,xt,ye,De,xe);((bn=xt.onVnodeUpdated)||Rt)&&Cr(()=>{bn&&li(bn,ye,X,j),Rt&&Ei(X,j,ye,"updated")},De)},x=(j,X,ye,De,xe,Qe,st)=>{for(var Ke=0;Ke<X.length;Ke++){var et=j[Ke],je=X[Ke],Rt=et.el&&(et.type===jt||!si(et,je)||et.shapeFlag&(6|64))?te(et.el):ye;ve(et,je,Rt,null,De,xe,Qe,st,!0)}},U=(j,X,ye,De,xe,Qe,st)=>{if(ye!==De){for(var Ke in De)if(!u.isReservedProp(Ke)){var et=De[Ke],je=ye[Ke];(et!==je&&Ke!=="value"||N&&N(j,Ke))&&E(j,Ke,je,et,st,X.children,xe,Qe,gn)}if(ye!==u.EMPTY_OBJ)for(var Rt in ye)!u.isReservedProp(Rt)&&!(Rt in De)&&E(j,Rt,ye[Rt],null,st,X.children,xe,Qe,gn);"value"in De&&E(j,"value",ye.value,De.value)}},he=(j,X,ye,De,xe,Qe,st,Ke,et)=>{var je=X.el=j?j.el:R("",ye),Rt=X.anchor=j?j.anchor:R("",ye),{patchFlag:Mt,dynamicChildren:xt,slotScopeIds:bn}=X;(ar||Mt&2048)&&(Mt=0,et=!1,xt=null),bn&&(Ke=Ke?Ke.concat(bn):bn),j==null?(p(je,ye,De),p(Rt,ye,De),wt(X.children,ye,Rt,xe,Qe,st,Ke,et)):Mt>0&&Mt&64&&xt&&j.dynamicChildren?(x(j.dynamicChildren,xt,ye,xe,Qe,st,Ke),xe&&xe.type.__hmrId?Mo(j,X):(X.key!=null||xe&&X===xe.subTree)&&Mo(j,X,!0)):tt(j,X,ye,Rt,xe,Qe,st,Ke,et)},Ie=(j,X,ye,De,xe,Qe,st,Ke,et)=>{X.slotScopeIds=Ke,j==null?X.shapeFlag&512?xe.ctx.activate(X,ye,De,st,et):Pe(X,ye,De,xe,Qe,st,et):Je(j,X,et)},Pe=(j,X,ye,De,xe,Qe,st)=>{var Ke=j.component=Jn(j,De,xe);if(Ke.type.__hmrId&&So(Ke),At(j),Sr(Ke,"mount"),qn(j)&&(Ke.ctx.renderer=ui),Sr(Ke,"init"),Tl(Ke),Fi(Ke,"init"),Ke.asyncDep){if(xe&&xe.registerDep(Ke,ct),!j.el){var et=Ke.subTree=zn(fn);me(null,et,X,ye)}return}if(ct(Ke,j,X,ye,xe,Qe,st),Ke.$wxsModules){var je=k.resolveOwnerEl(Ke);if(je){je.setAttribute(k.ATTR_V_OWNER_ID,Ke.uid);var{$renderjsModules:Rt}=Ke.type;Rt&&je.setAttribute(k.ATTR_V_RENDERJS,Rt)}}tn(),Fi(Ke,"mount")},Je=(j,X,ye)=>{var De=X.component=j.component;if(ba(j,X,ye))if(De.asyncDep&&!De.asyncResolved){At(X),Xe(De,X,ye),tn();return}else De.next=X,zi(De.update),De.update();else X.el=j.el,De.vnode=X},ct=(j,X,ye,De,xe,Qe,st)=>{var Ke=()=>{if(j.isMounted){var{next:Ur,bu:ul,u:fi,parent:Eo,vnode:bs}=j,fl=Ur,as;At(Ur||j.vnode),ai(j,!1),Ur?(Ur.el=bs.el,Xe(j,Ur,st)):Ur=bs,ul&&u.invokeArrayFns(ul),(as=Ur.props&&Ur.props.onVnodeBeforeUpdate)&&li(as,Eo,Ur,bs),ai(j,!0),Sr(j,"render");var ys=Qi(j);Fi(j,"render");var Da=j.subTree;j.subTree=ys,Sr(j,"patch"),ve(Da,ys,te(Da.el),Wn(Da),j,xe,Qe),Fi(j,"patch"),Ur.el=ys.el,fl===null&&un(j,ys.el),fi&&Cr(fi,xe),(as=Ur.props&&Ur.props.onVnodeUpdated)&&Cr(()=>li(as,Eo,Ur,bs),xe),Ki(j),tn()}else{var Rt,{el:Mt,props:xt}=X,{bm:bn,m:$i,parent:Zn}=j,Qr=Cn(X);if(ai(j,!1),bn&&u.invokeArrayFns(bn),!Qr&&(Rt=xt&&xt.onVnodeBeforeMount)&&li(Rt,Zn,X),ai(j,!0),Mt&&Ba){var ao=()=>{Sr(j,"render"),j.subTree=Qi(j),Fi(j,"render"),Sr(j,"hydrate"),Ba(Mt,j.subTree,j,xe,null),Fi(j,"hydrate")};Qr?X.type.__asyncLoader().then(()=>!j.isUnmounted&&ao()):ao()}else{Sr(j,"render");var Ma=j.subTree=Qi(j);Fi(j,"render"),Sr(j,"patch"),ve(null,Ma,ye,De,j,xe,Qe),Fi(j,"patch"),X.el=Ma.el}if($i&&Cr($i,xe),!Qr&&(Rt=xt&&xt.onVnodeMounted)){var ta=X;Cr(()=>li(Rt,Zn,ta),xe)}(X.shapeFlag&256||Zn&&Cn(Zn.vnode)&&Zn.vnode.shapeFlag&256)&&j.a&&Cr(j.a,xe),j.isMounted=!0,er(j),X=ye=De=null}},et=j.effect=new I.ReactiveEffect(Ke,()=>Pi(je),j.scope),je=j.update=()=>et.run();je.id=j.uid,ai(j,!0),et.onTrack=j.rtc?Rt=>u.invokeArrayFns(j.rtc,Rt):void 0,et.onTrigger=j.rtg?Rt=>u.invokeArrayFns(j.rtg,Rt):void 0,je.ownerInstance=j,je()},Xe=(j,X,ye)=>{X.component=j;var De=j.vnode.props;j.vnode=X,j.next=null,ut(j,X.props,De,ye),qa(j,X.children,ye),I.pauseTracking(),Gi(void 0,j.update),I.resetTracking()},tt=function(j,X,ye,De,xe,Qe,st,Ke){var et=arguments.length>8&&arguments[8]!==void 0?arguments[8]:!1,je=j&&j.children,Rt=j?j.shapeFlag:0,Mt=X.children,{patchFlag:xt,shapeFlag:bn}=X;if(xt>0){if(xt&128){Ct(je,Mt,ye,De,xe,Qe,st,Ke,et);return}else if(xt&256){We(je,Mt,ye,De,xe,Qe,st,Ke,et);return}}bn&8?(Rt&16&&gn(je,xe,Qe),Mt!==je&&oe(ye,Mt)):Rt&16?bn&16?Ct(je,Mt,ye,De,xe,Qe,st,Ke,et):gn(je,xe,Qe,!0):(Rt&8&&oe(ye,""),bn&16&&wt(Mt,ye,De,xe,Qe,st,Ke,et))},We=(j,X,ye,De,xe,Qe,st,Ke,et)=>{j=j||u.EMPTY_ARR,X=X||u.EMPTY_ARR;var je=j.length,Rt=X.length,Mt=Math.min(je,Rt),xt;for(xt=0;xt<Mt;xt++){var bn=X[xt]=et?Vi(X[xt]):Tn(X[xt]);ve(j[xt],bn,ye,null,xe,Qe,st,Ke,et)}je>Rt?gn(j,xe,Qe,!0,!1,Mt):wt(X,ye,De,xe,Qe,st,Ke,et,Mt)},Ct=(j,X,ye,De,xe,Qe,st,Ke,et)=>{for(var je=0,Rt=X.length,Mt=j.length-1,xt=Rt-1;je<=Mt&&je<=xt;){var bn=j[je],$i=X[je]=et?Vi(X[je]):Tn(X[je]);if(si(bn,$i))ve(bn,$i,ye,null,xe,Qe,st,Ke,et);else break;je++}for(;je<=Mt&&je<=xt;){var Zn=j[Mt],Qr=X[xt]=et?Vi(X[xt]):Tn(X[xt]);if(si(Zn,Qr))ve(Zn,Qr,ye,null,xe,Qe,st,Ke,et);else break;Mt--,xt--}if(je>Mt){if(je<=xt)for(var ao=xt+1,Ma=ao<Rt?X[ao].el:De;je<=xt;)ve(null,X[je]=et?Vi(X[je]):Tn(X[je]),ye,Ma,xe,Qe,st,Ke,et),je++}else if(je>xt)for(;je<=Mt;)Pt(j[je],xe,Qe,!0),je++;else{var ta=je,Ur=je,ul=new Map;for(je=Ur;je<=xt;je++){var fi=X[je]=et?Vi(X[je]):Tn(X[je]);fi.key!=null&&(ul.has(fi.key)&&A("Duplicate keys found during update:",JSON.stringify(fi.key),"Make sure keys are unique."),ul.set(fi.key,je))}var Eo,bs=0,fl=xt-Ur+1,as=!1,ys=0,Da=new Array(fl);for(je=0;je<fl;je++)Da[je]=0;for(je=ta;je<=Mt;je++){var Ws=j[je];if(bs>=fl){Pt(Ws,xe,Qe,!0);continue}var Es=void 0;if(Ws.key!=null)Es=ul.get(Ws.key);else for(Eo=Ur;Eo<=xt;Eo++)if(Da[Eo-Ur]===0&&si(Ws,X[Eo])){Es=Eo;break}Es===void 0?Pt(Ws,xe,Qe,!0):(Da[Es-Ur]=je+1,Es>=ys?ys=Es:as=!0,ve(Ws,X[Es],ye,null,xe,Qe,st,Ke,et),bs++)}var Xc=as?Za(Da):u.EMPTY_ARR;for(Eo=Xc.length-1,je=fl-1;je>=0;je--){var yc=Ur+je,Qc=X[yc],eu=yc+1<Rt?X[yc+1].el:De;Da[je]===0?ve(null,Qc,ye,eu,xe,Qe,st,Ke,et):as&&(Eo<0||je!==Xc[Eo]?pt(Qc,ye,eu,2):Eo--)}}},pt=function(j,X,ye,De){var xe=arguments.length>4&&arguments[4]!==void 0?arguments[4]:null,{el:Qe,type:st,transition:Ke,children:et,shapeFlag:je}=j;if(je&6){pt(j.component.subTree,X,ye,De);return}if(je&128){j.suspense.move(X,ye,De);return}if(je&64){st.move(j,X,ye,ui);return}if(st===jt){p(Qe,X,ye);for(var Rt=0;Rt<et.length;Rt++)pt(et[Rt],X,ye,De);p(j.anchor,X,ye);return}if(st===Br){ot(j,X,ye);return}var Mt=De!==2&&je&1&&Ke;if(Mt)if(De===0)Ke.beforeEnter(Qe),p(Qe,X,ye),Cr(()=>Ke.enter(Qe),xe);else{var{leave:xt,delayLeave:bn,afterLeave:$i}=Ke,Zn=()=>p(Qe,X,ye),Qr=()=>{xt(Qe,()=>{Zn(),$i&&$i()})};bn?bn(Qe,Zn,Qr):Qr()}else p(Qe,X,ye)},Pt=function(j,X,ye){var De=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1,xe=arguments.length>4&&arguments[4]!==void 0?arguments[4]:!1,{type:Qe,props:st,ref:Ke,children:et,dynamicChildren:je,shapeFlag:Rt,patchFlag:Mt,dirs:xt}=j;if(Ke!=null&&ur(Ke,null,ye,j,!0),Rt&256){X.ctx.deactivate(j);return}var bn=Rt&1&&xt,$i=!Cn(j),Zn;if($i&&(Zn=st&&st.onVnodeBeforeUnmount)&&li(Zn,X,j),Rt&6)Wt(j.component,ye,De);else{if(Rt&128){j.suspense.unmount(ye,De);return}bn&&Ei(j,null,X,"beforeUnmount"),Rt&64?j.type.remove(j,X,ye,xe,ui,De):je&&(Qe!==jt||Mt>0&&Mt&64)?gn(je,X,ye,!1,!0):(Qe===jt&&Mt&(128|256)||!xe&&Rt&16)&&gn(et,X,ye),De&&en(j)}($i&&(Zn=st&&st.onVnodeUnmounted)||bn)&&Cr(()=>{Zn&&li(Zn,X,j),bn&&Ei(j,null,X,"unmounted")},ye)},en=j=>{var{type:X,el:ye,anchor:De,transition:xe}=j;if(X===jt){j.patchFlag>0&&j.patchFlag&2048&&xe&&!xe.persisted?j.children.forEach(je=>{je.type===fn?w(je.el):en(je)}):nn(ye,De);return}if(X===Br){dt(j);return}var Qe=()=>{w(ye),xe&&!xe.persisted&&xe.afterLeave&&xe.afterLeave()};if(j.shapeFlag&1&&xe&&!xe.persisted){var{leave:st,delayLeave:Ke}=xe,et=()=>st(ye,Qe);Ke?Ke(j.el,Qe,et):et()}else Qe()},nn=(j,X)=>{for(var ye;j!==X;)ye=Ee(j),w(j),j=ye;w(X)},Wt=(j,X,ye)=>{j.type.__hmrId&&Co(j);var{bum:De,scope:xe,update:Qe,subTree:st,um:Ke}=j;De&&u.invokeArrayFns(De),xe.stop(),Qe&&(Qe.active=!1,Pt(st,j,X,ye)),Ke&&Cr(Ke,X),Cr(()=>{j.isUnmounted=!0},X),X&&X.pendingBranch&&!X.isUnmounted&&j.asyncDep&&!j.asyncResolved&&j.suspenseId===X.pendingId&&(X.deps--,X.deps===0&&X.resolve()),Ji(j)},gn=function(j,X,ye){for(var De=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1,xe=arguments.length>4&&arguments[4]!==void 0?arguments[4]:!1,Qe=arguments.length>5&&arguments[5]!==void 0?arguments[5]:0,st=Qe;st<j.length;st++)Pt(j[st],X,ye,De,xe)},Wn=j=>j.shapeFlag&6?Wn(j.component.subTree):j.shapeFlag&128?j.suspense.next():Ee(j.anchor||j.el),Vo=(j,X,ye)=>{j==null?X._vnode&&Pt(X._vnode,null,null,!0):ve(X._vnode||null,j,X,null,null,null,ye),hi(),X._vnode=j},ui={p:ve,um:Pt,m:pt,r:en,mt:Pe,mc:wt,pc:tt,pbc:x,n:Wn,o:i},hr,Ba;return a&&([hr,Ba]=a(ui)),{render:Vo,hydrate:hr,createApp:Di(Vo,hr)}}function ai(i,a){var{effect:f,update:p}=i;f.allowRecurse=p.allowRecurse=a}function Mo(i,a){var f=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!1,p=i.children,w=a.children;if(u.isArray(p)&&u.isArray(w))for(var E=0;E<p.length;E++){var N=p[E],L=w[E];L.shapeFlag&1&&!L.dynamicChildren&&((L.patchFlag<=0||L.patchFlag===32)&&(L=w[E]=Vi(w[E]),L.el=N.el),f||Mo(N,L)),L.type===fn&&!L.el&&(L.el=N.el)}}function Za(i){var a=i.slice(),f=[0],p,w,E,N,L,R=i.length;for(p=0;p<R;p++){var K=i[p];if(K!==0){if(w=f[f.length-1],i[w]<K){a[p]=w,f.push(p);continue}for(E=0,N=f.length-1;E<N;)L=E+N>>1,i[f[L]]<K?E=L+1:N=L;K<i[f[E]]&&(E>0&&(a[p]=f[E-1]),f[E]=p)}}for(E=f.length,N=f[E-1];E-- >0;)f[E]=N,N=a[N];return f}var Ci=i=>i.__isTeleport,mo=i=>i&&(i.disabled||i.disabled===""),Xa=i=>typeof SVGElement!="undefined"&&i instanceof SVGElement,Ds=(i,a)=>{var f=i&&i.to;if(u.isString(f))if(a){var p=a(f);return p||A('Failed to locate Teleport target with selector "'.concat(f,'". ')+"Note the target element must exist before the component is mounted - i.e. the target cannot be rendered by the component itself, and ideally should be outside of the entire Vue component tree."),p}else return A("Current renderer does not support string target for Teleports. (missing querySelector renderer option)"),null;else return!f&&!mo(i)&&A("Invalid Teleport target: ".concat(f)),f},Ue={__isTeleport:!0,process(i,a,f,p,w,E,N,L,R,K){var{mc:ue,pc:oe,pbc:te,o:{insert:Ee,querySelector:He,createText:rt,createComment:ft}}=K,ve=mo(a.props),{shapeFlag:le,children:me,dynamicChildren:Ze}=a;if(ar&&(R=!1,Ze=null),i==null){var Oe=a.el=ft("teleport start",f),ot=a.anchor=ft("teleport end",f);Ee(Oe,f,p),Ee(ot,f,p);var dt=a.target=Ds(a.props,He),Ye=a.targetAnchor=rt("",f);dt?(Ee(Ye,dt),N=N||Xa(dt)):ve||A("Invalid Teleport target on mount:",dt,"(".concat(typeof dt,")"));var Ot=(Pe,Je)=>{le&16&&ue(me,Pe,Je,w,E,N,L,R)};ve?Ot(f,ot):dt&&Ot(dt,Ye)}else{a.el=i.el;var Tt=a.anchor=i.anchor,wt=a.target=i.target,$t=a.targetAnchor=i.targetAnchor,x=mo(i.props),U=x?f:wt,he=x?Tt:$t;if(N=N||Xa(wt),Ze?(te(i.dynamicChildren,Ze,U,w,E,N,L),Mo(i,a,!0)):R||oe(i,a,U,he,w,E,N,L,!1),ve)x||It(a,f,Tt,K,1);else if((a.props&&a.props.to)!==(i.props&&i.props.to)){var Ie=a.target=Ds(a.props,He);Ie?It(a,Ie,null,K,0):A("Invalid Teleport target on update:",wt,"(".concat(typeof wt,")"))}else x&&It(a,wt,$t,K,1)}},remove(i,a,f,p,w,E){var{um:N,o:{remove:L}}=w,{shapeFlag:R,children:K,anchor:ue,targetAnchor:oe,target:te,props:Ee}=i;if(te&&L(oe),(E||!mo(Ee))&&(L(ue),R&16))for(var He=0;He<K.length;He++){var rt=K[He];N(rt,a,f,!0,!!rt.dynamicChildren)}},move:It,hydrate:Bt};function It(i,a,f,p){var{o:{insert:w},m:E}=p,N=arguments.length>4&&arguments[4]!==void 0?arguments[4]:2;N===0&&w(i.targetAnchor,a,f);var{el:L,anchor:R,shapeFlag:K,children:ue,props:oe}=i,te=N===2;if(te&&w(L,a,f),(!te||mo(oe))&&K&16)for(var Ee=0;Ee<ue.length;Ee++)E(ue[Ee],a,f,2);te&&w(R,a,f)}function Bt(i,a,f,p,w,E,N,L){var{o:{nextSibling:R,parentNode:K,querySelector:ue}}=N,oe=a.target=Ds(a.props,ue);if(oe){var te=oe._lpa||oe.firstChild;if(a.shapeFlag&16)if(mo(a.props))a.anchor=L(R(i),a,K(i),f,p,w,E),a.targetAnchor=te;else{a.anchor=R(i);for(var Ee=te;Ee;)if(Ee=R(Ee),Ee&&Ee.nodeType===8&&Ee.data==="teleport anchor"){a.targetAnchor=Ee,oe._lpa=a.targetAnchor&&R(a.targetAnchor);break}L(te,a,oe,f,p,w,E)}}return a.anchor&&R(a.anchor)}var Ht=Ue,jt=Symbol("Fragment"),it=Symbol("Text"),fn=Symbol("Comment"),Br=Symbol("Static"),rr=[],Mr=null;function _o(){var i=arguments.length>0&&arguments[0]!==void 0?arguments[0]:!1;rr.push(Mr=i?null:[])}function Oa(){rr.pop(),Mr=rr[rr.length-1]||null}var Ko=1;function el(i){Ko+=i}function nc(i){return i.dynamicChildren=Ko>0?Mr||u.EMPTY_ARR:null,Oa(),Ko>0&&Mr&&Mr.push(i),i}function wl(i,a,f,p,w,E){return nc(Mn(i,a,f,p,w,E,!0))}function bo(i,a,f,p,w){return nc(zn(i,a,f,p,w,!0))}function fr(i){return i?i.__v_isVNode===!0:!1}function si(i,a){return a.shapeFlag&6&&Ir.has(a.type)?!1:i.type===a.type&&i.key===a.key}var Ta;function Sl(i){Ta=i}var Fs=function(){for(var i=arguments.length,a=new Array(i),f=0;f<i;f++)a[f]=arguments[f];return Cl(...Ta?Ta(a,Sn):a)},Do="__vInternal",Qa=i=>{var{key:a}=i;return a!=null?a:null},ps=i=>{var{ref:a,ref_key:f,ref_for:p}=i;return a!=null?u.isString(a)||I.isRef(a)||u.isFunction(a)?{i:Sn,r:a,k:f,f:!!p}:a:null};function Mn(i){var a=arguments.length>1&&arguments[1]!==void 0?arguments[1]:null,f=arguments.length>2&&arguments[2]!==void 0?arguments[2]:null,p=arguments.length>3&&arguments[3]!==void 0?arguments[3]:0,w=arguments.length>4&&arguments[4]!==void 0?arguments[4]:null,E=arguments.length>5&&arguments[5]!==void 0?arguments[5]:i===jt?0:1,N=arguments.length>6&&arguments[6]!==void 0?arguments[6]:!1,L=arguments.length>7&&arguments[7]!==void 0?arguments[7]:!1,R={__v_isVNode:!0,__v_skip:!0,type:i,props:a,key:a&&Qa(a),ref:a&&ps(a),scopeId:Nn,slotScopeIds:null,children:f,component:null,suspense:null,ssContent:null,ssFallback:null,dirs:null,transition:null,el:null,anchor:null,target:null,targetAnchor:null,staticCount:0,shapeFlag:E,patchFlag:p,dynamicProps:w,dynamicChildren:null,appContext:null};return L?(Ia(R,f),E&128&&i.normalize(R)):f&&(R.shapeFlag|=u.isString(f)?8:16),R.key!==R.key&&A("VNode created with invalid key (NaN). VNode type:",R.type),Ko>0&&!N&&Mr&&(R.patchFlag>0||E&6)&&R.patchFlag!==32&&Mr.push(R),R}var zn=Fs;function Cl(i){var a=arguments.length>1&&arguments[1]!==void 0?arguments[1]:null,f=arguments.length>2&&arguments[2]!==void 0?arguments[2]:null,p=arguments.length>3&&arguments[3]!==void 0?arguments[3]:0,w=arguments.length>4&&arguments[4]!==void 0?arguments[4]:null,E=arguments.length>5&&arguments[5]!==void 0?arguments[5]:!1;if((!i||i===fo)&&(i||A("Invalid vnode type when creating vnode: ".concat(i,".")),i=fn),fr(i)){var N=Ai(i,a,!0);return f&&Ia(N,f),Ko>0&&!E&&Mr&&(N.shapeFlag&6?Mr[Mr.indexOf(i)]=N:Mr.push(N)),N.patchFlag|=-2,N}if(xl(i)&&(i=i.__vccOpts),a){a=Li(a);var{class:L,style:R}=a;L&&!u.isString(L)&&(a.class=u.normalizeClass(L)),u.isObject(R)&&(I.isProxy(R)&&!u.isArray(R)&&(R=u.extend({},R)),a.style=u.normalizeStyle(R))}var K=u.isString(i)?1:qr(i)?128:Ci(i)?64:u.isObject(i)?4:u.isFunction(i)?2:0;return K&4&&I.isProxy(i)&&(i=I.toRaw(i),A("Vue received a Component which was made a reactive object. This can lead to unnecessary performance overhead, and should be avoided by marking the component with `markRaw` or using `shallowRef` instead of `ref`.",`
Component that was made reactive: `,i)),Mn(i,a,f,p,w,K,E,!0)}function Li(i){return i?I.isProxy(i)||Do in i?u.extend({},i):i:null}function Ai(i,a){var f=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!1,{props:p,ref:w,patchFlag:E,children:N}=i,L=a?Dr(p||{},a):p,R={__v_isVNode:!0,__v_skip:!0,type:i.type,props:L,key:L&&Qa(L),ref:a&&a.ref?f&&w?u.isArray(w)?w.concat(ps(a)):[w,ps(a)]:ps(a):w,scopeId:i.scopeId,slotScopeIds:i.slotScopeIds,children:E===-1&&u.isArray(N)?N.map(es):N,target:i.target,targetAnchor:i.targetAnchor,staticCount:i.staticCount,shapeFlag:i.shapeFlag,patchFlag:a&&i.type!==jt?E===-1?16:E|16:E,dynamicProps:i.dynamicProps,dynamicChildren:i.dynamicChildren,appContext:i.appContext,dirs:i.dirs,transition:i.transition,component:i.component,suspense:i.suspense,ssContent:i.ssContent&&Ai(i.ssContent),ssFallback:i.ssFallback&&Ai(i.ssFallback),el:i.el,anchor:i.anchor};return R}function es(i){var a=Ai(i);return u.isArray(i.children)&&(a.children=i.children.map(es)),a}function Al(){var i=arguments.length>0&&arguments[0]!==void 0?arguments[0]:" ",a=arguments.length>1&&arguments[1]!==void 0?arguments[1]:0;return zn(it,null,i,a)}function rc(i,a){var f=zn(Br,null,i);return f.staticCount=a,f}function io(){var i=arguments.length>0&&arguments[0]!==void 0?arguments[0]:"",a=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!1;return a?(_o(),bo(fn,null,i)):zn(fn,null,i)}function Tn(i){return i==null||typeof i=="boolean"?zn(fn):u.isArray(i)?zn(jt,null,i.slice()):typeof i=="object"?Vi(i):zn(it,null,String(i))}function Vi(i){return i.el===null||i.memo?i:Ai(i)}function Ia(i,a){var f=0,{shapeFlag:p}=i;if(a==null)a=null;else if(u.isArray(a))f=16;else if(typeof a=="object")if(p&(1|64)){var w=a.default;w&&(w._c&&(w._d=!1),Ia(i,w()),w._c&&(w._d=!0));return}else{f=32;var E=a._;!E&&!(Do in a)?a._ctx=Sn:E===3&&Sn&&(Sn.slots._===1?a._=1:(a._=2,i.patchFlag|=1024))}else u.isFunction(a)?(a={default:a,_ctx:Sn},f=32):(a=String(a),p&64?(f=16,a=[Al(a)]):f=8);i.children=a,i.shapeFlag|=f}function Dr(){for(var i={},a=0;a<arguments.length;a++){var f=a<0||arguments.length<=a?void 0:arguments[a];for(var p in f)if(p==="class")i.class!==f.class&&(i.class=u.normalizeClass([i.class,f.class]));else if(p==="style")i.style=u.normalizeStyle([i.style,f.style]);else if(u.isOn(p)){var w=i[p],E=f[p];E&&w!==E&&!(u.isArray(w)&&w.includes(E))&&(i[p]=w?[].concat(w,E):E)}else p!==""&&(i[p]=f[p])}return i}function li(i,a,f){var p=arguments.length>3&&arguments[3]!==void 0?arguments[3]:null;Ft(i,a,7,[f,p])}var tl=Ms(),Ol=0;function Jn(i,a,f){var p=i.type,w=(a?a.appContext:i.appContext)||tl,E={uid:Ol++,vnode:i,type:p,parent:a,appContext:w,root:null,next:null,subTree:null,effect:null,update:null,scope:new I.EffectScope(!0),render:null,proxy:null,exposed:null,exposeProxy:null,withProxy:null,provides:a?a.provides:Object.create(w.provides),accessCache:null,renderCache:[],components:null,directives:null,propsOptions:St(p,w),emitsOptions:Zi(p,w),emit:null,emitted:null,propsDefaults:u.EMPTY_OBJ,inheritAttrs:p.inheritAttrs,ctx:u.EMPTY_OBJ,data:u.EMPTY_OBJ,props:u.EMPTY_OBJ,attrs:u.EMPTY_OBJ,slots:u.EMPTY_OBJ,refs:u.EMPTY_OBJ,setupState:u.EMPTY_OBJ,setupContext:null,suspense:f,suspenseId:f?f.pendingId:0,asyncDep:null,asyncResolved:!1,isMounted:!1,isUnmounted:!1,isDeactivated:!1,bc:null,c:null,bm:null,m:null,bu:null,u:null,um:null,bum:null,da:null,a:null,rtg:null,rtc:null,ec:null,sp:null};return E.ctx=El(E),E.root=a?a.root:E,E.emit=Ho.bind(null,E),i.ce&&i.ce(E),E}var In=null,ci=()=>In||Sn,Zr=i=>{In=i,i.scope.on()},fa=()=>{In&&In.scope.off(),In=null},ts=u.makeMap("slot,component");function Xr(i,a){var f=a.isNativeTag||u.NO;(ts(i)||f(i))&&A("Do not use built-in or reserved HTML elements as component id: "+i)}function Fo(i){return i.vnode.shapeFlag&4}C.isInSSRComponentSetup=!1;function Tl(i){var a=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!1;C.isInSSRComponentSetup=a;var{props:f,children:p}=i.vnode,w=Fo(i);gt(i,f,w,a),qo(i,p);var E=w?Il(i,a):void 0;return C.isInSSRComponentSetup=!1,E}function Il(i,a){var f,p=i.type;{if(p.name&&Xr(p.name,i.appContext.config),p.components)for(var w=Object.keys(p.components),E=0;E<w.length;E++)Xr(w[E],i.appContext.config);if(p.directives)for(var N=Object.keys(p.directives),L=0;L<N.length;L++)Zs(N[L]);p.compilerOptions&&nl()&&A('"compilerOptions" is only supported when using a build of Vue that includes the runtime compiler. Since you are using a runtime-only build, the options should be passed via your build tool config instead.')}i.accessCache=Object.create(null),i.proxy=I.markRaw(new Proxy(i.ctx,go)),xs(i);var{setup:R}=p;if(R){var K=i.setupContext=R.length>1?rs(i):null;Zr(i),I.pauseTracking();var ue=hn(R,i,0,[I.shallowReadonly(i.props),K]);if(I.resetTracking(),fa(),u.isPromise(ue)){if(ue.then(fa,fa),a)return ue.then(te=>{ns(i,te,a)}).catch(te=>{Vt(te,i,0)});if(i.asyncDep=ue,!i.suspense){var oe=(f=p.name)!==null&&f!==void 0?f:"Anonymous";A("Component <".concat(oe,">: setup function returned a promise, but no ")+"<Suspense> boundary was found in the parent component tree. A component with async setup() must be nested in a <Suspense> in order to be rendered.")}}else ns(i,ue,a)}else ic(i,a)}function ns(i,a,f){u.isFunction(a)?i.type.__ssrInlineRender?i.ssrRender=a:i.render=a:u.isObject(a)?(fr(a)&&A("setup() should not return VNodes directly - return a render function instead."),i.devtoolsRawSetupState=a,i.setupState=I.proxyRefs(a),Qs(i)):a!==void 0&&A("setup() should return an object. Received: ".concat(a===null?"null":typeof a)),ic(i,f)}var Pa,Pl;function Nl(i){Pa=i,Pl=a=>{a.render._rc&&(a.withProxy=new Proxy(a.ctx,Rs))}}var nl=()=>!Pa;function ic(i,a,f){var p=i.type;if(!i.render){if(!a&&Pa&&!p.render){var w=p.template;if(w){Sr(i,"compile");var{isCustomElement:E,compilerOptions:N}=i.appContext.config,{delimiters:L,compilerOptions:R}=p,K=u.extend(u.extend({isCustomElement:E,delimiters:L},N),R);p.render=Pa(w,K),Fi(i,"compile")}}i.render=p.render||u.NOOP,Pl&&Pl(i)}Zr(i),I.pauseTracking(),q(i),I.resetTracking(),fa(),!p.render&&i.render===u.NOOP&&!a&&(!Pa&&p.template?A('Component provided template option but runtime compilation is not supported in this build of Vue. Configure your bundler to alias "vue" to "vue/dist/vue.esm-bundler.js".'):A("Component is missing template or render function."))}function kl(i){return new Proxy(i.attrs,{get(a,f){return ki(),I.track(i,"get","$attrs"),a[f]},set(){return A("setupContext.attrs is readonly."),!1},deleteProperty(){return A("setupContext.attrs is readonly."),!1}})}function rs(i){var a=p=>{i.exposed&&A("expose() should be called only once per setup()."),i.exposed=p||{}},f;return Object.freeze({get attrs(){return f||(f=kl(i))},get slots(){return I.shallowReadonly(i.slots)},get emit(){return function(p){for(var w=arguments.length,E=new Array(w>1?w-1:0),N=1;N<w;N++)E[N-1]=arguments[N];return i.emit(p,...E)}},expose:a})}function Ls(i){if(i.exposed)return i.exposeProxy||(i.exposeProxy=new Proxy(I.proxyRefs(I.markRaw(i.exposed)),{get(a,f){if(f in a)return a[f];if(f in po)return po[f](i)}}))}var Rl=/(?:^|[-_])(\w)/g,gs=i=>i.replace(Rl,a=>a.toUpperCase()).replace(/[-_]/g,"");function da(i){var a=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!0;return u.isFunction(i)?i.displayName||i.name:i.name||a&&i.__name}function Vs(i,a){var f=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!1,p=da(a);if(!p&&a.__file){var w=a.__file.match(/([^/\\]+)\.\w+$/);w&&(p=w[1])}if(!p&&i&&i.parent){var E=N=>{for(var L in N)if(N[L]===a)return L};p=E(i.components||i.parent.type.components)||E(i.appContext.components)}return p?gs(p):f?"App":"Anonymous"}function xl(i){return u.isFunction(i)&&"__vccOpts"in i}var $s=(i,a)=>I.computed(i,a,C.isInSSRComponentSetup),Us=i=>A("".concat(i,"() is a compiler-hint helper that is only usable inside ")+"<script setup> of a single file component. Its arguments should be compiled away and passing it at runtime has no effect.");function $c(){return Us("defineProps"),null}function oc(){return Us("defineEmits"),null}function Uc(i){Us("defineExpose")}function Hc(i,a){return Us("withDefaults"),null}function jc(){return sc().slots}function ac(){return sc().attrs}function sc(){var i=ci();return i||A("useContext() called without active instance."),i.setupContext||(i.setupContext=rs(i))}function zc(i,a){var f=u.isArray(i)?i.reduce((E,N)=>(E[N]={},E),{}):i;for(var p in a){var w=f[p];w?u.isArray(w)||u.isFunction(w)?f[p]={type:w,default:a[p]}:w.default=a[p]:w===null?f[p]={default:a[p]}:A('props default key "'.concat(p,'" has no corresponding declaration.'))}return f}function Wc(i,a){var f={},p=function(E){a.includes(E)||Object.defineProperty(f,E,{enumerable:!0,get:()=>i[E]})};for(var w in i)p(w);return f}function Gc(i){var a=ci();a||A("withAsyncContext called without active current instance. This is likely a bug.");var f=i();return fa(),u.isPromise(f)&&(f=f.catch(p=>{throw Zr(a),p})),[f,()=>Zr(a)]}function Bl(i,a,f){var p=arguments.length;return p===2?u.isObject(a)&&!u.isArray(a)?fr(a)?zn(i,null,[a]):zn(i,a):zn(i,null,a):(p>3?f=Array.prototype.slice.call(arguments,2):p===3&&fr(f)&&(f=[f]),zn(i,a,f))}var lc=Symbol("ssrContext"),Ml=()=>{{var i=eo(lc);return i||A("Server rendering context not provided. Make sure to only call useSSRContext() conditionally in the server build."),i}};function Dl(i){return!!(i&&i.__v_isShallow)}function Yc(){if(typeof window=="undefined")return;var i={style:"color:#3ba776"},a={style:"color:#0b1bc9"},f={style:"color:#b62e24"},p={style:"color:#9d288c"},w={header(oe){return u.isObject(oe)?oe.__isVue?["div",i,"VueInstance"]:I.isRef(oe)?["div",{},["span",i,ue(oe)],"<",L(oe.value),">"]:I.isReactive(oe)?["div",{},["span",i,Dl(oe)?"ShallowReactive":"Reactive"],"<",L(oe),">".concat(I.isReadonly(oe)?" (readonly)":"")]:I.isReadonly(oe)?["div",{},["span",i,Dl(oe)?"ShallowReadonly":"Readonly"],"<",L(oe),">"]:null:null},hasBody(oe){return oe&&oe.__isVue},body(oe){if(oe&&oe.__isVue)return["div",{},...E(oe.$)]}};function E(oe){var te=[];oe.type.props&&oe.props&&te.push(N("props",I.toRaw(oe.props))),oe.setupState!==u.EMPTY_OBJ&&te.push(N("setup",oe.setupState)),oe.data!==u.EMPTY_OBJ&&te.push(N("data",I.toRaw(oe.data)));var Ee=R(oe,"computed");Ee&&te.push(N("computed",Ee));var He=R(oe,"inject");return He&&te.push(N("injected",He)),te.push(["div",{},["span",{style:p.style+";opacity:0.66"},"$ (internal): "],["object",{object:oe}]]),te}function N(oe,te){return te=u.extend({},te),Object.keys(te).length?["div",{style:"line-height:1.25em;margin-bottom:0.6em"},["div",{style:"color:#476582"},oe],["div",{style:"padding-left:1.25em"},...Object.keys(te).map(Ee=>["div",{},["span",p,Ee+": "],L(te[Ee],!1)])]]:["span",{}]}function L(oe){var te=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!0;return typeof oe=="number"?["span",a,oe]:typeof oe=="string"?["span",f,JSON.stringify(oe)]:typeof oe=="boolean"?["span",p,oe]:u.isObject(oe)?["object",{object:te?I.toRaw(oe):oe}]:["span",f,String(oe)]}function R(oe,te){var Ee=oe.type;if(!u.isFunction(Ee)){var He={};for(var rt in oe.ctx)K(Ee,rt,te)&&(He[rt]=oe.ctx[rt]);return He}}function K(oe,te,Ee){var He=oe[Ee];if(u.isArray(He)&&He.includes(te)||u.isObject(He)&&te in He||oe.extends&&K(oe.extends,te,Ee)||oe.mixins&&oe.mixins.some(rt=>K(rt,te,Ee)))return!0}function ue(oe){return Dl(oe)?"ShallowRef":oe.effect?"ComputedRef":"Ref"}window.devtoolsFormatters?window.devtoolsFormatters.push(w):window.devtoolsFormatters=[w]}function cc(i,a,f,p){var w=f[p];if(w&&rl(w,i))return w;var E=a();return E.memo=i.slice(),f[p]=E}function rl(i,a){var f=i.memo;if(f.length!=a.length)return!1;for(var p=0;p<f.length;p++)if(u.hasChanged(f[p],a[p]))return!1;return Ko>0&&Mr&&Mr.push(i),!0}var Fl="3.2.37",yo={createComponentInstance:Jn,setupComponent:Tl,renderComponentRoot:Qi,setCurrentRenderingInstance:lr,isVNode:fr,normalizeVNode:Tn},Hs=yo,dr=null,ha=null;function Jo(i,a){return i==="input"?new k.UniInputElement(i,a):i==="textarea"?new k.UniTextAreaElement(i,a):new k.UniElement(i,a)}function uc(i,a){return new k.UniTextNode(i,a)}function il(i,a){return new k.UniCommentNode(i,a)}var Zo,Ll={insert:(i,a,f)=>{a.insertBefore(i,f||null)},remove:i=>{var a=i.parentNode;a&&a.removeChild(i)},createElement:(i,a)=>Jo(i,a),createText:(i,a)=>uc(i,a),createComment:(i,a)=>il(i,a),setText:(i,a)=>{i.nodeValue=a},setElementText:(i,a)=>{i.textContent=a},parentNode:i=>i.parentNode,nextSibling:i=>i.nextSibling,setScopeId(i,a){i.setAttribute(a,"")},cloneNode(i){var a=i.cloneNode(!0);return"_value"in i&&(a._value=i._value),a},insertStaticContent(i,a,f){var p=Zo||(Zo=Jo("div"));p.innerHTML=i;for(var w=p.firstChild,E=w,N=E;E;)N=E,Ll.insert(E,a,f),E=p.firstChild;return[w,N]}};function Xo(i,a){a==null&&(a=""),i.setAttribute("class",a)}function fc(i,a,f){if(!f)i.removeAttribute("style");else if(u.isString(f))a!==f&&i.setAttribute("style",f);else{var p={},w=a&&!u.isString(a);if(w){for(var E in a)f[E]==null&&(p[E]="");for(var N in f){var L=f[N];L!==a[N]&&(p[N]=L)}}else for(var R in f)p[R]=f[R];Object.keys(p).length&&i.setAttribute("style",p)}}function oo(i,a,f){f==null?i.removeAttribute(a):i.setAttribute(a,f)}function dc(i,a,f,p){i.addEventListener(a,f,p)}function ol(i,a,f,p){i.removeEventListener(a,f,p)}function hc(i,a,f,p){var w=arguments.length>4&&arguments[4]!==void 0?arguments[4]:null,E=i._vei||(i._vei={}),N=E[a];if(p&&N)N.value=p;else{var[L,R]=vs(a);if(p){var K=E[a]=gc(p,w);dc(i,L,K,R)}else N&&(ol(i,L,N,R),E[a]=void 0)}}var pc=/(?:Once|Passive|Capture)$/;function vs(i){var a;if(pc.test(i)){a={};for(var f;f=i.match(pc);)i=i.slice(0,i.length-f[0].length),a[f[0].toLowerCase()]=!0}return[u.hyphenate(i.slice(2)),a]}function gc(i,a){var f=w=>{Ft(f.value,a,5,[w])};f.value=i;var p=new Set;return u.isArray(f.value)?f.value.forEach(w=>{w.modifiers&&w.modifiers.forEach(E=>{p.add(E)})}):(f.value.modifiers&&f.value.modifiers.forEach(w=>{p.add(w)}),vc(f,a)),f.modifiers=[...p],f}function vc(i,a){if(!!a){var{$wxsModules:f}=a;if(!!f){var p=i.value.toString();!f.find(w=>p.indexOf("."+w+".")>-1)||(i.wxsEvent=i.value())}}}var qc=function(i,a,f,p){var w=arguments.length>6?arguments[6]:void 0;switch(a){case"class":Xo(i,p);break;case"style":fc(i,f,p);break;default:if(u.isOn(a))u.isModelListener(a)||hc(i,a,f,p,w);else{if(u.isObject(p)){var E=f===p;if(p=k.JSON_PROTOCOL+JSON.stringify(p),E&&i.getAttribute(a)===p)return}else if(f===p)return;oo(i,a,p)}break}};function Kc(){var i=arguments.length>0&&arguments[0]!==void 0?arguments[0]:"$style";{var a=ci();if(!a)return A("useCssModule must be called inside setup()"),u.EMPTY_OBJ;var f=a.type.__cssModules;if(!f)return A("Current instance does not have CSS modules injected."),u.EMPTY_OBJ;var p=f[i];return p||(A('Current instance does not have CSS module named "'.concat(i,'".')),u.EMPTY_OBJ)}}function al(i){var a=ci();if(!a){A("useCssVars is called without current active component instance.");return}var f=()=>Vl(a.subTree,i(a.proxy));nr(()=>zo(f,{flush:"post"})),ko(f)}function Vl(i,a){if(i.shapeFlag&128){var f=i.suspense;i=f.activeBranch,f.pendingBranch&&!f.isHydrating&&f.effects.push(()=>{Vl(f.activeBranch,a)})}for(;i.component;)i=i.component.subTree;if(i.shapeFlag&1&&i.el)mc(i.el,a);else if(i.type===jt)i.children.forEach(E=>Vl(E,a));else if(i.type===Br)for(var{el:p,anchor:w}=i;p&&(mc(p,a),p!==w);)p=p.nextSibling}function mc(i,a){if(i.nodeType===1)for(var f in a)i.setAttribute("--".concat(f),a[f])}var Na="transition",js="animation",$l=(i,a)=>{var{slots:f}=a;return Bl(ie,bc(i),f)};$l.displayName="Transition";var sl={name:String,type:String,css:{type:Boolean,default:!0},duration:[String,Number,Object],enterFromClass:String,enterActiveClass:String,enterToClass:String,appearFromClass:String,appearActiveClass:String,appearToClass:String,leaveFromClass:String,leaveActiveClass:String,leaveToClass:String},Jc=$l.props=u.extend({},ie.props,sl),ka=function(i){var a=arguments.length>1&&arguments[1]!==void 0?arguments[1]:[];u.isArray(i)?i.forEach(f=>f(...a)):i&&i(...a)},_c=i=>i?u.isArray(i)?i.some(a=>a.length>1):i.length>1:!1;function bc(i){var a={};for(var f in i)f in sl||(a[f]=i[f]);if(i.css===!1)return a;var{name:p="v",type:w,duration:E,enterFromClass:N="".concat(p,"-enter-from"),enterActiveClass:L="".concat(p,"-enter-active"),enterToClass:R="".concat(p,"-enter-to"),appearFromClass:K=N,appearActiveClass:ue=L,appearToClass:oe=R,leaveFromClass:te="".concat(p,"-leave-from"),leaveActiveClass:Ee="".concat(p,"-leave-active"),leaveToClass:He="".concat(p,"-leave-to")}=i,rt=dn(E),ft=rt&&rt[0],ve=rt&&rt[1],{onBeforeEnter:le,onEnter:me,onEnterCancelled:Ze,onLeave:Oe,onLeaveCancelled:ot,onBeforeAppear:dt=le,onAppear:Ye=me,onAppearCancelled:Ot=Ze}=a,Tt=(x,U,he)=>{ea(x,U?oe:R),ea(x,U?ue:L),he&&he()},wt=(x,U)=>{ea(x,He),ea(x,Ee),U&&U()},$t=x=>(U,he)=>{var Ie=x?Ye:me,Pe=()=>Tt(U,x,he);ka(Ie,[U,Pe]),ll(()=>{ea(U,x?K:N),pa(U,x?oe:R),_c(Ie)||is(U,w,ft,Pe)})};return u.extend(a,{onBeforeEnter(x){ka(le,[x]),pa(x,N),pa(x,L)},onBeforeAppear(x){ka(dt,[x]),pa(x,K),pa(x,ue)},onEnter:$t(!1),onAppear:$t(!0),onLeave(x,U){var he=()=>wt(x,U);pa(x,te),Ar(),pa(x,Ee),ll(()=>{ea(x,te),pa(x,He),_c(Oe)||is(x,w,ve,he)}),ka(Oe,[x,he])},onEnterCancelled(x){Tt(x,!1),ka(Ze,[x])},onAppearCancelled(x){Tt(x,!0),ka(Ot,[x])},onLeaveCancelled(x){wt(x),ka(ot,[x])}})}function dn(i){if(i==null)return null;if(u.isObject(i))return[Qo(i.enter),Qo(i.leave)];var a=Qo(i);return[a,a]}function Qo(i){var a=u.toNumber(i);return Lo(a),a}function Lo(i){typeof i!="number"?A("<transition> explicit duration is not a valid number - "+"got ".concat(JSON.stringify(i),".")):isNaN(i)&&A("<transition> explicit duration is NaN - the duration expression might be incorrect.")}function pa(i,a){a.split(/\s+/).forEach(f=>f&&i.classList.add(f)),(i._vtc||(i._vtc=new Set)).add(a)}function ea(i,a){a.split(/\s+/).forEach(p=>p&&i.classList.remove(p));var{_vtc:f}=i;f&&(f.delete(a),f.size||(i._vtc=void 0))}function ll(i){requestAnimationFrame(()=>{requestAnimationFrame(i)})}var cl=0;function is(i,a,f,p){var w=i._endId=++cl,E=()=>{w===i._endId&&p()};if(f)return setTimeout(E,f);var{type:N,timeout:L,propCount:R}=zs(i,a);if(!N)return p();var K=N+"end",ue=0,oe=()=>{i.removeEventListener(K,te),E()},te=Ee=>{Ee.target===i&&++ue>=R&&oe()};setTimeout(()=>{ue<R&&oe()},L+1),i.addEventListener(K,te)}function zs(i,a){var f=window.getComputedStyle(i),p=He=>(f[He]||"").split(", "),w=p(Na+"Delay"),E=p(Na+"Duration"),N=Ra(w,E),L=p(js+"Delay"),R=p(js+"Duration"),K=Ra(L,R),ue=null,oe=0,te=0;a===Na?N>0&&(ue=Na,oe=N,te=E.length):a===js?K>0&&(ue=js,oe=K,te=R.length):(oe=Math.max(N,K),ue=oe>0?N>K?Na:js:null,te=ue?ue===Na?E.length:R.length:0);var Ee=ue===Na&&/\b(transform|all)(,|$)/.test(f[Na+"Property"]);return{type:ue,timeout:oe,propCount:te,hasTransform:Ee}}function Ra(i,a){for(;i.length<a.length;)i=i.concat(i);return Math.max(...a.map((f,p)=>ms(f)+ms(i[p])))}function ms(i){return Number(i.slice(0,-1).replace(",","."))*1e3}function Ar(){return document.body.offsetHeight}var _s=new WeakMap,ga=new WeakMap,os={name:"TransitionGroup",props:u.extend({},Jc,{tag:String,moveClass:String}),setup(i,a){var{slots:f}=a,p=ci(),w=tr(),E,N;return ko(()=>{if(!!E.length){var L=i.moveClass||"".concat(i.name||"v","-move");if(!!h(E[0].el,p.vnode.el,L)){E.forEach(xa),E.forEach(o);var R=E.filter(l);Ar(),R.forEach(K=>{var ue=K.el,oe=ue.style;pa(ue,L),oe.transform=oe.webkitTransform=oe.transitionDuration="";var te=ue._moveCb=Ee=>{Ee&&Ee.target!==ue||(!Ee||/transform$/.test(Ee.propertyName))&&(ue.removeEventListener("transitionend",te),ue._moveCb=null,ea(ue,L))};ue.addEventListener("transitionend",te)})}}}),()=>{var L=I.toRaw(i),R=bc(L),K=L.tag||jt;E=N,N=f.default?ge(f.default()):[];for(var ue=0;ue<N.length;ue++){var oe=N[ue];oe.key!=null?Z(oe,G(oe,R,w,p)):A("<TransitionGroup> children must be keyed.")}if(E)for(var te=0;te<E.length;te++){var Ee=E[te];Z(Ee,G(Ee,R,w,p)),_s.set(Ee,Ee.el.getBoundingClientRect())}return zn(K,null,N)}}},Zc=os;function xa(i){var a=i.el;a._moveCb&&a._moveCb(),a._enterCb&&a._enterCb()}function o(i){ga.set(i,i.el.getBoundingClientRect())}function l(i){var a=_s.get(i),f=ga.get(i),p=a.left-f.left,w=a.top-f.top;if(p||w){var E=i.el.style;return E.transform=E.webkitTransform="translate(".concat(p,"px,").concat(w,"px)"),E.transitionDuration="0s",i}}function h(i,a,f){var p=i.cloneNode();i._vtc&&i._vtc.forEach(N=>{N.split(/\s+/).forEach(L=>L&&p.classList.remove(L))}),f.split(/\s+/).forEach(N=>N&&p.classList.add(N)),p.style.display="none";var w=a.nodeType===1?a:a.parentNode;w.appendChild(p);var{hasTransform:E}=zs(p);return w.removeChild(p),E}var m=i=>{var a=i.props["onUpdate:modelValue"];return u.isArray(a)?f=>u.invokeArrayFns(a,f):a},S={created(i,a,f){var{value:p,modifiers:{trim:w,number:E}}=a;i.value=p==null?"":p,i._assign=m(f),dc(i,"input",N=>{var L=N.detail.value,R=i.pageNode;i.pageNode=null,i.value=L,i.pageNode=R,w?L=L.trim():E&&(L=u.toNumber(L)),i._assign(L)})},beforeUpdate(i,a,f){var{value:p}=a;i._assign=m(f);var w=p==null?"":p;i.value!==w&&(i.value=w)}},O=S,M=["ctrl","shift","alt","meta"],Y={stop:i=>i.stopPropagation(),prevent:i=>i.preventDefault(),self:i=>i.target!==i.currentTarget,ctrl:i=>!i.ctrlKey,shift:i=>!i.shiftKey,alt:i=>!i.altKey,meta:i=>!i.metaKey,left:i=>"button"in i&&i.button!==0,middle:i=>"button"in i&&i.button!==1,right:i=>"button"in i&&i.button!==2,exact:(i,a)=>M.some(f=>i["".concat(f,"Key")]&&!a.includes(f))},H=(i,a)=>{var f=function(p){for(var w=0;w<a.length;w++){var E=Y[a[w]];if(E&&E(p,a))return}for(var N=arguments.length,L=new Array(N>1?N-1:0),R=1;R<N;R++)L[R-1]=arguments[R];return i(p,...L)};return f.modifiers=a,f},ne={esc:"escape",space:" ",up:"arrow-up",left:"arrow-left",right:"arrow-right",down:"arrow-down",delete:"backspace"},Ne=(i,a)=>f=>{if("key"in f){var p=u.hyphenate(f.key);if(a.some(w=>w===p||ne[w]===p))return i(f)}},fe={beforeMount(i,a){var{value:f}=a;ce(i,f)},updated(i,a){var{value:f,oldValue:p}=a;!f!=!p&&ce(i,f)},beforeUnmount(i,a){var{value:f}=a;ce(i,f)}};function ce(i,a){i.setAttribute(".vShow",!!a)}var Fe=u.extend({patchProp:qc,forcePatchProp:k.forcePatchProp},Ll),Ve;function lt(){return Ve||(Ve=hs(Fe))}var mt=function(){lt().render(...arguments)},we=function(){var i=lt().createApp(...arguments);Se(i);var{mount:a}=i;return i.mount=f=>(u.isString(f)&&(f=il(f)),f&&a(f,!1,!1)),i},de=we;function Se(i){Object.defineProperty(i.config,"isNativeTag",{value:a=>u.isHTMLTag(a)||u.isSVGTag(a),writable:!1})}function nt(){}function ze(){}return Object.defineProperty(C,"camelize",{enumerable:!0,get:function(){return u.camelize}}),Object.defineProperty(C,"capitalize",{enumerable:!0,get:function(){return u.capitalize}}),Object.defineProperty(C,"normalizeClass",{enumerable:!0,get:function(){return u.normalizeClass}}),Object.defineProperty(C,"normalizeProps",{enumerable:!0,get:function(){return u.normalizeProps}}),Object.defineProperty(C,"normalizeStyle",{enumerable:!0,get:function(){return u.normalizeStyle}}),Object.defineProperty(C,"toDisplayString",{enumerable:!0,get:function(){return u.toDisplayString}}),Object.defineProperty(C,"toHandlerKey",{enumerable:!0,get:function(){return u.toHandlerKey}}),Object.defineProperty(C,"EffectScope",{enumerable:!0,get:function(){return I.EffectScope}}),Object.defineProperty(C,"ReactiveEffect",{enumerable:!0,get:function(){return I.ReactiveEffect}}),Object.defineProperty(C,"customRef",{enumerable:!0,get:function(){return I.customRef}}),Object.defineProperty(C,"effect",{enumerable:!0,get:function(){return I.effect}}),Object.defineProperty(C,"effectScope",{enumerable:!0,get:function(){return I.effectScope}}),Object.defineProperty(C,"getCurrentScope",{enumerable:!0,get:function(){return I.getCurrentScope}}),Object.defineProperty(C,"isProxy",{enumerable:!0,get:function(){return I.isProxy}}),Object.defineProperty(C,"isReactive",{enumerable:!0,get:function(){return I.isReactive}}),Object.defineProperty(C,"isReadonly",{enumerable:!0,get:function(){return I.isReadonly}}),Object.defineProperty(C,"isRef",{enumerable:!0,get:function(){return I.isRef}}),Object.defineProperty(C,"isShallow",{enumerable:!0,get:function(){return I.isShallow}}),Object.defineProperty(C,"markRaw",{enumerable:!0,get:function(){return I.markRaw}}),Object.defineProperty(C,"onScopeDispose",{enumerable:!0,get:function(){return I.onScopeDispose}}),Object.defineProperty(C,"proxyRefs",{enumerable:!0,get:function(){return I.proxyRefs}}),Object.defineProperty(C,"reactive",{enumerable:!0,get:function(){return I.reactive}}),Object.defineProperty(C,"readonly",{enumerable:!0,get:function(){return I.readonly}}),Object.defineProperty(C,"ref",{enumerable:!0,get:function(){return I.ref}}),Object.defineProperty(C,"shallowReactive",{enumerable:!0,get:function(){return I.shallowReactive}}),Object.defineProperty(C,"shallowReadonly",{enumerable:!0,get:function(){return I.shallowReadonly}}),Object.defineProperty(C,"shallowRef",{enumerable:!0,get:function(){return I.shallowRef}}),Object.defineProperty(C,"stop",{enumerable:!0,get:function(){return I.stop}}),Object.defineProperty(C,"toRaw",{enumerable:!0,get:function(){return I.toRaw}}),Object.defineProperty(C,"toRef",{enumerable:!0,get:function(){return I.toRef}}),Object.defineProperty(C,"toRefs",{enumerable:!0,get:function(){return I.toRefs}}),Object.defineProperty(C,"triggerRef",{enumerable:!0,get:function(){return I.triggerRef}}),Object.defineProperty(C,"unref",{enumerable:!0,get:function(){return I.unref}}),C.BaseTransition=ie,C.Comment=fn,C.Fragment=jt,C.KeepAlive=Po,C.Static=Br,C.Suspense=Yn,C.Teleport=Ht,C.Text=it,C.Transition=$l,C.TransitionGroup=Zc,C.callWithAsyncErrorHandling=Ft,C.callWithErrorHandling=hn,C.cloneVNode=Ai,C.compatUtils=ha,C.computed=$s,C.createApp=we,C.createBlock=bo,C.createComment=il,C.createCommentVNode=io,C.createElement=Jo,C.createElementBlock=wl,C.createElementVNode=Mn,C.createHydrationRenderer=Si,C.createPropsRestProxy=Wc,C.createRenderer=hs,C.createSSRApp=de,C.createSlots=Ro,C.createStaticVNode=rc,C.createTextNode=uc,C.createTextVNode=Al,C.createVNode=zn,C.createVueApp=we,C.defineAsyncComponent=_n,C.defineComponent=zt,C.defineEmits=oc,C.defineExpose=Uc,C.defineProps=$c,C.getCurrentInstance=ci,C.getTransitionRawChildren=ge,C.guardReactiveProps=Li,C.h=Bl,C.handleError=Vt,C.initCustomFormatter=Yc,C.inject=eo,C.injectHook=oi,C.isMemoSame=rl,C.isRuntimeOnly=nl,C.isVNode=fr,C.mergeDefaults=zc,C.mergeProps=Dr,C.nextTick=yr,C.onActivated=sa,C.onBeforeActivate=nt,C.onBeforeDeactivate=ze,C.onBeforeMount=wa,C.onBeforeUnmount=ca,C.onBeforeUpdate=Rr,C.onDeactivated=$a,C.onErrorCaptured=Is,C.onMounted=nr,C.onRenderTracked=Ts,C.onRenderTriggered=Os,C.onServerPrefetch=As,C.onUnmounted=xr,C.onUpdated=ko,C.openBlock=_o,C.popScopeId=Dt,C.provide=vr,C.pushScopeId=Oo,C.queuePostFlushCb=Wi,C.registerRuntimeCompiler=Nl,C.render=mt,C.renderList=Sa,C.renderSlot=ks,C.resolveComponent=Ha,C.resolveDirective=Ps,C.resolveDynamicComponent=Xs,C.resolveFilter=dr,C.resolveTransitionHooks=G,C.setBlockTracking=el,C.setDevtoolsHook=Pr,C.setTransitionHooks=Z,C.ssrContextKey=lc,C.ssrUtils=Hs,C.toHandlers=Ca,C.transformVNodeArgs=Sl,C.useAttrs=ac,C.useCssModule=Kc,C.useCssVars=al,C.useSSRContext=Ml,C.useSlots=jc,C.useTransitionState=tr,C.vModelDynamic=O,C.vModelText=S,C.vShow=fe,C.version=Fl,C.warn=A,C.watch=Kr,C.watchEffect=zo,C.watchPostEffect=La,C.watchSyncEffect=Ea,C.withAsyncContext=Gc,C.withCtx=Xi,C.withDefaults=Hc,C.withDirectives=Jr,C.withKeys=Ne,C.withMemo=cc,C.withModifiers=H,C.withScopeId=Re,Object.defineProperty(C,"__esModule",{value:!0}),C}({},c,b,T);return B.__TYPE__="vue",B}function fv(v,c,b){let T=b.Vue,B=b.setTimeout,C=b.clearTimeout,k=b.setInterval,u=b.clearInterval,I=b.__uniConfig,Ge=b.__uniRoutes,At=b.VueShared,tn=b.UniShared;var A=function(Q,ae,hn){"use strict";var Ft="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",Vt=function(){let e=new Uint8Array(256);for(var t=0;t<Ft.length;t++)e[Ft.charCodeAt(t)]=t;return e}();function zr(e){var t=new Uint8Array(e),n,r=t.length,s="";for(n=0;n<r;n+=3)s+=Ft[t[n]>>2],s+=Ft[(t[n]&3)<<4|t[n+1]>>4],s+=Ft[(t[n+1]&15)<<2|t[n+2]>>6],s+=Ft[t[n+2]&63];return r%3===2?s=s.substring(0,s.length-1)+"=":r%3===1&&(s=s.substring(0,s.length-2)+"=="),s}function ei(e){var t=e.length*.75,n=e.length,r,s=0,d,g,y,z;e[e.length-1]==="="&&(t--,e[e.length-2]==="="&&t--);var P=new ArrayBuffer(t),$=new Uint8Array(P);for(r=0;r<n;r+=4)d=Vt[e.charCodeAt(r)],g=Vt[e.charCodeAt(r+1)],y=Vt[e.charCodeAt(r+2)],z=Vt[e.charCodeAt(r+3)],$[s++]=d<<2|g>>4,$[s++]=(g&15)<<4|y>>2,$[s++]=(y&3)<<6|z&63;return P}let Tr=["original","compressed"],mn=["album","camera"],Gt=["GET","OPTIONS","HEAD","POST","PUT","DELETE","TRACE","CONNECT","PATCH"];function an(e,t){return!e||t.indexOf(e)===-1?t[0]:e}function Pn(e,t){return!Q.isArray(e)||e.length===0||e.find(n=>t.indexOf(n)===-1)?t:e}function Un(e,t){console.warn(`${e}: ${t}`)}function ir(e,t,n,r){r||(r=Un);for(let s in n){let d=Be(s,t[s],n[s],!Q.hasOwn(t,s));Q.isString(d)&&r(e,d)}}function Fn(e,t,n,r){if(!n)return;if(!Q.isArray(n))return ir(e,t[0]||Object.create(null),n,r);let s=n.length,d=t.length;for(let g=0;g<s;g++){let y=n[g],z=Object.create(null);d>g&&(z[y.name]=t[g]),ir(e,z,{[y.name]:y},r)}}function Be(e,t,n,r){Q.isPlainObject(n)||(n={type:n});let{type:s,required:d,validator:g}=n;if(d&&r)return'Missing required args: "'+e+'"';if(!(t==null&&!d)){if(s!=null){let y=!1,z=Q.isArray(s)?s:[s],P=[];for(let $=0;$<z.length&&!y;$++){let{valid:_e,expectedType:Te}=yt(t,z[$]);P.push(Te||""),y=_e}if(!y)return Zt(e,t,P)}if(g)return g(t)}}let at=Q.makeMap("String,Number,Boolean,Function,Symbol");function yt(e,t){let n,r=sn(t);if(at(r)){let s=typeof e;n=s===r.toLowerCase(),!n&&s==="object"&&(n=e instanceof t)}else r==="Object"?n=Q.isObject(e):r==="Array"?n=Q.isArray(e):n=e instanceof t||Q.toRawType(e)===sn(t);return{valid:n,expectedType:r}}function Zt(e,t,n){let r=`Invalid args: type check failed for args "${e}". Expected ${n.map(Q.capitalize).join(", ")}`,s=n[0],d=Q.toRawType(t),g=cn(t,s),y=cn(t,d);return n.length===1&&gr(s)&&!yr(s,d)&&(r+=` with value ${g}`),r+=`, got ${d} `,gr(d)&&(r+=`with value ${y}.`),r}function sn(e){let t=e&&e.toString().match(/^\s*function (\w+)/);return t?t[1]:""}function cn(e,t){return t==="String"?`"${e}"`:t==="Number"?`${Number(e)}`:`${e}`}function gr(e){return["string","number","boolean"].some(n=>e.toLowerCase()===n)}function yr(...e){return e.some(t=>t.toLowerCase()==="boolean")}function Ii(e){return function(){try{return e.apply(e,arguments)}catch(t){console.error(t)}}}let Pi=1,or={};function zi(e,t,n,r=!1){return or[e]={name:t,keepAlive:r,callback:n},e}function $o(e,t,n){if(typeof e=="number"){let r=or[e];if(r)return r.keepAlive||delete or[e],r.callback(t,n)}return t}function Ni(e){for(let t in or)if(or[t].name===e)return!0;return!1}function Wi(e,t){for(let n in or){let r=or[n];r.callback===t&&r.name===e&&delete or[n]}}function Gi(e){bt.off("api."+e)}function hi(e){bt.on("api."+e,t=>{for(let n in or){let r=or[n];r.name===e&&r.callback(t)}})}function Yi(e,t){return zi(Pi++,e,t,!0)}let Lr="success",Vr="fail",ar="complete";function Ir(e){let t={};for(let n in e){let r=e[n];Q.isFunction(r)&&(t[n]=Ii(r),delete e[n])}return t}function qi(e,t){return!e||e.indexOf(":fail")===-1?t+":ok":t+e.substring(e.indexOf(":fail"))}function So(e,t={},{beforeAll:n,beforeSuccess:r}={}){Q.isPlainObject(t)||(t={});let{success:s,fail:d,complete:g}=Ir(t),y=Q.isFunction(s),z=Q.isFunction(d),P=Q.isFunction(g),$=Pi++;return zi($,e,_e=>{_e=_e||{},_e.errMsg=qi(_e.errMsg,e),Q.isFunction(n)&&n(_e),_e.errMsg===e+":ok"?(Q.isFunction(r)&&r(_e,t),y&&s(_e)):z&&d(_e),P&&g(_e)}),$}let Co="success",ti="fail",Qn="complete",pi={},ni={};function sr(e){return function(t){return e(t)||t}}function gi(e,t){let n=!1;for(let r=0;r<e.length;r++){let s=e[r];if(n)n=Promise.resolve(sr(s));else{let d=s(t);if(Q.isPromise(d)&&(n=Promise.resolve(d)),d===!1)return{then(){},catch(){}}}}return n||{then(r){return r(t)},catch(){}}}function vi(e,t={}){return[Co,ti,Qn].forEach(n=>{let r=e[n];if(!Q.isArray(r))return;let s=t[n];t[n]=function(g){gi(r,g).then(y=>Q.isFunction(s)&&s(y)||y)}}),t}function mi(e,t){let n=[];Q.isArray(pi.returnValue)&&n.push(...pi.returnValue);let r=ni[e];return r&&Q.isArray(r.returnValue)&&n.push(...r.returnValue),n.forEach(s=>{t=s(t)||t}),t}function Er(e){let t=Object.create(null);Object.keys(pi).forEach(r=>{r!=="returnValue"&&(t[r]=pi[r].slice())});let n=ni[e];return n&&Object.keys(n).forEach(r=>{r!=="returnValue"&&(t[r]=(t[r]||[]).concat(n[r]))}),t}function Pr(e,t,n,r){let s=Er(e);return s&&Object.keys(s).length?Q.isArray(s.invoke)?gi(s.invoke,n).then(g=>t(vi(s,g),...r)):t(vi(s,n),...r):t(n,...r)}function Wr(e){return!!(Q.isPlainObject(e)&&[Lr,Vr,ar].find(t=>Q.isFunction(e[t])))}function Gr(e){return e}function er(e,t){return(n={},...r)=>Wr(n)?mi(e,Pr(e,t,n,r)):mi(e,new Promise((s,d)=>{Pr(e,t,Q.extend(n,{success:s,fail:d}),r)}))}function Ki(e,t){let n=e[0];if(!t||!Q.isPlainObject(t.formatArgs)&&Q.isPlainObject(n))return;let r=t.formatArgs,s=Object.keys(r);for(let d=0;d<s.length;d++){let g=s[d],y=r[g];if(Q.isFunction(y)){let z=y(e[0][g],n);if(Q.isString(z))return z}else Q.hasOwn(n,g)||(n[g]=y)}}function Ji(e,t,n){return $o(e,Q.extend(n||{},{errMsg:t+":ok"}))}function uo(e,t,n,r){return $o(e,Q.extend({errMsg:t+":fail"+(n?" "+n:"")},r))}function _i(e,t,n,r){if(r&&r.beforeInvoke){let d=r.beforeInvoke(t);if(Q.isString(d))return d}let s=Ki(t,r);if(s)return s}function Ao(e){if(!Q.isFunction(e))throw new Error('Invalid args: type check failed for args "callback". Expected Function')}function Uo(e,t,n){return r=>{Ao(r);let s=_i(e,[r],void 0,n);if(s)throw new Error(s);let d=!Ni(e);Yi(e,r),d&&(hi(e),t())}}function _a(e,t,n){return r=>{Ao(r);let s=_i(e,[r],void 0,n);if(s)throw new Error(s);e=e.replace("off","on"),Wi(e,r),Ni(e)||(Gi(e),t())}}function Ho(e){return!e||Q.isString(e)?e:e.stack?(console.error(e.message+ae.LINEFEED+e.stack),e.message):e}function Zi(e,t,n,r){return s=>{let d=So(e,s,r),g=_i(e,[s],n,r);return g?uo(d,e,g):t(s,{resolve:y=>Ji(d,e,y),reject:(y,z)=>uo(d,e,Ho(y),z)})}}function wn(e,t,n,r){return(...s)=>{let d=_i(e,s,n,r);if(d)throw new Error(d);return t.apply(null,s)}}function Sn(e,t,n,r){return Zi(e,t,n,r)}function Nn(e,t,n){return Uo(e,t,n)}function lr(e,t,n){return _a(e,t,n)}function Oo(e,t,n,r){return er(e,Zi(e,t,void 0,r))}function Dt(e,t,n,r){return wn(e,t,void 0,r)}function Re(e,t,n,r){return er(e,Sn(e,t,void 0,r))}let Xi="base64ToArrayBuffer",ri=[{name:"base64",type:String,required:!0}],ki="arrayBufferToBase64",Qi=[{name:"arrayBuffer",type:[ArrayBuffer,Uint8Array],required:!0}],Ri=Dt(Xi,e=>ei(e),ri),Yr=Dt(ki,e=>zr(e),Qi);function ia(){if(typeof __SYSTEM_INFO__!="undefined")return window.__SYSTEM_INFO__;let{resolutionWidth:e}=c.screen.getCurrentSize()||{resolutionWidth:0};return{platform:(c.os.name||"").toLowerCase(),pixelRatio:c.screen.scale,windowWidth:Math.round(e)}}function To(e,t,n){e.$page.meta.isNVue?ba(e,t,n):Xt(e,t,n)}function Xt(e,t,n){bt.invokeViewMethod("requestComponentInfo",{reqs:t.map(r=>(r.component&&(r.component=r.component.$el.nodeId),r))},e.$page.id,n)}function ba(e,t,n){let r=xi(t),s=new Array(r.length);un(r,e.$el,s),qr(e.$requireNativePlugin("dom"),s,0,[],d=>{n(d)})}function xi(e){let t=[];for(let n=0;n<e.length;n++){let r=e[n].selector;r.indexOf("#")===0&&t.push(r.substring(1))}return t}function un(e,t,n){let r=t.children;if(!Q.isArray(r))return!1;for(let s=0;s<r.length;s++){let d=r[s];if(d.attr){let g=e.indexOf(d.attr.id);if(g>=0&&(n[g]={id:e[g],ref:d.ref,dataset:ae.parseNVueDataset(d.attr)},e.length===1))break}d.children&&un(e,d,n)}}function qr(e,t,n,r,s){let d=t[n];e.getComponentRect(d.ref,g=>{g.size.id=d.id,g.size.dataset=d.dataset,r.push(g.size),n+=1,n<t.length?qr(e,t,n,r,s):s(r)})}function Bi(e,t){bt.invokeViewMethod("setPageMeta",t,e.$page.id)}let Yn=e=>e!==null&&typeof e=="object",Io=["{","}"];class Fa{constructor(){this._caches=Object.create(null)}interpolate(t,n,r=Io){if(!n)return[t];let s=this._caches[t];return s||(s=aa(t,r),this._caches[t]=s),ya(s,n)}}let oa=/^(?:\d)+/,jo=/^(?:\w)+/;function aa(e,[t,n]){let r=[],s=0,d="";for(;s<e.length;){let g=e[s++];if(g===t){d&&r.push({type:"text",value:d}),d="";let y="";for(g=e[s++];g!==void 0&&g!==n;)y+=g,g=e[s++];let z=g===n,P=oa.test(y)?"list":z&&jo.test(y)?"named":"unknown";r.push({value:y,type:P})}else d+=g}return d&&r.push({type:"text",value:d}),r}function ya(e,t){let n=[],r=0,s=Array.isArray(t)?"list":Yn(t)?"named":"unknown";if(s==="unknown")return n;for(;r<e.length;){let d=e[r];switch(d.type){case"text":n.push(d.value);break;case"list":n.push(t[parseInt(d.value,10)]);break;case"named":s==="named"&&n.push(t[d.value]);break;case"unknown":break}r++}return n}let Nr="zh-Hans",kr="zh-Hant",kn="en",cr="fr",vr="es",eo=Object.prototype.hasOwnProperty,zo=(e,t)=>eo.call(e,t),La=new Fa;function Ea(e,t){return!!t.find(n=>e.indexOf(n)!==-1)}function to(e,t){return t.find(n=>e.indexOf(n)===0)}function Kr(e,t){if(!e)return;if(e=e.trim().replace(/_/g,"-"),t&&t[e])return e;if(e=e.toLowerCase(),e==="chinese")return Nr;if(e.indexOf("zh")===0)return e.indexOf("-hans")>-1?Nr:e.indexOf("-hant")>-1||Ea(e,["-tw","-hk","-mo","-cht"])?kr:Nr;let n=to(e,[kn,cr,vr]);if(n)return n}class Mi{constructor({locale:t,fallbackLocale:n,messages:r,watcher:s,formater:d}){this.locale=kn,this.fallbackLocale=kn,this.message={},this.messages={},this.watchers=[],n&&(this.fallbackLocale=n),this.formater=d||La,this.messages=r||{},this.setLocale(t||kn),s&&this.watchLocale(s)}setLocale(t){let n=this.locale;this.locale=Kr(t,this.messages)||this.fallbackLocale,this.messages[this.locale]||(this.messages[this.locale]={}),this.message=this.messages[this.locale],n!==this.locale&&this.watchers.forEach(r=>{r(this.locale,n)})}getLocale(){return this.locale}watchLocale(t){let n=this.watchers.push(t)-1;return()=>{this.watchers.splice(n,1)}}add(t,n,r=!0){let s=this.messages[t];s?r?Object.assign(s,n):Object.keys(n).forEach(d=>{zo(s,d)||(s[d]=n[d])}):this.messages[t]=n}f(t,n,r){return this.formater.interpolate(t,n,r).join("")}t(t,n,r){let s=this.message;return typeof n=="string"?(n=Kr(n,this.messages),n&&(s=this.messages[n])):r=n,zo(s,t)?this.formater.interpolate(s[t],r).join(""):(console.warn(`Cannot translate the value of keypath ${t}. Use the value of keypath as default.`),t)}}function Wo(e,t){e.$watchLocale?e.$watchLocale(n=>{t.setLocale(n)}):e.$watch(()=>e.$locale,n=>{t.setLocale(n)})}function ii(){return typeof se!="undefined"&&se.getLocale?se.getLocale():typeof global!="undefined"&&global.getLocale?global.getLocale():kn}function bi(e,t={},n,r){typeof e!="string"&&([e,t]=[t,e]),typeof e!="string"&&(e=ii()),typeof n!="string"&&(n=typeof I!="undefined"&&I.fallbackLocale||kn);let s=new Mi({locale:e,fallbackLocale:n,messages:t,watcher:r}),d=(g,y)=>{if(typeof En!="function")d=function(z,P){return s.t(z,P)};else{let z=!1;d=function(P,$){let _e=En().$vm;return _e&&(_e.$locale,z||(z=!0,Wo(_e,s))),s.t(P,$)}}return d(g,y)};return{i18n:s,f(g,y,z){return s.f(g,y,z)},t(g,y){return d(g,y)},add(g,y,z=!0){return s.add(g,y,z)},watch(g){return s.watchLocale(g)},getLocale(){return s.getLocale()},setLocale(g){return s.setLocale(g)}}}function tr(e,t){return e.indexOf(t[0])>-1}let wr=ae.once(()=>typeof I!="undefined"&&I.locales&&!!Object.keys(I.locales).length),D;function ie(){let e=se.getLocale(),t=I.locales;return t[e]||t[I.fallbackLocale]||t.en||{}}function be(e){return tr(e,ae.I18N_JSON_DELIMITERS)?Z().f(e,ie(),ae.I18N_JSON_DELIMITERS):e}function G(e,t){if(t.length===1){if(e){let r=e[t[0]];if(Q.isString(r)&&tr(r,ae.I18N_JSON_DELIMITERS))return e}return}let n=t.shift();return G(e&&e[n],t)}function V(e,t){return t.map(n=>J(e,n))}function J(e,t){let n=G(e,t);if(!n)return!1;let r=t[t.length-1],s=n[r];return Object.defineProperty(n,r,{get(){return be(s)},set(d){s=d}}),!0}function Z(){if(!D){let e;if(typeof En=="function"?e=v.requireModule("plus").getLanguage():e=c.webview.currentWebview().getStyle().locale,D=bi(e),wr()){let t=Object.keys(I.locales||{});t.length&&t.forEach(n=>D.add(n,I.locales[n])),D.setLocale(e)}}return D}function ge(e,t,n){return t.reduce((r,s,d)=>(r[e+s]=n[d],r),{})}let zt=ae.once(()=>{let e="uni.app.",t=["quit"];Z().add(kn,ge(e,t,["Press back button again to exit"]),!1),Z().add(vr,ge(e,t,["Pulse otra vez para salir"]),!1),Z().add(cr,ge(e,t,["Appuyez \xE0 nouveau pour quitter l'application"]),!1),Z().add(Nr,ge(e,t,["\u518D\u6309\u4E00\u6B21\u9000\u51FA\u5E94\u7528"]),!1),Z().add(kr,ge(e,t,["\u518D\u6309\u4E00\u6B21\u9000\u51FA\u61C9\u7528"]),!1)}),Cn=ae.once(()=>{let e="uni.showActionSheet.",t=["cancel"];Z().add(kn,ge(e,t,["Cancel"]),!1),Z().add(vr,ge(e,t,["Cancelar"]),!1),Z().add(cr,ge(e,t,["Annuler"]),!1),Z().add(Nr,ge(e,t,["\u53D6\u6D88"]),!1),Z().add(kr,ge(e,t,["\u53D6\u6D88"]),!1)}),_n=ae.once(()=>{let e="uni.showModal.",t=["cancel","confirm"];Z().add(kn,ge(e,t,["Cancel","OK"]),!1),Z().add(vr,ge(e,t,["Cancelar","OK"]),!1),Z().add(cr,ge(e,t,["Annuler","OK"]),!1),Z().add(Nr,ge(e,t,["\u53D6\u6D88","\u786E\u5B9A"]),!1),Z().add(kr,ge(e,t,["\u53D6\u6D88","\u78BA\u5B9A"]),!1)}),mr=ae.once(()=>{let e="uni.chooseImage.",t=["cancel","sourceType.album","sourceType.camera"];Z().add(kn,ge(e,t,["Cancel","Album","Camera"]),!1),Z().add(vr,ge(e,t,["Cancelar","\xC1lbum","C\xE1mara"]),!1),Z().add(cr,ge(e,t,["Annuler","Album","Cam\xE9ra"]),!1),Z().add(Nr,ge(e,t,["\u53D6\u6D88","\u4ECE\u76F8\u518C\u9009\u62E9","\u62CD\u6444"]),!1),Z().add(kr,ge(e,t,["\u53D6\u6D88","\u5F9E\u76F8\u518A\u9078\u64C7","\u62CD\u651D"]),!1)}),qn=ae.once(()=>{let e="uni.chooseVideo.",t=["cancel","sourceType.album","sourceType.camera"];Z().add(kn,ge(e,t,["Cancel","Album","Camera"]),!1),Z().add(vr,ge(e,t,["Cancelar","\xC1lbum","C\xE1mara"]),!1),Z().add(cr,ge(e,t,["Annuler","Album","Cam\xE9ra"]),!1),Z().add(Nr,ge(e,t,["\u53D6\u6D88","\u4ECE\u76F8\u518C\u9009\u62E9","\u62CD\u6444"]),!1),Z().add(kr,ge(e,t,["\u53D6\u6D88","\u5F9E\u76F8\u518A\u9078\u64C7","\u62CD\u651D"]),!1)}),Va=ae.once(()=>{let e="uni.previewImage.",t=["cancel","button.save","save.success","save.fail"];Z().add(kn,ge(e,t,["Cancel","Save Image","Saved successfully","Save failed"]),!1),Z().add(vr,ge(e,t,["Cancelar","Guardar imagen","Guardado exitosamente","Error al guardar"]),!1),Z().add(cr,ge(e,t,["Annuler","Guardar imagen","Enregistr\xE9 avec succ\xE8s","\xC9chec de la sauvegarde"]),!1),Z().add(Nr,ge(e,t,["\u53D6\u6D88","\u4FDD\u5B58\u56FE\u50CF","\u4FDD\u5B58\u56FE\u50CF\u5230\u76F8\u518C\u6210\u529F","\u4FDD\u5B58\u56FE\u50CF\u5230\u76F8\u518C\u5931\u8D25"]),!1),Z().add(kr,ge(e,t,["\u53D6\u6D88","\u4FDD\u5B58\u5716\u50CF","\u4FDD\u5B58\u5716\u50CF\u5230\u76F8\u518A\u6210\u529F","\u4FDD\u5B58\u5716\u50CF\u5230\u76F8\u518A\u5931\u6557"]),!1)}),Po=ae.once(()=>{let e="uni.setClipboardData.",t=["success","fail"];Z().add(kn,ge(e,t,["Content copied","Copy failed, please copy manually"]),!1),Z().add(vr,ge(e,t,["Contenido copiado","Error al copiar, copie manualmente"]),!1),Z().add(cr,ge(e,t,["Contenu copi\xE9","\xC9chec de la copie, copiez manuellement"]),!1),Z().add(Nr,ge(e,t,["\u5185\u5BB9\u5DF2\u590D\u5236","\u590D\u5236\u5931\u8D25\uFF0C\u8BF7\u624B\u52A8\u590D\u5236"]),!1),Z().add(kr,ge(e,t,["\u5167\u5BB9\u5DF2\u5FA9\u5236","\u5FA9\u5236\u5931\u6557\uFF0C\u8ACB\u624B\u52D5\u5FA9\u88FD"]),!1)}),No=ae.once(()=>{let e="uni.scanCode.",t=["title","album","fail","flash.on","flash.off"];Z().add(kn,ge(e,t,["Scan code","Album","Recognition failure","Tap to turn light on","Tap to turn light off"]),!1),Z().add(vr,ge(e,t,["C\xF3digo de escaneo","\xC1lbum","\xC9chec de la reconnaissance","Toque para encender la luz","Toque para apagar la luz"]),!1),Z().add(cr,ge(e,t,["Code d\u2019analyse","Album","Fallo de reconocimiento","Appuyez pour activer l'\xE9clairage","Appuyez pour d\xE9sactiver l'\xE9clairage"]),!1),Z().add(Nr,ge(e,t,["\u626B\u7801","\u76F8\u518C","\u8BC6\u522B\u5931\u8D25","\u8F7B\u89E6\u7167\u4EAE","\u8F7B\u89E6\u5173\u95ED"]),!1),Z().add(kr,ge(e,t,["\u6383\u78BC","\u76F8\u518A","\u8B58\u5225\u5931\u6557","\u8F15\u89F8\u7167\u4EAE","\u8F15\u89F8\u95DC\u9589"]),!1)}),sa=ae.once(()=>{let e="uni.startSoterAuthentication.",t=["authContent"];Z().add(kn,ge(e,t,["Fingerprint recognition"]),!1),Z().add(vr,ge(e,t,["Reconocimiento de huellas dactilares"]),!1),Z().add(cr,ge(e,t,["Reconnaissance de l'empreinte digitale"]),!1),Z().add(Nr,ge(e,t,["\u6307\u7EB9\u8BC6\u522B\u4E2D..."]),!1),Z().add(kr,ge(e,t,["\u6307\u7D0B\u8B58\u5225\u4E2D..."]),!1)});function $a(e){if(wr())return V(e,[["titleText"],["searchInput","placeholder"]])}function Ua(e){if(wr()){let t="caption";return V(e,[["contentdown",t],["contentover",t],["contentrefresh",t]])}}function Cs(e){let t=new ae.Emitter;return{on(n,r){return t.on(n,r)},once(n,r){return t.once(n,r)},off(n,r){return t.off(n,r)},emit(n,...r){return t.emit(n,...r)},subscribe(n,r,s=!1){t[s?"once":"on"](`${e}.${n}`,r)},unsubscribe(n,r){t.off(`${e}.${n}`,r)},subscribeHandler(n,r,s){t.emit(`${e}.${n}`,r,s)}}}let la="invokeViewApi",Go="invokeServiceApi";function oi(e){return e=e+"",e.indexOf("rpx")!==-1||e.indexOf("upx")!==-1}function yi(e,t=!1){if(t)return wa(e);if(Q.isString(e)){let n=parseInt(e)||0;return oi(e)?se.upx2px(n):n}return e}function wa(e){return oi(e)?e.replace(/(\d+(\.\d+)?)[ru]px/g,(t,n)=>se.upx2px(parseFloat(n))+"px"):e}function nr(e){let t=ae.resolveComponentInstance(e);if(t.$page)return t.$page.id;if(!t.$)return;let n=t.$.root.proxy;if(n&&n.$page)return n.$page.id}function Rr(){let e=Gn(),t=e.length;if(t)return e[t-1]}function ko(){let e=Rr();if(e)return e.$page.meta}function ca(){let e=ko();return e?e.id:-1}function xr(){let e=Rr();if(e)return e.$vm}let As=["navigationBar","pullToRefresh"];function Os(){return JSON.parse(JSON.stringify(I.globalStyle||{}))}function Ts(e,t){let n=Os(),r=Q.extend({id:t},n,e);As.forEach(d=>{r[d]=Q.extend({},n[d],e[d])});let{navigationBar:s}=r;return s.titleText&&s.titleImage&&(s.titleText=""),r}function Is(e){return JSON.parse(yi(JSON.stringify(e),!0))}function Zs(e){return e.offset&&(e.offset=yi(e.offset)),e.height&&(e.height=yi(e.height)),e.range&&(e.range=yi(e.range)),e}function Jr(e,t,n,r,s){let{id:d,route:g}=r;return{id:d,path:ae.addLeadingSlash(g),route:g,fullPath:t,options:n,meta:r,openType:e,eventChannel:s,statusBarStyle:r.navigationBar.titleColor==="#000000"?"dark":"light"}}function Ei(e,t,n){let r=e.$[t];!Q.isArray(r)||n.__weh&&Q.remove(r,n.__weh)}function Hn(e,t,n){if(Q.isString(e))n=t,t=e,e=xr();else if(typeof e=="number"){let s=Gn().find(d=>d.$page.id===e);s?e=s.$vm:e=xr()}if(!e)return;if(e.__call_hook)return e.__call_hook(t,n);let r=e.$[t];return r&&ae.invokeArrayFns(r,n)}function yl(e){if(e.indexOf("/")===0)return e;let t="",n=Gn();return n.length&&(t=n[n.length-1].$page.route),Ha(t,e)}function Ha(e,t){if(t.indexOf("/")===0)return t;if(t.indexOf("./")===0)return Ha(e,t.slice(2));let n=t.split("/"),r=n.length,s=0;for(;s<r&&n[s]==="..";s++);n.splice(0,s),t=n.join("/");let d=e.length>0?e.split("/"):[];return d.splice(d.length-s-1,s+1),ae.addLeadingSlash(d.concat(n).join("/"))}function fo(e,t=!1){return t?Ge.find(n=>n.path===e||n.alias===e):Ge.find(n=>n.path===e)}function Xs(e){let t=fo(e);if(t)return t.meta}function Ps(e,t,n){let r=fo(ae.addLeadingSlash(t));if(r){let{meta:d}=r;delete d.tabBarIndex,d.isQuit=d.isTabBar=!1}let s=fo(ae.addLeadingSlash(n));if(s){let{meta:d}=s;d.tabBarIndex=e,d.isQuit=d.isTabBar=!0;let g=I.tabBar;g&&g.list&&g.list[e]&&(g.list[e].pagePath=ae.removeLeadingSlash(n))}}let ho,Ns,Sa;function Ro(){return typeof window=="object"&&typeof navigator=="object"&&typeof document=="object"?"webview":"v8"}function ks(){return ho.webview.currentWebview().id}let ja,Ca,no={};function po(e){let t=e.data&&e.data.__message;if(!t||!t.__page)return;let n=t.__page,r=no[n];r&&r(t),t.keep||delete no[n]}function ua(e,t){Ro()==="v8"?Sa?(ja&&ja.close(),ja=new Sa(ks()),ja.onmessage=po):Ca||(Ca=Ns.requireModule("globalEvent"),Ca.addEventListener("plusMessage",po)):window.__plusMessage=po,no[e]=t}class go{constructor(t){this.webview=t}sendMessage(t){let n=JSON.parse(JSON.stringify({__message:{data:t}})),r=this.webview.id;Sa?new Sa(r).postMessage(n):ho.webview.postMessageToUniNView&&ho.webview.postMessageToUniNView(n,r)}close(){this.webview.close()}}function Rs({context:e={},url:t,data:n={},style:r={},onMessage:s,onClose:d}){ho=e.plus||c,Ns=e.weex||(typeof v=="object"?v:null),Sa=e.BroadcastChannel||(typeof BroadcastChannel=="object"?BroadcastChannel:null);let g={autoBackButton:!0,titleSize:"17px"},y=`page${Date.now()}`;r=Q.extend({},r),r.titleNView!==!1&&r.titleNView!=="none"&&(r.titleNView=Q.extend(g,r.titleNView));let z={top:0,bottom:0,usingComponents:{},popGesture:"close",scrollIndicator:"none",animationType:"pop-in",animationDuration:200,uniNView:{path:`/${t}.js`,defaultFontSize:16,viewport:ho.screen.resolutionWidth}};r=Q.extend(z,r);let P=ho.webview.create("",y,r,{extras:{from:ks(),runtime:Ro(),data:n,useGlobalEvent:!Sa}});return P.addEventListener("close",d),ua(y,$=>{Q.isFunction(s)&&s($.data),$.keep||P.close("auto")}),P.show(r.animationType,r.animationDuration),new go(P)}let El=(e,t)=>bt.emit("api."+e,t),xs=1;function Qs(){return ca()+"."+la}let _=(e,t,n,r)=>{let{subscribe:s,publishHandler:d}=bt,g=r?xs++:0;r&&s(la+"."+g,r,!0),d(Qs(),{id:g,name:e,args:t},n)},F=(e,t,n,r)=>{let{subscribe:s,unsubscribe:d,publishHandler:g}=bt,y=xs++,z=la+"."+y;return s(z,n),g(Qs(),{id:y,name:e,args:t},r),()=>{d(z)}},q=Object.create(null);function W(){bt.subscribe(Go,re)}function ee(e,t){q[e]||(q[e]=t)}function re({id:e,name:t,args:n},r){let s=g=>{e&&bt.publishHandler(Go+"."+e,g,r)},d=q[t];d?d(n,s):s({})}let pe=Q.extend(Cs("view"),{invokeOnCallback:El,invokeViewMethod:_,invokeViewMethodKeepAlive:F});function Ce(){let{on:e}=bt;e(ae.ON_RESIZE,Me),e(ae.ON_APP_ENTER_FOREGROUND,$e),e(ae.ON_APP_ENTER_BACKGROUND,Ae)}function Me(e){Hn(Rr(),ae.ON_RESIZE,e),bt.invokeOnCallback("onWindowResize",e)}function $e(e){let t=Rr();Hn(En(),ae.ON_SHOW,e),Hn(t,ae.ON_SHOW)}function Ae(){Hn(En(),ae.ON_HIDE),Hn(Rr(),ae.ON_HIDE)}let ke=[ae.ON_PAGE_SCROLL,ae.ON_REACH_BOTTOM];function qe(){ke.forEach(e=>bt.subscribe(e,vt(e)))}function vt(e){return(t,n)=>{Hn(parseInt(n),e,t)}}function Jt(){Ce(),qe()}function gt(e){e.$vm=e,e.$mpType="app";let t=hn.ref(Z().getLocale());Object.defineProperty(e,"$locale",{get(){return t.value},set(n){t.value=n}})}function ut(e,t){e.route=t.route,e.$vm=e,e.$page=t,e.$mpType="page",t.meta.isTabBar&&(e.$.__isTabBar=!0,e.$.__isActive=!0)}function Nt(){return{path:"",query:{},scene:1001,referrerInfo:{appId:"",extraData:{}}}}function pn(e,t){let n=e.$options||{};n.globalData=Q.extend(n.globalData||{},t),Object.defineProperty(e,"globalData",{get(){return n.globalData},set(r){n.globalData=r}})}function St(e){if(e.indexOf("//")===0)return"https:"+e;if(ae.SCHEME_RE.test(e)||ae.DATA_RE.test(e))return e;if(Lt(e))return"file://"+ht(e);let t="file://"+ht("_www");if(e.indexOf("/")===0)return e.startsWith("/storage/")||e.startsWith("/sdcard/")||e.includes("/Containers/Data/Application/")?"file://"+e:t+e;if(e.indexOf("../")===0||e.indexOf("./")===0){if(typeof __id__=="string")return t+Ha(ae.addLeadingSlash(__id__),e);{let n=Rr();if(n)return t+Ha(ae.addLeadingSlash(n.route),e)}}return e}let ht=ae.cacheStringFunction(e=>c.io.convertLocalFileSystemURL(e).replace(/^\/?apps\//,"/android_asset/apps/").replace(/\/$/,""));function Lt(e){return e.indexOf("_www")===0||e.indexOf("_doc")===0||e.indexOf("_documents")===0||e.indexOf("_downloads")===0}let Rn="success",xn="fail",Ln=[Rn,xn,"complete"];function Yt(e,t,n,r){if(!e)return;if(typeof n=="undefined")return e[t]();let[,s]=xo(n,r);return Object.keys(s).length?e[t](Ga(t,s)):e[t]()}function Kn(e,t,n,r){if(!e)return;let[s,d]=xo(n,r);return Object.keys(d).length?e[t](s,Ga(t,d)):e[t](s)}function za(e,t){let n=Wa(e,t.$el);return n||console.error("Can not find `"+e+"`")}function Wa(e,t){if(!e||!t)return;if(t.attr&&t.attr.id===e)return t;let n=t.children;if(!!n)for(let r=0,s=n.length;r<s;r++){let d=Wa(e,n[r]);if(d)return d}}function xo(e={},t){let n=Object.create(null),r=function(d){let g=e[d];Q.isFunction(g)&&(n[d]=g,delete e[d])};return Ln.forEach(r),t&&t.forEach(r),[e,n]}function Ga(e,t){return function(r){let s=r.type;delete r.type;let d=t[s];if(s===Rn?r.errMsg=`${e}:ok`:s===xn&&(r.errMsg=e+":fail "+(r.msg?" "+r.msg:"")),delete r.code,delete r.msg,Q.isFunction(d)&&d(r),s===Rn||s===xn){let g=t.complete;Q.isFunction(g)&&g(r)}}}let Bo;function Ya(){return Bo}function Bs(e){let t=e.$.appContext;Bo=Q.extend(t.app,{mountPage(n,r,s){let d=hn.createVNode(n,r);d.appContext=t,d.__page_container__=s,hn.render(d,s);let g=d.component.proxy;return g.__page_container__=s,g},unmountPage:n=>{let{__page_container__:r}=n;r&&(r.isUnmounted=!0,hn.render(null,r))}})}let An=[];function Yo(e){if(!e.$page.meta.isNVue)return An.push(e);let n=An.findIndex(r=>r.$page.id===e.$page.id);n>-1?An.splice(n,1,e):An.push(e)}function qo(e){return An.find(t=>t.$page.id===e)}function qa(){return An}function Ms(){let e=[];return An.forEach(t=>{t.$.__isTabBar?t.$.__isActive&&e.push(t):e.push(t)}),e}function Ka(){let e=Rr();!e||Di(e)}function Di(e){let t=An.findIndex(n=>n===e);t!==-1&&(e.$page.meta.isNVue||Ya().unmountPage(e),An.splice(t,1))}let ur={play(e){return Yt(e,"play")},pause(e){return Yt(e,"pause")},seek(e,t){return Kn(e,"seek",t.position)},stop(e){return Yt(e,"stop")},sendDanmu(e,t){return Kn(e,"sendDanmu",t)},playbackRate(e,t){return Kn(e,"playbackRate",t.rate)},requestFullScreen(e,t={}){return Kn(e,"requestFullScreen",t)},exitFullScreen(e){return Yt(e,"exitFullScreen")},showStatusBar(e){return Yt(e,"showStatusBar")},hideStatusBar(e){return Yt(e,"hideStatusBar")}};function On(e,t,n,r){let s=qo(t);if(s==null?void 0:s.$page.meta.isNVue){let d=s.$vm;return ur[n](za(e,d),r)}bt.invokeViewMethod("video."+e,{videoId:e,type:n,data:r},t)}let ro={getCenterLocation(e,t){return Yt(e,"getCenterLocation",t)},moveToLocation(e,t){return Kn(e,"moveToLocation",t)},translateMarker(e,t){return Kn(e,"translateMarker",t,["animationEnd"])},includePoints(e,t){return Kn(e,"includePoints",t)},getRegion(e,t){return Yt(e,"getRegion",t)},getScale(e,t){return Yt(e,"getScale",t)},addCustomLayer(e,t){return Kn(e,"addCustomLayer",t)},removeCustomLayer(e,t){return Kn(e,"removeCustomLayer",t)},addGroundOverlay(e,t){return Kn(e,"addGroundOverlay",t)},removeGroundOverlay(e,t){return Kn(e,"removeGroundOverlay",t)},updateGroundOverlay(e,t){return Kn(e,"updateGroundOverlay",t)},initMarkerCluster(e,t){return Kn(e,"initMarkerCluster",t)},addMarkers(e,t){return Kn(e,"addMarkers",t)},removeMarkers(e,t){return Kn(e,"removeMarkers",t)},moveAlong(e,t){return Kn(e,"moveAlong",t)},openMapApp(e,t){return Kn(e,"openMapApp",t)},on(e,t){return e.on(t.name,t.callback)}};function Ja(e,t,n,r,s){let d=qo(t);if(d==null?void 0:d.$page.meta.isNVue){let g=d.$vm;return ro[n](za(e,g),r)}bt.invokeViewMethod("map."+e,{type:n,data:r},t,s)}function Aa(e){return`IntersectionObserver.${e}`}function wi({reqId:e,component:t,options:n,callback:r},s){let d=Aa(e);bt.invokeViewMethod("addIntersectionObserver",{reqId:e,component:t.$el.nodeId,options:n,eventName:d},s),bt.subscribe(d,r)}function $r({reqId:e,component:t},n){bt.invokeViewMethod("removeIntersectionObserver",{reqId:e,component:t.$el.nodeId},n),bt.unsubscribe(Aa(e))}function Sr(e){return`MediaQueryObserver.${e}`}function Fi({reqId:e,component:t,options:n,callback:r},s){let d=Sr(e);bt.invokeViewMethod("addMediaQueryObserver",{reqId:e,component:t.$el.nodeId,options:n,eventName:d},s),bt.subscribe(d,r)}function ds({reqId:e,component:t},n){bt.invokeViewMethod("removeMediaQueryObserver",{reqId:e,component:t.$el.nodeId},n),bt.unsubscribe(Sr(e))}let jn=200,Cr=["unknown","none","ethernet","wifi","2g","3g","4g","5g"],hs="_doc/uniapp_temp",Si=`${hs}_${Date.now()}`;function vo(e){let t=e.split("/");return t[t.length-1]}function ai(e){let t=e.split(".");return t.length>1?"."+t[t.length-1]:""}let Mo="backbutton";function Za(){se.navigateBack({from:"backbutton",success(){}})}let Ci=Nt(),mo=Nt();function Xa(){return Q.extend({},mo)}function Ds(){return Q.extend({},Ci)}function Ue({path:e,query:t,referrerInfo:n}){Q.extend(Ci,{path:e,query:t?ae.parseQuery(t):{},referrerInfo:n||{}})}function It({path:e,query:t,referrerInfo:n}){return Q.extend(mo,{path:e,query:t?ae.parseQuery(t):{},referrerInfo:n||{},channel:c.runtime.channel,launcher:c.runtime.launcher}),Q.extend(Ci,mo),Q.extend({},mo)}function Bt(){let e=v.requireModule("plus");if(e.getRedirectInfo){let{path:t,query:n,extraData:r,userAction:s,fromAppid:d}=e.getRedirectInfo()||{},g={appId:d,extraData:{}};return r&&(g.extraData=r),{path:t||"",query:n?"?"+n:"",referrerInfo:g,userAction:s}}}function Ht(e){var t={exports:{}};return e(t,t.exports),t.exports}var jt=Ht(function(e,t){var n=typeof Uint8Array!="undefined"&&typeof Uint16Array!="undefined"&&typeof Int32Array!="undefined";function r(g,y){return Object.prototype.hasOwnProperty.call(g,y)}t.assign=function(g){for(var y=Array.prototype.slice.call(arguments,1);y.length;){var z=y.shift();if(!!z){if(typeof z!="object")throw new TypeError(z+"must be non-object");for(var P in z)r(z,P)&&(g[P]=z[P])}}return g},t.shrinkBuf=function(g,y){return g.length===y?g:g.subarray?g.subarray(0,y):(g.length=y,g)};var s={arraySet:function(g,y,z,P,$){if(y.subarray&&g.subarray){g.set(y.subarray(z,z+P),$);return}for(var _e=0;_e<P;_e++)g[$+_e]=y[z+_e]},flattenChunks:function(g){var y,z,P,$,_e,Te;for(P=0,y=0,z=g.length;y<z;y++)P+=g[y].length;for(Te=new Uint8Array(P),$=0,y=0,z=g.length;y<z;y++)_e=g[y],Te.set(_e,$),$+=_e.length;return Te}},d={arraySet:function(g,y,z,P,$){for(var _e=0;_e<P;_e++)g[$+_e]=y[z+_e]},flattenChunks:function(g){return[].concat.apply([],g)}};t.setTyped=function(g){g?(t.Buf8=Uint8Array,t.Buf16=Uint16Array,t.Buf32=Int32Array,t.assign(t,s)):(t.Buf8=Array,t.Buf16=Array,t.Buf32=Array,t.assign(t,d))},t.setTyped(n)}),it=jt,fn=4,Br=0,rr=1,Mr=2;function _o(e){for(var t=e.length;--t>=0;)e[t]=0}var Oa=0,Ko=1,el=2,nc=3,wl=258,bo=29,fr=256,si=fr+1+bo,Ta=30,Sl=19,Fs=2*si+1,Do=15,Qa=16,ps=7,Mn=256,zn=16,Cl=17,Li=18,Ai=[0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0],es=[0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13],Al=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7],rc=[16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15],io=512,Tn=new Array((si+2)*2);_o(Tn);var Vi=new Array(Ta*2);_o(Vi);var Ia=new Array(io);_o(Ia);var Dr=new Array(wl-nc+1);_o(Dr);var li=new Array(bo);_o(li);var tl=new Array(Ta);_o(tl);function Ol(e,t,n,r,s){this.static_tree=e,this.extra_bits=t,this.extra_base=n,this.elems=r,this.max_length=s,this.has_stree=e&&e.length}var Jn,In,ci;function Zr(e,t){this.dyn_tree=e,this.max_code=0,this.stat_desc=t}function fa(e){return e<256?Ia[e]:Ia[256+(e>>>7)]}function ts(e,t){e.pending_buf[e.pending++]=t&255,e.pending_buf[e.pending++]=t>>>8&255}function Xr(e,t,n){e.bi_valid>Qa-n?(e.bi_buf|=t<<e.bi_valid&65535,ts(e,e.bi_buf),e.bi_buf=t>>Qa-e.bi_valid,e.bi_valid+=n-Qa):(e.bi_buf|=t<<e.bi_valid&65535,e.bi_valid+=n)}function Fo(e,t,n){Xr(e,n[t*2],n[t*2+1])}function Tl(e,t){var n=0;do n|=e&1,e>>>=1,n<<=1;while(--t>0);return n>>>1}function Il(e){e.bi_valid===16?(ts(e,e.bi_buf),e.bi_buf=0,e.bi_valid=0):e.bi_valid>=8&&(e.pending_buf[e.pending++]=e.bi_buf&255,e.bi_buf>>=8,e.bi_valid-=8)}function ns(e,t){var n=t.dyn_tree,r=t.max_code,s=t.stat_desc.static_tree,d=t.stat_desc.has_stree,g=t.stat_desc.extra_bits,y=t.stat_desc.extra_base,z=t.stat_desc.max_length,P,$,_e,Te,Le,Et,kt=0;for(Te=0;Te<=Do;Te++)e.bl_count[Te]=0;for(n[e.heap[e.heap_max]*2+1]=0,P=e.heap_max+1;P<Fs;P++)$=e.heap[P],Te=n[n[$*2+1]*2+1]+1,Te>z&&(Te=z,kt++),n[$*2+1]=Te,!($>r)&&(e.bl_count[Te]++,Le=0,$>=y&&(Le=g[$-y]),Et=n[$*2],e.opt_len+=Et*(Te+Le),d&&(e.static_len+=Et*(s[$*2+1]+Le)));if(kt!==0){do{for(Te=z-1;e.bl_count[Te]===0;)Te--;e.bl_count[Te]--,e.bl_count[Te+1]+=2,e.bl_count[z]--,kt-=2}while(kt>0);for(Te=z;Te!==0;Te--)for($=e.bl_count[Te];$!==0;)_e=e.heap[--P],!(_e>r)&&(n[_e*2+1]!==Te&&(e.opt_len+=(Te-n[_e*2+1])*n[_e*2],n[_e*2+1]=Te),$--)}}function Pa(e,t,n){var r=new Array(Do+1),s=0,d,g;for(d=1;d<=Do;d++)r[d]=s=s+n[d-1]<<1;for(g=0;g<=t;g++){var y=e[g*2+1];y!==0&&(e[g*2]=Tl(r[y]++,y))}}function Pl(){var e,t,n,r,s,d=new Array(Do+1);for(n=0,r=0;r<bo-1;r++)for(li[r]=n,e=0;e<1<<Ai[r];e++)Dr[n++]=r;for(Dr[n-1]=r,s=0,r=0;r<16;r++)for(tl[r]=s,e=0;e<1<<es[r];e++)Ia[s++]=r;for(s>>=7;r<Ta;r++)for(tl[r]=s<<7,e=0;e<1<<es[r]-7;e++)Ia[256+s++]=r;for(t=0;t<=Do;t++)d[t]=0;for(e=0;e<=143;)Tn[e*2+1]=8,e++,d[8]++;for(;e<=255;)Tn[e*2+1]=9,e++,d[9]++;for(;e<=279;)Tn[e*2+1]=7,e++,d[7]++;for(;e<=287;)Tn[e*2+1]=8,e++,d[8]++;for(Pa(Tn,si+1,d),e=0;e<Ta;e++)Vi[e*2+1]=5,Vi[e*2]=Tl(e,5);Jn=new Ol(Tn,Ai,fr+1,si,Do),In=new Ol(Vi,es,0,Ta,Do),ci=new Ol(new Array(0),Al,0,Sl,ps)}function Nl(e){var t;for(t=0;t<si;t++)e.dyn_ltree[t*2]=0;for(t=0;t<Ta;t++)e.dyn_dtree[t*2]=0;for(t=0;t<Sl;t++)e.bl_tree[t*2]=0;e.dyn_ltree[Mn*2]=1,e.opt_len=e.static_len=0,e.last_lit=e.matches=0}function nl(e){e.bi_valid>8?ts(e,e.bi_buf):e.bi_valid>0&&(e.pending_buf[e.pending++]=e.bi_buf),e.bi_buf=0,e.bi_valid=0}function ic(e,t,n,r){nl(e),r&&(ts(e,n),ts(e,~n)),it.arraySet(e.pending_buf,e.window,t,n,e.pending),e.pending+=n}function kl(e,t,n,r){var s=t*2,d=n*2;return e[s]<e[d]||e[s]===e[d]&&r[t]<=r[n]}function rs(e,t,n){for(var r=e.heap[n],s=n<<1;s<=e.heap_len&&(s<e.heap_len&&kl(t,e.heap[s+1],e.heap[s],e.depth)&&s++,!kl(t,r,e.heap[s],e.depth));)e.heap[n]=e.heap[s],n=s,s<<=1;e.heap[n]=r}function Ls(e,t,n){var r,s,d=0,g,y;if(e.last_lit!==0)do r=e.pending_buf[e.d_buf+d*2]<<8|e.pending_buf[e.d_buf+d*2+1],s=e.pending_buf[e.l_buf+d],d++,r===0?Fo(e,s,t):(g=Dr[s],Fo(e,g+fr+1,t),y=Ai[g],y!==0&&(s-=li[g],Xr(e,s,y)),r--,g=fa(r),Fo(e,g,n),y=es[g],y!==0&&(r-=tl[g],Xr(e,r,y)));while(d<e.last_lit);Fo(e,Mn,t)}function Rl(e,t){var n=t.dyn_tree,r=t.stat_desc.static_tree,s=t.stat_desc.has_stree,d=t.stat_desc.elems,g,y,z=-1,P;for(e.heap_len=0,e.heap_max=Fs,g=0;g<d;g++)n[g*2]!==0?(e.heap[++e.heap_len]=z=g,e.depth[g]=0):n[g*2+1]=0;for(;e.heap_len<2;)P=e.heap[++e.heap_len]=z<2?++z:0,n[P*2]=1,e.depth[P]=0,e.opt_len--,s&&(e.static_len-=r[P*2+1]);for(t.max_code=z,g=e.heap_len>>1;g>=1;g--)rs(e,n,g);P=d;do g=e.heap[1],e.heap[1]=e.heap[e.heap_len--],rs(e,n,1),y=e.heap[1],e.heap[--e.heap_max]=g,e.heap[--e.heap_max]=y,n[P*2]=n[g*2]+n[y*2],e.depth[P]=(e.depth[g]>=e.depth[y]?e.depth[g]:e.depth[y])+1,n[g*2+1]=n[y*2+1]=P,e.heap[1]=P++,rs(e,n,1);while(e.heap_len>=2);e.heap[--e.heap_max]=e.heap[1],ns(e,t),Pa(n,z,e.bl_count)}function gs(e,t,n){var r,s=-1,d,g=t[0*2+1],y=0,z=7,P=4;for(g===0&&(z=138,P=3),t[(n+1)*2+1]=65535,r=0;r<=n;r++)d=g,g=t[(r+1)*2+1],!(++y<z&&d===g)&&(y<P?e.bl_tree[d*2]+=y:d!==0?(d!==s&&e.bl_tree[d*2]++,e.bl_tree[zn*2]++):y<=10?e.bl_tree[Cl*2]++:e.bl_tree[Li*2]++,y=0,s=d,g===0?(z=138,P=3):d===g?(z=6,P=3):(z=7,P=4))}function da(e,t,n){var r,s=-1,d,g=t[0*2+1],y=0,z=7,P=4;for(g===0&&(z=138,P=3),r=0;r<=n;r++)if(d=g,g=t[(r+1)*2+1],!(++y<z&&d===g)){if(y<P)do Fo(e,d,e.bl_tree);while(--y!==0);else d!==0?(d!==s&&(Fo(e,d,e.bl_tree),y--),Fo(e,zn,e.bl_tree),Xr(e,y-3,2)):y<=10?(Fo(e,Cl,e.bl_tree),Xr(e,y-3,3)):(Fo(e,Li,e.bl_tree),Xr(e,y-11,7));y=0,s=d,g===0?(z=138,P=3):d===g?(z=6,P=3):(z=7,P=4)}}function Vs(e){var t;for(gs(e,e.dyn_ltree,e.l_desc.max_code),gs(e,e.dyn_dtree,e.d_desc.max_code),Rl(e,e.bl_desc),t=Sl-1;t>=3&&e.bl_tree[rc[t]*2+1]===0;t--);return e.opt_len+=3*(t+1)+5+5+4,t}function xl(e,t,n,r){var s;for(Xr(e,t-257,5),Xr(e,n-1,5),Xr(e,r-4,4),s=0;s<r;s++)Xr(e,e.bl_tree[rc[s]*2+1],3);da(e,e.dyn_ltree,t-1),da(e,e.dyn_dtree,n-1)}function $s(e){var t=4093624447,n;for(n=0;n<=31;n++,t>>>=1)if(t&1&&e.dyn_ltree[n*2]!==0)return Br;if(e.dyn_ltree[9*2]!==0||e.dyn_ltree[10*2]!==0||e.dyn_ltree[13*2]!==0)return rr;for(n=32;n<fr;n++)if(e.dyn_ltree[n*2]!==0)return rr;return Br}var Us=!1;function $c(e){Us||(Pl(),Us=!0),e.l_desc=new Zr(e.dyn_ltree,Jn),e.d_desc=new Zr(e.dyn_dtree,In),e.bl_desc=new Zr(e.bl_tree,ci),e.bi_buf=0,e.bi_valid=0,Nl(e)}function oc(e,t,n,r){Xr(e,(Oa<<1)+(r?1:0),3),ic(e,t,n,!0)}function Uc(e){Xr(e,Ko<<1,3),Fo(e,Mn,Tn),Il(e)}function Hc(e,t,n,r){var s,d,g=0;e.level>0?(e.strm.data_type===Mr&&(e.strm.data_type=$s(e)),Rl(e,e.l_desc),Rl(e,e.d_desc),g=Vs(e),s=e.opt_len+3+7>>>3,d=e.static_len+3+7>>>3,d<=s&&(s=d)):s=d=n+5,n+4<=s&&t!==-1?oc(e,t,n,r):e.strategy===fn||d===s?(Xr(e,(Ko<<1)+(r?1:0),3),Ls(e,Tn,Vi)):(Xr(e,(el<<1)+(r?1:0),3),xl(e,e.l_desc.max_code+1,e.d_desc.max_code+1,g+1),Ls(e,e.dyn_ltree,e.dyn_dtree)),Nl(e),r&&nl(e)}function jc(e,t,n){return e.pending_buf[e.d_buf+e.last_lit*2]=t>>>8&255,e.pending_buf[e.d_buf+e.last_lit*2+1]=t&255,e.pending_buf[e.l_buf+e.last_lit]=n&255,e.last_lit++,t===0?e.dyn_ltree[n*2]++:(e.matches++,t--,e.dyn_ltree[(Dr[n]+fr+1)*2]++,e.dyn_dtree[fa(t)*2]++),e.last_lit===e.lit_bufsize-1}var ac=$c,sc=oc,zc=Hc,Wc=jc,Gc=Uc,Bl={_tr_init:ac,_tr_stored_block:sc,_tr_flush_block:zc,_tr_tally:Wc,_tr_align:Gc};function lc(e,t,n,r){for(var s=e&65535|0,d=e>>>16&65535|0,g=0;n!==0;){g=n>2e3?2e3:n,n-=g;do s=s+t[r++]|0,d=d+s|0;while(--g);s%=65521,d%=65521}return s|d<<16|0}var Ml=lc;function Dl(){for(var e,t=[],n=0;n<256;n++){e=n;for(var r=0;r<8;r++)e=e&1?3988292384^e>>>1:e>>>1;t[n]=e}return t}var Yc=Dl();function cc(e,t,n,r){var s=Yc,d=r+n;e^=-1;for(var g=r;g<d;g++)e=e>>>8^s[(e^t[g])&255];return e^-1}var rl=cc,Fl={2:"need dictionary",1:"stream end",0:"","-1":"file error","-2":"stream error","-3":"data error","-4":"insufficient memory","-5":"buffer error","-6":"incompatible version"},yo=Bl,Hs=Ml,dr=rl,ha=Fl,Jo=0,uc=1,il=3,Zo=4,Ll=5,Xo=0,fc=1,oo=-2,dc=-3,ol=-5,hc=-1,pc=1,vs=2,gc=3,vc=4,qc=0,Kc=2,al=8,Vl=9,mc=15,Na=8,js=29,$l=256,sl=$l+1+js,Jc=30,ka=19,_c=2*sl+1,bc=15,dn=3,Qo=258,Lo=Qo+dn+1,pa=32,ea=42,ll=69,cl=73,is=91,zs=103,Ra=113,ms=666,Ar=1,_s=2,ga=3,os=4,Zc=3;function xa(e,t){return e.msg=ha[t],t}function o(e){return(e<<1)-(e>4?9:0)}function l(e){for(var t=e.length;--t>=0;)e[t]=0}function h(e){var t=e.state,n=t.pending;n>e.avail_out&&(n=e.avail_out),n!==0&&(it.arraySet(e.output,t.pending_buf,t.pending_out,n,e.next_out),e.next_out+=n,t.pending_out+=n,e.total_out+=n,e.avail_out-=n,t.pending-=n,t.pending===0&&(t.pending_out=0))}function m(e,t){yo._tr_flush_block(e,e.block_start>=0?e.block_start:-1,e.strstart-e.block_start,t),e.block_start=e.strstart,h(e.strm)}function S(e,t){e.pending_buf[e.pending++]=t}function O(e,t){e.pending_buf[e.pending++]=t>>>8&255,e.pending_buf[e.pending++]=t&255}function M(e,t,n,r){var s=e.avail_in;return s>r&&(s=r),s===0?0:(e.avail_in-=s,it.arraySet(t,e.input,e.next_in,s,n),e.state.wrap===1?e.adler=Hs(e.adler,t,s,n):e.state.wrap===2&&(e.adler=dr(e.adler,t,s,n)),e.next_in+=s,e.total_in+=s,s)}function Y(e,t){var n=e.max_chain_length,r=e.strstart,s,d,g=e.prev_length,y=e.nice_match,z=e.strstart>e.w_size-Lo?e.strstart-(e.w_size-Lo):0,P=e.window,$=e.w_mask,_e=e.prev,Te=e.strstart+Qo,Le=P[r+g-1],Et=P[r+g];e.prev_length>=e.good_match&&(n>>=2),y>e.lookahead&&(y=e.lookahead);do if(s=t,!(P[s+g]!==Et||P[s+g-1]!==Le||P[s]!==P[r]||P[++s]!==P[r+1])){r+=2,s++;do;while(P[++r]===P[++s]&&P[++r]===P[++s]&&P[++r]===P[++s]&&P[++r]===P[++s]&&P[++r]===P[++s]&&P[++r]===P[++s]&&P[++r]===P[++s]&&P[++r]===P[++s]&&r<Te);if(d=Qo-(Te-r),r=Te-Qo,d>g){if(e.match_start=t,g=d,d>=y)break;Le=P[r+g-1],Et=P[r+g]}}while((t=_e[t&$])>z&&--n!==0);return g<=e.lookahead?g:e.lookahead}function H(e){var t=e.w_size,n,r,s,d,g;do{if(d=e.window_size-e.lookahead-e.strstart,e.strstart>=t+(t-Lo)){it.arraySet(e.window,e.window,t,t,0),e.match_start-=t,e.strstart-=t,e.block_start-=t,r=e.hash_size,n=r;do s=e.head[--n],e.head[n]=s>=t?s-t:0;while(--r);r=t,n=r;do s=e.prev[--n],e.prev[n]=s>=t?s-t:0;while(--r);d+=t}if(e.strm.avail_in===0)break;if(r=M(e.strm,e.window,e.strstart+e.lookahead,d),e.lookahead+=r,e.lookahead+e.insert>=dn)for(g=e.strstart-e.insert,e.ins_h=e.window[g],e.ins_h=(e.ins_h<<e.hash_shift^e.window[g+1])&e.hash_mask;e.insert&&(e.ins_h=(e.ins_h<<e.hash_shift^e.window[g+dn-1])&e.hash_mask,e.prev[g&e.w_mask]=e.head[e.ins_h],e.head[e.ins_h]=g,g++,e.insert--,!(e.lookahead+e.insert<dn)););}while(e.lookahead<Lo&&e.strm.avail_in!==0)}function ne(e,t){var n=65535;for(n>e.pending_buf_size-5&&(n=e.pending_buf_size-5);;){if(e.lookahead<=1){if(H(e),e.lookahead===0&&t===Jo)return Ar;if(e.lookahead===0)break}e.strstart+=e.lookahead,e.lookahead=0;var r=e.block_start+n;if((e.strstart===0||e.strstart>=r)&&(e.lookahead=e.strstart-r,e.strstart=r,m(e,!1),e.strm.avail_out===0)||e.strstart-e.block_start>=e.w_size-Lo&&(m(e,!1),e.strm.avail_out===0))return Ar}return e.insert=0,t===Zo?(m(e,!0),e.strm.avail_out===0?ga:os):(e.strstart>e.block_start&&(m(e,!1),e.strm.avail_out===0),Ar)}function Ne(e,t){for(var n,r;;){if(e.lookahead<Lo){if(H(e),e.lookahead<Lo&&t===Jo)return Ar;if(e.lookahead===0)break}if(n=0,e.lookahead>=dn&&(e.ins_h=(e.ins_h<<e.hash_shift^e.window[e.strstart+dn-1])&e.hash_mask,n=e.prev[e.strstart&e.w_mask]=e.head[e.ins_h],e.head[e.ins_h]=e.strstart),n!==0&&e.strstart-n<=e.w_size-Lo&&(e.match_length=Y(e,n)),e.match_length>=dn)if(r=yo._tr_tally(e,e.strstart-e.match_start,e.match_length-dn),e.lookahead-=e.match_length,e.match_length<=e.max_lazy_match&&e.lookahead>=dn){e.match_length--;do e.strstart++,e.ins_h=(e.ins_h<<e.hash_shift^e.window[e.strstart+dn-1])&e.hash_mask,n=e.prev[e.strstart&e.w_mask]=e.head[e.ins_h],e.head[e.ins_h]=e.strstart;while(--e.match_length!==0);e.strstart++}else e.strstart+=e.match_length,e.match_length=0,e.ins_h=e.window[e.strstart],e.ins_h=(e.ins_h<<e.hash_shift^e.window[e.strstart+1])&e.hash_mask;else r=yo._tr_tally(e,0,e.window[e.strstart]),e.lookahead--,e.strstart++;if(r&&(m(e,!1),e.strm.avail_out===0))return Ar}return e.insert=e.strstart<dn-1?e.strstart:dn-1,t===Zo?(m(e,!0),e.strm.avail_out===0?ga:os):e.last_lit&&(m(e,!1),e.strm.avail_out===0)?Ar:_s}function fe(e,t){for(var n,r,s;;){if(e.lookahead<Lo){if(H(e),e.lookahead<Lo&&t===Jo)return Ar;if(e.lookahead===0)break}if(n=0,e.lookahead>=dn&&(e.ins_h=(e.ins_h<<e.hash_shift^e.window[e.strstart+dn-1])&e.hash_mask,n=e.prev[e.strstart&e.w_mask]=e.head[e.ins_h],e.head[e.ins_h]=e.strstart),e.prev_length=e.match_length,e.prev_match=e.match_start,e.match_length=dn-1,n!==0&&e.prev_length<e.max_lazy_match&&e.strstart-n<=e.w_size-Lo&&(e.match_length=Y(e,n),e.match_length<=5&&(e.strategy===pc||e.match_length===dn&&e.strstart-e.match_start>4096)&&(e.match_length=dn-1)),e.prev_length>=dn&&e.match_length<=e.prev_length){s=e.strstart+e.lookahead-dn,r=yo._tr_tally(e,e.strstart-1-e.prev_match,e.prev_length-dn),e.lookahead-=e.prev_length-1,e.prev_length-=2;do++e.strstart<=s&&(e.ins_h=(e.ins_h<<e.hash_shift^e.window[e.strstart+dn-1])&e.hash_mask,n=e.prev[e.strstart&e.w_mask]=e.head[e.ins_h],e.head[e.ins_h]=e.strstart);while(--e.prev_length!==0);if(e.match_available=0,e.match_length=dn-1,e.strstart++,r&&(m(e,!1),e.strm.avail_out===0))return Ar}else if(e.match_available){if(r=yo._tr_tally(e,0,e.window[e.strstart-1]),r&&m(e,!1),e.strstart++,e.lookahead--,e.strm.avail_out===0)return Ar}else e.match_available=1,e.strstart++,e.lookahead--}return e.match_available&&(r=yo._tr_tally(e,0,e.window[e.strstart-1]),e.match_available=0),e.insert=e.strstart<dn-1?e.strstart:dn-1,t===Zo?(m(e,!0),e.strm.avail_out===0?ga:os):e.last_lit&&(m(e,!1),e.strm.avail_out===0)?Ar:_s}function ce(e,t){for(var n,r,s,d,g=e.window;;){if(e.lookahead<=Qo){if(H(e),e.lookahead<=Qo&&t===Jo)return Ar;if(e.lookahead===0)break}if(e.match_length=0,e.lookahead>=dn&&e.strstart>0&&(s=e.strstart-1,r=g[s],r===g[++s]&&r===g[++s]&&r===g[++s])){d=e.strstart+Qo;do;while(r===g[++s]&&r===g[++s]&&r===g[++s]&&r===g[++s]&&r===g[++s]&&r===g[++s]&&r===g[++s]&&r===g[++s]&&s<d);e.match_length=Qo-(d-s),e.match_length>e.lookahead&&(e.match_length=e.lookahead)}if(e.match_length>=dn?(n=yo._tr_tally(e,1,e.match_length-dn),e.lookahead-=e.match_length,e.strstart+=e.match_length,e.match_length=0):(n=yo._tr_tally(e,0,e.window[e.strstart]),e.lookahead--,e.strstart++),n&&(m(e,!1),e.strm.avail_out===0))return Ar}return e.insert=0,t===Zo?(m(e,!0),e.strm.avail_out===0?ga:os):e.last_lit&&(m(e,!1),e.strm.avail_out===0)?Ar:_s}function Fe(e,t){for(var n;;){if(e.lookahead===0&&(H(e),e.lookahead===0)){if(t===Jo)return Ar;break}if(e.match_length=0,n=yo._tr_tally(e,0,e.window[e.strstart]),e.lookahead--,e.strstart++,n&&(m(e,!1),e.strm.avail_out===0))return Ar}return e.insert=0,t===Zo?(m(e,!0),e.strm.avail_out===0?ga:os):e.last_lit&&(m(e,!1),e.strm.avail_out===0)?Ar:_s}function Ve(e,t,n,r,s){this.good_length=e,this.max_lazy=t,this.nice_length=n,this.max_chain=r,this.func=s}var lt;lt=[new Ve(0,0,0,0,ne),new Ve(4,4,8,4,Ne),new Ve(4,5,16,8,Ne),new Ve(4,6,32,32,Ne),new Ve(4,4,16,16,fe),new Ve(8,16,32,32,fe),new Ve(8,16,128,128,fe),new Ve(8,32,128,256,fe),new Ve(32,128,258,1024,fe),new Ve(32,258,258,4096,fe)];function mt(e){e.window_size=2*e.w_size,l(e.head),e.max_lazy_match=lt[e.level].max_lazy,e.good_match=lt[e.level].good_length,e.nice_match=lt[e.level].nice_length,e.max_chain_length=lt[e.level].max_chain,e.strstart=0,e.block_start=0,e.lookahead=0,e.insert=0,e.match_length=e.prev_length=dn-1,e.match_available=0,e.ins_h=0}function we(){this.strm=null,this.status=0,this.pending_buf=null,this.pending_buf_size=0,this.pending_out=0,this.pending=0,this.wrap=0,this.gzhead=null,this.gzindex=0,this.method=al,this.last_flush=-1,this.w_size=0,this.w_bits=0,this.w_mask=0,this.window=null,this.window_size=0,this.prev=null,this.head=null,this.ins_h=0,this.hash_size=0,this.hash_bits=0,this.hash_mask=0,this.hash_shift=0,this.block_start=0,this.match_length=0,this.prev_match=0,this.match_available=0,this.strstart=0,this.match_start=0,this.lookahead=0,this.prev_length=0,this.max_chain_length=0,this.max_lazy_match=0,this.level=0,this.strategy=0,this.good_match=0,this.nice_match=0,this.dyn_ltree=new it.Buf16(_c*2),this.dyn_dtree=new it.Buf16((2*Jc+1)*2),this.bl_tree=new it.Buf16((2*ka+1)*2),l(this.dyn_ltree),l(this.dyn_dtree),l(this.bl_tree),this.l_desc=null,this.d_desc=null,this.bl_desc=null,this.bl_count=new it.Buf16(bc+1),this.heap=new it.Buf16(2*sl+1),l(this.heap),this.heap_len=0,this.heap_max=0,this.depth=new it.Buf16(2*sl+1),l(this.depth),this.l_buf=0,this.lit_bufsize=0,this.last_lit=0,this.d_buf=0,this.opt_len=0,this.static_len=0,this.matches=0,this.insert=0,this.bi_buf=0,this.bi_valid=0}function de(e){var t;return!e||!e.state?xa(e,oo):(e.total_in=e.total_out=0,e.data_type=Kc,t=e.state,t.pending=0,t.pending_out=0,t.wrap<0&&(t.wrap=-t.wrap),t.status=t.wrap?ea:Ra,e.adler=t.wrap===2?0:1,t.last_flush=Jo,yo._tr_init(t),Xo)}function Se(e){var t=de(e);return t===Xo&&mt(e.state),t}function nt(e,t){return!e||!e.state||e.state.wrap!==2?oo:(e.state.gzhead=t,Xo)}function ze(e,t,n,r,s,d){if(!e)return oo;var g=1;if(t===hc&&(t=6),r<0?(g=0,r=-r):r>15&&(g=2,r-=16),s<1||s>Vl||n!==al||r<8||r>15||t<0||t>9||d<0||d>vc)return xa(e,oo);r===8&&(r=9);var y=new we;return e.state=y,y.strm=e,y.wrap=g,y.gzhead=null,y.w_bits=r,y.w_size=1<<y.w_bits,y.w_mask=y.w_size-1,y.hash_bits=s+7,y.hash_size=1<<y.hash_bits,y.hash_mask=y.hash_size-1,y.hash_shift=~~((y.hash_bits+dn-1)/dn),y.window=new it.Buf8(y.w_size*2),y.head=new it.Buf16(y.hash_size),y.prev=new it.Buf16(y.w_size),y.lit_bufsize=1<<s+6,y.pending_buf_size=y.lit_bufsize*4,y.pending_buf=new it.Buf8(y.pending_buf_size),y.d_buf=1*y.lit_bufsize,y.l_buf=(1+2)*y.lit_bufsize,y.level=t,y.strategy=d,y.method=n,Se(e)}function i(e,t){return ze(e,t,al,mc,Na,qc)}function a(e,t){var n,r,s,d;if(!e||!e.state||t>Ll||t<0)return e?xa(e,oo):oo;if(r=e.state,!e.output||!e.input&&e.avail_in!==0||r.status===ms&&t!==Zo)return xa(e,e.avail_out===0?ol:oo);if(r.strm=e,n=r.last_flush,r.last_flush=t,r.status===ea)if(r.wrap===2)e.adler=0,S(r,31),S(r,139),S(r,8),r.gzhead?(S(r,(r.gzhead.text?1:0)+(r.gzhead.hcrc?2:0)+(r.gzhead.extra?4:0)+(r.gzhead.name?8:0)+(r.gzhead.comment?16:0)),S(r,r.gzhead.time&255),S(r,r.gzhead.time>>8&255),S(r,r.gzhead.time>>16&255),S(r,r.gzhead.time>>24&255),S(r,r.level===9?2:r.strategy>=vs||r.level<2?4:0),S(r,r.gzhead.os&255),r.gzhead.extra&&r.gzhead.extra.length&&(S(r,r.gzhead.extra.length&255),S(r,r.gzhead.extra.length>>8&255)),r.gzhead.hcrc&&(e.adler=dr(e.adler,r.pending_buf,r.pending,0)),r.gzindex=0,r.status=ll):(S(r,0),S(r,0),S(r,0),S(r,0),S(r,0),S(r,r.level===9?2:r.strategy>=vs||r.level<2?4:0),S(r,Zc),r.status=Ra);else{var g=al+(r.w_bits-8<<4)<<8,y=-1;r.strategy>=vs||r.level<2?y=0:r.level<6?y=1:r.level===6?y=2:y=3,g|=y<<6,r.strstart!==0&&(g|=pa),g+=31-g%31,r.status=Ra,O(r,g),r.strstart!==0&&(O(r,e.adler>>>16),O(r,e.adler&65535)),e.adler=1}if(r.status===ll)if(r.gzhead.extra){for(s=r.pending;r.gzindex<(r.gzhead.extra.length&65535)&&!(r.pending===r.pending_buf_size&&(r.gzhead.hcrc&&r.pending>s&&(e.adler=dr(e.adler,r.pending_buf,r.pending-s,s)),h(e),s=r.pending,r.pending===r.pending_buf_size));)S(r,r.gzhead.extra[r.gzindex]&255),r.gzindex++;r.gzhead.hcrc&&r.pending>s&&(e.adler=dr(e.adler,r.pending_buf,r.pending-s,s)),r.gzindex===r.gzhead.extra.length&&(r.gzindex=0,r.status=cl)}else r.status=cl;if(r.status===cl)if(r.gzhead.name){s=r.pending;do{if(r.pending===r.pending_buf_size&&(r.gzhead.hcrc&&r.pending>s&&(e.adler=dr(e.adler,r.pending_buf,r.pending-s,s)),h(e),s=r.pending,r.pending===r.pending_buf_size)){d=1;break}r.gzindex<r.gzhead.name.length?d=r.gzhead.name.charCodeAt(r.gzindex++)&255:d=0,S(r,d)}while(d!==0);r.gzhead.hcrc&&r.pending>s&&(e.adler=dr(e.adler,r.pending_buf,r.pending-s,s)),d===0&&(r.gzindex=0,r.status=is)}else r.status=is;if(r.status===is)if(r.gzhead.comment){s=r.pending;do{if(r.pending===r.pending_buf_size&&(r.gzhead.hcrc&&r.pending>s&&(e.adler=dr(e.adler,r.pending_buf,r.pending-s,s)),h(e),s=r.pending,r.pending===r.pending_buf_size)){d=1;break}r.gzindex<r.gzhead.comment.length?d=r.gzhead.comment.charCodeAt(r.gzindex++)&255:d=0,S(r,d)}while(d!==0);r.gzhead.hcrc&&r.pending>s&&(e.adler=dr(e.adler,r.pending_buf,r.pending-s,s)),d===0&&(r.status=zs)}else r.status=zs;if(r.status===zs&&(r.gzhead.hcrc?(r.pending+2>r.pending_buf_size&&h(e),r.pending+2<=r.pending_buf_size&&(S(r,e.adler&255),S(r,e.adler>>8&255),e.adler=0,r.status=Ra)):r.status=Ra),r.pending!==0){if(h(e),e.avail_out===0)return r.last_flush=-1,Xo}else if(e.avail_in===0&&o(t)<=o(n)&&t!==Zo)return xa(e,ol);if(r.status===ms&&e.avail_in!==0)return xa(e,ol);if(e.avail_in!==0||r.lookahead!==0||t!==Jo&&r.status!==ms){var z=r.strategy===vs?Fe(r,t):r.strategy===gc?ce(r,t):lt[r.level].func(r,t);if((z===ga||z===os)&&(r.status=ms),z===Ar||z===ga)return e.avail_out===0&&(r.last_flush=-1),Xo;if(z===_s&&(t===uc?yo._tr_align(r):t!==Ll&&(yo._tr_stored_block(r,0,0,!1),t===il&&(l(r.head),r.lookahead===0&&(r.strstart=0,r.block_start=0,r.insert=0))),h(e),e.avail_out===0))return r.last_flush=-1,Xo}return t!==Zo?Xo:r.wrap<=0?fc:(r.wrap===2?(S(r,e.adler&255),S(r,e.adler>>8&255),S(r,e.adler>>16&255),S(r,e.adler>>24&255),S(r,e.total_in&255),S(r,e.total_in>>8&255),S(r,e.total_in>>16&255),S(r,e.total_in>>24&255)):(O(r,e.adler>>>16),O(r,e.adler&65535)),h(e),r.wrap>0&&(r.wrap=-r.wrap),r.pending!==0?Xo:fc)}function f(e){var t;return!e||!e.state?oo:(t=e.state.status,t!==ea&&t!==ll&&t!==cl&&t!==is&&t!==zs&&t!==Ra&&t!==ms?xa(e,oo):(e.state=null,t===Ra?xa(e,dc):Xo))}function p(e,t){var n=t.length,r,s,d,g,y,z,P,$;if(!e||!e.state||(r=e.state,g=r.wrap,g===2||g===1&&r.status!==ea||r.lookahead))return oo;for(g===1&&(e.adler=Hs(e.adler,t,n,0)),r.wrap=0,n>=r.w_size&&(g===0&&(l(r.head),r.strstart=0,r.block_start=0,r.insert=0),$=new it.Buf8(r.w_size),it.arraySet($,t,n-r.w_size,r.w_size,0),t=$,n=r.w_size),y=e.avail_in,z=e.next_in,P=e.input,e.avail_in=n,e.next_in=0,e.input=t,H(r);r.lookahead>=dn;){s=r.strstart,d=r.lookahead-(dn-1);do r.ins_h=(r.ins_h<<r.hash_shift^r.window[s+dn-1])&r.hash_mask,r.prev[s&r.w_mask]=r.head[r.ins_h],r.head[r.ins_h]=s,s++;while(--d);r.strstart=s,r.lookahead=dn-1,H(r)}return r.strstart+=r.lookahead,r.block_start=r.strstart,r.insert=r.lookahead,r.lookahead=0,r.match_length=r.prev_length=dn-1,r.match_available=0,e.next_in=z,e.input=P,e.avail_in=y,r.wrap=g,Xo}var w=i,E=ze,N=Se,L=de,R=nt,K=a,ue=f,oe=p,te="pako deflate (from Nodeca project)",Ee={deflateInit:w,deflateInit2:E,deflateReset:N,deflateResetKeep:L,deflateSetHeader:R,deflate:K,deflateEnd:ue,deflateSetDictionary:oe,deflateInfo:te},He=!0,rt=!0;try{String.fromCharCode.apply(null,[0])}catch(e){He=!1}try{String.fromCharCode.apply(null,new Uint8Array(1))}catch(e){rt=!1}for(var ft=new it.Buf8(256),ve=0;ve<256;ve++)ft[ve]=ve>=252?6:ve>=248?5:ve>=240?4:ve>=224?3:ve>=192?2:1;ft[254]=ft[254]=1;var le=function(e){var t,n,r,s,d,g=e.length,y=0;for(s=0;s<g;s++)n=e.charCodeAt(s),(n&64512)===55296&&s+1<g&&(r=e.charCodeAt(s+1),(r&64512)===56320&&(n=65536+(n-55296<<10)+(r-56320),s++)),y+=n<128?1:n<2048?2:n<65536?3:4;for(t=new it.Buf8(y),d=0,s=0;d<y;s++)n=e.charCodeAt(s),(n&64512)===55296&&s+1<g&&(r=e.charCodeAt(s+1),(r&64512)===56320&&(n=65536+(n-55296<<10)+(r-56320),s++)),n<128?t[d++]=n:n<2048?(t[d++]=192|n>>>6,t[d++]=128|n&63):n<65536?(t[d++]=224|n>>>12,t[d++]=128|n>>>6&63,t[d++]=128|n&63):(t[d++]=240|n>>>18,t[d++]=128|n>>>12&63,t[d++]=128|n>>>6&63,t[d++]=128|n&63);return t};function me(e,t){if(t<65534&&(e.subarray&&rt||!e.subarray&&He))return String.fromCharCode.apply(null,it.shrinkBuf(e,t));for(var n="",r=0;r<t;r++)n+=String.fromCharCode(e[r]);return n}var Ze=function(e){return me(e,e.length)},Oe=function(e){for(var t=new it.Buf8(e.length),n=0,r=t.length;n<r;n++)t[n]=e.charCodeAt(n);return t},ot=function(e,t){var n,r,s,d,g=t||e.length,y=new Array(g*2);for(r=0,n=0;n<g;){if(s=e[n++],s<128){y[r++]=s;continue}if(d=ft[s],d>4){y[r++]=65533,n+=d-1;continue}for(s&=d===2?31:d===3?15:7;d>1&&n<g;)s=s<<6|e[n++]&63,d--;if(d>1){y[r++]=65533;continue}s<65536?y[r++]=s:(s-=65536,y[r++]=55296|s>>10&1023,y[r++]=56320|s&1023)}return me(y,r)},dt=function(e,t){var n;for(t=t||e.length,t>e.length&&(t=e.length),n=t-1;n>=0&&(e[n]&192)===128;)n--;return n<0||n===0?t:n+ft[e[n]]>t?n:t},Ye={string2buf:le,buf2binstring:Ze,binstring2buf:Oe,buf2string:ot,utf8border:dt};function Ot(){this.input=null,this.next_in=0,this.avail_in=0,this.total_in=0,this.output=null,this.next_out=0,this.avail_out=0,this.total_out=0,this.msg="",this.state=null,this.data_type=2,this.adler=0}var Tt=Ot,wt=Ee,$t=Ye,x=Tt,U=Object.prototype.toString,he=0,Ie=4,Pe=0,Je=1,ct=2,Xe=-1,tt=0,We=8;function Ct(e){if(!(this instanceof Ct))return new Ct(e);this.options=it.assign({level:Xe,method:We,chunkSize:16384,windowBits:15,memLevel:8,strategy:tt,to:""},e||{});var t=this.options;t.raw&&t.windowBits>0?t.windowBits=-t.windowBits:t.gzip&&t.windowBits>0&&t.windowBits<16&&(t.windowBits+=16),this.err=0,this.msg="",this.ended=!1,this.chunks=[],this.strm=new x,this.strm.avail_out=0;var n=wt.deflateInit2(this.strm,t.level,t.method,t.windowBits,t.memLevel,t.strategy);if(n!==Pe)throw new Error(ha[n]);if(t.header&&wt.deflateSetHeader(this.strm,t.header),t.dictionary){var r;if(typeof t.dictionary=="string"?r=$t.string2buf(t.dictionary):U.call(t.dictionary)==="[object ArrayBuffer]"?r=new Uint8Array(t.dictionary):r=t.dictionary,n=wt.deflateSetDictionary(this.strm,r),n!==Pe)throw new Error(ha[n]);this._dict_set=!0}}Ct.prototype.push=function(e,t){var n=this.strm,r=this.options.chunkSize,s,d;if(this.ended)return!1;d=t===~~t?t:t===!0?Ie:he,typeof e=="string"?n.input=$t.string2buf(e):U.call(e)==="[object ArrayBuffer]"?n.input=new Uint8Array(e):n.input=e,n.next_in=0,n.avail_in=n.input.length;do{if(n.avail_out===0&&(n.output=new it.Buf8(r),n.next_out=0,n.avail_out=r),s=wt.deflate(n,d),s!==Je&&s!==Pe)return this.onEnd(s),this.ended=!0,!1;(n.avail_out===0||n.avail_in===0&&(d===Ie||d===ct))&&(this.options.to==="string"?this.onData($t.buf2binstring(it.shrinkBuf(n.output,n.next_out))):this.onData(it.shrinkBuf(n.output,n.next_out)))}while((n.avail_in>0||n.avail_out===0)&&s!==Je);return d===Ie?(s=wt.deflateEnd(this.strm),this.onEnd(s),this.ended=!0,s===Pe):(d===ct&&(this.onEnd(Pe),n.avail_out=0),!0)},Ct.prototype.onData=function(e){this.chunks.push(e)},Ct.prototype.onEnd=function(e){e===Pe&&(this.options.to==="string"?this.result=this.chunks.join(""):this.result=it.flattenChunks(this.chunks)),this.chunks=[],this.err=e,this.msg=this.strm.msg};function pt(e,t){var n=new Ct(t);if(n.push(e,!0),n.err)throw n.msg||ha[n.err];return n.result}function Pt(e,t){return t=t||{},t.raw=!0,pt(e,t)}function en(e,t){return t=t||{},t.gzip=!0,pt(e,t)}var nn=Ct,Wt=pt,gn=Pt,Wn=en,Vo={Deflate:nn,deflate:Wt,deflateRaw:gn,gzip:Wn},ui=30,hr=12,Ba=function(t,n){var r,s,d,g,y,z,P,$,_e,Te,Le,Et,kt,rn,Ut,Dn,Vn,ln,_t,vn,on,qt,yn,br,Kt;r=t.state,s=t.next_in,br=t.input,d=s+(t.avail_in-5),g=t.next_out,Kt=t.output,y=g-(n-t.avail_out),z=g+(t.avail_out-257),P=r.dmax,$=r.wsize,_e=r.whave,Te=r.wnext,Le=r.window,Et=r.hold,kt=r.bits,rn=r.lencode,Ut=r.distcode,Dn=(1<<r.lenbits)-1,Vn=(1<<r.distbits)-1;e:do{kt<15&&(Et+=br[s++]<<kt,kt+=8,Et+=br[s++]<<kt,kt+=8),ln=rn[Et&Dn];t:for(;;){if(_t=ln>>>24,Et>>>=_t,kt-=_t,_t=ln>>>16&255,_t===0)Kt[g++]=ln&65535;else if(_t&16){vn=ln&65535,_t&=15,_t&&(kt<_t&&(Et+=br[s++]<<kt,kt+=8),vn+=Et&(1<<_t)-1,Et>>>=_t,kt-=_t),kt<15&&(Et+=br[s++]<<kt,kt+=8,Et+=br[s++]<<kt,kt+=8),ln=Ut[Et&Vn];n:for(;;){if(_t=ln>>>24,Et>>>=_t,kt-=_t,_t=ln>>>16&255,_t&16){if(on=ln&65535,_t&=15,kt<_t&&(Et+=br[s++]<<kt,kt+=8,kt<_t&&(Et+=br[s++]<<kt,kt+=8)),on+=Et&(1<<_t)-1,on>P){t.msg="invalid distance too far back",r.mode=ui;break e}if(Et>>>=_t,kt-=_t,_t=g-y,on>_t){if(_t=on-_t,_t>_e&&r.sane){t.msg="invalid distance too far back",r.mode=ui;break e}if(qt=0,yn=Le,Te===0){if(qt+=$-_t,_t<vn){vn-=_t;do Kt[g++]=Le[qt++];while(--_t);qt=g-on,yn=Kt}}else if(Te<_t){if(qt+=$+Te-_t,_t-=Te,_t<vn){vn-=_t;do Kt[g++]=Le[qt++];while(--_t);if(qt=0,Te<vn){_t=Te,vn-=_t;do Kt[g++]=Le[qt++];while(--_t);qt=g-on,yn=Kt}}}else if(qt+=Te-_t,_t<vn){vn-=_t;do Kt[g++]=Le[qt++];while(--_t);qt=g-on,yn=Kt}for(;vn>2;)Kt[g++]=yn[qt++],Kt[g++]=yn[qt++],Kt[g++]=yn[qt++],vn-=3;vn&&(Kt[g++]=yn[qt++],vn>1&&(Kt[g++]=yn[qt++]))}else{qt=g-on;do Kt[g++]=Kt[qt++],Kt[g++]=Kt[qt++],Kt[g++]=Kt[qt++],vn-=3;while(vn>2);vn&&(Kt[g++]=Kt[qt++],vn>1&&(Kt[g++]=Kt[qt++]))}}else if((_t&64)===0){ln=Ut[(ln&65535)+(Et&(1<<_t)-1)];continue n}else{t.msg="invalid distance code",r.mode=ui;break e}break}}else if((_t&64)===0){ln=rn[(ln&65535)+(Et&(1<<_t)-1)];continue t}else if(_t&32){r.mode=hr;break e}else{t.msg="invalid literal/length code",r.mode=ui;break e}break}}while(s<d&&g<z);vn=kt>>3,s-=vn,kt-=vn<<3,Et&=(1<<kt)-1,t.next_in=s,t.next_out=g,t.avail_in=s<d?5+(d-s):5-(s-d),t.avail_out=g<z?257+(z-g):257-(g-z),r.hold=Et,r.bits=kt},j=15,X=852,ye=592,De=0,xe=1,Qe=2,st=[3,4,5,6,7,8,9,10,11,13,15,17,19,23,27,31,35,43,51,59,67,83,99,115,131,163,195,227,258,0,0],Ke=[16,16,16,16,16,16,16,16,17,17,17,17,18,18,18,18,19,19,19,19,20,20,20,20,21,21,21,21,16,72,78],et=[1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0],je=[16,16,16,16,17,17,18,18,19,19,20,20,21,21,22,22,23,23,24,24,25,25,26,26,27,27,28,28,29,29,64,64],Rt=function(t,n,r,s,d,g,y,z){var P=z.bits,$=0,_e=0,Te=0,Le=0,Et=0,kt=0,rn=0,Ut=0,Dn=0,Vn=0,ln,_t,vn,on,qt,yn=null,br=0,Kt,us=new it.Buf16(j+1),qu=new it.Buf16(j+1),Ku=null,kg=0,Rg,Ju,Zu;for($=0;$<=j;$++)us[$]=0;for(_e=0;_e<s;_e++)us[n[r+_e]]++;for(Et=P,Le=j;Le>=1&&us[Le]===0;Le--);if(Et>Le&&(Et=Le),Le===0)return d[g++]=1<<24|64<<16|0,d[g++]=1<<24|64<<16|0,z.bits=1,0;for(Te=1;Te<Le&&us[Te]===0;Te++);for(Et<Te&&(Et=Te),Ut=1,$=1;$<=j;$++)if(Ut<<=1,Ut-=us[$],Ut<0)return-1;if(Ut>0&&(t===De||Le!==1))return-1;for(qu[1]=0,$=1;$<j;$++)qu[$+1]=qu[$]+us[$];for(_e=0;_e<s;_e++)n[r+_e]!==0&&(y[qu[n[r+_e]]++]=_e);if(t===De?(yn=Ku=y,Kt=19):t===xe?(yn=st,br-=257,Ku=Ke,kg-=257,Kt=256):(yn=et,Ku=je,Kt=-1),Vn=0,_e=0,$=Te,qt=g,kt=Et,rn=0,vn=-1,Dn=1<<Et,on=Dn-1,t===xe&&Dn>X||t===Qe&&Dn>ye)return 1;for(;;){Rg=$-rn,y[_e]<Kt?(Ju=0,Zu=y[_e]):y[_e]>Kt?(Ju=Ku[kg+y[_e]],Zu=yn[br+y[_e]]):(Ju=32+64,Zu=0),ln=1<<$-rn,_t=1<<kt,Te=_t;do _t-=ln,d[qt+(Vn>>rn)+_t]=Rg<<24|Ju<<16|Zu|0;while(_t!==0);for(ln=1<<$-1;Vn&ln;)ln>>=1;if(ln!==0?(Vn&=ln-1,Vn+=ln):Vn=0,_e++,--us[$]===0){if($===Le)break;$=n[r+y[_e]]}if($>Et&&(Vn&on)!==vn){for(rn===0&&(rn=Et),qt+=Te,kt=$-rn,Ut=1<<kt;kt+rn<Le&&(Ut-=us[kt+rn],!(Ut<=0));)kt++,Ut<<=1;if(Dn+=1<<kt,t===xe&&Dn>X||t===Qe&&Dn>ye)return 1;vn=Vn&on,d[vn]=Et<<24|kt<<16|qt-g|0}}return Vn!==0&&(d[qt+Vn]=$-rn<<24|64<<16|0),z.bits=Et,0},Mt=Ba,xt=Rt,bn=0,$i=1,Zn=2,Qr=4,ao=5,Ma=6,ta=0,Ur=1,ul=2,fi=-2,Eo=-3,bs=-4,fl=-5,as=8,ys=1,Da=2,Ws=3,Es=4,Xc=5,yc=6,Qc=7,eu=8,Td=9,Id=10,Su=11,Gs=12,pf=13,Pd=14,gf=15,Nd=16,kd=17,Rd=18,xd=19,Cu=20,Au=21,Bd=22,Md=23,Dd=24,Fd=25,Ld=26,vf=27,Vd=28,$d=29,Or=30,Ud=31,Rv=32,xv=852,Bv=592,Mv=15,Dv=Mv;function Hd(e){return(e>>>24&255)+(e>>>8&65280)+((e&65280)<<8)+((e&255)<<24)}function Fv(){this.mode=0,this.last=!1,this.wrap=0,this.havedict=!1,this.flags=0,this.dmax=0,this.check=0,this.total=0,this.head=null,this.wbits=0,this.wsize=0,this.whave=0,this.wnext=0,this.window=null,this.hold=0,this.bits=0,this.length=0,this.offset=0,this.extra=0,this.lencode=null,this.distcode=null,this.lenbits=0,this.distbits=0,this.ncode=0,this.nlen=0,this.ndist=0,this.have=0,this.next=null,this.lens=new it.Buf16(320),this.work=new it.Buf16(288),this.lendyn=null,this.distdyn=null,this.sane=0,this.back=0,this.was=0}function jd(e){var t;return!e||!e.state?fi:(t=e.state,e.total_in=e.total_out=t.total=0,e.msg="",t.wrap&&(e.adler=t.wrap&1),t.mode=ys,t.last=0,t.havedict=0,t.dmax=32768,t.head=null,t.hold=0,t.bits=0,t.lencode=t.lendyn=new it.Buf32(xv),t.distcode=t.distdyn=new it.Buf32(Bv),t.sane=1,t.back=-1,ta)}function zd(e){var t;return!e||!e.state?fi:(t=e.state,t.wsize=0,t.whave=0,t.wnext=0,jd(e))}function Wd(e,t){var n,r;return!e||!e.state||(r=e.state,t<0?(n=0,t=-t):(n=(t>>4)+1,t<48&&(t&=15)),t&&(t<8||t>15))?fi:(r.window!==null&&r.wbits!==t&&(r.window=null),r.wrap=n,r.wbits=t,zd(e))}function Gd(e,t){var n,r;return e?(r=new Fv,e.state=r,r.window=null,n=Wd(e,t),n!==ta&&(e.state=null),n):fi}function Lv(e){return Gd(e,Dv)}var Yd=!0,mf,_f;function Vv(e){if(Yd){var t;for(mf=new it.Buf32(512),_f=new it.Buf32(32),t=0;t<144;)e.lens[t++]=8;for(;t<256;)e.lens[t++]=9;for(;t<280;)e.lens[t++]=7;for(;t<288;)e.lens[t++]=8;for(xt($i,e.lens,0,288,mf,0,e.work,{bits:9}),t=0;t<32;)e.lens[t++]=5;xt(Zn,e.lens,0,32,_f,0,e.work,{bits:5}),Yd=!1}e.lencode=mf,e.lenbits=9,e.distcode=_f,e.distbits=5}function qd(e,t,n,r){var s,d=e.state;return d.window===null&&(d.wsize=1<<d.wbits,d.wnext=0,d.whave=0,d.window=new it.Buf8(d.wsize)),r>=d.wsize?(it.arraySet(d.window,t,n-d.wsize,d.wsize,0),d.wnext=0,d.whave=d.wsize):(s=d.wsize-d.wnext,s>r&&(s=r),it.arraySet(d.window,t,n-r,s,d.wnext),r-=s,r?(it.arraySet(d.window,t,n-r,r,0),d.wnext=r,d.whave=d.wsize):(d.wnext+=s,d.wnext===d.wsize&&(d.wnext=0),d.whave<d.wsize&&(d.whave+=s))),0}function $v(e,t){var n,r,s,d,g,y,z,P,$,_e,Te,Le,Et,kt,rn=0,Ut,Dn,Vn,ln,_t,vn,on,qt,yn=new it.Buf8(4),br,Kt,us=[16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15];if(!e||!e.state||!e.output||!e.input&&e.avail_in!==0)return fi;n=e.state,n.mode===Gs&&(n.mode=pf),g=e.next_out,s=e.output,z=e.avail_out,d=e.next_in,r=e.input,y=e.avail_in,P=n.hold,$=n.bits,_e=y,Te=z,qt=ta;e:for(;;)switch(n.mode){case ys:if(n.wrap===0){n.mode=pf;break}for(;$<16;){if(y===0)break e;y--,P+=r[d++]<<$,$+=8}if(n.wrap&2&&P===35615){n.check=0,yn[0]=P&255,yn[1]=P>>>8&255,n.check=dr(n.check,yn,2,0),P=0,$=0,n.mode=Da;break}if(n.flags=0,n.head&&(n.head.done=!1),!(n.wrap&1)||(((P&255)<<8)+(P>>8))%31){e.msg="incorrect header check",n.mode=Or;break}if((P&15)!==as){e.msg="unknown compression method",n.mode=Or;break}if(P>>>=4,$-=4,on=(P&15)+8,n.wbits===0)n.wbits=on;else if(on>n.wbits){e.msg="invalid window size",n.mode=Or;break}n.dmax=1<<on,e.adler=n.check=1,n.mode=P&512?Id:Gs,P=0,$=0;break;case Da:for(;$<16;){if(y===0)break e;y--,P+=r[d++]<<$,$+=8}if(n.flags=P,(n.flags&255)!==as){e.msg="unknown compression method",n.mode=Or;break}if(n.flags&57344){e.msg="unknown header flags set",n.mode=Or;break}n.head&&(n.head.text=P>>8&1),n.flags&512&&(yn[0]=P&255,yn[1]=P>>>8&255,n.check=dr(n.check,yn,2,0)),P=0,$=0,n.mode=Ws;case Ws:for(;$<32;){if(y===0)break e;y--,P+=r[d++]<<$,$+=8}n.head&&(n.head.time=P),n.flags&512&&(yn[0]=P&255,yn[1]=P>>>8&255,yn[2]=P>>>16&255,yn[3]=P>>>24&255,n.check=dr(n.check,yn,4,0)),P=0,$=0,n.mode=Es;case Es:for(;$<16;){if(y===0)break e;y--,P+=r[d++]<<$,$+=8}n.head&&(n.head.xflags=P&255,n.head.os=P>>8),n.flags&512&&(yn[0]=P&255,yn[1]=P>>>8&255,n.check=dr(n.check,yn,2,0)),P=0,$=0,n.mode=Xc;case Xc:if(n.flags&1024){for(;$<16;){if(y===0)break e;y--,P+=r[d++]<<$,$+=8}n.length=P,n.head&&(n.head.extra_len=P),n.flags&512&&(yn[0]=P&255,yn[1]=P>>>8&255,n.check=dr(n.check,yn,2,0)),P=0,$=0}else n.head&&(n.head.extra=null);n.mode=yc;case yc:if(n.flags&1024&&(Le=n.length,Le>y&&(Le=y),Le&&(n.head&&(on=n.head.extra_len-n.length,n.head.extra||(n.head.extra=new Array(n.head.extra_len)),it.arraySet(n.head.extra,r,d,Le,on)),n.flags&512&&(n.check=dr(n.check,r,Le,d)),y-=Le,d+=Le,n.length-=Le),n.length))break e;n.length=0,n.mode=Qc;case Qc:if(n.flags&2048){if(y===0)break e;Le=0;do on=r[d+Le++],n.head&&on&&n.length<65536&&(n.head.name+=String.fromCharCode(on));while(on&&Le<y);if(n.flags&512&&(n.check=dr(n.check,r,Le,d)),y-=Le,d+=Le,on)break e}else n.head&&(n.head.name=null);n.length=0,n.mode=eu;case eu:if(n.flags&4096){if(y===0)break e;Le=0;do on=r[d+Le++],n.head&&on&&n.length<65536&&(n.head.comment+=String.fromCharCode(on));while(on&&Le<y);if(n.flags&512&&(n.check=dr(n.check,r,Le,d)),y-=Le,d+=Le,on)break e}else n.head&&(n.head.comment=null);n.mode=Td;case Td:if(n.flags&512){for(;$<16;){if(y===0)break e;y--,P+=r[d++]<<$,$+=8}if(P!==(n.check&65535)){e.msg="header crc mismatch",n.mode=Or;break}P=0,$=0}n.head&&(n.head.hcrc=n.flags>>9&1,n.head.done=!0),e.adler=n.check=0,n.mode=Gs;break;case Id:for(;$<32;){if(y===0)break e;y--,P+=r[d++]<<$,$+=8}e.adler=n.check=Hd(P),P=0,$=0,n.mode=Su;case Su:if(n.havedict===0)return e.next_out=g,e.avail_out=z,e.next_in=d,e.avail_in=y,n.hold=P,n.bits=$,ul;e.adler=n.check=1,n.mode=Gs;case Gs:if(t===ao||t===Ma)break e;case pf:if(n.last){P>>>=$&7,$-=$&7,n.mode=vf;break}for(;$<3;){if(y===0)break e;y--,P+=r[d++]<<$,$+=8}switch(n.last=P&1,P>>>=1,$-=1,P&3){case 0:n.mode=Pd;break;case 1:if(Vv(n),n.mode=Cu,t===Ma){P>>>=2,$-=2;break e}break;case 2:n.mode=kd;break;case 3:e.msg="invalid block type",n.mode=Or}P>>>=2,$-=2;break;case Pd:for(P>>>=$&7,$-=$&7;$<32;){if(y===0)break e;y--,P+=r[d++]<<$,$+=8}if((P&65535)!==(P>>>16^65535)){e.msg="invalid stored block lengths",n.mode=Or;break}if(n.length=P&65535,P=0,$=0,n.mode=gf,t===Ma)break e;case gf:n.mode=Nd;case Nd:if(Le=n.length,Le){if(Le>y&&(Le=y),Le>z&&(Le=z),Le===0)break e;it.arraySet(s,r,d,Le,g),y-=Le,d+=Le,z-=Le,g+=Le,n.length-=Le;break}n.mode=Gs;break;case kd:for(;$<14;){if(y===0)break e;y--,P+=r[d++]<<$,$+=8}if(n.nlen=(P&31)+257,P>>>=5,$-=5,n.ndist=(P&31)+1,P>>>=5,$-=5,n.ncode=(P&15)+4,P>>>=4,$-=4,n.nlen>286||n.ndist>30){e.msg="too many length or distance symbols",n.mode=Or;break}n.have=0,n.mode=Rd;case Rd:for(;n.have<n.ncode;){for(;$<3;){if(y===0)break e;y--,P+=r[d++]<<$,$+=8}n.lens[us[n.have++]]=P&7,P>>>=3,$-=3}for(;n.have<19;)n.lens[us[n.have++]]=0;if(n.lencode=n.lendyn,n.lenbits=7,br={bits:n.lenbits},qt=xt(bn,n.lens,0,19,n.lencode,0,n.work,br),n.lenbits=br.bits,qt){e.msg="invalid code lengths set",n.mode=Or;break}n.have=0,n.mode=xd;case xd:for(;n.have<n.nlen+n.ndist;){for(;rn=n.lencode[P&(1<<n.lenbits)-1],Ut=rn>>>24,Dn=rn>>>16&255,Vn=rn&65535,!(Ut<=$);){if(y===0)break e;y--,P+=r[d++]<<$,$+=8}if(Vn<16)P>>>=Ut,$-=Ut,n.lens[n.have++]=Vn;else{if(Vn===16){for(Kt=Ut+2;$<Kt;){if(y===0)break e;y--,P+=r[d++]<<$,$+=8}if(P>>>=Ut,$-=Ut,n.have===0){e.msg="invalid bit length repeat",n.mode=Or;break}on=n.lens[n.have-1],Le=3+(P&3),P>>>=2,$-=2}else if(Vn===17){for(Kt=Ut+3;$<Kt;){if(y===0)break e;y--,P+=r[d++]<<$,$+=8}P>>>=Ut,$-=Ut,on=0,Le=3+(P&7),P>>>=3,$-=3}else{for(Kt=Ut+7;$<Kt;){if(y===0)break e;y--,P+=r[d++]<<$,$+=8}P>>>=Ut,$-=Ut,on=0,Le=11+(P&127),P>>>=7,$-=7}if(n.have+Le>n.nlen+n.ndist){e.msg="invalid bit length repeat",n.mode=Or;break}for(;Le--;)n.lens[n.have++]=on}}if(n.mode===Or)break;if(n.lens[256]===0){e.msg="invalid code -- missing end-of-block",n.mode=Or;break}if(n.lenbits=9,br={bits:n.lenbits},qt=xt($i,n.lens,0,n.nlen,n.lencode,0,n.work,br),n.lenbits=br.bits,qt){e.msg="invalid literal/lengths set",n.mode=Or;break}if(n.distbits=6,n.distcode=n.distdyn,br={bits:n.distbits},qt=xt(Zn,n.lens,n.nlen,n.ndist,n.distcode,0,n.work,br),n.distbits=br.bits,qt){e.msg="invalid distances set",n.mode=Or;break}if(n.mode=Cu,t===Ma)break e;case Cu:n.mode=Au;case Au:if(y>=6&&z>=258){e.next_out=g,e.avail_out=z,e.next_in=d,e.avail_in=y,n.hold=P,n.bits=$,Mt(e,Te),g=e.next_out,s=e.output,z=e.avail_out,d=e.next_in,r=e.input,y=e.avail_in,P=n.hold,$=n.bits,n.mode===Gs&&(n.back=-1);break}for(n.back=0;rn=n.lencode[P&(1<<n.lenbits)-1],Ut=rn>>>24,Dn=rn>>>16&255,Vn=rn&65535,!(Ut<=$);){if(y===0)break e;y--,P+=r[d++]<<$,$+=8}if(Dn&&(Dn&240)===0){for(ln=Ut,_t=Dn,vn=Vn;rn=n.lencode[vn+((P&(1<<ln+_t)-1)>>ln)],Ut=rn>>>24,Dn=rn>>>16&255,Vn=rn&65535,!(ln+Ut<=$);){if(y===0)break e;y--,P+=r[d++]<<$,$+=8}P>>>=ln,$-=ln,n.back+=ln}if(P>>>=Ut,$-=Ut,n.back+=Ut,n.length=Vn,Dn===0){n.mode=Ld;break}if(Dn&32){n.back=-1,n.mode=Gs;break}if(Dn&64){e.msg="invalid literal/length code",n.mode=Or;break}n.extra=Dn&15,n.mode=Bd;case Bd:if(n.extra){for(Kt=n.extra;$<Kt;){if(y===0)break e;y--,P+=r[d++]<<$,$+=8}n.length+=P&(1<<n.extra)-1,P>>>=n.extra,$-=n.extra,n.back+=n.extra}n.was=n.length,n.mode=Md;case Md:for(;rn=n.distcode[P&(1<<n.distbits)-1],Ut=rn>>>24,Dn=rn>>>16&255,Vn=rn&65535,!(Ut<=$);){if(y===0)break e;y--,P+=r[d++]<<$,$+=8}if((Dn&240)===0){for(ln=Ut,_t=Dn,vn=Vn;rn=n.distcode[vn+((P&(1<<ln+_t)-1)>>ln)],Ut=rn>>>24,Dn=rn>>>16&255,Vn=rn&65535,!(ln+Ut<=$);){if(y===0)break e;y--,P+=r[d++]<<$,$+=8}P>>>=ln,$-=ln,n.back+=ln}if(P>>>=Ut,$-=Ut,n.back+=Ut,Dn&64){e.msg="invalid distance code",n.mode=Or;break}n.offset=Vn,n.extra=Dn&15,n.mode=Dd;case Dd:if(n.extra){for(Kt=n.extra;$<Kt;){if(y===0)break e;y--,P+=r[d++]<<$,$+=8}n.offset+=P&(1<<n.extra)-1,P>>>=n.extra,$-=n.extra,n.back+=n.extra}if(n.offset>n.dmax){e.msg="invalid distance too far back",n.mode=Or;break}n.mode=Fd;case Fd:if(z===0)break e;if(Le=Te-z,n.offset>Le){if(Le=n.offset-Le,Le>n.whave&&n.sane){e.msg="invalid distance too far back",n.mode=Or;break}Le>n.wnext?(Le-=n.wnext,Et=n.wsize-Le):Et=n.wnext-Le,Le>n.length&&(Le=n.length),kt=n.window}else kt=s,Et=g-n.offset,Le=n.length;Le>z&&(Le=z),z-=Le,n.length-=Le;do s[g++]=kt[Et++];while(--Le);n.length===0&&(n.mode=Au);break;case Ld:if(z===0)break e;s[g++]=n.length,z--,n.mode=Au;break;case vf:if(n.wrap){for(;$<32;){if(y===0)break e;y--,P|=r[d++]<<$,$+=8}if(Te-=z,e.total_out+=Te,n.total+=Te,Te&&(e.adler=n.check=n.flags?dr(n.check,s,Te,g-Te):Hs(n.check,s,Te,g-Te)),Te=z,(n.flags?P:Hd(P))!==n.check){e.msg="incorrect data check",n.mode=Or;break}P=0,$=0}n.mode=Vd;case Vd:if(n.wrap&&n.flags){for(;$<32;){if(y===0)break e;y--,P+=r[d++]<<$,$+=8}if(P!==(n.total&4294967295)){e.msg="incorrect length check",n.mode=Or;break}P=0,$=0}n.mode=$d;case $d:qt=Ur;break e;case Or:qt=Eo;break e;case Ud:return bs;case Rv:default:return fi}return e.next_out=g,e.avail_out=z,e.next_in=d,e.avail_in=y,n.hold=P,n.bits=$,(n.wsize||Te!==e.avail_out&&n.mode<Or&&(n.mode<vf||t!==Qr))&&qd(e,e.output,e.next_out,Te-e.avail_out),_e-=e.avail_in,Te-=e.avail_out,e.total_in+=_e,e.total_out+=Te,n.total+=Te,n.wrap&&Te&&(e.adler=n.check=n.flags?dr(n.check,s,Te,e.next_out-Te):Hs(n.check,s,Te,e.next_out-Te)),e.data_type=n.bits+(n.last?64:0)+(n.mode===Gs?128:0)+(n.mode===Cu||n.mode===gf?256:0),(_e===0&&Te===0||t===Qr)&&qt===ta&&(qt=fl),qt}function Uv(e){if(!e||!e.state)return fi;var t=e.state;return t.window&&(t.window=null),e.state=null,ta}function Hv(e,t){var n;return!e||!e.state||(n=e.state,(n.wrap&2)===0)?fi:(n.head=t,t.done=!1,ta)}function jv(e,t){var n=t.length,r,s,d;return!e||!e.state||(r=e.state,r.wrap!==0&&r.mode!==Su)?fi:r.mode===Su&&(s=1,s=Hs(s,t,n,0),s!==r.check)?Eo:(d=qd(e,t,n,n),d?(r.mode=Ud,bs):(r.havedict=1,ta))}var zv=zd,Wv=Wd,Gv=jd,Yv=Lv,qv=Gd,Kv=$v,Jv=Uv,Zv=Hv,Xv=jv,Qv="pako inflate (from Nodeca project)",em={inflateReset:zv,inflateReset2:Wv,inflateResetKeep:Gv,inflateInit:Yv,inflateInit2:qv,inflate:Kv,inflateEnd:Jv,inflateGetHeader:Zv,inflateSetDictionary:Xv,inflateInfo:Qv},tm={Z_NO_FLUSH:0,Z_PARTIAL_FLUSH:1,Z_SYNC_FLUSH:2,Z_FULL_FLUSH:3,Z_FINISH:4,Z_BLOCK:5,Z_TREES:6,Z_OK:0,Z_STREAM_END:1,Z_NEED_DICT:2,Z_ERRNO:-1,Z_STREAM_ERROR:-2,Z_DATA_ERROR:-3,Z_BUF_ERROR:-5,Z_NO_COMPRESSION:0,Z_BEST_SPEED:1,Z_BEST_COMPRESSION:9,Z_DEFAULT_COMPRESSION:-1,Z_FILTERED:1,Z_HUFFMAN_ONLY:2,Z_RLE:3,Z_FIXED:4,Z_DEFAULT_STRATEGY:0,Z_BINARY:0,Z_TEXT:1,Z_UNKNOWN:2,Z_DEFLATED:8};function nm(){this.text=0,this.time=0,this.xflags=0,this.os=0,this.extra=null,this.extra_len=0,this.name="",this.comment="",this.hcrc=0,this.done=!1}var rm=nm,Ec=em,Hr=tm,im=rm,Kd=Object.prototype.toString;function Ul(e){if(!(this instanceof Ul))return new Ul(e);this.options=it.assign({chunkSize:16384,windowBits:0,to:""},e||{});var t=this.options;t.raw&&t.windowBits>=0&&t.windowBits<16&&(t.windowBits=-t.windowBits,t.windowBits===0&&(t.windowBits=-15)),t.windowBits>=0&&t.windowBits<16&&!(e&&e.windowBits)&&(t.windowBits+=32),t.windowBits>15&&t.windowBits<48&&(t.windowBits&15)===0&&(t.windowBits|=15),this.err=0,this.msg="",this.ended=!1,this.chunks=[],this.strm=new x,this.strm.avail_out=0;var n=Ec.inflateInit2(this.strm,t.windowBits);if(n!==Hr.Z_OK)throw new Error(ha[n]);if(this.header=new im,Ec.inflateGetHeader(this.strm,this.header),t.dictionary&&(typeof t.dictionary=="string"?t.dictionary=$t.string2buf(t.dictionary):Kd.call(t.dictionary)==="[object ArrayBuffer]"&&(t.dictionary=new Uint8Array(t.dictionary)),t.raw&&(n=Ec.inflateSetDictionary(this.strm,t.dictionary),n!==Hr.Z_OK)))throw new Error(ha[n])}Ul.prototype.push=function(e,t){var n=this.strm,r=this.options.chunkSize,s=this.options.dictionary,d,g,y,z,P,$=!1;if(this.ended)return!1;g=t===~~t?t:t===!0?Hr.Z_FINISH:Hr.Z_NO_FLUSH,typeof e=="string"?n.input=$t.binstring2buf(e):Kd.call(e)==="[object ArrayBuffer]"?n.input=new Uint8Array(e):n.input=e,n.next_in=0,n.avail_in=n.input.length;do{if(n.avail_out===0&&(n.output=new it.Buf8(r),n.next_out=0,n.avail_out=r),d=Ec.inflate(n,Hr.Z_NO_FLUSH),d===Hr.Z_NEED_DICT&&s&&(d=Ec.inflateSetDictionary(this.strm,s)),d===Hr.Z_BUF_ERROR&&$===!0&&(d=Hr.Z_OK,$=!1),d!==Hr.Z_STREAM_END&&d!==Hr.Z_OK)return this.onEnd(d),this.ended=!0,!1;n.next_out&&(n.avail_out===0||d===Hr.Z_STREAM_END||n.avail_in===0&&(g===Hr.Z_FINISH||g===Hr.Z_SYNC_FLUSH))&&(this.options.to==="string"?(y=$t.utf8border(n.output,n.next_out),z=n.next_out-y,P=$t.buf2string(n.output,y),n.next_out=z,n.avail_out=r-z,z&&it.arraySet(n.output,n.output,y,z,0),this.onData(P)):this.onData(it.shrinkBuf(n.output,n.next_out))),n.avail_in===0&&n.avail_out===0&&($=!0)}while((n.avail_in>0||n.avail_out===0)&&d!==Hr.Z_STREAM_END);return d===Hr.Z_STREAM_END&&(g=Hr.Z_FINISH),g===Hr.Z_FINISH?(d=Ec.inflateEnd(this.strm),this.onEnd(d),this.ended=!0,d===Hr.Z_OK):(g===Hr.Z_SYNC_FLUSH&&(this.onEnd(Hr.Z_OK),n.avail_out=0),!0)},Ul.prototype.onData=function(e){this.chunks.push(e)},Ul.prototype.onEnd=function(e){e===Hr.Z_OK&&(this.options.to==="string"?this.result=this.chunks.join(""):this.result=it.flattenChunks(this.chunks)),this.chunks=[],this.err=e,this.msg=this.strm.msg};function bf(e,t){var n=new Ul(t);if(n.push(e,!0),n.err)throw n.msg||ha[n.err];return n.result}function om(e,t){return t=t||{},t.raw=!0,bf(e,t)}var am=Ul,sm=bf,lm=om,cm=bf,um={Inflate:am,inflate:sm,inflateRaw:lm,ungzip:cm},fm=Vo,dm=um,hm=it.assign,Jd={};hm(Jd,fm,dm,Hr);var Zd=Jd;let pm="upx2px",gm=[{name:"upx",type:[Number,String],required:!0}],vm=1e-4,mm=750,Xd=!1,yf=0,Qd=0,eh=960,th=375;function _m(){let{platform:e,pixelRatio:t,windowWidth:n}=ia();yf=n,Qd=t,Xd=e==="ios"}function nh(e,t){let n=Number(e);return isNaN(n)?t:n}function bm(){let e=I.globalStyle||{};eh=nh(e.rpxCalcMaxDeviceWidth,960),th=nh(e.rpxCalcBaseDeviceWidth,375)}let ym=Dt(pm,(e,t)=>{if(yf===0&&(_m(),bm()),e=Number(e),e===0)return 0;let n=t||yf;n=n<=eh?n:th;let r=e/mm*n;return r<0&&(r=-r),r=Math.floor(r+vm),r===0&&(Qd===1||!Xd?r=1:r=.5),e<0?-r:r},gm),Em="addInterceptor",wm="removeInterceptor",rh=[{name:"method",type:[String,Object],required:!0}],Sm=rh;function ih(e,t){Object.keys(t).forEach(n=>{Q.isFunction(t[n])&&(e[n]=Cm(e[n],t[n]))})}function oh(e,t){!e||!t||Object.keys(t).forEach(n=>{let r=e[n],s=t[n];Q.isArray(r)&&Q.isFunction(s)&&Q.remove(r,s)})}function Cm(e,t){let n=t?e?e.concat(t):Q.isArray(t)?t:[t]:e;return n&&Am(n)}function Am(e){let t=[];for(let n=0;n<e.length;n++)t.indexOf(e[n])===-1&&t.push(e[n]);return t}let Om=Dt(Em,(e,t)=>{Q.isString(e)&&Q.isPlainObject(t)?ih(ni[e]||(ni[e]={}),t):Q.isPlainObject(e)&&ih(pi,e)},rh),Tm=Dt(wm,(e,t)=>{Q.isString(e)?Q.isPlainObject(t)?oh(ni[e],t):delete ni[e]:Q.isPlainObject(e)&&oh(pi,e)},Sm),Im={},Pm="$on",ah=[{name:"event",type:String,required:!0},{name:"callback",type:Function,required:!0}],Nm="$once",km=ah,Rm="$off",xm=[{name:"event",type:[String,Array]},{name:"callback",type:Function}],Bm="$emit",Mm=[{name:"event",type:String,required:!0}],Hl=new ae.Emitter,Dm=Dt(Pm,(e,t)=>(Hl.on(e,t),()=>Hl.off(e,t)),ah),Fm=Dt(Nm,(e,t)=>(Hl.once(e,t),()=>Hl.off(e,t)),km),Lm=Dt(Rm,(e,t)=>{if(!e){Hl.e={};return}Q.isArray(e)||(e=[e]),e.forEach(n=>Hl.off(n,t))},xm),Vm=Dt(Bm,(e,...t)=>{Hl.emit(e,...t)},Mm),sh=[{name:"id",type:String,required:!0}],$m="createVideoContext",Um="createMapContext",Hm=sh,jm="createCanvasContext",zm=[{name:"canvasId",type:String,required:!0},{name:"componentInstance",type:Object}],Wm="createInnerAudioContext",Gm="createLivePusherContext",Ym=sh.concat({name:"componentInstance",type:Object}),qm=[.5,.8,1,1.25,1.5,2];class Ef{constructor(t,n){this.id=t,this.pageId=n}play(){On(this.id,this.pageId,"play")}pause(){On(this.id,this.pageId,"pause")}stop(){On(this.id,this.pageId,"stop")}seek(t){On(this.id,this.pageId,"seek",{position:t})}sendDanmu(t){On(this.id,this.pageId,"sendDanmu",t)}playbackRate(t){~qm.indexOf(t)||(t=1),On(this.id,this.pageId,"playbackRate",{rate:t})}requestFullScreen(t={}){On(this.id,this.pageId,"requestFullScreen",t)}exitFullScreen(){On(this.id,this.pageId,"exitFullScreen")}showStatusBar(){On(this.id,this.pageId,"showStatusBar")}hideStatusBar(){On(this.id,this.pageId,"hideStatusBar")}}let Km=Dt($m,(e,t)=>t?new Ef(e,nr(t)):new Ef(e,nr(xr()))),Jm=(e,t)=>{let n=t.errMsg||"";new RegExp("\\:\\s*fail").test(n)?e.fail&&e.fail(t):e.success&&e.success(t),e.complete&&e.complete(t)},so=(e,t,n,r)=>{Ja(e,t,n,r,s=>{r&&Jm(r,s)})};class wf{constructor(t,n){this.id=t,this.pageId=n}getCenterLocation(t){so(this.id,this.pageId,"getCenterLocation",t)}moveToLocation(t){so(this.id,this.pageId,"moveToLocation",t)}getScale(t){so(this.id,this.pageId,"getScale",t)}getRegion(t){so(this.id,this.pageId,"getRegion",t)}includePoints(t){so(this.id,this.pageId,"includePoints",t)}translateMarker(t){so(this.id,this.pageId,"translateMarker",t)}$getAppMap(){return c.maps.getMapById(this.pageId+"-map-"+this.id)}addCustomLayer(t){so(this.id,this.pageId,"addCustomLayer",t)}removeCustomLayer(t){so(this.id,this.pageId,"removeCustomLayer",t)}addGroundOverlay(t){so(this.id,this.pageId,"addGroundOverlay",t)}removeGroundOverlay(t){so(this.id,this.pageId,"removeGroundOverlay",t)}updateGroundOverlay(t){so(this.id,this.pageId,"updateGroundOverlay",t)}initMarkerCluster(t){so(this.id,this.pageId,"initMarkerCluster",t)}addMarkers(t){so(this.id,this.pageId,"addMarkers",t)}removeMarkers(t){so(this.id,this.pageId,"removeMarkers",t)}moveAlong(t){so(this.id,this.pageId,"moveAlong",t)}openMapApp(t){so(this.id,this.pageId,"openMapApp",t)}on(t){so(this.id,this.pageId,"on",t)}}let Zm=Dt(Um,(e,t)=>t?new wf(e,nr(t)):new wf(e,nr(xr())),Hm);function dl(e,t){return function(n,r){n?r[e]=Math.round(n):typeof t!="undefined"&&(r[e]=t)}}let lh=dl("width"),ch=dl("height"),Xm="canvasGetImageData",uh={formatArgs:{x:dl("x"),y:dl("y"),width:lh,height:ch}},fh={canvasId:{type:String,required:!0},x:{type:Number,required:!0},y:{type:Number,required:!0},width:{type:Number,required:!0},height:{type:Number,required:!0}},Qm="canvasPutImageData",e_=uh,t_=Q.extend({data:{type:Uint8ClampedArray,required:!0}},fh,{height:{type:Number}}),dh={PNG:"png",JPG:"jpg",JPEG:"jpg"},n_="canvasToTempFilePath",r_={formatArgs:{x:dl("x",0),y:dl("y",0),width:lh,height:ch,destWidth:dl("destWidth"),destHeight:dl("destHeight"),fileType(e,t){e=(e||"").toUpperCase();let n=dh[e];n||(n=dh.PNG),t.fileType=n},quality(e,t){t.quality=e&&e>0&&e<1?e:1}}},i_={x:Number,y:Number,width:Number,height:Number,destWidth:Number,destHeight:Number,canvasId:{type:String,required:!0},fileType:String,quality:Number};function Ou(e,t,n,r,s){bt.invokeViewMethod(`canvas.${e}`,{type:n,data:r},t,d=>{s&&s(d)})}var o_=["scale","rotate","translate","setTransform","transform"],a_=["drawImage","fillText","fill","stroke","fillRect","strokeRect","clearRect","strokeText"],s_=["setFillStyle","setTextAlign","setStrokeStyle","setGlobalAlpha","setShadow","setFontSize","setLineCap","setLineJoin","setLineWidth","setMiterLimit","setTextBaseline","setLineDash"];function l_(e,t){let r=document.createElement("canvas").getContext("2d");return r.font=t,r.measureText(e).width||0}let hh={aliceblue:"#f0f8ff",antiquewhite:"#faebd7",aqua:"#00ffff",aquamarine:"#7fffd4",azure:"#f0ffff",beige:"#f5f5dc",bisque:"#ffe4c4",black:"#000000",blanchedalmond:"#ffebcd",blue:"#0000ff",blueviolet:"#8a2be2",brown:"#a52a2a",burlywood:"#deb887",cadetblue:"#5f9ea0",chartreuse:"#7fff00",chocolate:"#d2691e",coral:"#ff7f50",cornflowerblue:"#6495ed",cornsilk:"#fff8dc",crimson:"#dc143c",cyan:"#00ffff",darkblue:"#00008b",darkcyan:"#008b8b",darkgoldenrod:"#b8860b",darkgray:"#a9a9a9",darkgrey:"#a9a9a9",darkgreen:"#006400",darkkhaki:"#bdb76b",darkmagenta:"#8b008b",darkolivegreen:"#556b2f",darkorange:"#ff8c00",darkorchid:"#9932cc",darkred:"#8b0000",darksalmon:"#e9967a",darkseagreen:"#8fbc8f",darkslateblue:"#483d8b",darkslategray:"#2f4f4f",darkslategrey:"#2f4f4f",darkturquoise:"#00ced1",darkviolet:"#9400d3",deeppink:"#ff1493",deepskyblue:"#00bfff",dimgray:"#696969",dimgrey:"#696969",dodgerblue:"#1e90ff",firebrick:"#b22222",floralwhite:"#fffaf0",forestgreen:"#228b22",fuchsia:"#ff00ff",gainsboro:"#dcdcdc",ghostwhite:"#f8f8ff",gold:"#ffd700",goldenrod:"#daa520",gray:"#808080",grey:"#808080",green:"#008000",greenyellow:"#adff2f",honeydew:"#f0fff0",hotpink:"#ff69b4",indianred:"#cd5c5c",indigo:"#4b0082",ivory:"#fffff0",khaki:"#f0e68c",lavender:"#e6e6fa",lavenderblush:"#fff0f5",lawngreen:"#7cfc00",lemonchiffon:"#fffacd",lightblue:"#add8e6",lightcoral:"#f08080",lightcyan:"#e0ffff",lightgoldenrodyellow:"#fafad2",lightgray:"#d3d3d3",lightgrey:"#d3d3d3",lightgreen:"#90ee90",lightpink:"#ffb6c1",lightsalmon:"#ffa07a",lightseagreen:"#20b2aa",lightskyblue:"#87cefa",lightslategray:"#778899",lightslategrey:"#778899",lightsteelblue:"#b0c4de",lightyellow:"#ffffe0",lime:"#00ff00",limegreen:"#32cd32",linen:"#faf0e6",magenta:"#ff00ff",maroon:"#800000",mediumaquamarine:"#66cdaa",mediumblue:"#0000cd",mediumorchid:"#ba55d3",mediumpurple:"#9370db",mediumseagreen:"#3cb371",mediumslateblue:"#7b68ee",mediumspringgreen:"#00fa9a",mediumturquoise:"#48d1cc",mediumvioletred:"#c71585",midnightblue:"#191970",mintcream:"#f5fffa",mistyrose:"#ffe4e1",moccasin:"#ffe4b5",navajowhite:"#ffdead",navy:"#000080",oldlace:"#fdf5e6",olive:"#808000",olivedrab:"#6b8e23",orange:"#ffa500",orangered:"#ff4500",orchid:"#da70d6",palegoldenrod:"#eee8aa",palegreen:"#98fb98",paleturquoise:"#afeeee",palevioletred:"#db7093",papayawhip:"#ffefd5",peachpuff:"#ffdab9",peru:"#cd853f",pink:"#ffc0cb",plum:"#dda0dd",powderblue:"#b0e0e6",purple:"#800080",rebeccapurple:"#663399",red:"#ff0000",rosybrown:"#bc8f8f",royalblue:"#4169e1",saddlebrown:"#8b4513",salmon:"#fa8072",sandybrown:"#f4a460",seagreen:"#2e8b57",seashell:"#fff5ee",sienna:"#a0522d",silver:"#c0c0c0",skyblue:"#87ceeb",slateblue:"#6a5acd",slategray:"#708090",slategrey:"#708090",snow:"#fffafa",springgreen:"#00ff7f",steelblue:"#4682b4",tan:"#d2b48c",teal:"#008080",thistle:"#d8bfd8",tomato:"#ff6347",turquoise:"#40e0d0",violet:"#ee82ee",wheat:"#f5deb3",white:"#ffffff",whitesmoke:"#f5f5f5",yellow:"#ffff00",yellowgreen:"#9acd32",transparent:"#00000000"};function Sf(e){e=e||"#000000";var t=null;if((t=/^#([0-9|A-F|a-f]{6})$/.exec(e))!=null){let r=parseInt(t[1].slice(0,2),16),s=parseInt(t[1].slice(2,4),16),d=parseInt(t[1].slice(4),16);return[r,s,d,255]}if((t=/^#([0-9|A-F|a-f]{3})$/.exec(e))!=null){let r=t[1].slice(0,1),s=t[1].slice(1,2),d=t[1].slice(2,3);return r=parseInt(r+r,16),s=parseInt(s+s,16),d=parseInt(d+d,16),[r,s,d,255]}if((t=/^rgb\((.+)\)$/.exec(e))!=null)return t[1].split(",").map(function(r){return Math.min(255,parseInt(r.trim()))}).concat(255);if((t=/^rgba\((.+)\)$/.exec(e))!=null)return t[1].split(",").map(function(r,s){return s===3?Math.floor(255*parseFloat(r.trim())):Math.min(255,parseInt(r.trim()))});var n=e.toLowerCase();if(Q.hasOwn(hh,n)){t=/^#([0-9|A-F|a-f]{6,8})$/.exec(hh[n]);let r=parseInt(t[1].slice(0,2),16),s=parseInt(t[1].slice(2,4),16),d=parseInt(t[1].slice(4,6),16),g=parseInt(t[1].slice(6,8),16);return g=g>=0?g:255,[r,s,d,g]}return console.error("unsupported color:"+e),[0,0,0,255]}class ph{constructor(t,n){this.type=t,this.data=n,this.colorStop=[]}addColorStop(t,n){this.colorStop.push([t,Sf(n)])}}class c_{constructor(t,n){this.type="pattern",this.data=t,this.colorStop=n}}class u_{constructor(t){this.width=t}}class tu{constructor(t,n){this.id=t,this.pageId=n,this.actions=[],this.path=[],this.subpath=[],this.drawingState=[],this.state={lineDash:[0,0],shadowOffsetX:0,shadowOffsetY:0,shadowBlur:0,shadowColor:[0,0,0,0],font:"10px sans-serif",fontSize:10,fontWeight:"normal",fontStyle:"normal",fontFamily:"sans-serif"}}draw(t=!1,n){var r=[...this.actions];this.actions=[],this.path=[],Ou(this.id,this.pageId,"actionsChanged",{actions:r,reserve:t},n)}createLinearGradient(t,n,r,s){return new ph("linear",[t,n,r,s])}createCircularGradient(t,n,r){return new ph("radial",[t,n,r])}createPattern(t,n){if(n===void 0)console.error("Failed to execute 'createPattern' on 'CanvasContext': 2 arguments required, but only 1 present.");else if(["repeat","repeat-x","repeat-y","no-repeat"].indexOf(n)<0)console.error("Failed to execute 'createPattern' on 'CanvasContext': The provided type ('"+n+"') is not one of 'repeat', 'no-repeat', 'repeat-x', or 'repeat-y'.");else return new c_(t,n)}measureText(t){let n=this.state.font,r=0;{let s=c.webview.all().find(d=>d.getURL().endsWith("www/__uniappview.html"));s&&(r=Number(s.evalJSSync(`(${l_.toString()})(${JSON.stringify(t)},${JSON.stringify(n)})`)))}return new u_(r)}save(){this.actions.push({method:"save",data:[]}),this.drawingState.push(this.state)}restore(){this.actions.push({method:"restore",data:[]}),this.state=this.drawingState.pop()||{lineDash:[0,0],shadowOffsetX:0,shadowOffsetY:0,shadowBlur:0,shadowColor:[0,0,0,0],font:"10px sans-serif",fontSize:10,fontWeight:"normal",fontStyle:"normal",fontFamily:"sans-serif"}}beginPath(){this.path=[],this.subpath=[],this.path.push({method:"beginPath",data:[]})}moveTo(t,n){this.path.push({method:"moveTo",data:[t,n]}),this.subpath=[[t,n]]}lineTo(t,n){this.path.length===0&&this.subpath.length===0?this.path.push({method:"moveTo",data:[t,n]}):this.path.push({method:"lineTo",data:[t,n]}),this.subpath.push([t,n])}quadraticCurveTo(t,n,r,s){this.path.push({method:"quadraticCurveTo",data:[t,n,r,s]}),this.subpath.push([r,s])}bezierCurveTo(t,n,r,s,d,g){this.path.push({method:"bezierCurveTo",data:[t,n,r,s,d,g]}),this.subpath.push([d,g])}arc(t,n,r,s,d,g=!1){this.path.push({method:"arc",data:[t,n,r,s,d,g]}),this.subpath.push([t,n])}rect(t,n,r,s){this.path.push({method:"rect",data:[t,n,r,s]}),this.subpath=[[t,n]]}arcTo(t,n,r,s,d){this.path.push({method:"arcTo",data:[t,n,r,s,d]}),this.subpath.push([r,s])}clip(){this.actions.push({method:"clip",data:[...this.path]})}closePath(){this.path.push({method:"closePath",data:[]}),this.subpath.length&&(this.subpath=[this.subpath.shift()])}clearActions(){this.actions=[],this.path=[],this.subpath=[]}getActions(){var t=[...this.actions];return this.clearActions(),t}set lineDashOffset(t){this.actions.push({method:"setLineDashOffset",data:[t]})}set globalCompositeOperation(t){this.actions.push({method:"setGlobalCompositeOperation",data:[t]})}set shadowBlur(t){this.actions.push({method:"setShadowBlur",data:[t]})}set shadowColor(t){this.actions.push({method:"setShadowColor",data:[t]})}set shadowOffsetX(t){this.actions.push({method:"setShadowOffsetX",data:[t]})}set shadowOffsetY(t){this.actions.push({method:"setShadowOffsetY",data:[t]})}set font(t){var n=this;this.state.font=t;var r=t.match(/^(([\w\-]+\s)*)(\d+r?px)(\/(\d+\.?\d*(r?px)?))?\s+(.*)/);if(r){var s=r[1].trim().split(/\s/),d=parseFloat(r[3]),g=r[7],y=[];s.forEach(function(P,$){["italic","oblique","normal"].indexOf(P)>-1?(y.push({method:"setFontStyle",data:[P]}),n.state.fontStyle=P):["bold","normal"].indexOf(P)>-1?(y.push({method:"setFontWeight",data:[P]}),n.state.fontWeight=P):$===0?(y.push({method:"setFontStyle",data:["normal"]}),n.state.fontStyle="normal"):$===1&&z()}),s.length===1&&z(),s=y.map(function(P){return P.data[0]}).join(" "),this.state.fontSize=d,this.state.fontFamily=g,this.actions.push({method:"setFont",data:[`${s} ${d}px ${g}`]})}else console.warn("Failed to set 'font' on 'CanvasContext': invalid format.");function z(){y.push({method:"setFontWeight",data:["normal"]}),n.state.fontWeight="normal"}}get font(){return this.state.font}set fillStyle(t){this.setFillStyle(t)}set strokeStyle(t){this.setStrokeStyle(t)}set globalAlpha(t){t=Math.floor(255*parseFloat(t)),this.actions.push({method:"setGlobalAlpha",data:[t]})}set textAlign(t){this.actions.push({method:"setTextAlign",data:[t]})}set lineCap(t){this.actions.push({method:"setLineCap",data:[t]})}set lineJoin(t){this.actions.push({method:"setLineJoin",data:[t]})}set lineWidth(t){this.actions.push({method:"setLineWidth",data:[t]})}set miterLimit(t){this.actions.push({method:"setMiterLimit",data:[t]})}set textBaseline(t){this.actions.push({method:"setTextBaseline",data:[t]})}}let f_=ae.once(()=>{[...o_,...a_].forEach(function(e){function t(n){switch(n){case"fill":case"stroke":return function(){this.actions.push({method:n+"Path",data:[...this.path]})};case"fillRect":return function(r,s,d,g){this.actions.push({method:"fillPath",data:[{method:"rect",data:[r,s,d,g]}]})};case"strokeRect":return function(r,s,d,g){this.actions.push({method:"strokePath",data:[{method:"rect",data:[r,s,d,g]}]})};case"fillText":case"strokeText":return function(r,s,d,g){var y=[r.toString(),s,d];typeof g=="number"&&y.push(g),this.actions.push({method:n,data:y})};case"drawImage":return function(r,s,d,g,y,z,P,$,_e){_e===void 0&&(z=s,P=d,$=g,_e=y,s=void 0,d=void 0,g=void 0,y=void 0);var Te;function Le(Et){return typeof Et=="number"}Te=Le(s)&&Le(d)&&Le(g)&&Le(y)?[r,z,P,$,_e,s,d,g,y]:Le($)&&Le(_e)?[r,z,P,$,_e]:[r,z,P],this.actions.push({method:n,data:Te})};default:return function(...r){this.actions.push({method:n,data:r})}}}tu.prototype[e]=t(e)}),s_.forEach(function(e){function t(n){switch(n){case"setFillStyle":case"setStrokeStyle":return function(r){typeof r!="object"?this.actions.push({method:n,data:["normal",Sf(r)]}):this.actions.push({method:n,data:[r.type,r.data,r.colorStop]})};case"setGlobalAlpha":return function(r){r=Math.floor(255*parseFloat(r)),this.actions.push({method:n,data:[r]})};case"setShadow":return function(r,s,d,g){g=Sf(g),this.actions.push({method:n,data:[r,s,d,g]}),this.state.shadowBlur=d,this.state.shadowColor=g,this.state.shadowOffsetX=r,this.state.shadowOffsetY=s};case"setLineDash":return function(r,s){r=r||[0,0],s=s||0,this.actions.push({method:n,data:[r,s]}),this.state.lineDash=r};case"setFontSize":return function(r){this.state.font=this.state.font.replace(/\d+\.?\d*px/,r+"px"),this.state.fontSize=r,this.actions.push({method:n,data:[r]})};default:return function(...r){this.actions.push({method:n,data:r})}}}tu.prototype[e]=t(e)})}),d_=Dt(jm,(e,t)=>{if(f_(),t)return new tu(e,nr(t));let n=nr(xr());if(n)return new tu(e,n);bt.emit(ae.ON_ERROR,"createCanvasContext:fail")},zm),h_=Re(Xm,({canvasId:e,x:t,y:n,width:r,height:s},{resolve:d,reject:g})=>{let y=nr(xr());if(!y){g();return}function z(P){if(P.errMsg&&P.errMsg.indexOf("fail")!==-1){g("",P);return}let $=P.data;$&&$.length&&(P.compressed&&($=Zd.inflateRaw($)),P.data=new Uint8ClampedArray($)),delete P.compressed,d(P)}Ou(e,y,"getImageData",{x:t,y:n,width:r,height:s},z)},fh,uh),p_=Re(Qm,({canvasId:e,data:t,x:n,y:r,width:s,height:d},{resolve:g,reject:y})=>{var z=nr(xr());if(!z){y();return}let P,$=()=>{Ou(e,z,"putImageData",{data:t,x:n,y:r,width:s,height:d,compressed:P},_e=>{if(_e.errMsg&&_e.errMsg.indexOf("fail")!==-1){y();return}g(_e)})};c.os.name!=="iOS"||typeof __WEEX_DEVTOOL__=="boolean"?(t=Zd.deflateRaw(t,{to:"string"}),P=!0):t=Array.prototype.slice.call(t),$()},t_,e_),g_=Re(n_,({x:e=0,y:t=0,width:n,height:r,destWidth:s,destHeight:d,canvasId:g,fileType:y,quality:z},{resolve:P,reject:$})=>{var _e=nr(xr());if(!_e){$();return}let Te=`${Si}/canvas`;Ou(g,_e,"toTempFilePath",{x:e,y:t,width:n,height:r,destWidth:s,destHeight:d,fileType:y,quality:z,dirname:Te},Le=>{if(Le.errMsg&&Le.errMsg.indexOf("fail")!==-1){$("",Le);return}P(Le)})},i_,r_),gh=["onCanplay","onPlay","onPause","onStop","onEnded","onTimeUpdate","onError","onWaiting","onSeeking","onSeeked"],v_=["offCanplay","offPlay","offPause","offStop","offEnded","offTimeUpdate","offError","offWaiting","offSeeking","offSeeked"],m_={thresholds:[0],initialRatio:0,observeAll:!1},__=["top","right","bottom","left"],b_=1;function vh(e={}){return __.map(t=>`${Number(e[t])||0}px`).join(" ")}class mh{constructor(t,n){this._pageId=nr(t),this._component=t,this._options=Q.extend({},m_,n)}relativeTo(t,n){return this._options.relativeToSelector=t,this._options.rootMargin=vh(n),this}relativeToViewport(t){return this._options.relativeToSelector=void 0,this._options.rootMargin=vh(t),this}observe(t,n){!Q.isFunction(n)||(this._options.selector=t,this._reqId=b_++,wi({reqId:this._reqId,component:this._component,options:this._options,callback:n},this._pageId))}disconnect(){this._reqId&&$r({reqId:this._reqId,component:this._component},this._pageId)}}let y_=Dt("createIntersectionObserver",(e,t)=>(e=ae.resolveComponentInstance(e),e&&!nr(e)&&(t=e,e=null),e?new mh(e,t):new mh(xr(),t))),E_=1;class _h{constructor(t){this._pageId=t.$page&&t.$page.id,this._component=t}observe(t,n){!Q.isFunction(n)||(this._reqId=E_++,Fi({reqId:this._reqId,component:this._component,options:t,callback:n},this._pageId))}disconnect(){this._reqId&&ds({reqId:this._reqId,component:this._component},this._pageId)}}let w_=Dt("createMediaQueryObserver",e=>(e=ae.resolveComponentInstance(e),e&&!nr(e)&&(e=null),e?new _h(e):new _h(xr()))),S_=0,Cf={};function C_(e,t,n,r){let s={options:r},d=r&&("success"in r||"fail"in r||"complete"in r);if(d){let g=String(S_++);s.callbackId=g,Cf[g]=r}bt.invokeViewMethod(`editor.${e}`,{type:n,data:s},t,({callbackId:g,data:y})=>{d&&(ae.callOptions(Cf[g],y),delete Cf[g])})}class A_{constructor(t,n){this.id=t,this.pageId=n}format(t,n){this._exec("format",{name:t,value:n})}insertDivider(){this._exec("insertDivider")}insertImage(t){this._exec("insertImage",t)}insertText(t){this._exec("insertText",t)}setContents(t){this._exec("setContents",t)}getContents(t){this._exec("getContents",t)}clear(t){this._exec("clear",t)}removeFormat(t){this._exec("removeFormat",t)}undo(t){this._exec("undo",t)}redo(t){this._exec("redo",t)}blur(t){this._exec("blur",t)}getSelectionText(t){this._exec("getSelectionText",t)}scrollIntoView(t){this._exec("scrollIntoView",t)}_exec(t,n){C_(this.id,this.pageId,t,n)}}let O_={canvas:tu,map:wf,video:Ef,editor:A_};function bh(e){if(e&&e.contextInfo){let{id:t,type:n,page:r}=e.contextInfo,s=O_[n];e.context=new s(t,r),delete e.contextInfo}}class Af{constructor(t,n,r,s){this._selectorQuery=t,this._component=n,this._selector=r,this._single=s}boundingClientRect(t){return this._selectorQuery._push(this._selector,this._component,this._single,{id:!0,dataset:!0,rect:!0,size:!0},t),this._selectorQuery}fields(t,n){return this._selectorQuery._push(this._selector,this._component,this._single,t,n),this._selectorQuery}scrollOffset(t){return this._selectorQuery._push(this._selector,this._component,this._single,{id:!0,dataset:!0,scrollOffset:!0},t),this._selectorQuery}context(t){return this._selectorQuery._push(this._selector,this._component,this._single,{context:!0},t),this._selectorQuery}node(t){return this._selectorQuery}}class T_{constructor(t){this._component=void 0,this._page=t,this._queue=[],this._queueCb=[]}exec(t){return To(this._page,this._queue,n=>{let r=this._queueCb;n.forEach((s,d)=>{Q.isArray(s)?s.forEach(bh):bh(s);let g=r[d];Q.isFunction(g)&&g.call(this,s)}),Q.isFunction(t)&&t.call(this,n)}),this._nodesRef}in(t){return this._component=ae.resolveComponentInstance(t),this}select(t){return this._nodesRef=new Af(this,this._component,t,!0)}selectAll(t){return this._nodesRef=new Af(this,this._component,t,!1)}selectViewport(){return this._nodesRef=new Af(this,null,"",!0)}_push(t,n,r,s,d){this._queue.push({component:n,selector:t,single:r,fields:s}),this._queueCb.push(d)}}let I_=Dt("createSelectorQuery",e=>(e=ae.resolveComponentInstance(e),e&&!nr(e)&&(e=null),new T_(e||xr()))),P_="createAnimation",N_={formatArgs:{}},k_={duration:Number,timingFunction:String,delay:Number,transformOrigin:String},R_={duration:400,timingFunction:"linear",delay:0,transformOrigin:"50% 50% 0"};class yh{constructor(t){this.actions=[],this.currentTransform={},this.currentStepAnimates=[],this.option=Q.extend({},R_,t)}_getOption(t){let n={transition:Q.extend({},this.option,t),transformOrigin:""};return n.transformOrigin=n.transition.transformOrigin,delete n.transition.transformOrigin,n}_pushAnimates(t,n){this.currentStepAnimates.push({type:t,args:n})}_converType(t){return t.replace(/[A-Z]/g,n=>`-${n.toLowerCase()}`)}_getValue(t){return typeof t=="number"?`${t}px`:t}export(){let t=this.actions;return this.actions=[],{actions:t}}step(t){return this.currentStepAnimates.forEach(n=>{n.type!=="style"?this.currentTransform[n.type]=n:this.currentTransform[`${n.type}.${n.args[0]}`]=n}),this.actions.push({animates:Object.values(this.currentTransform),option:this._getOption(t)}),this.currentStepAnimates=[],this}}let x_=ae.once(()=>{let e=["matrix","matrix3d","rotate","rotate3d","rotateX","rotateY","rotateZ","scale","scale3d","scaleX","scaleY","scaleZ","skew","skewX","skewY","translate","translate3d","translateX","translateY","translateZ"],t=["opacity","backgroundColor"],n=["width","height","left","right","top","bottom"];e.concat(t,n).forEach(r=>{yh.prototype[r]=function(...s){return t.concat(n).includes(r)?this._pushAnimates("style",[this._converType(r),n.includes(r)?this._getValue(s[0]):s[0]]):this._pushAnimates(r,s),this}})}),B_=Dt(P_,e=>(x_(),new yh(e)),k_,N_),Eh="onTabBarMidButtonTap",M_=Nn(Eh,()=>{}),D_="onWindowResize",F_="offWindowResize",L_=Nn(D_,()=>{}),V_=lr(F_,()=>{}),wh="setLocale",$_="getLocale",Sh="onLocaleChange",nu=Dt($_,()=>{let e=En({allowDefault:!0});return e&&e.$vm?e.$vm.$locale:Z().getLocale()}),U_=Nn(Sh,()=>{}),H_=Dt(wh,e=>{let t=En();return t&&t.$vm.$locale!==e?(t.$vm.$locale=e,Gn().forEach(s=>{bt.publishHandler(wh,e,s.$page.id)}),v.requireModule("plus").setLanguage(e),bt.invokeOnCallback(Sh,{locale:e}),!0):!1}),j_=Re("setPageMeta",(e,{resolve:t})=>{t(Bi(xr(),e))}),Ch="getSelectedTextRange",z_=Re(Ch,(e,{resolve:t,reject:n})=>{bt.invokeViewMethod(Ch,{},ca(),r=>{typeof r.end=="undefined"&&typeof r.start=="undefined"?n("no focused"):t(r)})}),Tu={[ae.ON_UNHANDLE_REJECTION]:[],[ae.ON_PAGE_NOT_FOUND]:[],[ae.ON_ERROR]:[],[ae.ON_SHOW]:[],[ae.ON_HIDE]:[]};function ru(e,t){let n=En({allowDefault:!0});if(n&&n.$vm)return hn.injectHook(e,t,n.$vm.$);Tu[e].push(t)}function W_(e){Object.keys(Tu).forEach(t=>{Tu[t].forEach(n=>{hn.injectHook(t,n,e)})})}function iu(e,t){let n=En({allowDefault:!0});if(n&&n.$vm)return Ei(n.$vm,e,t);Q.remove(Tu[e],t)}function G_(e){ru(ae.ON_UNHANDLE_REJECTION,e)}function Y_(e){iu(ae.ON_UNHANDLE_REJECTION,e)}function q_(e){ru(ae.ON_PAGE_NOT_FOUND,e)}function K_(e){iu(ae.ON_PAGE_NOT_FOUND,e)}function J_(e){ru(ae.ON_ERROR,e)}function Z_(e){iu(ae.ON_ERROR,e)}function X_(e){ru(ae.ON_SHOW,e)}function Q_(e){iu(ae.ON_SHOW,e)}function eb(e){ru(ae.ON_HIDE,e)}function tb(e){iu(ae.ON_HIDE,e)}let nb=Dt("getEnterOptionsSync",()=>Ds()),rb=Dt("getLaunchOptionsSync",()=>Xa()),ou,Of,Tf,Ah;function Oh(e){try{return JSON.parse(e)}catch(t){}return e}function If(e){if(e.type==="enabled")Tf=!0,Ah=e.offline;else if(e.type==="clientId")ou=e.cid,Of=e.errMsg,Th(ou,e.errMsg);else if(e.type==="pushMsg"){let t={type:"receive",data:Oh(e.message)};for(let n=0;n<hl.length&&(hl[n](t),!t.stopped);n++);}else e.type==="click"&&hl.forEach(t=>{t({type:"click",data:Oh(e.message)})})}let Pf=[];function Th(e,t){Pf.forEach(n=>{n(e,t)}),Pf.length=0}let ib=Re("getPushClientId",(e,{resolve:t,reject:n})=>{if(Ah){c.push.getClientInfoAsync(r=>{t({cid:r.clientid})},r=>{n(r.code+": "+r.message)});return}Promise.resolve().then(()=>{typeof Tf=="undefined"&&(Tf=!1,ou="",Of="uniPush is not enabled"),Pf.push((r,s)=>{r?t({cid:r}):n(s)}),typeof ou!="undefined"&&Th(ou,Of)})}),hl=[],Ih=!1,ob=e=>{hl.indexOf(e)===-1&&hl.push(e),Ih||(Ih=!0,c.push.addEventListener("click",t=>{If({type:"click",message:t})}),c.push.addEventListener("receive",t=>{If({type:"pushMsg",message:t})}))},ab=e=>{if(!e)hl.length=0;else{let t=hl.indexOf(e);t>-1&&hl.splice(t,1)}},sb="canIUse",lb=[{name:"schema",type:String,required:!0}],cb="getBackgroundAudioManager",ub="makePhoneCall",fb={phoneNumber:String},db="addPhoneContact",hb={formatArgs:{firstName(e){if(!e)return"addPhoneContact:fail parameter error: parameter.firstName should not be empty;"}}},pb={firstName:{type:String,required:!0},photoFilePath:String,nickName:String,lastName:String,middleName:String,remark:String,mobilePhoneNumber:String,weChatNumber:String,addressCountry:String,addressState:String,addressCity:String,addressStreet:String,addressPostalCode:String,organization:String,title:String,workFaxNumber:String,workPhoneNumber:String,hostNumber:String,email:String,url:String,workAddressCountry:String,workAddressState:String,workAddressCity:String,workAddressStreet:String,workAddressPostalCode:String,homeFaxNumber:String,homePhoneNumber:String,homeAddressCountry:String,homeAddressState:String,homeAddressCity:String,homeAddressStreet:String,homeAddressPostalCode:String},gb="getClipboardData",vb="setClipboardData",mb={formatArgs:{showToast:!0},beforeInvoke(){Po()},beforeSuccess(e,t){if(!t.showToast)return;let{t:n}=Z(),r=n("uni.setClipboardData.success");r&&se.showToast({title:r,icon:"success",mask:!1})}},_b={data:{type:String,required:!0},showToast:{type:Boolean}},Ph="onAccelerometer",bb="offAccelerometer",yb="startAccelerometer",Eb="stopAccelerometer",Nh="onCompass",wb="offCompass",Sb="startCompass",Cb="stopCompass",Ab="vibrateShort",Ob="vibrateLong",kh="onBluetoothDeviceFound",Rh="onBluetoothAdapterStateChange",xh="onBLEConnectionStateChange",Bh="onBLECharacteristicValueChange",Tb="startBluetoothDevicesDiscovery",Ib={services:Array,allowDuplicatesKey:Boolean,interval:Number},Pb="getConnectedBluetoothDevices",Nb={services:{type:Array,required:!0}},kb="createBLEConnection",Rb={deviceId:{type:String,required:!0}},xb="closeBLEConnection",Bb={deviceId:{type:String,required:!0}},Mb="getBLEDeviceServices",Db={deviceId:{type:String,required:!0}},Fb="getBLEDeviceCharacteristics",Lb={deviceId:{type:String,required:!0},serviceId:{type:String,required:!0}},Vb="notifyBLECharacteristicValueChange",$b={deviceId:{type:String,required:!0},serviceId:{type:String,required:!0},characteristicId:{type:String,required:!0},state:{type:Boolean,required:!0}},Ub="readBLECharacteristicValue",Hb={deviceId:{type:String,required:!0},serviceId:{type:String,required:!0},characteristicId:{type:String,required:!0}},jb="writeBLECharacteristicValue",zb={deviceId:{type:String,required:!0},serviceId:{type:String,required:!0},characteristicId:{type:String,required:!0},value:{type:Array,required:!0}},Wb="setBLEMTU",Gb={deviceId:{type:String,required:!0},mtu:{type:Number,required:!0}},Yb="getBLEDeviceRSSI",qb={deviceId:{type:String,required:!0}},Mh="onBeaconUpdate",Dh="onBeaconServiceChange",Kb="getBeacons",Jb="startBeaconDiscovery",Zb={uuids:{type:Array,required:!0}},Xb="stopBeaconDiscovery",Qb="getScreenBrightness",e0="setScreenBrightness",t0="setKeepScreenOn",n0="soterAuthentication",r0="checkIsSoterEnrolledInDevice",i0=["fingerPrint","facial","speech"],o0={formatArgs:{checkAuthMode(e,t){if(!e||!i0.includes(e))return"checkAuthMode \u586B\u5199\u9519\u8BEF"}}},a0={checkAuthMode:String},s0="checkIsSoterEnrolledInDevice",l0={formatArgs:{requestAuthModes(e,t){if(!e.includes("fingerPrint")&&!e.includes("facial"))return"requestAuthModes \u586B\u5199\u9519\u8BEF"}}},c0={requestAuthModes:{type:Array,required:!0},challenge:String,authContent:String},u0="scanCode",f0={onlyFromCamera:Boolean,scanType:Array,autoDecodeCharSet:Boolean,sound:String,autoZoom:Boolean},d0=["default","none"],h0={formatArgs:{sound(e,t){d0.includes(e)||(t.sound="none")},autoZoom(e,t){typeof e=="undefined"&&(t.autoZoom=!0)}}},p0="getSystemSetting",g0="getAppAuthorizeSetting",v0="openAppAuthorizeSetting",m0="getStorage",Fh={key:{type:String,required:!0}},_0="getStorageSync",Lh=[{name:"key",type:String,required:!0}],b0="setStorage",y0={key:{type:String,required:!0},data:{required:!0}},E0="setStorageSync",w0=[{name:"key",type:String,required:!0},{name:"data",required:!0}],Vh="removeStorage",S0=Fh,C0=Lh,A0="saveFile",O0={formatArgs:{tempFilePath(e,t){t.tempFilePath=St(e)}}},T0={tempFilePath:{type:String,required:!0}},I0="getSavedFileList",P0="removeSavedFile",N0={formatArgs:{filePath(e,t){t.filePath=St(e)}}},k0={filePath:{type:String,required:!0}},R0="getFileInfo",x0={formatArgs:{filePath(e,t){t.filePath=St(e)}}},B0={filePath:{type:String,required:!0}},M0="getSavedFileInfo",D0={formatArgs:{filePath(e,t){t.filePath=St(e)}}},F0={filePath:{type:String,required:!0}},L0="openDocument",V0={formatArgs:{filePath(e,t){t.filePath=St(e)}}},$0={filePath:{type:String,required:!0},fileType:String},U0="hideKeyboard",H0="showKeyboard",j0="chooseLocation",z0={keyword:String,latitude:Number,longitude:Number},W0="getLocation",$h=["wgs84","gcj02"],G0={formatArgs:{type(e,t){e=(e||"").toLowerCase(),$h.indexOf(e)===-1?t.type=$h[0]:t.type=e},altitude(e,t){t.altitude=e||!1}}},Y0={type:String,altitude:Boolean},q0="openLocation",Uh=(e,t)=>{if(t===void 0)return`${e} should not be empty.`;if(typeof t!="number"){let n=typeof t;return n=n[0].toUpperCase()+n.substring(1),`Expected Number, got ${n} with value ${JSON.stringify(t)}.`}},K0={formatArgs:{latitude(e,t){let n=Uh("latitude",e);if(n)return n;t.latitude=e},longitude(e,t){let n=Uh("longitude",e);if(n)return n;t.longitude=e},scale(e,t){e=Math.floor(e),t.scale=e>=5&&e<=18?e:18}}},J0={latitude:Number,longitude:Number,scale:Number,name:String,address:String},Z0="chooseImage",X0={formatArgs:{count(e,t){(!e||e<=0)&&(t.count=9)},sizeType(e,t){t.sizeType=Pn(e,Tr)},sourceType(e,t){t.sourceType=Pn(e,mn)},extension(e,t){if(e instanceof Array&&e.length===0)return"param extension should not be empty.";e||(t.extension=["*"])}}},Q0={count:Number,sizeType:[Array,String],sourceType:Array,extension:Array},ey="chooseVideo",ty={formatArgs:{sourceType(e,t){t.sourceType=Pn(e,mn)},compressed:!0,maxDuration:60,camera:"back",extension(e,t){if(e instanceof Array&&e.length===0)return"param extension should not be empty.";e||(t.extension=["*"])}}},ny={sourceType:Array,compressed:Boolean,maxDuration:Number,camera:String,extension:Array},ry="getImageInfo",iy={formatArgs:{src(e,t){t.src=St(e)}}},oy={src:{type:String,required:!0}},ay="previewImage",sy={formatArgs:{urls(e,t){t.urls=e.map(n=>Q.isString(n)&&n?St(n):"")},current(e,t){typeof e=="number"?t.current=e>0&&e<t.urls.length?e:0:Q.isString(e)&&e&&(t.current=St(e))}}},ly={urls:{type:Array,required:!0},current:{type:[Number,String]}},cy="closePreviewImage",uy="getVideoInfo",fy={formatArgs:{src(e,t){t.src=St(e)}}},dy={src:{type:String,required:!0}},hy="saveImageToPhotosAlbum",py={formatArgs:{filePath(e,t){t.filePath=St(e)}}},gy={filePath:{type:String,required:!0}},vy="saveVideoToPhotosAlbum",my={formatArgs:{filePath(e,t){t.filePath=St(e)}}},_y={filePath:{type:String,required:!0}},by="getRecorderManager",yy="compressImage",Ey={formatArgs:{src(e,t){t.src=St(e)}}},wy={src:{type:String,required:!0}},Sy="compressVideo",Cy={formatArgs:{src(e,t){t.src=St(e)}}},Ay={src:{type:String,required:!0},quality:String,bitrate:Number,fps:Number,resolution:Number},Oy="request",Ty={JSON:"json"},Iy=["text","arraybuffer"],Py="text",Hh=encodeURIComponent;function Ny(e,t){let n=e.split("#"),r=n[1]||"";n=n[0].split("?");let s=n[1]||"";e=n[0];let d=s.split("&").filter(y=>y),g={};d.forEach(y=>{let z=y.split("=");g[z[0]]=z[1]});for(let y in t)if(Q.hasOwn(t,y)){let z=t[y];typeof z=="undefined"||z===null?z="":Q.isPlainObject(z)&&(z=JSON.stringify(z)),g[Hh(y)]=Hh(z)}return s=Object.keys(g).map(y=>`${y}=${g[y]}`).join("&"),e+(s?"?"+s:"")+(r?"#"+r:"")}let ky={method:String,data:[Object,String,Array,ArrayBuffer],url:{type:String,required:!0},header:Object,dataType:String,responseType:String,withCredentials:Boolean},Ry={formatArgs:{method(e,t){t.method=an((e||"").toUpperCase(),Gt)},data(e,t){t.data=e||""},url(e,t){t.method===Gt[0]&&Q.isPlainObject(t.data)&&Object.keys(t.data).length&&(t.url=Ny(e,t.data))},header(e,t){let n=t.header=e||{};t.method!==Gt[0]&&(Object.keys(n).find(r=>r.toLowerCase()==="content-type")||(n["Content-Type"]="application/json"))},dataType(e,t){t.dataType=(e||Ty.JSON).toLowerCase()},responseType(e,t){t.responseType=(e||"").toLowerCase(),Iy.indexOf(t.responseType)===-1&&(t.responseType=Py)}}},xy="configMTLS",By={certificates:{type:Array,required:!0}},My={formatArgs:{certificates(e){if(e.some(t=>Q.toRawType(t.host)!=="String"))return"\u53C2\u6570\u914D\u7F6E\u9519\u8BEF\uFF0C\u8BF7\u786E\u8BA4\u540E\u91CD\u8BD5"}}},Dy="downloadFile",Fy={formatArgs:{header(e,t){t.header=e||{}}}},Ly={url:{type:String,required:!0},header:Object,timeout:Number},Vy="uploadFile",$y={formatArgs:{filePath(e,t){e&&(t.filePath=St(e))},header(e,t){t.header=e||{}},formData(e,t){t.formData=e||{}}}},Uy={url:{type:String,required:!0},files:Array,filePath:String,name:String,header:Object,formData:Object,timeout:Number},Hy="connectSocket",jy={formatArgs:{header(e,t){t.header=e||{}},method(e,t){t.method=an((e||"").toUpperCase(),Gt)},protocols(e,t){Q.isString(e)&&(t.protocols=[e])}}},zy={url:{type:String,required:!0},header:{type:Object},method:String,protocols:[Array,String]},Wy="sendSocketMessage",Gy={data:[String,ArrayBuffer]},Yy="closeSocket",qy={code:Number,reason:String};function Ky(e){if(!Q.isString(e))return e;let t=e.indexOf("?");if(t===-1)return e;let n=e.slice(t+1).trim().replace(/^(\?|#|&)/,"");if(!n)return e;e=e.slice(0,t);let r=[];return n.split("&").forEach(s=>{let d=s.replace(/\+/g," ").split("="),g=d.shift(),y=d.length>0?d.join("="):"";r.push(g+"="+encodeURIComponent(y))}),r.length?e+"?"+r.join("&"):e}let Jy=["slide-in-right","slide-in-left","slide-in-top","slide-in-bottom","fade-in","zoom-out","zoom-fade-out","pop-in","none"],Zy=["slide-out-right","slide-out-left","slide-out-top","slide-out-bottom","fade-out","zoom-in","zoom-fade-in","pop-out","none"],wc={url:{type:String,required:!0}},Nf="navigateTo",kf="redirectTo",jh="reLaunch",Iu="switchTab",Xy="navigateBack",Rf="preloadPage",zh="unPreloadPage",Qy=Q.extend({},wc,Wh(Jy)),eE=Q.extend({delta:{type:Number}},Wh(Zy)),tE=wc,nE=wc,rE=wc,iE=wc,oE=wc,aE=Nu(Nf),sE=Nu(kf),lE=Nu(jh),cE=Nu(Iu),uE={formatArgs:{delta(e,t){e=parseInt(e+"")||1,t.delta=Math.min(Gn().length-1,e)}}};function Wh(e){return{animationType:{type:String,validator(t){if(t&&e.indexOf(t)===-1)return"`"+t+"` is not supported for `animationType` (supported values are: `"+e.join("`|`")+"`)"}},animationDuration:{type:Number}}}let Pu;function fE(){Pu=""}function Nu(e){return{formatArgs:{url:dE(e)},beforeAll:fE}}function dE(e){return function(n,r){if(!n)return'Missing required args: "url"';n=yl(n);let s=n.split("?")[0],d=fo(s,!0);if(!d)return"page `"+n+"` is not found";if(e===Nf||e===kf){if(d.meta.isTabBar)return`can not ${e} a tabbar page`}else if(e===Iu&&!d.meta.isTabBar)return"can not switch to no-tabBar page";if((e===Iu||e===Rf)&&d.meta.isTabBar&&r.openType!=="appLaunch"&&(n=s),d.meta.isEntry&&(n=n.replace(d.alias,"/")),r.url=Ky(n),e!==zh){if(e===Rf){if(!d.meta.isNVue)return"can not preload vue page";if(d.meta.isTabBar){let g=Gn(),y=d.path.slice(1);if(g.find(z=>z.route===y))return"tabBar page `"+y+"` already exists"}return}if(Pu===n&&r.openType!=="appLaunch")return`${Pu} locked`;I.ready&&(Pu=n)}}}let hE="hideLoading",pE="hideToast",Gh="loadFontFace",gE={family:{type:String,required:!0},source:{type:String,required:!0},desc:Object},vE=["#ffffff","#000000"],mE="setNavigationBarColor",_E={formatArgs:{animation(e,t){e||(e={duration:0,timingFunc:"linear"}),t.animation={duration:e.duration||0,timingFunc:e.timingFunc||"linear"}}}},bE={frontColor:{type:String,required:!0,validator(e){if(vE.indexOf(e)===-1)return`invalid frontColor "${e}"`}},backgroundColor:{type:String,required:!0},animation:Object},yE="setNavigationBarTitle",EE={title:{type:String,required:!0}},wE="showNavigationBarLoading",SE="hideNavigationBarLoading",Yh="pageScrollTo",CE={scrollTop:Number,selector:String,duration:Number},AE={formatArgs:{duration:300}},OE="showActionSheet",TE={itemList:{type:Array,required:!0},title:String,itemColor:String,popover:Object},IE={formatArgs:{itemColor:"#000"}},PE="showLoading",NE={title:String,mask:Boolean},kE={formatArgs:{title:"",mask:!1}},RE="showModal",xE={title:String,content:String,showCancel:Boolean,cancelText:String,cancelColor:String,confirmText:String,confirmColor:String},BE={beforeInvoke(){_n()},formatArgs:{title:"",content:"",placeholderText:"",showCancel:!0,editable:!1,cancelText(e,t){if(!Q.hasOwn(t,"cancelText")){let{t:n}=Z();t.cancelText=n("uni.showModal.cancel")}},cancelColor:"#000",confirmText(e,t){if(!Q.hasOwn(t,"confirmText")){let{t:n}=Z();t.confirmText=n("uni.showModal.confirm")}},confirmColor:ae.PRIMARY_COLOR}},ME="showToast",DE=["success","loading","none","error"],FE={title:String,icon:String,image:String,duration:Number,mask:Boolean},LE={formatArgs:{title:"",icon(e,t){t.icon=an(e,DE)},image(e,t){e?t.image=St(e):t.image=""},duration:1500,mask:!1}},VE="startPullDownRefresh",$E="stopPullDownRefresh",au={index:{type:Number,required:!0}},pl={beforeInvoke(){let e=ko();if(e&&!e.isTabBar)return"not TabBar page"},formatArgs:{index(e){if(!I.tabBar.list[e])return"tabbar item not found"}}},UE="setTabBarItem",HE=Q.extend({text:String,iconPath:String,selectedIconPath:String,pagePath:String},au),jE={beforeInvoke:pl.beforeInvoke,formatArgs:Q.extend({pagePath(e,t){e&&(t.pagePath=ae.removeLeadingSlash(e))}},pl.formatArgs)},zE="setTabBarStyle",WE={color:String,selectedColor:String,backgroundColor:String,backgroundImage:String,backgroundRepeat:String,borderStyle:String},GE=/^(linear|radial)-gradient\(.+?\);?$/,YE={beforeInvoke:pl.beforeInvoke,formatArgs:{backgroundImage(e,t){e&&!GE.test(e)&&(t.backgroundImage=St(e))},borderStyle(e,t){e&&(t.borderStyle=e==="white"?"white":"black")}}},qE="hideTabBar",qh={animation:Boolean},KE="showTabBar",JE=qh,ZE="hideTabBarRedDot",XE=au,QE=pl,ew="showTabBarRedDot",tw=au,nw=pl,rw="removeTabBarBadge",iw=au,ow=pl,aw="setTabBarBadge",sw=Q.extend({text:{type:String,required:!0}},au),lw={beforeInvoke:pl.beforeInvoke,formatArgs:Q.extend({text(e,t){ae.getLen(e)>=4&&(t.text="...")}},pl.formatArgs)},cw="getProvider",uw={service:{type:String,required:!0}},fw="login",dw={provider:String,scopes:[String,Array],timeout:Number,univerifyStyle:Object,onlyAuthorize:Boolean},hw="getUserInfo",pw={provider:String,withCredentials:Boolean,timeout:Number,lang:String},gw="ggetUserProfilegetUserProfile",vw={provider:String,withCredentials:Boolean,timeout:Number,lang:String},mw="preLogin",_w={UNIVERIFY:"univerify"},bw={formatArgs:{provider(e,t){if(Object.values(_w).indexOf(String(e))<0)return"provider error"}}},yw={provider:{type:String,required:!0}},Ew="closeAuthView",ww="getCheckBoxState",Sw="getUniverifyManager",Cw="share",Kh=["WXSceneSession","WXSceneTimeline","WXSceneFavorite"],Aw={formatArgs:{scene(e,t){let{provider:n,openCustomerServiceChat:r}=t;if(n==="weixin"&&!r&&(!e||!Kh.includes(e)))return`\u5206\u4EAB\u5230\u5FAE\u4FE1\u65F6\uFF0Cscene\u5FC5\u987B\u4E3A\u4EE5\u4E0B\u5176\u4E2D\u4E00\u4E2A\uFF1A${Kh.join("\u3001")}`},summary(e,t){if(t.type===1&&!e)return"\u5206\u4EAB\u7EAF\u6587\u672C\u65F6\uFF0Csummary\u5FC5\u586B"},href(e,t){if(t.type===0&&!e)return"\u5206\u4EAB\u56FE\u6587\u65F6\uFF0Chref\u5FC5\u586B"},imageUrl(e,t){if([0,2,5].includes(Number(t.type))&&!e)return"\u5206\u4EAB\u56FE\u6587\u3001\u7EAF\u56FE\u7247\u3001\u5C0F\u7A0B\u5E8F\u65F6\uFF0CimageUrl\u5FC5\u586B\uFF0C\u63A8\u8350\u4F7F\u7528\u5C0F\u4E8E20Kb\u7684\u56FE\u7247"},mediaUrl(e,t){if([3,4].includes(Number(t.type))&&!e)return"\u5206\u4EAB\u97F3\u4E50\u3001\u89C6\u9891\u65F6\uFF0CmediaUrl\u5FC5\u586B"},miniProgram(e,t){if(t.type===5&&!e)return"\u5206\u4EAB\u5C0F\u7A0B\u5E8F\u65F6\uFF0CminiProgram\u5FC5\u586B"},corpid(e,t){if(t.openCustomerServiceChat&&!e)return"\u4F7F\u7528\u6253\u5F00\u5BA2\u670D\u529F\u80FD\u65F6 corpid \u5FC5\u586B"},customerUrl(e,t){if(t.openCustomerServiceChat&&!e)return"\u4F7F\u7528\u6253\u5F00\u5BA2\u670D\u529F\u80FD\u65F6 customerUrl \u5FC5\u586B"}}},Ow={provider:{type:String,required:!0},type:Number,title:String,scene:String,summary:String,href:String,imageUrl:String,mediaUrl:String,miniProgram:Object},Tw="shareWithSystem",Jh=["text","image"],Iw={formatArgs:{type(e,t){if(e&&!Jh.includes(e))return"\u5206\u4EAB\u53C2\u6570 type \u4E0D\u6B63\u786E\u3002\u53EA\u652F\u6301text\u3001image";t.type=an(e,Jh)}}},Pw={type:String,summary:String,href:String,imageUrl:String},Nw="requestPayment",kw={provider:{type:String,required:!0},orderInfo:{type:[String,Object],required:!0},timeStamp:String,nonceStr:String,package:String,signType:String,paySign:String},Rw="createPushMessage",xw={formatArgs:{content(e){if(!e)return"content is required"}}},Bw="createRewardedVideoAd",Mw={formatArgs:{adpid:"",adUnitId:""}},Dw={adpid:String,adUnitId:String},Fw="createFullScreenVideoAd",Lw={formatArgs:{adpid:""}},Vw={adpid:String},$w="createInterstitialAd",Uw={formatArgs:{adpid:"",adUnitId:""}},Hw={adpid:String,adUnitId:String},jw="createInteractiveAd",zw={formatArgs:{adpid(e,t){if(!e)return"adpid should not be empty.";e&&(t.adpid=e)},provider(e,t){if(!e)return"provider should not be empty.";e&&(t.provider=e)}}},Ww={adpid:{type:String,required:!0},provider:{type:String,required:!0}};function jl(e,t){return function(r){delete r.code,delete r.message,Q.isFunction(t)&&(r=t(r)),e(r)}}function _r(e,t){return function(r){r=r||{},t=r.message||t||"",delete r.message,e(t,Q.extend({code:0},r))}}function Sc(e,t){return function(){e()(function(r){r&&(delete r.code,delete r.message),bt.invokeOnCallback(t,r)})}}function Oi(e,t,n){return function(r,{resolve:s,reject:d}){e()(Q.extend({},Q.isFunction(t)?t(r):r,{success:jl(s,n),fail:_r(d)}))}}function su(e=""){if(!(I.tabBar&&Q.isArray(I.tabBar.list)))return!1;try{if(!e){let n=Gn();if(!n.length)return!1;let r=n[n.length-1];return r?r.$page.meta.isTabBar:!1}/^\//.test(e)||(e=ae.addLeadingSlash(e));let t=fo(e);return t&&t.meta.isTabBar}catch(t){}return!1}let ss="__TYPE",Gw="uni-storage-keys";function xf(e){let t=["object","string","number","boolean","undefined"];try{let n=Q.isString(e)?JSON.parse(e):e,r=n.type;if(t.indexOf(r)>=0){let s=Object.keys(n);if(s.length===2&&"data"in n){if(typeof n.data===r)return n.data;if(r==="object"&&/^\d{4}-\d{2}-\d{2}T\d{2}\:\d{2}\:\d{2}\.\d{3}Z$/.test(n.data))return new Date(n.data)}else if(s.length===1)return""}}catch(n){}}let Yw=Dt(E0,(e,t)=>{let n=typeof t,r=n==="string"?t:JSON.stringify({type:n,data:t});try{n==="string"&&xf(r)!==void 0?c.storage.setItem(e+ss,n):c.storage.removeItem(e+ss),c.storage.setItem(e,r)}catch(s){}},w0),qw=Re(b0,({key:e,data:t},{resolve:n,reject:r})=>{let s=typeof t,d=s==="string"?t:JSON.stringify({type:s,data:t});try{let g=c.storage;s==="string"&&xf(d)!==void 0?g.setItemAsync(e+ss,s):g.removeItemAsync(e+ss),g.setItemAsync(e,d,n,_r(r))}catch(g){r(g.message)}},y0);function Bf(e,t){let n=t;if(e!=="string"||e==="string"&&t==='{"type":"undefined"}')try{let r=JSON.parse(t),s=xf(r);if(s!==void 0)n=s;else if(e&&(n=r,Q.isString(r))){r=JSON.parse(r);let d=typeof r;d==="number"&&e==="date"?n=new Date(r):d===(["null","array"].indexOf(e)<0?e:"object")&&(n=r)}}catch(r){}return n}let Kw=Dt(_0,(e,t)=>{let n=c.storage.getItem(e),s=(c.storage.getItem(e+ss)||"").toLowerCase();return Q.isString(n)?Bf(s,n):""},Lh),Jw=Re(m0,({key:e},{resolve:t,reject:n})=>{let r=c.storage;r.getItemAsync(e,function(s){r.getItemAsync(e+ss,function(d){let y=(d.data||"").toLowerCase();t({data:Bf(y,s.data)})},function(){t({data:Bf("",s.data)})})},_r(n))},Fh),Zw=Dt(Vh,e=>{c.storage.removeItem(e+ss),c.storage.removeItem(e)},C0),Xw=Re(Vh,({key:e},{resolve:t,reject:n})=>{c.storage.removeItemAsync(e+ss),c.storage.removeItemAsync(e,t,_r(n))},S0),Qw=Dt("clearStorageSync",()=>{c.storage.clear()}),eS=Re("clearStorage",(e,{resolve:t,reject:n})=>{c.storage.clearAsync(t,_r(n))}),Zh=Dt("getStorageInfoSync",()=>{let e=c.storage.getLength()||0,t=[],n=0;for(let r=0;r<e;r++){let s=c.storage.key(r);if(s!==Gw&&(s.indexOf(ss)<0||s.indexOf(ss)+ss.length!==s.length)){let d=c.storage.getItem(s);n+=s.length+d.length,t.push(s)}}return{keys:t,currentSize:Math.ceil(n*2/1024),limitSize:Number.MAX_VALUE}}),tS=Re("getStorageInfo",(e,{resolve:t})=>{t(Zh())}),nS=Re(R0,(e,{resolve:t,reject:n})=>{c.io.getFileInfo(Q.extend(e,{success:jl(t),fail:_r(n)}))},B0,x0),rS=0,Xh="uniapp_save",iS=`_doc/${Xh}`;function oS(e,t){t=t||function(){},c.io.requestFileSystem(c.io.PRIVATE_DOC,n=>{n.root.getDirectory(Xh,{create:!0},e,t)},t)}let aS=Re(A0,({tempFilePath:e},{resolve:t,reject:n})=>{let r=_r(n),s=`${Date.now()}${rS++}${ai(e)}`;c.io.resolveLocalFileSystemURL(e,d=>{oS(g=>{d.copyTo(g,s,()=>{let y=iS+"/"+s;t({savedFilePath:y})},r)},r)},r)},T0,O0),sS="uniapp_save";function lS(e,t){t=t||function(){},c.io.requestFileSystem(c.io.PRIVATE_DOC,n=>{n.root.getDirectory(sS,{create:!0},e,t)},t)}let cS=Re(I0,(e,{resolve:t,reject:n})=>{let r=_r(n);lS(s=>{var d=s.createReader(),g=[];d.readEntries(y=>{y&&y.length?y.forEach(z=>{z.getMetadata(P=>{g.push({filePath:c.io.convertAbsoluteFileSystem(z.fullPath),createTime:P.modificationTime.getTime(),size:P.size}),g.length===y.length&&t({fileList:g})},r,!1)}):t({fileList:g})},r)},r)}),uS=Re(M0,({filePath:e},{resolve:t,reject:n})=>{let r=_r(n);c.io.resolveLocalFileSystemURL(e,s=>{s.getMetadata(d=>{t({createTime:d.modificationTime.getTime(),size:d.size})},r,!1)},r)},F0,D0),fS=Re(P0,({filePath:e},{resolve:t,reject:n})=>{let r=_r(n);c.io.resolveLocalFileSystemURL(e,s=>{s.remove(()=>{t()},r)},r)},k0,N0),dS=Re(L0,({filePath:e,fileType:t},{resolve:n,reject:r})=>{let s=_r(r);c.runtime.openDocument(St(e),void 0,n,s)},$0,V0),hS=Dt(sb,e=>!!Q.hasOwn(se,e),lb),Mf;function pS(){return Mf=Mf||c.device.uuid,Mf}let lu,Df=!0,pr;function gS(e,t,n){!pr||(e==="none"?(pr.hideTabBarRedDot({index:t}),pr.removeTabBarBadge({index:t})):e==="text"?pr.setTabBarBadge({index:t,text:n}):e==="redDot"&&pr.showTabBarRedDot({index:t}))}function vS(e,t,n,r,s,d){let g={index:e};if(t!==void 0&&(g.text=t),n&&(g.iconPath=St(n)),r&&(g.selectedIconPath=St(r)),d!==void 0&&(g.iconfont=d),s!==void 0){g.visible=lu.list[e].visible=s,delete g.index;let y=lu.list.map(z=>({visible:z.visible}));y[e]=g,pr&&pr.setTabBarItems({list:y})}else pr&&pr.setTabBarItem(g)}function mS(e){pr&&pr.setTabBarStyle(e)}function _S(e){Df=!1,pr&&pr.hideTabBar({animation:e})}function bS(e){Df=!0,pr&&pr.showTabBar({animation:e})}let ku=[];var Ti={id:"0",init(e,t){e&&e.list.length&&(lu=e);try{pr=v.requireModule("uni-tabview")}catch(n){console.log(`uni.requireNativePlugin("uni-tabview") error ${n}`)}pr.onMaskClick(()=>{ku.forEach(n=>{n()})}),pr&&pr.onClick(({index:n})=>{t(lu.list[n],n)}),pr&&pr.onMidButtonClick(()=>bt.invokeOnCallback(Eh))},indexOf(e){let t=this.config,n=t&&t.list&&t.list.length;if(n){for(let r=0;r<n;r++)if(t.list[r].pagePath===e||t.list[r].pagePath===`${e}.html`)return r}return-1},switchTab(e){let t=this.indexOf(e);return t>=0?(pr&&pr.switchSelect({index:t}),!0):!1},setTabBarBadge:gS,setTabBarItem:vS,setTabBarStyle:mS,hideTabBar:_S,showTabBar:bS,append(e){pr&&pr.append({id:e.id},({code:t})=>{t!==0&&B(()=>{this.append(e)},20)})},get config(){return lu||I.tabBar},get visible(){return Df},get height(){let e=this.config;return(e&&e.height?parseFloat(e.height):ae.TABBAR_HEIGHT)+c.navigator.getSafeAreaInsets().deviceBottom},get cover(){let e=this.config;return e&&["extralight","light","dark"].indexOf(e.blurEffect)>=0},setStyle({mask:e}){pr.setMask({color:e})},addEventListener(e,t){ku.push(t)},removeEventListener(e,t){let n=ku.indexOf(t);ku.splice(n,1)}};function Ru(){let e=Rr();return e?e.$getAppWebview():null}function Qh(e){return e?e.$getAppWebview():Ru()}let ep=null;function tp(){return ep}function Ff(e){ep=e}function Lf(){return c.navigator.isImmersedStatusbar()?Math.round(c.os.name==="iOS"?c.navigator.getSafeAreaInsets().top:c.navigator.getStatusbarHeight()):0}function np(){let e=c.navigator.getStatusBarStyle();return e==="UIStatusBarStyleBlackTranslucent"||e==="UIStatusBarStyleBlackOpaque"||e==="null"?e="light":e==="UIStatusBarStyleDefault"&&(e="dark"),e}function yS(){let{resolutionWidth:e,resolutionHeight:t}=c.screen.getCurrentSize()||{resolutionWidth:0,resolutionHeight:0};return{screenWidth:Math.round(e),screenHeight:Math.round(t)}}let rp=Dt("getWindowInfo",()=>{let e=c.os.name.toLowerCase()==="ios",{screenWidth:t,screenHeight:n}=yS(),r=Lf(),s,d={height:0,cover:!1},g=Ru();if(g){let Et=g.getStyle(),kt=Et&&Et.titleNView;kt&&kt.type&&kt.type!=="none"&&(d.height=kt.type==="transparent"?0:r+ae.NAVBAR_HEIGHT,d.cover=kt.type==="transparent"||kt.type==="float"),s=g.getSafeAreaInsets()}else s=c.navigator.getSafeAreaInsets();let y={height:0,cover:!1};su()&&(y.height=Ti.visible?Ti.height:0,y.cover=Ti.cover);let z=d.cover?d.height:0,P=y.cover?y.height:0,$=n-d.height-y.height,_e=n-(d.cover?0:d.height)-(y.cover?0:y.height),Te=t;(!y.height||y.cover)&&!s.bottom&&s.deviceBottom&&($-=s.deviceBottom,_e-=s.deviceBottom),s=e?s:{left:0,right:0,top:d.height&&!d.cover?0:r,bottom:0};let Le={left:s.left,right:Te-s.right,top:s.top,bottom:_e-s.bottom,width:Te-s.left-s.right,height:_e-s.top-s.bottom};return{pixelRatio:c.screen.scale,screenWidth:t,screenHeight:n,windowWidth:Te,windowHeight:$,statusBarHeight:r,safeArea:Le,safeAreaInsets:{top:s.top,right:s.right,bottom:s.bottom,left:s.left},windowTop:z,windowBottom:P,screenTop:n-$}}),ws,xu=!0;function Vf(){if(!xu)return;let{getSystemInfoSync:e}=v.requireModule("plus");if(ws=e(),Q.isString(ws))try{ws=JSON.parse(ws)}catch(t){}}let ip=Dt("getDeviceInfo",()=>{Vf();let{deviceBrand:e="",deviceModel:t,osName:n,osVersion:r,deviceOrientation:s,deviceType:d}=ws,g=e.toLowerCase(),y=n.toLowerCase();return{brand:g,deviceBrand:g,deviceModel:t,devicePixelRatio:c.screen.scale,deviceId:pS(),deviceOrientation:s,deviceType:d,model:t,platform:y,system:`${y==="ios"?"iOS":"Android"} ${r}`}}),op=Dt("getAppBaseInfo",()=>{Vf();let{hostPackageName:e,hostName:t,hostVersion:n,hostLanguage:r,osLanguage:s,hostTheme:d,appId:g,appName:y,appVersion:z,appVersionCode:P,appWgtVersion:$}=ws;return{appId:g,appName:y,appVersion:z,appVersionCode:P,appWgtVersion:$,appLanguage:nu?nu():s,enableDebug:!1,hostPackageName:e,hostName:t,hostVersion:n,hostLanguage:r,hostTheme:d,hostFontSizeSetting:void 0,hostSDKVersion:void 0,language:s,SDKVersion:"",theme:void 0,version:c.runtime.innerVersion}}),ap=Dt("getSystemInfoSync",()=>{xu=!0,Vf(),xu=!1;let e=rp(),t=ip(),n=op();xu=!0;let r={fontSizeSetting:n.hostFontSizeSetting,osName:ws.osName.toLowerCase()};ws.hostName&&(r.hostSDKVersion=ws.uniRuntimeVersion);let s=Q.extend(ws,e,t,n,r);return delete s.screenTop,delete s.enableDebug,delete s.theme,ae.sortObject(s)}),ES=Re("getSystemInfo",(e,{resolve:t})=>t(ap())),Cc=null,wS=Nn(Nh,()=>{sp()}),SS=lr(wb,()=>{lp()}),sp=Re(Sb,(e,{resolve:t,reject:n})=>{Cc||(Cc=c.orientation.watchOrientation(r=>{bt.invokeOnCallback(Nh,{direction:r.magneticHeading})},r=>{n(r.message),Cc=null},{frequency:jn})),B(t,jn)}),lp=Re(Cb,(e,{resolve:t})=>{Cc&&(c.orientation.clearWatch(Cc),Cc=null),t()}),CS=Re(Ab,(e,{resolve:t})=>{c.device.vibrate(15),t()}),AS=Re(Ob,(e,{resolve:t})=>{c.device.vibrate(400),t()}),Ac=null,OS=Nn(Ph,()=>{cp()}),TS=lr(bb,()=>{up()}),cp=Re(yb,(e,{resolve:t,reject:n})=>{Ac||(Ac=c.accelerometer.watchAcceleration(r=>{bt.invokeOnCallback(Ph,{x:r&&r.xAxis||0,y:r&&r.yAxis||0,z:r&&r.zAxis||0})},r=>{Ac=null,n(`startAccelerometer:fail ${r.message}`)},{frequency:jn})),B(t,jn)}),up=Re(Eb,(e,{resolve:t})=>{Ac&&(c.accelerometer.clearWatch(Ac),Ac=null),t()}),IS=Nn(kh,Sc(()=>c.bluetooth.onBluetoothDeviceFound.bind(c.bluetooth),kh)),PS=Nn(Rh,Sc(()=>c.bluetooth.onBluetoothAdapterStateChange.bind(c.bluetooth),Rh)),NS=Nn(xh,Sc(()=>c.bluetooth.onBLEConnectionStateChange.bind(c.bluetooth),xh)),kS=Nn(Bh,Sc(()=>c.bluetooth.onBLECharacteristicValueChange.bind(c.bluetooth),Bh)),RS=Re("openBluetoothAdapter",Oi(()=>c.bluetooth.openBluetoothAdapter.bind(c.bluetooth))),xS=Re("closeBluetoothAdapter",Oi(()=>c.bluetooth.closeBluetoothAdapter.bind(c.bluetooth))),BS=Re("getBluetoothAdapterState",Oi(()=>c.bluetooth.getBluetoothAdapterState.bind(c.bluetooth))),MS=Re(Tb,Oi(()=>c.bluetooth.startBluetoothDevicesDiscovery.bind(c.bluetooth)),Ib),DS=Re("stopBluetoothDevicesDiscovery",Oi(()=>c.bluetooth.stopBluetoothDevicesDiscovery.bind(c.bluetooth))),FS=Re("getBluetoothDevices",Oi(()=>c.bluetooth.getBluetoothDevices.bind(c.bluetooth))),LS=Re(Pb,Oi(()=>c.bluetooth.getConnectedBluetoothDevices.bind(c.bluetooth)),Nb),VS=Re(kb,Oi(()=>c.bluetooth.createBLEConnection.bind(c.bluetooth)),Rb),$S=Re(xb,Oi(()=>c.bluetooth.closeBLEConnection.bind(c.bluetooth)),Bb),US=Re(Mb,Oi(()=>c.bluetooth.getBLEDeviceServices.bind(c.bluetooth)),Db),HS=Re(Fb,Oi(()=>c.bluetooth.getBLEDeviceCharacteristics.bind(c.bluetooth)),Lb),jS=Re(Vb,Oi(()=>c.bluetooth.notifyBLECharacteristicValueChange.bind(c.bluetooth)),$b),zS=Re(Ub,Oi(()=>c.bluetooth.readBLECharacteristicValue.bind(c.bluetooth)),Hb),WS=Re(jb,Oi(()=>c.bluetooth.writeBLECharacteristicValue.bind(c.bluetooth)),zb),GS=Re(Wb,Oi(()=>c.bluetooth.setBLEMTU.bind(c.bluetooth)),Gb),YS=Re(Yb,Oi(()=>c.bluetooth.getBLEDeviceRSSI.bind(c.bluetooth)),qb),qS=Nn(Mh,Sc(()=>c.ibeacon.onBeaconUpdate.bind(c.ibeacon),Mh)),KS=Nn(Dh,Sc(()=>c.ibeacon.onBeaconServiceChange.bind(c.ibeacon),Dh)),JS=Re(Kb,Oi(()=>c.ibeacon.getBeacons.bind(c.ibeacon))),ZS=Re(Jb,Oi(()=>c.ibeacon.startBeaconDiscovery.bind(c.ibeacon)),Zb),XS=Re(Xb,Oi(()=>c.ibeacon.stopBeaconDiscovery.bind(c.ibeacon))),QS=Re(ub,({phoneNumber:e},{resolve:t})=>(c.device.dial(e),t()),fb),eC={name:{givenName:"firstName",middleName:"middleName",familyName:"lastName"},nickname:"nickName",photos:{type:"url",value:"photoFilePath"},note:"remark",phoneNumbers:[{type:"mobile",value:"mobilePhoneNumber"},{type:"work",value:"workPhoneNumber"},{type:"company",value:"hostNumber"},{type:"home fax",value:"homeFaxNumber"},{type:"work fax",value:"workFaxNumber"}],emails:[{type:"home",value:"email"}],urls:[{type:"other",value:"url"}],organizations:[{type:"company",name:"organization",title:"title"}],ims:[{type:"other",value:"weChatNumber"}],addresses:[{type:"other",preferred:!0,country:"addressCountry",region:"addressState",locality:"addressCity",streetAddress:"addressStreet",postalCode:"addressPostalCode"},{type:"home",country:"homeAddressCountry",region:"homeAddressState",locality:"homeAddressCity",streetAddress:"homeAddressStreet",postalCode:"homeAddressPostalCode"},{type:"company",country:"workAddressCountry",region:"workAddressState",locality:"workAddressCity",streetAddress:"workAddressStreet",postalCode:"workAddressPostalCode"}]},tC=["type","preferred"];function $f(e,t,n){let r=0;return Object.keys(n).forEach(s=>{let d=n[s];typeof d!=="object"?tC.indexOf(s)!==-1?e[s]=n[s]:typeof t[d]!="undefined"?(r++,e[s]=t[d]):delete e[s]:d instanceof Array?(e[s]=[],d.forEach(y=>{let z={};$f(z,t,y)&&e[s].push(z)}),e[s].length?r++:delete e[s]):(e[s]={},$f(e[s],t,d)?r++:delete e[s])}),r}let nC=Re(db,(e,{resolve:t,reject:n})=>{!e.photoFilePath&&(e.photoFilePath=""),c.contacts.getAddressBook(c.contacts.ADDRESSBOOK_PHONE,r=>{let s=r.create();$f(s,e,eC),s.save(()=>t(),d=>n())},r=>n())},pb,hb);function va(e){return typeof v!="undefined"?v.requireModule(e):__requireNativePlugin__(e)}function fp(e,t,n){return va("plus").sendNativeEvent(e,t,n)}let rC=Re(gb,(e,{resolve:t,reject:n})=>{va("clipboard").getString(s=>{s.result==="success"?t({data:s.data}):n("getClipboardData:fail")})}),iC=Re(vb,(e,{resolve:t})=>{va("clipboard").setString(e.data),t()},_b,mb),dp="onNetworkStatusChange";function hp(){pp().then(({networkType:e})=>{bt.invokeOnCallback(dp,{isConnected:e!=="none",networkType:e})})}let oC=Nn(dp,()=>{c.globalEvent.addEventListener("netchange",hp)}),aC=lr("offNetworkStatusChange",()=>{c.globalEvent.removeEventListener("netchange",hp)}),pp=Re("getNetworkType",(e,{resolve:t})=>{let n=Cr[c.networkinfo.getCurrentType()]||"unknown";return t({networkType:n})});function gp(){if(c.os.name.toLowerCase()!=="ios")return!1;let t=va("faceID");return!!(t&&t.isSupport())}function vp(){return!!(c.fingerprint&&c.fingerprint.isSupport())}let mp=e=>{let t=[];return vp()&&t.push("fingerPrint"),gp()&&t.push("facial"),e&&e({supportMode:t}),{supportMode:t,errMsg:"checkIsSupportSoterAuthentication:ok"}},sC=Re(n0,(e,{resolve:t,reject:n})=>{mp(t)}),_p=({checkAuthMode:e,resolve:t,reject:n})=>{let r=(d,g)=>n&&n(d,g),s=d=>t&&t(d);if(e==="fingerPrint"){if(vp()){let d=c.fingerprint.isKeyguardSecure()&&c.fingerprint.isEnrolledFingerprints();return s({isEnrolled:d}),{isEnrolled:d,errMsg:"checkIsSoterEnrolledInDevice:ok"}}return r("not support",{isEnrolled:!1}),{isEnrolled:!1,errMsg:"checkIsSoterEnrolledInDevice:fail not support"}}else if(e==="facial"){if(gp()){let d=va("faceID"),g=d&&d.isKeyguardSecure()&&d.isEnrolledFaceID();return s({isEnrolled:g}),{isEnrolled:g,errMsg:"checkIsSoterEnrolledInDevice:ok"}}return r("not support",{isEnrolled:!1}),{isEnrolled:!1,errMsg:"checkIsSoterEnrolledInDevice:fail not support"}}return r("not support",{isEnrolled:!1}),{isEnrolled:!1,errMsg:"checkIsSoterEnrolledInDevice:fail not support"}},lC=Re(r0,({checkAuthMode:e},{resolve:t,reject:n})=>{_p({checkAuthMode:e,resolve:t,reject:n})},a0,o0),cC=Re(s0,({requestAuthModes:e,challenge:t=!1,authContent:n},{resolve:r,reject:s})=>{sa();let{t:d}=Z(),g=mp().supportMode;if(g.length===0)return{authMode:"fingerPrint",errCode:90001,errMsg:"startSoterAuthentication:fail"};let y=[];if(e.map(($,_e)=>{g.indexOf($)>-1&&y.push($)}),y.length===0)return{authMode:"fingerPrint",errCode:90003,errMsg:"startSoterAuthentication:fail no corresponding mode"};let z=[];if(y.map(($,_e)=>{_p({checkAuthMode:$}).isEnrolled&&z.push($)}),z.length===0)return{authMode:y[0],errCode:90011,errMsg:`startSoterAuthentication:fail no ${y[0]} enrolled`};let P=z[0];P==="fingerPrint"?(c.os.name.toLowerCase()==="android"&&(c.nativeUI.showWaiting(n||d("uni.startSoterAuthentication.authContent")).onclose=function(){c.fingerprint.cancel()}),c.fingerprint.authenticate(()=>{c.nativeUI.closeWaiting(),r({authMode:P,errCode:0})},$=>{let _e={authMode:P};switch($.code){case $.AUTHENTICATE_MISMATCH:break;case $.AUTHENTICATE_OVERLIMIT:c.nativeUI.closeWaiting(),s("authenticate freeze. please try again later",Q.extend(_e,{errCode:90010}));break;case $.CANCEL:c.nativeUI.closeWaiting(),s("cancel",Q.extend(_e,{errCode:90008}));break;default:c.nativeUI.closeWaiting(),s("",Q.extend(_e,{errCode:90007}));break}},{message:n})):P==="facial"&&va("faceID").authenticate({message:n},_e=>{let Te={authMode:P};if(_e.type==="success"&&_e.code===0)r({authMode:P,errCode:0});else switch(_e.code){case 4:s("",Q.extend(Te,{errCode:90009}));break;case 5:s("authenticate freeze. please try again later",Q.extend(Te,{errCode:90010}));break;case 6:s("",Q.extend(Te,{errCode:90008}));break;default:s("",Q.extend(Te,{errCode:90007}));break}})},c0,l0),uC=Re(u0,(e,{resolve:t,reject:n})=>{No();let{t:r}=Z(),d=np()!=="light",g,y=!1,z=Rs({url:"__uniappscan",data:Object.assign({},e,{messages:{fail:r("uni.scanCode.fail"),"flash.on":r("uni.scanCode.flash.on"),"flash.off":r("uni.scanCode.flash.off")}}),style:{animationType:e.animationType||"pop-in",titleNView:{autoBackButton:!0,type:"float",titleText:e.titleText||r("uni.scanCode.title"),titleColor:"#ffffff",backgroundColor:"rgba(0,0,0,0)",buttons:e.onlyFromCamera?[]:[{text:e.albumText||r("uni.scanCode.album"),fontSize:"17px",width:"60px",onclick:()=>{z.sendMessage({type:"gallery"})}}]},popGesture:"close",background:"#000000",backButtonAutoControl:"close"},onMessage({event:P,detail:$}){g=$,y=P==="marked"},onClose(){d&&c.navigator.setStatusBarStyle("dark"),g?y?(delete g.message,t(g)):n(g.message):n("cancel")}});d&&(c.navigator.setStatusBarStyle("light"),z.webview.addEventListener("popGesture",({type:P,result:$})=>{P==="start"?c.navigator.setStatusBarStyle("dark"):P==="end"&&!$&&c.navigator.setStatusBarStyle("light")}))},f0,h0),fC=Nn(ae.ON_THEME_CHANGE,()=>{bt.on(ae.ON_THEME_CHANGE,e=>{bt.invokeOnCallback(ae.ON_THEME_CHANGE,e)})}),dC=Re(Qb,(e,{resolve:t})=>{let n=c.screen.getBrightness(!1);t({value:n})}),hC=Re(e0,(e,{resolve:t})=>{c.screen.setBrightness(e.value,!1),t()}),pC=Re(t0,(e,{resolve:t})=>{c.device.setWakelock(!!e.keepScreenOn),t()}),gC=Dt(p0,()=>{let{getSystemSetting:e}=v.requireModule("plus"),t=e();try{typeof t=="string"&&(t=JSON.parse(t))}catch(n){}return t}),bp=Dt(g0,()=>{let{getAppAuthorizeSetting:e}=v.requireModule("plus"),t=e();try{typeof t=="string"&&(t=JSON.parse(t))}catch(n){}for(let n in t)Q.hasOwn(t,n)&&t[n]==="undefined"&&(t[n]=void 0);return t}),vC=Re(v0,(e,{resolve:t,reject:n})=>{let{openAppAuthorizeSetting:r}=v.requireModule("plus");r(d=>{d.type==="success"?t():n()})}),mC=Re(ry,(e,{resolve:t,reject:n})=>{let r=Si+"/download/";c.io.getImageInfo(Q.extend(e,{savePath:r,filename:r,success:jl(t),fail:_r(n)}))},oy,iy),_C=Re(uy,(e,{resolve:t,reject:n})=>{c.io.getVideoInfo({filePath:e.src,success:r=>{t({orientation:r.orientation,type:r.type,duration:r.duration,size:r.size,height:r.height,width:r.width,fps:r.fps||30,bitrate:r.bitrate})},fail:_r(n)})},dy,fy),bC=Re(ay,({current:e=0,indicator:t="number",loop:n=!1,urls:r,longPressActions:s},{resolve:d,reject:g})=>{Va();let{t:y}=Z();r=r.map(P=>St(P));let z=Number(e);isNaN(z)?(e=r.indexOf(St(e)),e=e<0?0:e):e=z,c.nativeUI.previewImage(r,{current:e,indicator:t,loop:n,onLongPress:function(P){let $=[],_e="",Te=s&&Q.isPlainObject(s);Te?($=s.itemList?s.itemList:[],_e=s.itemColor?s.itemColor:"#000000"):($=[y("uni.previewImage.button.save")],_e="#000000");let Le={buttons:$.map(Et=>({title:Et,color:_e})),cancel:y("uni.previewImage.cancel")};c.nativeUI.actionSheet(Le,Et=>{if(Et.index>0){if(Te){Q.isFunction(s.success)&&s.success({tapIndex:Et.index-1,index:P.index});return}c.gallery.save(P.url,()=>{c.nativeUI.toast(y("uni.previewImage.save.success"))},function(){c.nativeUI.toast(y("uni.previewImage.save.fail"))})}else Te&&Q.isFunction(s.fail)&&s.fail({errMsg:"showActionSheet:fail cancel"})})}}),d()},ly,sy),yC=Re(cy,(e,{resolve:t,reject:n})=>{try{c.nativeUI.closePreviewImage(),t()}catch(r){n()}}),Uf,Oc=!1,Hf,Tc=(e,t={})=>{EC(Q.extend({state:e},t))},cu={start({duration:e=6e4,sampleRate:t,numberOfChannels:n,encodeBitRate:r,format:s="mp3",frameSize:d}={}){if(Oc)return Tc("start");Uf=c.audio.getRecorder(),Uf.record({format:s,samplerate:t?String(t):"",filename:Si+"/recorder/"},g=>Tc("stop",{tempFilePath:g}),g=>Tc("error",{errMsg:g.message})),Hf=B(()=>{cu.stop()},e),Tc("start"),Oc=!0},stop(){Oc&&(Uf.stop(),Oc=!1,Hf&&C(Hf))},pause(){Oc&&Tc("error",{errMsg:"Unsupported operation: pause"})},resume(){Oc&&Tc("error",{errMsg:"Unsupported operation: resume"})}},zl={pause:null,resume:null,start:null,stop:null,error:null};function EC(e){let t=e.state;delete e.state,delete e.errMsg,t&&Q.isFunction(zl[t])&&zl[t](e)}class wC{constructor(){}onError(t){zl.error=t}onFrameRecorded(t){}onInterruptionBegin(t){}onInterruptionEnd(t){}onPause(t){zl.pause=t}onResume(t){zl.resume=t}onStart(t){zl.start=t}onStop(t){zl.stop=t}pause(){cu.pause()}resume(){cu.resume()}start(t={}){cu.start(t)}stop(){cu.stop()}}let yp,SC=Dt(by,()=>yp||(yp=new wC)),CC=Re(vy,(e,{resolve:t,reject:n})=>{c.gallery.save(e.filePath,jl(t),_r(n))},_y,my),AC=Re(hy,(e,{resolve:t,reject:n})=>{c.gallery.save(e.filePath,jl(t),_r(n))},gy,py),OC=Re(yy,(e,{resolve:t,reject:n})=>{let r=`${Si}/compressed/${Date.now()}_${vo(e.src)}`;c.zip.compressImage(Q.extend({},e,{dst:r}),()=>{t({tempFilePath:r})},n)},wy,Ey),TC=Re(Sy,(e,{resolve:t,reject:n})=>{let r=`${Si}/compressed/${Date.now()}_${vo(e.src)}`;c.zip.compressVideo(Q.extend({},e,{filename:r}),()=>{t({tempFilePath:r})},n)},Ay,Cy);function IC(e){return new Promise((t,n)=>{c.io.resolveLocalFileSystemURL(e,function(r){r.getMetadata(t,n,!1)},n)})}let PC=Re(Z0,({count:e,sizeType:t,sourceType:n,crop:r}={},{resolve:s,reject:d})=>{mr();let{t:g}=Z(),y=_r(d);function z(_e){let Te=[],Le=[];Promise.all(_e.map(Et=>IC(Et))).then(Et=>{Et.forEach((kt,rn)=>{let Ut=_e[rn];Le.push(Ut),Te.push({path:Ut,size:kt.size})}),s({tempFilePaths:Le,tempFiles:Te})}).catch(y)}function P(){c.camera.getCamera().captureImage(Te=>z([Te]),y,{filename:Si+"/camera/",resolution:"high",crop:r,sizeType:t})}function $(){c.gallery.pick(({files:_e})=>z(_e),y,{maximum:e,multiple:!0,system:!1,filename:Si+"/gallery/",permissionAlert:!0,crop:r,sizeType:t})}if(n.length===1){if(n.includes("album")){$();return}else if(n.includes("camera")){P();return}}c.nativeUI.actionSheet({cancel:g("uni.chooseImage.cancel"),buttons:[{title:g("uni.chooseImage.sourceType.camera")},{title:g("uni.chooseImage.sourceType.album")}]},_e=>{switch(_e.index){case 1:P();break;case 2:$();break;default:y();break}})},Q0,X0),NC=Re(ey,({sourceType:e,compressed:t,maxDuration:n,camera:r},{resolve:s,reject:d})=>{qn();let{t:g}=Z(),y=_r(d);function z(_e){c.io.getVideoInfo({filePath:_e,success(Te){let Le={errMsg:"chooseVideo:ok",tempFilePath:_e,size:Te.size,duration:Te.duration,width:Te.width,height:Te.height};s(Le)},fail:y})}function P(){c.gallery.pick(({files:_e})=>z(_e[0]),y,{filter:"video",system:!1,multiple:!0,maximum:1,filename:Si+"/gallery/",permissionAlert:!0,videoCompress:t})}function $(){c.camera.getCamera().startVideoCapture(z,y,{index:r==="front"?"2":"1",videoMaximumDuration:n,filename:Si+"/camera/",videoCompress:t})}if(e.length===1){if(e.includes("album")){P();return}else if(e.includes("camera")){$();return}}c.nativeUI.actionSheet({cancel:g("uni.chooseVideo.cancel"),buttons:[{title:g("uni.chooseVideo.sourceType.camera")},{title:g("uni.chooseVideo.sourceType.album")}]},_e=>{switch(_e.index){case 1:$();break;case 2:P();break;default:y();break}})},ny,ty),kC=Re(H0,(e,{resolve:t})=>{c.key.showSoftKeybord(),t()}),RC=Re(U0,(e,{resolve:t})=>{c.key.hideSoftKeybord(),t()});function Ep(e){bt.invokeOnCallback(ae.ON_KEYBOARD_HEIGHT_CHANGE,e)}let xC=Nn(ae.ON_KEYBOARD_HEIGHT_CHANGE,()=>{bt.on(ae.ON_KEYBOARD_HEIGHT_CHANGE,Ep)}),BC=lr(ae.ON_KEYBOARD_HEIGHT_CHANGE,()=>{bt.off(ae.ON_KEYBOARD_HEIGHT_CHANGE,Ep)});class MC{constructor(t){this._callbacks=[],this._downloader=t,t.addEventListener("statechanged",(n,r)=>{n.downloadedSize&&n.totalSize&&this._callbacks.forEach(s=>{s({progress:Math.round(n.downloadedSize/n.totalSize*100),totalBytesWritten:n.downloadedSize,totalBytesExpectedToWrite:n.totalSize})})})}abort(){this._downloader.abort()}onProgressUpdate(t){!Q.isFunction(t)||this._callbacks.push(t)}offProgressUpdate(t){let n=this._callbacks.indexOf(t);n>=0&&this._callbacks.splice(n,1)}onHeadersReceived(t){throw new Error("Method not implemented.")}offHeadersReceived(t){throw new Error("Method not implemented.")}}let DC=Oo(Dy,({url:e,header:t,timeout:n},{resolve:r,reject:s})=>{n=(n||I.networkTimeout&&I.networkTimeout.request||60*1e3)/1e3;let d=c.downloader.createDownload(e,{timeout:n,filename:Si+"/download/",retry:0,retryInterval:0},(y,z)=>{z?r({tempFilePath:y.filename,statusCode:z}):s(`statusCode: ${z}`)}),g=new MC(d);for(let y in t)Q.hasOwn(t,y)&&d.setRequestHeader(y,t[y]);return d.start(),g},Ly,Fy),FC=e=>{let t=e["Set-Cookie"]||e["set-cookie"],n=[];if(!t)return[];t[0]==="["&&t[t.length-1]==="]"&&(t=t.slice(1,-1));let r=t.split(";");for(let s=0;s<r.length;s++)r[s].indexOf("Expires=")!==-1||r[s].indexOf("expires=")!==-1?n.push(r[s].replace(",","")):n.push(r[s]);return n=n.join(";").split(","),n};function LC(e,t){if(Q.isString(e.data)&&e.data.charCodeAt(0)===65279&&(e.data=e.data.slice(1)),e.statusCode=parseInt(String(e.statusCode),10),Q.isPlainObject(e.header)&&(e.header=Object.keys(e.header).reduce(function(n,r){let s=e.header[r];return Q.isArray(s)?n[r]=s.join(","):Q.isString(s)&&(n[r]=s),n},{})),t.dataType&&t.dataType.toLowerCase()==="json")try{e.data=JSON.parse(e.data)}catch(n){}return e}class VC{constructor(t){this._requestTask=t}abort(){this._requestTask.abort()}offHeadersReceived(){}onHeadersReceived(){}}let $C=Oo(Oy,(e,{resolve:t,reject:n})=>{let{header:r,method:s,data:d,timeout:g,url:y,responseType:z,sslVerify:P,firstIpv4:$,tls:_e}=e,Te;for(let _t in r)if(_t.toLowerCase()==="content-type"){Te=r[_t];break}s!=="GET"&&Te.indexOf("application/json")===0&&Q.isPlainObject(d)&&(d=JSON.stringify(d));let Le=va("stream"),Et={},kt,rn,Ut=!1;for(let _t in r)if(!Ut&&_t.toLowerCase()==="content-type"){if(Ut=!0,Et["Content-Type"]=r[_t],s!=="GET"&&r[_t].indexOf("application/x-www-form-urlencoded")===0&&!Q.isString(d)&&!(d instanceof ArrayBuffer)){let vn=[];for(let on in d)Q.hasOwn(d,on)&&vn.push(encodeURIComponent(on)+"="+encodeURIComponent(d[on]));d=vn.join("&")}}else Et[_t]=r[_t];!Ut&&s==="POST"&&(Et["Content-Type"]="application/x-www-form-urlencoded; charset=UTF-8"),g&&(kt=B(()=>{rn=!0,n("timeout")},g+200));let Dn={method:s,url:y.trim(),headers:Et,type:z==="arraybuffer"?"base64":"text",timeout:g||6e5,sslVerify:!P,firstIpv4:$,tls:_e},Vn=!1;s!=="GET"&&(toString.call(d)==="[object ArrayBuffer]"?Vn=!0:Dn.body=Q.isString(d)?d:JSON.stringify(d));let ln=({ok:_t,status:vn,data:on,headers:qt,errorMsg:yn})=>{if(rn)return;kt&&C(kt);let br=vn;if(br>0)t(LC({data:_t&&z==="arraybuffer"?Ri(on):on,statusCode:br,header:qt,cookies:FC(qt)},e));else{let Kt="abort statusCode:"+br;yn&&(Kt=Kt+" "+yn),n(Kt)}};return Vn?Le.fetchWithArrayBuffer({"@type":"binary",base64:Yr(d)},Dn,ln):Le.fetch(Dn,ln),new VC({abort(){rn=!0,kt&&C(kt),n("abort")}})},ky,Ry),UC=Re(xy,({certificates:e},{resolve:t,reject:n})=>{va("stream").configMTLS(e,({type:s,code:d,message:g})=>{switch(s){case"success":t({code:d});break;case"fail":n(g,{code:d});break}})},By,My),Ic=[],Pc={},jf={open:"",close:"",error:"",message:""},uu;function HC(e){let t=String(Date.now()),n;try{uu||(uu=va("uni-webSocket"),jC(uu)),uu.WebSocket({id:t,url:e.url,protocol:Q.isArray(e.protocols)?e.protocols.join(","):e.protocols,header:e.header})}catch(r){n=r}return{socket:uu,socketId:t,errMsg:n}}function jC(e){e.onopen(t=>{let n=Pc[t.id];!n||n._socketOnOpen()}),e.onmessage(t=>{let n=Pc[t.id];!n||n._socketOnMessage(t)}),e.onerror(t=>{let n=Pc[t.id];!n||n._socketOnError()}),e.onclose(t=>{let n=Pc[t.id];!n||n._socketOnClose()})}class zC{constructor(t,n){this.id=n,this._socket=t,this._callbacks={open:[],close:[],error:[],message:[]},this.CLOSED=3,this.CLOSING=2,this.CONNECTING=0,this.OPEN=1,this.readyState=this.CLOSED,!!this._socket}_socketOnOpen(){this.readyState=this.OPEN,this.socketStateChange("open")}_socketOnMessage(t){this.socketStateChange("message",{data:typeof t.data=="object"?Ri(t.data.base64):t.data})}_socketOnError(){this.socketStateChange("error"),this.onErrorOrClose()}_socketOnClose(){this.socketStateChange("close"),this.onErrorOrClose()}onErrorOrClose(){this.readyState=this.CLOSED,delete Pc[this.id];let t=Ic.indexOf(this);t>=0&&Ic.splice(t,1)}socketStateChange(t,n={}){let r=t==="message"?n:{};this===Ic[0]&&jf[t]&&bt.invokeOnCallback(jf[t],r),this._callbacks[t].forEach(s=>{Q.isFunction(s)&&s(r)})}send(t,n=!0){this.readyState!==this.OPEN&&ae.callOptions(t,"sendSocketMessage:fail WebSocket is not connected");try{this._socket.send({id:this.id,data:typeof t.data=="object"?{"@type":"binary",base64:Yr(t.data)}:t.data}),n&&ae.callOptions(t,"sendSocketMessage:ok")}catch(r){n&&ae.callOptions(t,`sendSocketMessage:fail ${r}`)}}close(t,n=!0){this.readyState=this.CLOSING;try{this._socket.close(Q.extend({id:this.id,args:t})),n&&ae.callOptions(t,"closeSocket:ok")}catch(r){n&&ae.callOptions(t,`closeSocket:fail ${r}`)}}onOpen(t){this._callbacks.open.push(t)}onClose(t){this._callbacks.close.push(t)}onError(t){this._callbacks.error.push(t)}onMessage(t){this._callbacks.message.push(t)}}let WC=Oo(Hy,({url:e,protocols:t,header:n,method:r},{resolve:s,reject:d})=>{let{socket:g,socketId:y,errMsg:z}=HC({url:e,protocols:t,header:n,method:r}),P=new zC(g,y);return z?B(()=>{d(z)},0):(Ic.push(P),Pc[y]=P),B(()=>{s()},0),P},zy,jy),GC=Re(Wy,(e,{resolve:t,reject:n})=>{let r=Ic[0];if(!r||r.readyState!==r.OPEN){n("WebSocket is not connected");return}r.send({data:e.data},!1),t()},Gy),YC=Re(Yy,(e,{resolve:t,reject:n})=>{let r=Ic[0];if(!r){n("WebSocket is not connected");return}r.readyState=r.CLOSING,r.close(e,!1),t()},qy);function Bu(e){let t=`onSocket${Q.capitalize(e)}`;return Nn(t,()=>{jf[e]=t})}let qC=Bu("open"),KC=Bu("error"),JC=Bu("message"),ZC=Bu("close");class XC{constructor(t){this._callbacks=[],this._uploader=t,t.addEventListener("statechanged",(n,r)=>{n.uploadedSize&&n.totalSize&&this._callbacks.forEach(s=>{s({progress:parseInt(String(n.uploadedSize/n.totalSize*100)),totalBytesSent:n.uploadedSize,totalBytesExpectedToSend:n.totalSize})})})}abort(){this._uploader.abort()}onProgressUpdate(t){!Q.isFunction(t)||this._callbacks.push(t)}onHeadersReceived(){}offProgressUpdate(t){let n=this._callbacks.indexOf(t);n>=0&&this._callbacks.splice(n,1)}offHeadersReceived(){}}let QC=Oo(Vy,({url:e,timeout:t,header:n,formData:r,files:s,filePath:d,name:g},{resolve:y,reject:z})=>{let P=c.uploader.createUpload(e,{timeout:t,retry:0,retryInterval:0},(_e,Te)=>{Te?y({data:_e.responseText,statusCode:Te}):z(`statusCode: ${Te}`)});for(let _e in n)Q.hasOwn(n,_e)&&P.setRequestHeader(_e,String(n[_e]));for(let _e in r)Q.hasOwn(r,_e)&&P.addData(_e,String(r[_e]));s&&s.length?s.forEach(_e=>{P.addFile(St(_e.uri),{key:_e.name||"file"})}):P.addFile(St(d),{key:g});let $=new XC(P);return P.start(),$},Uy,$y),gl={},eA=["play","canplay","ended","stop","waiting","seeking","seeked","pause"],wp="playback",tA=e=>{let t=gl[e];!t||t.initStateChage||(t.initStateChage=!0,t.addEventListener("error",n=>{Sp({state:"error",audioId:e,errMsg:"MediaError",errCode:n.code})}),eA.forEach(n=>{t.addEventListener(n,()=>{n==="play"?t.isStopped=!1:n==="stop"&&(t.isStopped=!0),Sp({state:n,audioId:e})})}))};function nA(){let e=`${Date.now()}${Math.random()}`,t=gl[e]=c.audio.createPlayer("");return t.src="",t.volume=1,t.startTime=0,t.setSessionCategory(wp),{errMsg:"createAudioInstance:ok",audioId:e}}function rA({audioId:e,src:t,startTime:n,autoplay:r=!1,loop:s=!1,obeyMuteSwitch:d,volume:g,sessionCategory:y=wp,playbackRate:z}){let P=gl[e];if(P){let $={loop:s,autoplay:r};if(t){let _e=St(t);P.src!==_e&&(P.src=$.src=_e)}n&&(P.startTime=$.startTime=n),typeof g=="number"&&(P.volume=$.volume=g),P.setStyles($),y&&P.setSessionCategory(y),z&&P.playbackRate&&P.playbackRate(z),tA(e)}return{errMsg:"setAudioState:ok"}}function iA({audioId:e}){let t=gl[e];if(!t)return{errMsg:"getAudioState:fail"};let{src:n,startTime:r,volume:s}=t;return{errMsg:"getAudioState:ok",duration:1e3*(t.getDuration()||0),currentTime:t.isStopped?0:1e3*t.getPosition(),paused:t.isPaused(),src:n,volume:s,startTime:1e3*r,buffered:1e3*t.getBuffered()}}function oA({operationType:e,audioId:t,currentTime:n}){let r=gl[t];switch(e){case"play":case"pause":case"stop":r[e==="play"&&r.isPaused()?"resume":e]();break;case"seek":typeof n!="undefined"&&r.seekTo(n/1e3);break}return{errMsg:"operateAudio:ok"}}let zf=Object.create(null),Sp=({state:e,audioId:t,errMsg:n,errCode:r})=>{let s=zf[t];if(s)if(Cp(s,e,n,r),e==="play"){let d=s.currentTime;s.__timing=k(()=>{s.currentTime!==d&&Cp(s,"timeUpdate")},200)}else(e==="pause"||e==="stop"||e==="error")&&u(s.__timing)},aA=[{name:"src",cache:!0},{name:"startTime",default:0,cache:!0},{name:"autoplay",default:!1,cache:!0},{name:"loop",default:!1,cache:!0},{name:"obeyMuteSwitch",default:!0,readonly:!0,cache:!0},{name:"duration",readonly:!0},{name:"currentTime",readonly:!0},{name:"paused",readonly:!0},{name:"buffered",readonly:!0},{name:"volume"},{name:"playbackRate",cache:!0}];class Wf{constructor(t){this.id=t,this._callbacks={},this._options={},gh.forEach(n=>{this._callbacks[n]=[]}),aA.forEach(n=>{let r=n.name;Object.defineProperty(this,r,{get:()=>{let s=n.cache?this._options:iA({audioId:this.id}),d=r in s?s[r]:n.default;return typeof d=="number"&&r!=="volume"?d/1e3:d},set:n.readonly?void 0:s=>{this._options[r]=s,rA(Q.extend({},this._options,{audioId:this.id}))}})}),sA()}play(){this._operate("play")}pause(){this._operate("pause")}stop(){this._operate("stop")}seek(t){this._operate("seek",{currentTime:t*1e3})}destroy(){u(this.__timing),gl[this.id]&&(gl[this.id].close(),delete gl[this.id]),delete zf[this.id]}_operate(t,n){oA(Q.extend({},n,{audioId:this.id,operationType:t}))}}let sA=ae.once(()=>{gh.forEach(e=>{Wf.prototype[e]=function(t){Q.isFunction(t)&&this._callbacks[e].push(t)}}),v_.forEach(e=>{Wf.prototype[e]=function(t){let n=this._callbacks[e],r=n.indexOf(t);r>=0&&n.splice(r,1)}})});function Cp(e,t,n,r){let s=`on${Q.capitalize(t)}`;e._callbacks[s].forEach(d=>{Q.isFunction(d)&&d(t==="error"?{errMsg:n,errCode:r}:{})})}let lA=Dt(Wm,()=>{let{audioId:e}=nA(),t=new Wf(e);return zf[e]=t,t}),cA=["canplay","play","pause","stop","ended","timeUpdate","prev","next","error","waiting"],Ap={canplay:[],play:[],pause:[],stop:[],ended:[],timeUpdate:[],prev:[],next:[],error:[],waiting:[]},Qt,Gf=null,uA=250,fA=["play","pause","ended","stop","canplay"];function dA(){Mu(),Gf=k(()=>{Nc({state:"timeUpdate"})},uA)}function Mu(){Gf!==null&&u(Gf)}function hA(){if(Qt)return;let e=bt.invokeOnCallback;Qt=c.audio.createPlayer({autoplay:!0,backgroundControl:!0}),Qt.src=Qt.title=Qt.epname=Qt.singer=Qt.coverImgUrl=Qt.webUrl="",Qt.startTime=0,fA.forEach(t=>{Qt.addEventListener(t,()=>{t==="play"?(Qt.isStopped=!1,dA()):t==="stop"&&(Qt.isStopped=!0),(t==="pause"||t==="ended"||t==="stop")&&Mu();let n=`onMusic${t[0].toUpperCase()+t.slice(1)}`;e(n,{dataUrl:Qt.src,errMsg:`${n}:ok`}),Nc({state:t,dataUrl:Qt.src})})}),Qt.addEventListener("waiting",()=>{Mu(),Nc({state:"waiting",dataUrl:Qt.src})}),Qt.addEventListener("error",t=>{Mu(),e("onMusicError",{dataUrl:Qt.src,errMsg:"Error:"+t.message}),Nc({state:"error",dataUrl:Qt.src,errMsg:t.message,errCode:t.code})}),Qt.addEventListener("prev",()=>{Nc({state:"prev"})}),Qt.addEventListener("next",()=>{Nc({state:"next"})})}function pA(){let e={duration:0,currentTime:0,paused:!1,src:"",buffered:0,title:"",epname:"",singer:"",coverImgUrl:"",webUrl:"",startTime:0,errMsg:"getBackgroundAudioState:ok"};if(Qt){let t={duration:Qt.getDuration()||0,currentTime:Qt.isStopped?0:Qt.getPosition(),paused:Qt.isPaused(),src:Qt.src,buffered:Qt.getBuffered(),title:Qt.title,epname:Qt.epname,singer:Qt.singer,coverImgUrl:Qt.coverImgUrl,webUrl:Qt.webUrl,startTime:Qt.startTime};e=Q.extend(e,t)}return e}function Op(e,t){hA();let n=["src","startTime","coverImgUrl","webUrl","singer","epname","title"];if(t==="playbackRate"){let s=e[t];Qt.playbackRate&&Qt.playbackRate(parseFloat(s));return}let r={};Object.keys(e).forEach(s=>{if(n.indexOf(s)>=0){let d=e[s];s===n[0]&&d&&(d=St(d)),Qt[s]=r[s]=d}}),Qt.setStyles(r)}function gA({operationType:e,src:t,position:n,api:r="operateMusicPlayer",title:s,coverImgUrl:d}){var g=["resume","pause","stop"];return g.indexOf(e)>0?Qt&&Qt[e]():e==="play"?(Op({src:t,startTime:n,title:s,coverImgUrl:d}),Qt.play()):e==="seek"&&Qt&&Qt.seekTo(n),{errMsg:`${r}:ok`}}function vA({operationType:e,src:t,startTime:n,currentTime:r}){return gA({operationType:e,src:t,position:n||r||0,api:"operateBackgroundAudio"})}function Nc({state:e,errMsg:t,errCode:n,dataUrl:r}){Ap[e].forEach(s=>{Q.isFunction(s)&&s(e==="error"?{errMsg:t,errCode:n}:{})})}let mA=ae.once(()=>{cA.forEach(e=>{Tp.prototype[`on${Q.capitalize(e)}`]=function(t){Ap[e].push(t)}})}),_A=[{name:"duration",readonly:!0},{name:"currentTime",readonly:!0},{name:"paused",readonly:!0},{name:"src",cache:!0},{name:"startTime",default:0,cache:!0},{name:"buffered",readonly:!0},{name:"title",cache:!0},{name:"epname",cache:!0},{name:"singer",cache:!0},{name:"coverImgUrl",cache:!0},{name:"webUrl",cache:!0},{name:"protocol",readonly:!0,default:"http"},{name:"playbackRate",default:1,cache:!0}];class Tp{constructor(){this._options={},_A.forEach(t=>{let n=t.name;Object.defineProperty(this,n,{get:()=>{let r=t.cache?this._options:pA();return n in r?r[n]:t.default},set:t.readonly?void 0:r=>{this._options[n]=r,Op(this._options,n)}})}),mA()}play(){this._operate("play")}pause(){this._operate("pause")}stop(){this._operate("stop")}seek(t){this._operate("seek",{currentTime:t})}_operate(t,n){vA(Q.extend({},n,{operationType:t}))}}let Ip,bA=Dt(cb,()=>Ip||(Ip=new Tp));class yA{constructor(t,n){this.id=t,this.ctx=n}start(t){return Yt(this.ctx,"start",t)}stop(t){return Yt(this.ctx,"stop",t)}pause(t){return Yt(this.ctx,"pause",t)}resume(t){return Yt(this.ctx,"resume",t)}switchCamera(t){return Yt(this.ctx,"switchCamera",t)}snapshot(t){return Yt(this.ctx,"snapshot",t)}toggleTorch(t){return Yt(this.ctx,"toggleTorch",t)}playBGM(t){return Kn(this.ctx,"playBGM",t)}stopBGM(t){return Yt(this.ctx,"stopBGM",t)}pauseBGM(t){return Yt(this.ctx,"pauseBGM",t)}resumeBGM(t){return Yt(this.ctx,"resumeBGM",t)}setBGMVolume(t){return Kn(this.ctx,"setBGMVolume",t)}startPreview(t){return Yt(this.ctx,"startPreview",t)}stopPreview(t){return Yt(this.ctx,"stopPreview",t)}}function vl(e,t,n,r){bt.invokeViewMethod("livepusher."+e,{livePusherId:e,type:n,data:r},t)}class EA{constructor(t,n){this.id=t,this.pageId=n}start(){vl(this.id,this.pageId,"start")}stop(){vl(this.id,this.pageId,"stop")}pause(){vl(this.id,this.pageId,"pause")}resume(){vl(this.id,this.pageId,"resume")}switchCamera(){vl(this.id,this.pageId,"switchCamera")}startPreview(){vl(this.id,this.pageId,"preview")}stopPreview(){vl(this.id,this.pageId,"stop")}snapshot(){vl(this.id,this.pageId,"snapshot")}}let wA=Dt(Gm,(e,t)=>{if(t.$page.meta.isNVue){if(!t)return console.warn("uni.createLivePusherContext: 2 arguments required, but only 1 present");let n=za(e,t);return n?new yA(e,n):console.warn("Can not find `"+e+"`")}return new EA(e,t.$page.id)},Ym),Ui=3.141592653589793,Du=6378245,Fu=.006693421622965943;function SA(e,t){if(t=+t,e=+e,Pp(e,t))return[e,t];let n=Np(e-105,t-35),r=kp(e-105,t-35),s=t/180*Ui,d=Math.sin(s);d=1-Fu*d*d;let g=Math.sqrt(d);n=n*180/(Du*(1-Fu)/(d*g)*Ui),r=r*180/(Du/g*Math.cos(s)*Ui);let y=t+n,z=e+r;return[e*2-z,t*2-y]}function CA(e,t){if(t=+t,e=+e,Pp(e,t))return[e,t];let n=Np(e-105,t-35),r=kp(e-105,t-35),s=t/180*Ui,d=Math.sin(s);d=1-Fu*d*d;let g=Math.sqrt(d);n=n*180/(Du*(1-Fu)/(d*g)*Ui),r=r*180/(Du/g*Math.cos(s)*Ui);let y=t+n;return[e+r,y]}let Pp=function(e,t){return e<72.004||e>137.8347||t<.8293||t>55.8271||!1},Np=function(e,t){let n=-100+2*e+3*t+.2*t*t+.1*e*t+.2*Math.sqrt(Math.abs(e));return n+=(20*Math.sin(6*e*Ui)+20*Math.sin(2*e*Ui))*2/3,n+=(20*Math.sin(t*Ui)+40*Math.sin(t/3*Ui))*2/3,n+=(160*Math.sin(t/12*Ui)+320*Math.sin(t*Ui/30))*2/3,n},kp=function(e,t){let n=300+e+2*t+.1*e*e+.1*e*t+.1*Math.sqrt(Math.abs(e));return n+=(20*Math.sin(6*e*Ui)+20*Math.sin(2*e*Ui))*2/3,n+=(20*Math.sin(e*Ui)+40*Math.sin(e/3*Ui))*2/3,n+=(150*Math.sin(e/12*Ui)+300*Math.sin(e/30*Ui))*2/3,n};function Rp(e,t,n){let r=t.coords;if(e!==t.coordsType){let s;e==="wgs84"?s=SA(r.longitude,r.latitude):e==="gcj02"&&(s=CA(r.longitude,r.latitude)),s&&(r.longitude=s[0],r.latitude=s[1])}n({type:e,altitude:r.altitude||0,latitude:r.latitude,longitude:r.longitude,speed:r.speed,accuracy:r.accuracy,address:t.address,errMsg:"getLocation:ok"})}let AA=Re(W0,({type:e="wgs84",geocode:t=!1,altitude:n=!1,highAccuracyExpireTime:r,isHighAccuracy:s=!1},{resolve:d,reject:g})=>{c.geolocation.getCurrentPosition(y=>{Rp(e,y,d)},y=>{if(y.code===1501){Rp(e,y,d);return}g("getLocation:fail "+y.message)},{geocode:t,enableHighAccuracy:s||n,timeout:r,coordsType:e})},Y0,G0),OA=Re(j0,(e,{resolve:t,reject:n})=>{let s=np()!=="light",d,g=Rs({url:"__uniappchooselocation",data:Q.extend({},e,{locale:nu()}),style:{animationType:e.animationType||"slide-in-bottom",titleNView:!1,popGesture:"close",scrollIndicator:"none"},onMessage({event:y,detail:z}){y==="selected"&&(d=z)},onClose(){s&&c.navigator.setStatusBarStyle("dark"),d?t(d):n("cancel")}});s&&(c.navigator.setStatusBarStyle("light"),g.webview.addEventListener("popGesture",({type:y,result:z})=>{y==="start"?c.navigator.setStatusBarStyle("dark"):y==="end"&&!z&&c.navigator.setStatusBarStyle("light")}))},z0),TA=Re(q0,(e,{resolve:t,reject:n})=>(Rs({url:"__uniappopenlocation",data:Q.extend({},e,{locale:nu()}),style:{titleNView:{type:"transparent"},popGesture:"close",backButtonAutoControl:"close"},onClose(){n("cancel")}}),t()),J0,K0),IA=Re(RE,({title:e="",content:t="",showCancel:n=!0,cancelText:r,cancelColor:s,confirmText:d,confirmColor:g,editable:y=!1,placeholderText:z=""}={},{resolve:P})=>{let $=n?[r,d]:[d],_e=y?z:$;t=t||" ",c.nativeUI[y?"prompt":"confirm"](t,Te=>{if(n){let Le=Te.index===1,Et={confirm:Le,cancel:Te.index===0||Te.index===-1};Le&&y&&(Et.content=Te.value),P(Et)}else{let Le={confirm:Te.index===0,cancel:!1};y&&(Le.content=Te.value),P(Le)}},e,_e,$)},xE,BE),PA=Re(OE,({itemList:e=[],itemColor:t="#000000",title:n="",popover:r},{resolve:s,reject:d})=>{Cn();let{t:g}=Z(),y={title:n,cancel:g("uni.showActionSheet.cancel"),buttons:e.map(z=>({title:z,color:t}))};c.nativeUI.actionSheet(Q.extend(y,{popover:r}),z=>{z.index>0?s({tapIndex:z.index-1}):d("showActionSheet:fail cancel")})},TE,IE),fu,Yf=!1,Lu="",Vu,NA=Re(PE,(e,t)=>xp(Q.extend({},e,{type:"loading",icon:"loading"}),t),NE,kE),xp=({title:e="",icon:t="success",image:n="",duration:r=1500,mask:s=!1,position:d,type:g="toast",style:y},{resolve:z,reject:P})=>{if($u(""),Lu=g,["top","center","bottom"].includes(String(d)))c.nativeUI.toast(e,{verticalAlign:d}),Yf=!0;else{t&&!~["success","loading","error","none"].indexOf(t)&&(t="success");let $={modal:s,back:"transmit",padding:"10px",size:"16px"};!n&&(!t||t==="none")?$.loading={display:"none"}:($.width="140px",$.height="112px"),n?$.loading={display:"block",height:"55px",icon:n,interval:r}:["success","error"].indexOf(t)!==-1&&($.loading={display:"block",height:"55px",icon:t==="success"?"__uniappsuccess.png":"__uniapperror.png",interval:r});try{fu=c.nativeUI.showWaiting(e,Q.extend($,y))}catch(_e){P(`${_e}`)}}return Lu==="toast"&&(Vu=B(()=>{$u("")},r)),z()},kA=Re(ME,xp,FE,LE),RA=Re(pE,(e,t)=>$u("toast",t)),xA=Re(hE,(e,t)=>$u("loading",t));function $u(e="toast",t){return e&&e!==Lu||(Vu&&(C(Vu),Vu=null),Yf?c.nativeUI.closeToast():fu&&fu.close&&fu.close(),fu=null,Yf=!1,Lu=""),t&&t.resolve()}let BA=Re(VE,(e,{resolve:t,reject:n})=>{let r=tp();if(r&&r.endPullToRefresh(),r=Ru(),!r)return n();r.beginPullToRefresh(),Ff(r),t()}),MA=Re($E,(e,{resolve:t,reject:n})=>{let r=tp()||Ru();if(!r)return n();r.endPullToRefresh(),Ff(null),t()}),DA=Re(Gh,(e,{resolve:t,reject:n})=>{let r=nr(xr());bt.invokeViewMethod(Gh,e,r,s=>{s?n(s):t()})},gE),FA=Re(Yh,(e,{resolve:t})=>{let n=nr(xr());bt.invokeViewMethod(Yh,e,n,t)},CE,AE),LA=Re(yE,({__page__:e,title:t},{resolve:n,reject:r})=>{let s=Qh(e);if(s){let d=s.getStyle();d&&d.titleNView&&s.setStyle({titleNView:{titleText:t}}),n()}else r()},EE),VA=Re(wE,(e,{resolve:t})=>{c.nativeUI.showWaiting("",{modal:!1}),t()}),$A=Re(SE,(e,{resolve:t})=>{c.nativeUI.closeWaiting(),t()});function UA(e){let t=Gn();!t.length||(t[t.length-1].$page.statusBarStyle=e)}let HA=Re(mE,({__page__:e,frontColor:t,backgroundColor:n},{resolve:r,reject:s})=>{let d=Qh(e);if(d){let g={};t&&(g.titleColor=t),n&&(g.backgroundColor=n);let y=t==="#000000"?"dark":"light";c.navigator.setStatusBarStyle(y),UA(y);let z=d.getStyle();z&&z.titleNView&&(z.titleNView.autoBackButton&&(g.backButton=g.backButton||{},g.backButton.color=t),d.setStyle({titleNView:g})),r()}else s()},bE,_E),jA=Re(aw,({index:e,text:t},{resolve:n,reject:r})=>{Ti.setTabBarBadge("text",e,t),n()},sw,lw),zA=Re(UE,({index:e,text:t,iconPath:n,selectedIconPath:r,pagePath:s,visible:d,iconfont:g},{resolve:y})=>{if(Ti.setTabBarItem(e,t,n,r,d,g),s){let z=I.tabBar.list[e];if(z){let P=z.pagePath,$=ae.removeLeadingSlash(s);$!==P&&Ps(e,P,$)}}y()},HE,jE),WA=Re(zE,(e={},{resolve:t,reject:n})=>{if(!su())return n("not TabBar page");let r={black:"rgba(0,0,0,0.4)",white:"rgba(255,255,255,0.4)"},s=e.borderStyle;s&&s in r&&(e.borderStyle=r[s]),Ti.setTabBarStyle(e),t()},WE,YE),GA=Re(qE,(e,{resolve:t,reject:n})=>{let r=e&&e.animation;if(!su())return n("not TabBar page");Ti.hideTabBar(Boolean(r)),t()},qh),YA=Re(KE,(e,{resolve:t,reject:n})=>{let r=e&&e.animation;if(!su())return n("not TabBar page");Ti.showTabBar(Boolean(r)),t()},JE),qA=Re(ew,({index:e},{resolve:t,reject:n})=>{Ti.setTabBarBadge("redDot",e),t()},tw,nw),Bp=e=>Ti.setTabBarBadge("none",e),KA=Re(rw,({index:e},{resolve:t,reject:n})=>{Bp(e),t()},iw,ow),JA=Re(ZE,({index:e},{resolve:t,reject:n})=>{Bp(e),t()},XE,QE),Mp="vdSync",ZA="__uniapp__service",kc="onWebviewReady",XA=0,QA="webviewInserted",eO="webviewRemoved",Dp="UniAppSubNVue";class tO{constructor(t,n){this.callbacks=[];let r=this.webview=c.webview.getWebviewById(t);if(this.isSub=n||!1,r.__uniapp_mask_id){let s=this.maskWebview=r.__uniapp_mask_id==="0"?{setStyle({mask:g}){va("uni-tabview").setMask({color:g})}}:c.webview.getWebviewById(r.__uniapp_mask_id),d=function(){s.setStyle({mask:"none"})};r.addEventListener("hide",d),r.addEventListener("close",d)}}show(...t){if(this.maskWebview){let n=this.webview.__uniapp_mask;this.maskWebview.setStyle({mask:n})}this.webview.show(...t)}hide(...t){this.webview.hide(...t)}setStyle(t){this.webview.setStyle(t)}initMessage(){if(this.messageReady)return;this.messageReady=!0;let t=r=>{if(r.data&&r.data.type===Dp){let s=r.data.target;s.id===this.webview.id&&s.isSub===this.isSub&&this.callbacks.forEach(d=>{d({origin:this.webview.__uniapp_host,data:r.data.data})})}};va("globalEvent").addEventListener("plusMessage",t),this.webview.addEventListener("close",()=>{this.callbacks.length=0})}postMessage(t){c.webview.postMessageToUniNView({type:Dp,data:t,target:{id:this.webview.id,isSub:!this.isSub}},ZA)}onMessage(t){this.initMessage(),this.callbacks.push(t)}}let nO=function(e,t){return new tO(e,t)},du,Fp=c.navigator.setStatusBarStyle;function rO(e){Fp=e}function Lp(e){du=e,Fp(e)}c.navigator.setStatusBarStyle=Lp;function Ys(e){if(!e){let t=Rr();if(!t||(e=t.$page.statusBarStyle,!e||e===du))return}e!==du&&(du=e,c.navigator.setStatusBarStyle(e))}function iO(e,t,n,r,s,d,g){c!==n&&(T=hn=e,v=t,c=n,rO(c.navigator.setStatusBarStyle),c.navigator.setStatusBarStyle=Lp,B=r,C=s,k=d,u=g),I.serviceReady=!0}function oO(){let e=["ArrayBuffer","Int8Array","Uint8Array","Uint8ClampedArray","Int16Array","Uint16Array","Int32Array","Uint32Array","Float32Array","Float64Array","BigInt64Array","BigUint64Array"],t={};for(let n=0;n<e.length;n++){let r=e[n];t[r]=global[r]}return t}let Vp={oauth(e){c.oauth.getServices(t=>{t=t;let n=[];t.forEach(({id:r})=>{n.push(r)}),e(null,n,t)},t=>{t=t,e(t)})},share(e){c.share.getServices(t=>{t=t;let n=[];t.forEach(({id:r})=>{n.push(r)}),e(null,n,t)},t=>{e(t)})},payment(e){c.payment.getChannels(t=>{let n=[];t.forEach(({id:r})=>{n.push(r)}),e(null,n,t)},t=>{e(t)})},push(e){if(typeof v!="undefined"||typeof c!="undefined"){let t=c.push.getClientInfo();e(null,[t.id],[t])}else e(null,[])}},aO=Re(cw,({service:e},{resolve:t,reject:n})=>{Vp[e]?Vp[e]((r,s=[],d=[])=>{r?n(r.message):t({service:e,provider:s,providers:d.map(g=>(typeof g.serviceReady=="boolean"&&(g.isAppExist=g.serviceReady),typeof g.nativeClient=="boolean"&&(g.isAppExist=g.nativeClient),g))})}):n("service not found")},uw),Uu;function hu(e){return new Promise((t,n)=>{c.oauth.getServices(r=>{let s=r.find(({id:d})=>d===e);s?t(s):n(new Error("provider not find"))},n)})}let $p=Re(fw,(e,{resolve:t,reject:n})=>{let r=e.provider||"weixin",s=_r(n),d=r==="apple",g=d?{scope:"email"}:e.univerifyStyle?{univerifyStyle:cO(e.univerifyStyle,s)}:{};hu(r).then(y=>{function z(){if(e.onlyAuthorize&&r==="weixin"){y.authorize(({code:P})=>{t({code:P,authResult:""})},s);return}y.login(P=>{let $=P.target.authResult,_e=P.target.appleInfo;t({code:$.code,authResult:$,appleInfo:_e})},s,g)}d||r==="univerify"?z():y.logout(z,z)}).catch(s)},dw),Up=(e,{resolve:t,reject:n})=>{let r=e.provider||"weixin",s=_r(n);hu(r).then(d=>{d.getUserInfo(g=>{let y={nickName:""};if(r==="weixin"){let P=d.userInfo;P&&(y={openId:P.openid,nickName:P.nickname,gender:P.sex,city:P.city,province:P.province,country:P.country,avatarUrl:P.headimgurl,unionId:P.unionid})}else if(r==="apple"){let P=d.appleInfo;P&&(y={openId:P.user,fullName:P.fullName,email:P.email,authorizationCode:P.authorizationCode,identityToken:P.identityToken,realUserStatus:P.realUserStatus})}else y=d.userInfo,y&&(y.openId=y.openId||y.openid||d.authResult.openid,y.nickName=y.nickName||y.nickname,y.avatarUrl=y.avatarUrl||y.headimgurl);let z={};e.data&&e.data.api_name==="webapi_getuserinfo"?z.data={data:JSON.stringify(y),rawData:"",signature:"",encryptedData:"",iv:""}:z.userInfo=y,t(z)},s)}).catch(()=>{n("\u8BF7\u5148\u8C03\u7528 uni.login")})},sO=Re(hw,Up,pw),lO=Re(gw,Up,vw),Hp=Re(mw,({provider:e},{resolve:t,reject:n})=>{let r=jl(t),s=_r(n);hu(e).then(d=>d.preLogin(r,s)).catch(s)},yw,bw),jp=()=>hu("univerify").then(e=>e.closeAuthView()),zp=Dt(Ew,jp),Wp=Re(ww,(e,{resolve:t,reject:n})=>{let r=jl(t),s=_r(n);try{hu("univerify").then(d=>{let g=d.getCheckBoxState();r({state:g})})}catch(d){s(d)}});function cO(e,t){return Q.isPlainObject(e)&&Q.isPlainObject(e.buttons)&&Q.toTypeString(e.buttons.list)==="[object Array]"&&e.buttons.list.forEach((n,r)=>{e.buttons.list[r].onclick=function(){let s={code:"30008",message:"\u7528\u6237\u70B9\u51FB\u4E86\u81EA\u5B9A\u4E49\u6309\u94AE",index:r,provider:n.provider};Q.isPlainObject(Uu)?Uu._triggerUniverifyButtonsClick(s):jp().then(()=>{t(s)})}}),e}class uO{constructor(){this.provider="univerify",this.eventName="api.univerifyButtonsClick"}close(){return zp()}login(t){return $p(this._getOptions(t))}getCheckBoxState(t){return Wp(t)}preLogin(t){return Hp(this._getOptions(t))}onButtonsClick(t){bt.on(this.eventName,t)}offButtonsClick(t){bt.off(this.eventName,t)}_triggerUniverifyButtonsClick(t){bt.emit(this.eventName,t)}_getOptions(t={}){return Q.extend({},t,{provider:this.provider})}}let fO=Dt(Sw,()=>Uu||(Uu=new uO)),dO=Re(Rw,(e,{resolve:t,reject:n})=>{let r=bp();if(r.notificationAuthorized!=="authorized")return n("notificationAuthorized: "+r.notificationAuthorized);let s=Q.extend({},e);delete s.content,delete s.payload,c.push.createMessage(e.content,e.payload,s),t()},void 0,xw),hO=Dt("registerRuntime",e=>{Q.extend(jsRuntime,e)}),pO={0:{name:"web",title:"\u56FE\u6587"},1:{name:"text",title:"\u7EAF\u6587\u5B57"},2:{name:"image",title:"\u7EAF\u56FE\u7247"},3:{name:"music",title:"\u97F3\u4E50"},4:{name:"video",title:"\u89C6\u9891"},5:{name:"miniProgram",title:"\u5C0F\u7A0B\u5E8F"}},gO=e=>{e.type=e.type||0;let{provider:t,type:n,title:r,summary:s,href:d,imageUrl:g,mediaUrl:y,scene:z,miniProgram:P,openCustomerServiceChat:$,corpid:_e,customerUrl:Te}=e;Q.isString(g)&&g&&(g=St(g));let Le=pO[n];if(Le){let Et={provider:t,type:Le.name,title:r,content:s,href:d,pictures:[g],thumbs:g?[g]:void 0,media:y,miniProgram:P,extra:{scene:z},openCustomerServiceChat:$,corpid:_e,url:Te};return t==="weixin"&&(n===1||n===2)&&delete Et.thumbs,Et}return"\u5206\u4EAB\u53C2\u6570 type \u4E0D\u6B63\u786E"},Gp=function(e,t,n,r,s="share"){let d=_r(r),g=t.openCustomerServiceChat?"openCustomerServiceChat":"send";try{e[g](t,()=>{n()},d)}catch(y){d({message:`${t.provider} ${g} \u65B9\u6CD5\u8C03\u7528\u5931\u8D25`})}},vO=Re(Cw,(e,{resolve:t,reject:n})=>{let r=gO(e),s=_r(n);if(Q.isString(r))return n(r);c.share.getServices(d=>{let g=d.find(({id:y})=>y===r.provider);g?g.authenticated?Gp(g,r,t,n):g.authorize(()=>Gp(g,r,t,n),s):n("service not found")},s)},Ow,Aw),mO=Re(Tw,({type:e,imageUrl:t,summary:n,href:r},{resolve:s,reject:d})=>{let g=_r(d);Q.isString(t)&&t&&(t=St(t)),c.share.sendWithSystem({type:e,pictures:t?[t]:void 0,content:n,href:r},()=>s(),g)},Pw,Iw),_O=Re(Nw,(e,{resolve:t,reject:n})=>{let r=e.provider,s=_r(n);c.payment.getChannels(d=>{let g=d.find(({id:y})=>y===r);g?c.payment.request(g,e.orderInfo,y=>{t(y)},s):n("service not found")},s)},kw),Yp=fp,bO=Re("navigateToMiniProgram",(e,{resolve:t,reject:n})=>{Yp("navigateToUniMP",e,r=>{if(r.errMsg&&r.errMsg.indexOf(":ok")===-1)return n(r.errMsg.split(" ")[1]);t()})}),qp=[];function Kp(e){qp.push(e)}let yO=Kp;function EO(e,t){qp.forEach(n=>n(e,t))}function wO(e,t,...n){let r=AO(e,t,n);r&&console[e](r)}function SO(){return typeof __channelId__=="string"&&__channelId__}function CO(e,t){switch(Q.toRawType(t)){case"Function":return"function() { [native code] }";default:return t}}function AO(e,t,n){return SO()?(n.push(t.replace("at ","uni-app:///")),console[e].apply(console,n)):n.map(function(s){let d=Q.toTypeString(s).toLowerCase();if(["[object object]","[object array]","[object module]"].indexOf(d)!==-1)try{s="---BEGIN:JSON---"+JSON.stringify(s,CO)+"---END:JSON---"}catch(g){s=d}else if(s===null)s="---NULL---";else if(s===void 0)s="---UNDEFINED---";else{let g=Q.toRawType(s).toUpperCase();g==="NUMBER"||g==="BOOLEAN"?s="---BEGIN:"+g+"---"+s+"---END:"+g+"---":s=String(s)}return s}).join("---COMMA---")+" "+t}let na={load:"load",close:"close",error:"error",adClicked:"adClicked"};class Jp{constructor(){this._callbacks={}}onLoad(t){this._addEventListener(na.load,t)}onClose(t){this._addEventListener(na.close,t)}onError(t){this._addEventListener(na.error,t)}offLoad(t){this._removeEventListener(na.load,t)}offClose(t){this._removeEventListener(na.close,t)}offError(t){this._removeEventListener(na.error,t)}_addEventListener(t,n){!Q.isFunction(n)||(this._callbacks[t]||(this._callbacks[t]=[]),this._callbacks[t].push(n))}_removeEventListener(t,n){let r=this._callbacks[t],s=r.indexOf(n);s>-1&&r.splice(s,1)}_dispatchEvent(t,n){this._callbacks[t].forEach(r=>{r(n||{})})}}class qf extends Jp{constructor(t,n){super();this.preload=!0,this._isLoaded=!1,this._isLoading=!1,this._loadPromiseResolve=null,this._loadPromiseReject=null,this._showPromiseResolve=null,this._showPromiseReject=null,this.preload=n.preload!==void 0?n.preload:!1;let r=this._adInstance=t;r.onLoad(()=>{this._isLoaded=!0,this._isLoading=!1,this._loadPromiseResolve!=null&&(this._loadPromiseResolve(),this._loadPromiseResolve=null),this._showPromiseResolve!=null&&(this._showPromiseResolve(),this._showPromiseResolve=null,this._showAd()),this._dispatchEvent(na.load,{})}),r.onClose(s=>{this._isLoaded=!1,this._isLoading=!1,this._dispatchEvent(na.close,s),this.preload===!0&&this._loadAd()}),r.onError(s=>{this._isLoading=!1;let d={code:s.code,errMsg:s.message};this._dispatchEvent(na.error,d);let g=new Error(JSON.stringify(d));this._loadPromiseReject!=null&&(this._loadPromiseReject(g),this._loadPromiseReject=null),this._showPromiseReject!=null&&(this._showPromiseReject(g),this._showPromiseReject=null)}),r.onAdClicked&&r.onAdClicked(()=>{this._dispatchEvent(na.adClicked,{})})}getProvider(){return this._adInstance.getProvider()}load(){return new Promise((t,n)=>{this._loadPromiseResolve=t,this._loadPromiseReject=n,!this._isLoading&&(this._isLoaded?t(""):this._loadAd())})}show(){return new Promise((t,n)=>{this._showPromiseResolve=t,this._showPromiseReject=n,!this._isLoading&&(this._isLoaded?(this._showAd(),t("")):this._loadAd())})}destroy(){this._adInstance.destroy()}_loadAd(){this._isLoaded=!1,this._isLoading=!0,this._adInstance.load()}_showAd(){this._adInstance.show()}}class OO extends qf{constructor(t){super(c.ad.createRewardedVideoAd(t),t);this._loadAd()}}let TO=Dt(Bw,e=>new OO(e),Dw,Mw);class IO extends qf{constructor(t){super(c.ad.createFullScreenVideoAd(t),t);this.preload=!1}}let PO=Dt(Fw,e=>new IO(e),Vw,Lw);class NO extends qf{constructor(t){super(c.ad.createInterstitialAd(t),t);this.preload=!1,this._loadAd()}}let kO=Dt($w,e=>new NO(e),Hw,Uw),ls={},Wl={};function RO(e){let t=e.provider;if(ls[t]||(ls[t]={}),typeof ls[t].plugin=="object"){e.success(ls[t].plugin);return}if(Wl[t]||(Wl[t]=[]),Wl[t].push(e),ls[t].status===!0){e.__plugin=ls[t].plugin;return}ls[t].status=!0;let n=va(t);if(!n||!n.initSDK){Wl[t].forEach(r=>{r.fail({code:-1,message:"provider ["+t+"] invalid"})}),Wl[t].length=0,ls[t].status=!1;return}ls[t].plugin=n,e.__plugin=n,n.initSDK(r=>{let s=r.code===1||r.code==="1";s?ls[t].plugin=n:ls[t].status=!1,Wl[t].forEach(d=>{s?d.success(d.__plugin):d.fail(r)}),Wl[t].length=0})}class xO extends Jp{constructor(t){super();this._adpid="",this._provider="",this._userData=null,this._isLoaded=!1,this._isLoading=!1,this._loadPromiseResolve=null,this._loadPromiseReject=null,this._showPromiseResolve=null,this._showPromiseReject=null,this._adInstance=null,this._adError="",this._adpid=t.adpid,this._provider=t.provider,this._userData=t.userData,B(()=>{this._init()})}_init(){this._adError="",RO({provider:this._provider,success:t=>{this._adInstance=t,this._userData&&this.bindUserData(this._userData),this._loadAd()},fail:t=>{this._adError=t,this._loadPromiseReject!=null&&(this._loadPromiseReject(this._createError(t)),this._loadPromiseReject=null),this._dispatchEvent(na.error,t)}})}getProvider(){return this._provider}load(){return new Promise((t,n)=>{if(this._loadPromiseResolve=t,this._loadPromiseReject=n,!this._isLoading){if(this._adError){this._init();return}this._isLoaded?t(""):this._loadAd()}})}show(){return new Promise((t,n)=>{if(this._showPromiseResolve=t,this._showPromiseReject=n,!this._isLoading){if(this._adError){this._init();return}this._isLoaded?(this._showAd(),t("")):this._loadAd()}})}reportExposure(){this._adInstance!==null&&this._adInstance.reportExposure()}bindUserData(t){this._adInstance!==null&&this._adInstance.bindUserData(t)}destroy(){this._adInstance!==null&&this._adInstance.destroy&&this._adInstance.destroy({adpid:this._adpid})}_loadAd(){if(this._adInstance!==null){if(this._isLoading===!0)return;this._isLoading=!0,this._adInstance.loadData({adpid:this._adpid},t=>{this._isLoaded=!0,this._isLoading=!1,this._loadPromiseResolve!=null&&(this._loadPromiseResolve(),this._loadPromiseResolve=null),this._showPromiseResolve!=null&&(this._showPromiseResolve(),this._showPromiseResolve=null,this._showAd()),this._dispatchEvent(na.load,t)},t=>{this._isLoading=!1,this._showPromiseReject!=null&&(this._showPromiseReject(this._createError(t)),this._showPromiseReject=null),this._dispatchEvent(na.error,t)})}}_showAd(){this._adInstance!==null&&this._isLoaded===!0&&this._adInstance.show({adpid:this._adpid},()=>{this._isLoaded=!1},t=>{this._isLoaded=!1,this._showPromiseReject!=null&&(this._showPromiseReject(this._createError(t)),this._showPromiseReject=null),this._dispatchEvent(na.error,t)})}_createError(t){return new Error(JSON.stringify(t))}}let BO=Dt(jw,e=>new xO(e),Ww,zw),Zp=c.os.name==="Android"&&parseInt(c.os.version)<6,MO=Zp?"slide-in-right":"pop-in",Hu=300,Xp=Zp?"slide-out-right":"pop-out",DO="_www/__uniappview.html",FO="webviewId",LO="uniMPNativeEvent";function VO(e,t,n){n&&t.isNVue&&(e.uniNView={path:n,defaultFontSize:I.defaultFontSize,viewport:I.viewport})}let $O=/^#[a-z0-9]{6}$/i;function Qp(e){return e&&($O.test(e)||e==="transparent")}function UO(e,t){let{backgroundColor:n}=t;!n||!Qp(n)||(e.background||(e.background=n),e.backgroundColorTop||(e.backgroundColorTop=n))}function HO(e,t){e.popGesture==="hide"&&delete e.popGesture,t.isQuit&&(e.popGesture=c.os.name==="iOS"?"appback":"none")}function jO(e,t){if(!t.enablePullDownRefresh)return;let n=Zs(Q.extend({},c.os.name==="Android"?WO:GO,t.pullToRefresh));e.pullToRefresh=zO(n,t)}function zO(e,t){let n=Ua(e);if(!n)return e;let[r,s,d]=n;return(r||s||d)&&se.onLocaleChange(()=>{let g=c.webview.getWebviewById(t.id+"");if(!g)return;let y={support:!0};r&&(y.contentdown={caption:e.contentdown.caption}),s&&(y.contentover={caption:e.contentover.caption}),d&&(y.contentrefresh={caption:e.contentrefresh.caption}),g.setStyle({pullToRefresh:y})}),e}let WO={support:!0,style:"circle"},GO={support:!0,style:"default",height:"50px",range:"200px",contentdown:{caption:""},contentover:{caption:""},contentrefresh:{caption:""}};function YO(e,t){let{navigationBar:n}=t;if(n.style==="custom")return!1;let r=!0;t.isQuit&&(r=!1);let s={autoBackButton:r};Object.keys(n).forEach(d=>{let g=n[d];d==="backgroundColor"?s.backgroundColor=Qp(g)?g:ae.BACKGROUND_COLOR:d==="titleImage"&&g?s.tags=KO(g):d==="buttons"&&Q.isArray(g)?s.buttons=g.map((y,z)=>(y.onclick=JO(z),y)):s[d]=g}),e.titleNView=qO(s,t)}function qO(e,t){let n=$a(e);if(!n)return e;let[r,s]=n;return(r||s)&&se.onLocaleChange(()=>{let d=c.webview.getWebviewById(t.id+"");if(!d)return;let g={};r&&(g.titleText=e.titleText),s&&(g.searchInput={placeholder:e.searchInput.placeholder}),d.setStyle({titleNView:g})}),e}function KO(e){return[{tag:"img",src:e,position:{left:"auto",top:"auto",width:"auto",height:"26px"}}]}function JO(e){return function(n){n.index=e,Hn(ae.ON_NAVIGATION_BAR_BUTTON_TAP,n)}}function eg(e,t,n){let r={bounce:"vertical"};return Object.keys(t).forEach(s=>{ZO.indexOf(s)===-1&&(r[s]=t[s])}),n.id!=="1"&&VO(r,t,e),HO(r,t),UO(r,t),YO(r,t),jO(r,t),r}let ZO=["id","route","isNVue","isQuit","isEntry","isTabBar","tabBarIndex","windowTop","topWindow","leftWindow","rightWindow","maxWidth","usingComponents","disableScroll","enablePullDownRefresh","navigationBar","pullToRefresh","onReachBottomDistance","pageOrientation","backgroundColor"],tg=2;function ng(){return tg}function rg(){return tg++}function ig(e){return e}function og(e,t){let n=t?ae.stringifyQuery(t,ig):"";return{path:e.slice(1),query:n&&n.slice(1)}}function XO(e,t,n){let r=n?ae.stringifyQuery(n,ig):"";return{isTab:e,arguments:JSON.stringify({path:t.slice(1),query:r&&r.slice(1)})}}function QO({path:e,query:t,routeOptions:n,webviewExtras:r}){let s=rg(),d=eg(e,n.meta,{id:s+""});return d.uniPageUrl=og(e,t),d.isTab=!!n.meta.isTabBar,c.webview.create("",String(s),d,Q.extend({nvue:!0,__path__:e,__query__:JSON.stringify(t)},r))}let lo;function ag(e){lo=e}function eT(){return lo}function tT(){return(!lo||lo.__uniapp_route)&&(lo=c.webview.create(DO,String(rg()),{contentAdjust:!1})),lo}function nT(e){let{popupSubNVueWebviews:t}=e;!t||e.addEventListener("close",()=>{Object.keys(t).forEach(n=>{t[n].close("none")})})}function sg(e){return I.realEntryPagePath&&e.$page.route===I.entryPagePath}function lg(){I.entryPagePath=I.realEntryPagePath,delete I.realEntryPagePath,se.reLaunch({url:ae.addLeadingSlash(I.entryPagePath)})}function rT(e){let t;e.addEventListener("popGesture",n=>{if(n.type==="start"){let r=Gn(),s=r[r.length-2];t=du;let d=s&&s.$page.statusBarStyle;d&&Ys(d)}else if(n.type==="end"&&!n.result)Ys(t);else if(n.type==="end"&&n.result){let r=Gn().length,s=Rr();Ka(),Ys(),s&&r===1&&sg(s)?lg():Hn(ae.ON_SHOW)}})}function iT(e){if(e.nvue)return;let t=e.id,{subscribe:n,unsubscribe:r}=bt,s=(d,g)=>{if(t!==g)return;r(kc,s);let y=qo(parseInt(g));y&&y.__page_container__.restore()};e.addEventListener("recovery",()=>{n(kc,s)})}function oT(e){let{emit:t}=bt,n=function({width:r,height:s}){let g={deviceOrientation:Math.abs(c.navigator.getOrientation())===90?"landscape":"portrait",size:{windowWidth:Math.ceil(r),windowHeight:Math.ceil(s)}};t(ae.ON_RESIZE,g,parseInt(e.id))};e.addEventListener("resize",ae.debounce(n,50,{setTimeout:B,clearTimeout:C}))}let cg={pullToRefresh:ae.ON_PULL_DOWN_REFRESH,titleNViewSearchInputChanged:ae.ON_NAVIGATION_BAR_SEARCH_INPUT_CHANGED,titleNViewSearchInputConfirmed:ae.ON_NAVIGATION_BAR_SEARCH_INPUT_CONFIRMED,titleNViewSearchInputClicked:ae.ON_NAVIGATION_BAR_SEARCH_INPUT_CLICKED,titleNViewSearchInputFocusChanged:ae.ON_NAVIGATION_BAR_SEARCH_INPUT_FOCUS_CHANGED};function aT(e){let t=parseInt(e.id);Object.keys(cg).forEach(n=>{let r=cg[n];e.addEventListener(n,s=>{r===ae.ON_PULL_DOWN_REFRESH&&Ff(e),Hn(t,r,s)})}),nT(e),oT(e),c.os.name==="iOS"&&(iT(e),rT(e))}function sT(e,t,n,r){let s=eg(t,r,e);s.uniPageUrl=og(t,n);let d=!!r.isTabBar;r.isNVue?s.isTab=d:s.debugRefresh=XO(d,t,n),s.locale=v.requireModule("plus").getLanguage(),e.setStyle(s)}function lT(e,t,n){(n.subNVues||[]).forEach(s=>{if(!s.path)return;let d=Is(s.style||{}),g=s.type==="navigationBar",y=s.type==="popup";d.uniNView={path:s.path.replace(".nvue",".js"),defaultFontSize:I.defaultFontSize,viewport:I.viewport};let z={__uniapp_host:t,__uniapp_origin:d.uniNView.path.split("?")[0].replace(".js",""),__uniapp_origin_id:e.id,__uniapp_origin_type:e.__uniapp_type},P;g?(d.position="dock",d.dock="top",d.top="0",d.width="100%",d.height=String(ae.NAVBAR_HEIGHT+Lf()),delete d.left,delete d.right,delete d.bottom,delete d.margin):y&&(d.position="absolute",su(t)?P=Ti:P=e,z.__uniapp_mask=d.mask||"rgba(0,0,0,0.5)",z.__uniapp_mask_id=P.id),delete d.mask;let $=c.webview.create("",s.id,d,z);if(y){P.popupSubNVueWebviews||(P.popupSubNVueWebviews={}),P.popupSubNVueWebviews[$.id]=$;let _e=function(){P.setStyle({mask:"none"}),$.hide("auto")};P.addEventListener("maskClick",_e);let Te=!1;$.addEventListener("show",()=>{Te||(c.key.removeEventListener("backbutton",Za),c.key.addEventListener("backbutton",_e),Te=!0)}),$.addEventListener("hide",()=>{Te&&(c.key.removeEventListener("backbutton",_e),c.key.addEventListener("backbutton",Za),Te=!1)}),$.addEventListener("close",()=>{delete P.popupSubNVueWebviews[$.id],Te&&(c.key.removeEventListener("backbutton",_e),c.key.addEventListener("backbutton",Za),Te=!1)})}else e.append($)})}function cT(e,t,n,r){(e.id==="1"||!r.isNVue)&&sT(e,t,n,r),lT(e,t,r),aT(e)}function ug(e){return e.routeOptions.meta.isNVue?QO(e):ng()===2?c.webview.getLaunchWebview():eT()}function fg(e,t){bt.once(kc+"."+e,t)}let cs=!1;function dg(e,t,n){cs={path:e,nvue:Xs(e).isNVue,callback:t}}function hg(e,t,n){Di(e),Gl(e.$getAppWebview(),t,n)}function ju(e,t,n=!1){if(!n&&cs)return console.error(`Waiting to navigate to: ${cs.path}, do not operate continuously: ${e}.`);if(I.renderer==="native")return Gn().length===0?dg(e,t,"waitForReady"):t();let r=!lo||lo&&lo.__uniapp_route,s=lo&&!lo.loaded;r||s?dg(e,t,r?"waitForCreate":"waitForReady"):t(),s&&fg(lo.id,zu)}function zu(){if(!cs)return;let{callback:e}=cs;return cs=!1,e()}function pg(){if(I.renderer==="native")return cs&&cs.nvue?zu():void 0;let e=tT();if(!!cs){if(cs.nvue)return zu();e.loaded?cs.callback():fg(e.id,zu)}}function Gl(e,t,n){e[e.__preload__?"hide":"close"](t,n)}function Wu(e,t,n,r,s){typeof s=="undefined"&&(s=e.nvue?0:100);let d=function(){d._called||(d._called=!0,r&&r(),pg())};d._called=!1,B(()=>{let g=B(()=>{d()},n+150);e.show(t,n,()=>{d._called||C(g),d()})},s)}function uT(e,t){let n=e.children();if(!n||!n.length)return t();let r=n.find(s=>s.id.indexOf(FO)===0)||n[0];r.canBack(({canBack:s})=>{s?r.back():t()})}let fT=Re(Xy,(e,{resolve:t,reject:n})=>{let r=Rr();if(!r)return n("getCurrentPages is empty");if(Hn(r,ae.ON_BACK_PRESS,{from:e.from||"navigateBack"}))return t();if(se.hideToast(),se.hideLoading(),r.$page.meta.isQuit)dT();else if(sg(r))lg();else{let{delta:s,animationType:d,animationDuration:g}=e;hT(s,d,g)}return t()},eE,uE),Gu=0;function dT(){zt(),Gu?Date.now()-Gu<2e3&&c.runtime.quit():(Gu=Date.now(),c.nativeUI.toast(Z().t("uni.app.quit")),B(()=>{Gu=0},2e3))}function hT(e,t,n){let r=Gn(),s=r.length,d=r[s-1];e>1&&r.slice(s-e,s-1).reverse().forEach(z=>{Gl(c.webview.getWebviewById(z.$page.id+""),"none",0)});let g=function(z){t?Gl(z,t,n||Hu):d.$page.openType==="redirectTo"?Gl(z,Xp,Hu):Gl(z,"auto"),r.slice(s-e,s).forEach(P=>Di(P)),Ys(),Hn(ae.ON_SHOW)},y=c.webview.getWebviewById(d.$page.id+"");if(!d.__uniapp_webview)return g(y);uT(y,()=>{g(y)})}class pT extends ae.UniNode{constructor(t,n,r=!1){super(ae.NODE_TYPE_PAGE,"#page",null);this._id=1,this._created=!1,this._updating=!1,this._createActionMap=new Map,this.updateActions=[],this.dicts=[],this.nodeId=0,this.pageId=t,this.pageNode=this,this.options=n,this.isUnmounted=!1,this.createAction=[ae.ACTION_TYPE_PAGE_CREATE,n],this.createdAction=[ae.ACTION_TYPE_PAGE_CREATED],this.normalizeDict=this._normalizeDict.bind(this),this._update=this.update.bind(this),r&&this.setup()}_normalizeDict(t,n=!0){if(!Q.isPlainObject(t))return this.addDict(t);let r=[];return Object.keys(t).forEach(s=>{let d=[this.addDict(s)],g=t[s];n?d.push(this.addDict(g)):d.push(g),r.push(d)}),r}addDict(t){let{dicts:n}=this,r=n.indexOf(t);return r>-1?r:n.push(t)-1}onInjectHook(t){(t===ae.ON_PAGE_SCROLL||t===ae.ON_REACH_BOTTOM)&&!this.scrollAction&&(this.scrollAction=[ae.ACTION_TYPE_PAGE_SCROLL,this.options.onReachBottomDistance],this.push(this.scrollAction))}onCreate(t,n){return mT(this,t.nodeId,n),t}onInsertBefore(t,n,r){return _T(this,n,t.nodeId,r&&r.nodeId||-1),n}onRemoveChild(t){return bT(this,t.nodeId),t}onAddEvent(t,n,r){t.parentNode&&yT(this,t.nodeId,n,r)}onAddWxsEvent(t,n,r,s){t.parentNode&&ET(this,t.nodeId,n,r,s)}onRemoveEvent(t,n){t.parentNode&&wT(this,t.nodeId,n)}onSetAttribute(t,n,r){t.parentNode&&CT(this,t.nodeId,n,r)}onRemoveAttribute(t,n){t.parentNode&&AT(this,t.nodeId,n)}onTextContent(t,n){t.parentNode&&vg(this,t.nodeId,n)}onNodeValue(t,n){t.parentNode&&vg(this,t.nodeId,n)}genId(){return this._id++}push(t,n){if(!this.isUnmounted){switch(t[0]){case ae.ACTION_TYPE_CREATE:this._createActionMap.set(t[1],t);break;case ae.ACTION_TYPE_INSERT:let r=this._createActionMap.get(t[1]);r?(r[3]=t[2],r[4]=t[3],n&&(r[5]=n)):(n&&(t[4]=n),this.updateActions.push(t));break}t[0]!==ae.ACTION_TYPE_INSERT&&this.updateActions.push(t),this._updating||(this._updating=!0,hn.queuePostFlushCb(this._update))}}restore(){this.clear(),this.setup(),this.scrollAction&&this.push(this.scrollAction);let t=n=>{this.onCreate(n,n.nodeName),this.onInsertBefore(n.parentNode,n,null),n.childNodes.forEach(r=>{t(r)})};this.childNodes.forEach(n=>t(n)),this.push(this.createdAction)}setup(){this.send([this.createAction])}update(){let{dicts:t,updateActions:n,_createActionMap:r}=this;this._created||(this._created=!0,n.push(this.createdAction)),n.length&&(t.length&&n.unshift([XA,t]),this.send(n)),this.clear()}clear(){this.dicts.length=0,this.updateActions.length=0,this._updating=!1,this._createActionMap.clear()}send(t){bt.publishHandler(Mp,t,this.pageId)}fireEvent(t,n){let r=gg(t,this);r&&r.dispatchEvent(n)}}function gT(e){let t=qo(e);return t?t.__page_container__:null}function Kf(e,t,n){if(typeof n=="number"&&(n=gT(n)),n[e]===t)return n;let{childNodes:r}=n;for(let s=0;s<r.length;s++){let d=Kf(e,t,r[s]);if(d)return d}return null}function gg(e,t){return Kf("nodeId",e,t)}function vT(e,t){return Kf("nodeName",e.toUpperCase(),t)}function mT(e,t,n){e.push([ae.ACTION_TYPE_CREATE,t,e.addDict(n),-1,-1])}function _T(e,t,n,r){let s=t.toJSON({attr:!0,normalize:e.normalizeDict});e.push([ae.ACTION_TYPE_INSERT,t.nodeId,n,r],Object.keys(s).length?s:void 0)}function bT(e,t){e.push([ae.ACTION_TYPE_REMOVE,t])}function yT(e,t,n,r){e.push([ae.ACTION_TYPE_ADD_EVENT,t,e.addDict(n),r])}function ET(e,t,n,r,s){e.push([ae.ACTION_TYPE_ADD_WXS_EVENT,t,e.addDict(n),e.addDict(r),s])}function wT(e,t,n){e.push([ae.ACTION_TYPE_REMOVE_EVENT,t,e.addDict(n)])}function ST(e,t,n){return t==="style"&&Q.isPlainObject(n)?e.normalizeDict(n):e.addDict(n)}function CT(e,t,n,r){e.push([ae.ACTION_TYPE_SET_ATTRIBUTE,t,e.addDict(n),ST(e,n,r)])}function AT(e,t,n){e.push([ae.ACTION_TYPE_REMOVE_ATTRIBUTE,t,e.addDict(n)])}function vg(e,t,n){e.push([ae.ACTION_TYPE_SET_TEXT,t,e.addDict(n)])}function OT(e,t,n){return new pT(e,t,n)}function mg(e){let t=e.setup;return e.inheritAttrs=!1,e.setup=(n,r)=>{let{attrs:{__pageId:s,__pagePath:d,__pageQuery:g,__pageInstance:y}}=r,P=hn.getCurrentInstance().proxy;if(ut(P,y),Yo(_g(s,P,y)),hn.onMounted(()=>{hn.nextTick(()=>{Hn(P,ae.ON_READY)})}),hn.onBeforeUnmount(()=>{Hn(P,ae.ON_UNLOAD)}),t)return t(g,r)},e}function _g(e,t,n){let r=()=>c.webview.getWebviewById(e+"");return t.$getAppWebview=r,t.$.ctx.$scope={$getAppWebview:r},t.getOpenerEventChannel=()=>(n.eventChannel||(n.eventChannel=new ae.EventChannel(e)),n.eventChannel),t}function TT(e){return Q.isFunction(e)}let bg=new Map;function IT(e,t){bg.set(e,ae.once(NT(t)))}function PT(e,t,n,r,s){let d=OT(e,s,!0),g=Ya(),y=bg.get(t)(),z=P=>g.mountPage(P,{__pageId:e,__pagePath:t,__pageQuery:n,__pageInstance:r},d);return Q.isPromise(y)?y.then(P=>z(P)):z(y)}function NT(e){return()=>TT(e)?e().then(t=>mg(t)):mg(e)}let yg=!1;function Eg(){if(yg)return;yg=!0;let e,t;if(v.requireModule("plus").getRedirectInfo){let{path:d,query:g,referrerInfo:y}=Bt();d&&(e=d,t=g),I.referrerInfo=y}else{let d=c.runtime.arguments;if(!d)return;try{let g=JSON.parse(d);e=g.path||g.pathName,t=g.query?"?"+g.query:""}catch(g){}}if(!e||e===I.entryPagePath){t&&(I.entryPageQuery=t);return}let r=ae.addLeadingSlash(e),s=fo(r);!s||(s.meta.isTabBar||(I.realEntryPagePath=I.realEntryPagePath||I.entryPagePath),I.entryPagePath=e,I.entryPageQuery=t)}function wg(e,t){let n=JSON.parse(JSON.stringify(fo(e)));return n.meta=Ts(n.meta),t!=="preloadPage"&&!I.realEntryPagePath&&(t==="reLaunch"||Gn().length===0)?n.meta.isQuit=!0:n.meta.isTabBar||(n.meta.isQuit=!1),n}let Ss={};function kT(e){let t=Object.keys(Ss).find(n=>Ss[n].id===e.id);t&&delete Ss[t]}function RT({url:e}){let t=Ss[e];return t&&(t.__page__&&Gn().find(n=>n===t.__page__)?t.__preload__=!1:t.close("none"),delete Ss[e]),t}function xT({url:e,path:t,query:n}){if(!Ss[e]){let r=wg(t,"preloadPage");Ss[e]=ug({path:t,routeOptions:r,query:n,webviewExtras:{__preload__:!0}})}return Ss[e]}function pu({url:e,path:t,query:n,openType:r,webview:s,nvuePageVm:d,eventChannel:g}){if(s&&Eg(),Ss[e]){s=Ss[e];let Te=s;if(Te.__page__)if(Gn().find(Le=>Le===Te.__page__))s=void 0;else return g&&(Te.__page__.$page.eventChannel=g),Yo(Te.__page__),Te}let y=wg(t,r);s?(s=c.webview.getWebviewById(s.id),s.nvue=y.meta.isNVue):s=ug({path:t,routeOptions:y,query:n}),y.meta.id=parseInt(s.id),!!y.meta.isTabBar&&Ti.append(s),cT(s,t,n,y.meta);let P=t.slice(1);s.__uniapp_route=P;let $=Jr(r,e,n,y.meta,g),_e=parseInt(s.id);return s.nvue?d?MT(_e,d,$):DT(_e,s,$):PT(_e,P,n,$,BT(y)),s}function BT({meta:e}){let t=Lf(),{platform:n,pixelRatio:r,windowWidth:s}=ia();return{css:!0,route:e.route,version:1,locale:"",platform:n,pixelRatio:r,windowWidth:s,disableScroll:e.disableScroll===!0,onPageScroll:!1,onPageReachBottom:!1,onReachBottomDistance:Q.hasOwn(e,"onReachBottomDistance")?e.onReachBottomDistance:ae.ON_REACH_BOTTOM_DISTANCE,statusbarHeight:t,windowTop:e.navigationBar.type==="float"?t+ae.NAVBAR_HEIGHT:0,windowBottom:Ti.indexOf(e.route)>=0&&Ti.cover?Ti.height:0}}function MT(e,t,n){ut(t,n),Yo(_g(e,t,n)),e===1&&(I.splashscreen&&I.splashscreen.autoclose&&!I.splashscreen.alwaysShowBeforeRender&&c.navigator.closeSplashscreen(),I.onReady(function(){pg()}))}function DT(e,t,n){let r={$:{},$getAppWebview(){return t},getOpenerEventChannel(){return n.eventChannel||(n.eventChannel=new ae.EventChannel(e)),n.eventChannel},__setup(s,d){s.$getAppWebview=()=>t,s.getOpenerEventChannel=d.getOpenerEventChannel,ut(s,n),t.__preload__&&(t.__page__=s);let g=qa(),y=g.findIndex(z=>z===d);y>-1&&g.splice(y,1,s)}};ut(r,n),t.__preload__?t.__page__=r:Yo(r)}let Sg=(e,{resolve:t,reject:n})=>{let{url:r,events:s,animationType:d,animationDuration:g}=e,{path:y,query:z}=ae.parseUrl(r),[P,$]=VT(y,d,g);ju(y,()=>{LT({url:r,path:y,query:z,events:s,aniType:P,aniDuration:$}).then(t).catch(n)},e.openType==="appLaunch")},FT=Re(Nf,Sg,Qy,aE);function LT({url:e,path:t,query:n,events:r,aniType:s,aniDuration:d}){Hn(ae.ON_HIDE);let g=new ae.EventChannel(ng()+1,r);return new Promise(y=>{Wu(pu({url:e,path:t,query:n,openType:"navigateTo",eventChannel:g}),s,d,()=>{y({eventChannel:g})}),Ys()})}function VT(e,t,n){let{globalStyle:r}=I,s=Xs(e);return[t||s.animationType||r.animationType||MO,n||s.animationDuration||r.animationDuration||Hu]}let $T=Re(kf,({url:e},{resolve:t,reject:n})=>{let{path:r,query:s}=ae.parseUrl(e);ju(r,()=>{UT({url:e,path:r,query:s}).then(t).catch(n)})},tE,sE);function UT({url:e,path:t,query:n}){let r=Rr();return r&&Di(r),new Promise(s=>{Wu(pu({url:e,path:t,query:n,openType:"redirectTo"}),"none",0,()=>{if(r){let d=r.$getAppWebview();d.__preload__&&kT(d),d.close("none")}s(void 0)}),Ys()})}let HT=({url:e},{resolve:t,reject:n})=>{let{path:r,query:s}=ae.parseUrl(e);ju(r,()=>{jT({url:e,path:r,query:s}).then(t).catch(n)})};function jT({url:e,path:t,query:n}){return new Promise(r=>{let s=qa().slice(0);Ge.find(g=>g.path===t).meta.isTabBar&&Ti.switchTab(t.slice(1)),Wu(pu({url:e,path:t,query:n,openType:"reLaunch"}),"none",0,()=>{s.forEach(g=>hg(g,"none")),r(void 0)}),Ys()})}let zT=Re(jh,HT,nE,lE),Cg=(e,{resolve:t,reject:n})=>{let{url:r}=e,{path:s,query:d}=ae.parseUrl(r);ju(s,()=>{GT({url:r,path:s,query:d}).then(t).catch(n)},e.openType==="appLaunch")},WT=Re(Iu,Cg,rE,cE);function GT({url:e,path:t,query:n}){Ti.switchTab(t.slice(1));let r=Gn(),s=r.length,d=!1,g=!1,y;s>=1&&(y=r[s-1],y&&!y.$.__isTabBar?(g=!0,r.reverse().forEach(P=>{!P.$.__isTabBar&&P!==y&&hg(P,"none")}),Di(y),B(()=>{y.$page.openType==="redirectTo"?Gl(y.$getAppWebview(),Xp,Hu):Gl(y.$getAppWebview(),"auto")},100)):d=!0);let z;return qa().forEach(P=>{ae.addLeadingSlash(P.route)===t?(P.$.__isActive||(g=!0),P.$.__isActive=!0,z=P):P.$.__isTabBar&&(P.$.__isActive=!1)}),y===z&&(d=!1),y&&d&&Hn(y,ae.ON_HIDE),new Promise(P=>{if(z){let $=z.$getAppWebview();$.show("none"),g&&!$.__preload__&&Hn(z,ae.ON_SHOW),Ys(),P(void 0)}else Wu(pu({url:e,path:t,query:n,openType:"switchTab"}),"none",0,()=>{Ys(),P(void 0)},70)})}let YT=Dt(zh,({url:e})=>{let t=RT({url:e});return t?{id:t.id,url:e,errMsg:"unPreloadPage:ok"}:{url:e,errMsg:"unPreloadPage:fail not found"}},oE),qT=Re(Rf,({url:e},{resolve:t,reject:n})=>{let r=e.split("?"),s=r[0],d=ae.parseQuery(r[1]||""),g=xT({url:e,path:s,query:d});t({id:g.id,url:e,errMsg:"preloadPage:ok"})},iE);var KT={__proto__:null,sendHostEvent:Yp,navigateToMiniProgram:bO,onHostEventReceive:Kp,onNativeEventReceive:yO,__log__:wO,navigateTo:FT,reLaunch:zT,switchTab:WT,upx2px:ym,addInterceptor:Om,removeInterceptor:Tm,interceptors:Im,arrayBufferToBase64:Yr,base64ToArrayBuffer:Ri,createIntersectionObserver:y_,createMediaQueryObserver:w_,createSelectorQuery:I_,createVideoContext:Km,createMapContext:Zm,createAnimation:B_,onWindowResize:L_,offWindowResize:V_,onTabBarMidButtonTap:M_,createCanvasContext:d_,canvasGetImageData:h_,canvasPutImageData:p_,canvasToTempFilePath:g_,getSelectedTextRange:z_,getLocale:nu,setLocale:H_,$on:Dm,$off:Lm,$once:Fm,$emit:Vm,onCreateVueApp:ae.onCreateVueApp,onLocaleChange:U_,setPageMeta:j_,getEnterOptionsSync:nb,getLaunchOptionsSync:rb,getPushClientId:ib,onPushMessage:ob,offPushMessage:ab,onAppHide:eb,onAppShow:X_,onError:J_,onPageNotFound:q_,onUnhandledRejection:G_,offAppHide:tb,offAppShow:Q_,offError:Z_,offPageNotFound:K_,offUnhandledRejection:Y_,invokePushCallback:If,setStorageSync:Yw,setStorage:qw,getStorageSync:Kw,getStorage:Jw,removeStorageSync:Zw,removeStorage:Xw,clearStorageSync:Qw,clearStorage:eS,getStorageInfoSync:Zh,getStorageInfo:tS,getFileInfo:nS,saveFile:aS,getSavedFileList:cS,getSavedFileInfo:uS,removeSavedFile:fS,openDocument:dS,canIUse:hS,getDeviceInfo:ip,getAppBaseInfo:op,getSystemInfoSync:ap,getSystemInfo:ES,onCompassChange:wS,offCompassChange:SS,startCompass:sp,stopCompass:lp,vibrateShort:CS,vibrateLong:AS,onAccelerometerChange:OS,offAccelerometerChange:TS,startAccelerometer:cp,stopAccelerometer:up,onBluetoothDeviceFound:IS,onBluetoothAdapterStateChange:PS,onBLEConnectionStateChange:NS,onBLECharacteristicValueChange:kS,openBluetoothAdapter:RS,closeBluetoothAdapter:xS,getBluetoothAdapterState:BS,startBluetoothDevicesDiscovery:MS,stopBluetoothDevicesDiscovery:DS,getBluetoothDevices:FS,getConnectedBluetoothDevices:LS,createBLEConnection:VS,closeBLEConnection:$S,getBLEDeviceServices:US,getBLEDeviceCharacteristics:HS,notifyBLECharacteristicValueChange:jS,readBLECharacteristicValue:zS,writeBLECharacteristicValue:WS,setBLEMTU:GS,getBLEDeviceRSSI:YS,onBeaconUpdate:qS,onBeaconServiceChange:KS,getBeacons:JS,startBeaconDiscovery:ZS,stopBeaconDiscovery:XS,makePhoneCall:QS,addPhoneContact:nC,getClipboardData:rC,setClipboardData:iC,onNetworkStatusChange:oC,offNetworkStatusChange:aC,getNetworkType:pp,checkIsSupportSoterAuthentication:sC,checkIsSoterEnrolledInDevice:lC,startSoterAuthentication:cC,scanCode:uC,onThemeChange:fC,getScreenBrightness:dC,setScreenBrightness:hC,setKeepScreenOn:pC,getWindowInfo:rp,getSystemSetting:gC,getAppAuthorizeSetting:bp,openAppAuthorizeSetting:vC,getImageInfo:mC,getVideoInfo:_C,previewImage:bC,closePreviewImage:yC,getRecorderManager:SC,saveVideoToPhotosAlbum:CC,saveImageToPhotosAlbum:AC,compressImage:OC,compressVideo:TC,chooseImage:PC,chooseVideo:NC,showKeyboard:kC,hideKeyboard:RC,onKeyboardHeightChange:xC,offKeyboardHeightChange:BC,downloadFile:DC,request:$C,configMTLS:UC,connectSocket:WC,sendSocketMessage:GC,closeSocket:YC,onSocketOpen:qC,onSocketError:KC,onSocketMessage:JC,onSocketClose:ZC,uploadFile:QC,createInnerAudioContext:lA,getBackgroundAudioManager:bA,createLivePusherContext:wA,getLocation:AA,chooseLocation:OA,openLocation:TA,showModal:IA,showActionSheet:PA,showLoading:NA,showToast:kA,hideToast:RA,hideLoading:xA,startPullDownRefresh:BA,stopPullDownRefresh:MA,loadFontFace:DA,pageScrollTo:FA,setNavigationBarTitle:LA,showNavigationBarLoading:VA,hideNavigationBarLoading:$A,setNavigationBarColor:HA,setTabBarBadge:jA,setTabBarItem:zA,setTabBarStyle:WA,hideTabBar:GA,showTabBar:YA,showTabBarRedDot:qA,removeTabBarBadge:KA,hideTabBarRedDot:JA,getSubNVueById:nO,restoreGlobal:iO,requireGlobal:oO,getProvider:aO,login:$p,getUserInfo:sO,getUserProfile:lO,preLogin:Hp,closeAuthView:zp,getCheckBoxState:Wp,getUniverifyManager:fO,createPushMessage:dO,registerRuntime:hO,share:vO,shareWithSystem:mO,requestPayment:_O,requireNativePlugin:va,sendNativeEvent:fp,createRewardedVideoAd:TO,createFullScreenVideoAd:PO,createInterstitialAd:kO,createInteractiveAd:BO,navigateBack:fT,redirectTo:$T,unPreloadPage:YT,preloadPage:qT};let JT=Q.extend(pe,{publishHandler:ZT});function ZT(e,t,n){t=JSON.stringify(t),Q.isArray(n)||(n=[n]);let r=`typeof UniViewJSBridge !== 'undefined' && UniViewJSBridge.subscribeHandler("${e}",${t},__PAGE_ID__)`;n.forEach(s=>{let d=String(s),g=c.webview.getWebviewById(d);g&&g.evalJS(r.replace("__PAGE_ID__",d))})}function XT(){let{tabBar:e}=I;if(!(e&&e.list&&e.list.length))return;let{entryPagePath:n}=I;e.selectedIndex=0;let r=e.list.findIndex(s=>s.pagePath===n);Ti.init(e,(s,d)=>{se.switchTab({url:ae.addLeadingSlash(s.pagePath),openType:"switchTab",from:"tabBar",success(){Hn(ae.ON_TAB_ITEM_TAP,{index:d,text:s.text,pagePath:s.pagePath})}})}),r!==-1&&(e.selectedIndex=r,r!==0&&Ti.switchTab(n))}function QT(){let e=c.globalEvent,t=v.requireModule("globalEvent"),n=bt.emit;v.config.preload?c.key.addEventListener(Mo,Za):e.addEventListener("splashclosed",()=>{c.key.addEventListener(Mo,Za)}),e.addEventListener("pause",()=>{n(ae.ON_APP_ENTER_BACKGROUND)}),e.addEventListener("resume",()=>{let s=Bt();s&&s.userAction&&Ue(s),n(ae.ON_APP_ENTER_FOREGROUND,Ds())}),t.addEventListener("uistylechange",function(s){let d={theme:s.uistyle};n(ae.ON_THEME_CHANGE,d)});let r=0;e.addEventListener("KeyboardHeightChange",function(s){r!==s.height&&(r=s.height,n(ae.ON_KEYBOARD_HEIGHT_CHANGE,{height:r}))}),t.addEventListener(LO,function(s){s&&s.event&&EO(s.event,s.data)}),e.addEventListener("plusMessage",Ag),e.addEventListener("WebviewPostMessage",Ag)}function Ag({data:e}){e&&e.type&&bt.subscribeHandler("plusMessage."+e.type,e.args)}function Og(e,t,n=!1){bt.subscribe("plusMessage."+e,t,n)}function eI(e){W_(e.$);let{entryPagePath:t,entryPageQuery:n,referrerInfo:r}=I,s=It({path:t,query:n,referrerInfo:r});Hn(e,ae.ON_LAUNCH,s),Hn(e,ae.ON_SHOW,s);let d=v.requireModule("plus").getAppState;(d&&Number(d()))===2&&Hn(e,ae.ON_HIDE,s)}function Tg(e){return e=e.replace(/\/$/,""),e.indexOf("_")===0?c.io.convertLocalFileSystemURL(e):e}function tI(){let e=Tg(hs),t=Tg(Si),n=t.split("/");n.pop();let r=n.join("/");c.io.resolveLocalFileSystemURL(c.io.convertAbsoluteFileSystem(r),s=>{s.createReader().readEntries(function(g){let y=g;y&&y.length&&y.forEach(function(z){z.isDirectory&&z.fullPath.indexOf(e)===0&&z.fullPath.indexOf(t)!==0&&z.removeRecursively()})})})}let Ig=0,Rc=0,Yu=null,Yl=null;function nI(e,t){if(Yu=null,Yl&&(C(Yl),Yl=null),e.type==="onFocus")if(Rc>0)e.detail.height=Rc;else{Yl=B(function(){e.detail.height=Rc,t(e)},Ig),Yu=function(){Yl&&(C(Yl),Yl=null),e.detail.height=Rc,t(e)};return}t(e)}function rI(){Ig=c.os.name.toLowerCase()==="android"?300:700,bt.on(ae.ON_KEYBOARD_HEIGHT_CHANGE,t=>{if(Rc=t.height,Rc>0){let n=Yu;Yu=null,n&&n()}})}function iI(e,t,n){let r=t.type;r==="onFocus"||r==="onBlur"?nI(t,s=>{n.fireEvent(e,s)}):n.fireEvent(e,t)}function oI(e,t){let n=qo(parseInt(t));if(!n)return;let r=n.__page_container__;e.forEach(s=>{switch(s[0]){case ae.ACTION_TYPE_EVENT:iI(s[1],s[2],r);break}})}let Pg={};function aI(e,t,n){let{adpid:r,width:s}=e,d=r+"-"+s,g=Pg[d];if(g&&g.length>0){t(g.splice(0,1)[0]);return}c.ad.getAds(e,y=>{let z=y.ads;t(z.splice(0,1)[0]),Pg[d]=g?g.concat(z):z},y=>{n({errCode:y.code,errMsg:y.message})})}function sI(){ee("getAdData",(e,t)=>{aI(e,n=>{t({code:0,data:n})},n=>{t({code:1,message:n})})})}let lI=["switchTab","reLaunch","redirectTo","navigateTo","navigateBack"];function cI(){lI.forEach(e=>{ee(e,t=>{se[e](Q.extend(t,{fail(n){console.error(n.errMsg)}}))})})}let Ng=!1;function uI(e,t){let n=t==="1";if(!(n&&Ng)){if(n?(Ng=!0,ag(c.webview.getLaunchWebview())):lo||ag(c.webview.getWebviewById(t)),!lo.loaded){if(lo.id!==t)return console.error(`webviewReady[${lo.id}][${t}] not match`);lo.loaded=!0}bt.emit(kc+"."+t),n&&fI()}}function fI(){let{autoclose:e,alwaysShowBeforeRender:t}=I.splashscreen;e&&!t&&c.navigator.closeSplashscreen();let n=ae.addLeadingSlash(I.entryPagePath),r=fo(n);if(!r.meta.isNVue){let s={url:n+(I.entryPageQuery||""),openType:"appLaunch"},d={resolve(){},reject(){}};return r.meta.isTabBar?Cg(s,d):Sg(s,d)}}function dI(e,t){let n=qo(parseInt(t));n&&(n.__uniapp_webview=!0)}function hI(e,t){let n=qo(parseInt(t));n&&delete n.__uniapp_webview}let pI=({name:e,arg:t},n)=>{e==="postMessage"?gI(n[0],t):se[e](Q.extend(t,{fail(r){console.error(r.errMsg)}}))};function gI(e,t){let n=vT("web-view",parseInt(e));n&&n.dispatchEvent(ae.createUniEvent({type:"onMessage",target:Object.create(null),currentTarget:Object.create(null),detail:{data:[t]}}))}function vI({nodeId:e,ownerId:t,method:n,args:r},s){let d=gg(e,parseInt(s));if(!d)return;let g=mI(t,d.__vueParentComponent);!g||!g[n]||g[n](r)}function mI(e,t){if(!t)return null;if(t.uid===e)return t.proxy;let n=t.parent;for(;n;){if(n.uid===e)return n.proxy;n=n.parent}return t.proxy}function _I(){let{subscribe:e,subscribeHandler:t,publishHandler:n}=bt;if(Og("subscribeHandler",({type:r,data:s,pageId:d})=>{t(r,s,d)}),Og(ae.WEB_INVOKE_APPSERVICE,({data:r,webviewIds:s})=>{pI(r,s)}),I.renderer!=="native"){e(kc,uI),e(Mp,oI),W(),sI(),cI(),e(QA,dI),e(eO,hI),e(ae.ON_WXS_INVOKE_CALL_METHOD,vI);let r=fo(ae.addLeadingSlash(I.entryPagePath));r&&!r.meta.isNVue&&n(kc,{},1)}}let xc,Jf={globalData:{}};function bI({allowDefault:e=!1}={}){if(xc)return xc;if(e)return Jf;console.error("[warn]: getApp() failed. Learn more: https://uniapp.dcloud.io/collocation/frame/window?id=getapp.")}function yI(e){if(se.Vuex&&e.$store){let{useStore:t}=se.Vuex;se.Vuex.useStore=n=>n?t(n):e.$store}Bs(e),xc=e,gt(xc),Q.extend(xc,Jf),pn(xc,Jf.globalData),Jt(),Eg(),XT(),QT(),rI(),_I(),eI(e),B(tI,1e4),I.ready=!0}var EI={uni:KT,getApp:bI,getCurrentPages:Ms,__definePage:IT,__registerApp:yI,__registerPage:pu,UniServiceJSBridge:JT};return EI}(At,tn,T);A=A.default||A;let se=A.uni,En=A.getApp,Gn=A.getCurrentPages,bt=A.UniServiceJSBridge;return A}var dv=rN(aN);var vd,md,_d,Js,bd,yd,Ed;function hv(){return Js?{__definePage:vd,__registerApp:md,__registerPage:_d,uni:Js,wx:Js,getApp:bd,getCurrentPages:yd,UniServiceJSBridge:Ed}:{}}function pv(v){let{weex:c,plus:b,VueShared:T}=v;return Js||({__definePage:vd,__registerApp:md,__registerPage:_d,uni:Js,getApp:bd,getCurrentPages:yd,UniServiceJSBridge:Ed}=fv(c,b,v),Js.VueShared=T,Bg(Js)),{__definePage:vd,__registerApp:md,__registerPage:_d,plus:b,uni:Js,wx:Js,getApp:bd,getCurrentPages:yd,UniServiceJSBridge:Ed}}function gv(v,c){let{__uniConfig:b}=c;if(!b)return;let T=c.weex;T.document.__$automator__=!!b.automator;let B=b.renderer!=="native"&&T.config.bundleUrl.indexOf("app-service.js")!==-1;if(di(c,hv()),B?dv(c):(Lg(v,c),iv(c.Vue.parseClassStyles)),di(c,pv(c)),T.config.plus_web_id==="1"){let I=T.requireModule("plus");I.setDefaultFontSize&&I.setDefaultFontSize(Math.round(c.plus.screen.resolutionWidth/20))}let{scale:C,deviceWidth:k,platform:u}=global.WXEnvironment;if(u.toLowerCase()==="ios"){let I=Math.ceil(k/C);T.requireModule("meta").setViewport({width:I,roundOffDeviation:!1})}}var Ql=class extends Xl{constructor(c){super();this.nodeType=8;this.type="comment";this.value="";this.value=c}toString(){return"<!-- "+this.value+" -->"}};function ra(v,c=[]){return{module:"dom",method:v,args:c}}var Vc=class{constructor(c,b){this.id=c,this.batched=!1,this.updates=[],$n(b)?Object.defineProperty(this,"handler",{configurable:!0,enumerable:!0,writable:!0,value:b}):console.error("[JS Runtime] invalid parameter, handler must be a function")}createFinish(c){return this.handler([ra("createFinish")],c)}updateFinish(c){return this.handler([ra("updateFinish")],c)}refreshFinish(c){return this.handler([ra("refreshFinish")],c)}createBody(c){let b=c.toJSON(),T=b.children;delete b.children;let B=[ra("createBody",[b])];return T&&B.push.apply(B,T.map(C=>ra("addElement",[b.ref,C,-1]))),this.addActions(B)}addElement(c,b,T){return T>=0||(T=-1),this.addActions(ra("addElement",[b,c.toJSON(),T]))}removeElement(c){if(Hi(c)){let b=c.map(T=>ra("removeElement",[T]));return this.addActions(b)}return this.addActions(ra("removeElement",[c]))}moveElement(c,b,T){return this.addActions(ra("moveElement",[c,b,T]))}setAttr(c,b,T){return this.addActions(ra("updateAttrs",[c,{[b]:T}]))}setStyle(c,b,T){return this.addActions(ra("updateStyle",[c,{[b]:T}]))}setStyles(c,b){return this.addActions(ra("updateStyle",[c,b]))}addEvent(c,b){return this.addActions(ra("addEvent",[c,b]))}removeEvent(c,b){return this.addActions(ra("removeEvent",[c,b]))}handler(c,b){return b&&b()}addActions(c){let b=this.updates,T=this.handler;if(Hi(c)||(c=[c]),this.batched)b.push.apply(b,c);else return T(c)}};var wd={createBody:"callCreateBody",addElement:"callAddElement",removeElement:"callRemoveElement",moveElement:"callMoveElement",updateAttrs:"callUpdateAttrs",updateStyle:"callUpdateStyle",addEvent:"callAddEvent",removeEvent:"callRemoveEvent"};function vv(v,c){let b=c||global.callNative;return $n(b)||console.error("[JS Runtime] no default handler"),function(B){Hi(B)||(B=[B]);for(let C=0;C<B.length;C++){let k=lN(v,B[C],b);if(k===-1)return k}}}function sN(v,c){return v==="dom"&&wd[c]&&$n(global[wd[c]])}function lN(v,c,b){let{module:T,method:B,args:C}=c;return sN(T,B)?global[wd[B]](v,...C,"-1"):b(v,[c],"-1")}var ff=class extends wo{constructor(c){super();this.value=c,this.nodeType=3,this.type="text",this.value=""}toString(){return""+this.value}};var mv={slider:{change:function(v){return{index:v.index,source:v.source}},scroll:function(v){return{offsetXRatio:v.offsetXRatio,offsetYRatio:v.offsetYRatio,drag:v.drag}}},"scroll-view":{scrollend:function(v){return{contentOffset:v.contentOffset}}}};function _v(v){let{attr:c,offsetLeft:b,offsetTop:T}=v,B={};return c&&Object.keys(c).forEach(C=>{C.indexOf("data-")===0&&(B[C.replace("data-","")]=c[C])}),{id:c&&c.id||"",dataset:B,offsetLeft:b||0,offsetTop:T||0}}var cN=["a","div","list","cell","loading","refresh","recycle-list","scroller","indicator","waterfall","web","richtext"],uN=["viewappear","viewdisappear"],fN={markertap:["markerId"],controltap:["controlId"],regionchange:["causedBy"],end:["causedBy"],appear:["direction"],disappear:["direction"]};function bv(v,c){let b=v.type;if(uN.indexOf(b)!==-1)return v;let T=v.currentTarget,B=T.type.replace("u-","");if(cN.indexOf(B)!==-1)return v;let{timestamp:C,target:k}=v;if(!c){let Ge=mv[B];Ge?$n(Ge[b])?c=Ge[b](v):c=v.detail||{}:c=v.detail||{}}let u={type:b,timeStamp:C,target:_v(k),currentTarget:_v(T),detail:c,touches:b==="touchend"||b==="panend"?[]:v.changedTouches,changedTouches:v.changedTouches};v.componentId&&(u.componentId=v.componentId);let I=fN[b];return I&&I.forEach(Ge=>{ql(v,Ge)&&(u[Ge]=v[Ge])}),u}function dN(v,c){let b=c.attrs||{};for(let B in b)v.setAttr(B,b[B],!0);let T=c.style||{};for(let B in T)v.setStyle(B,T[B],!0)}var ma=class{constructor(c,b="",T){c=c?c.toString():"",this.id=c,this.URL=b,Jg(c,this),this.nodeMap={};let B=ma.Listener||Vc;this.listener=new B(c,T||vv(c,ma.handler)),this.taskCenter=new Lc(c,T?(C,k)=>T(k):ma.handler),this.createDocumentElement()}getRef(c){return this.nodeMap[c]}open(){this.listener.batched=!1}close(){this.listener.batched=!0}createDocumentElement(){if(!this.documentElement){let c=new wo("document");c.docId=this.id,c.ownerDocument=this,c.role="documentElement",c.ref="_documentElement",this.nodeMap._documentElement=c,this.documentElement=c,Object.defineProperty(c,"appendChild",{configurable:!0,enumerable:!0,writable:!0,value:b=>{nd(this,b)}}),Object.defineProperty(c,"insertBefore",{configurable:!0,enumerable:!0,writable:!0,value:(b,T)=>{nd(this,b,T)}}),Xn("debug")&&co(`Create document element (id: "${c.docId}", ref: "${c.ref}")`)}return this.documentElement}createBody(c,b){if(!this.body){let T=new wo(c,b);rd(this,T),Xn("debug")&&co(`[createBody](${this.id},${T.type},${T.ref}) (${JSON.stringify(T.toJSON(!0))}).`)}return this.body}createElement(c,b){let T=new wo(c,b);return Xn("debug")&&co(`[createElement](${this.id},${T.type},${T.ref}) (${JSON.stringify(T.toJSON(!0))}).`),T}createComment(c){return new Ql(c)}createText(c){return new ff(c)}fireEvent(c,b,T,B,C){if(!c)return;T=T||{},T.type=T.type||b,T.target=c,T.currentTarget=c,T.timestamp=Date.now(),B&&dN(c,B);let k,u=this.getRef("_root");if(u&&u.attr){let I=u.attr.bubble;k=I==="true"||I===!0}return T=bv(T),c.fireEvent(b,T,k,C)}destroy(){Xn("debug")&&co(`[destroy](${this.id},document) Destroy document (id: "${this.id}", URL: "${this.URL}")`),this.taskCenter.destroyCallback(),delete this.listener,delete this.nodeMap,delete this.taskCenter,Zg(this.id)}};ma.handler=null;var yv={InputElementDiv:"<WhiteSpace>|<LineTerminator>|<ReservedWord>|<Identifier>|<NumericLiteral>|<Punctuator>|<StringLiteral>",InputElementRegExp:"<WhiteSpace>|<LineTerminator>|<ReservedWord>|<Identifier>|<NumericLiteral>|<Punctuator>|<StringLiteral>",ReservedWord:"<Keyword>|<NullLiteral>|<BooleanLiteral>",WhiteSpace:/[\t\v\f\u0020\u00A0\u1680\u180E\u2000-\u200A\u202F\u205f\u3000\uFEFF]/,LineTerminator:/[\n\r\u2028\u2029]/,Keyword:/new(?![_$a-zA-Z0-9])|void(?![_$a-zA-Z0-9])|delete(?![_$a-zA-Z0-9])|in(?![_$a-zA-Z0-9])|instanceof(?![_$a-zA-Z0-9])|typeof(?![_$a-zA-Z0-9])/,NullLiteral:/null(?![_$a-zA-Z0-9])/,BooleanLiteral:/(?:true|false)(?![_$a-zA-Z0-9])/,Identifier:/[_$a-zA-Z][_$a-zA-Z0-9]*/,Punctuator:/\/|=>|\*\*|>>>=|>>=|<<=|===|!==|>>>|<<|%=|\*=|-=|\+=|<=|>=|==|!=|\^=|\|=|\|\||&&|&=|>>|\+\+|--|\:|}|\*|&|\||\^|!|~|-|\+|\?|%|=|>|<|,|;|\.(?![0-9])|\]|\[|\)|\(|{/,DivPunctuator:/\/=|\//,NumericLiteral:/(?:0[xX][0-9a-fA-F]*|\.[0-9]+|(?:[1-9]+[0-9]*|0)(?:\.[0-9]*|\.)?)(?:[eE][+-]{0,1}[0-9]+)?(?![_$a-zA-Z0-9])/,StringLiteral:/"(?:[^"\n\\\r\u2028\u2029]|\\(?:['"\\bfnrtv\n\r\u2028\u2029]|\r\n)|\\x[0-9a-fA-F]{2}|\\u[0-9a-fA-F]{4}|\\[^0-9ux'"\\bfnrtv\n\\\r\u2028\u2029])*"|'(?:[^'\n\\\r\u2028\u2029]|\\(?:['"\\bfnrtv\n\r\u2028\u2029]|\r\n)|\\x[0-9a-fA-F]{2}|\\u[0-9a-fA-F]{4}|\\[^0-9ux'"\\bfnrtv\n\\\r\u2028\u2029])*'/,RegularExpressionLiteral:/\/(?:\[(?:\\[\s\S]|[^\]])*\]|[^*\/\\\n\r\u2028\u2029]|\\[^\n\r\u2028\u2029])(?:\[(?:\\[\s\S]|[^\]])*\]|[^\/\\\n\r\u2028\u2029]|\\[^\n\r\u2028\u2029])*\/[0-9a-zA-Z]*/};function Ev(v,c,b){var T=[c];function B(k){var u=new RegExp;return u.compile(k.replace(/<([^>]+)>/g,function(I,Ge){return v[Ge]?(T.push(Ge),v[Ge]instanceof RegExp?"("+v[Ge].source+")":"("+B(v[Ge]).source+")"):""}),b),u}var C=B(v[c]);this.exec=function(k){var u=C.exec(k);if(u==null)return null;for(var I=new String(u[0]),Ge=0;Ge<T.length;Ge++)u[Ge]&&(I[T[Ge]]=u[Ge]);return I},Object.defineProperty(this,"lastIndex",{get:function(){return C.lastIndex},set:function(k){C.lastIndex=k}})}function hN(){var v=new Ev(yv,"InputElementDiv","g"),c=new Ev(yv,"InputElementRegExp","g"),b;Object.defineProperty(this,"source",{get:function(){return b},set:function(T){b=T,v.lastIndex=0,c.lastIndex=0}}),this.reset=function(){v.lastIndex=0,c.lastIndex=0},this.getNextToken=function(T){var B=v.lastIndex,C;T?C=v:C=c;var k=C.exec(b);if(k&&C.lastIndex-B>k.length)throw new SyntaxError("Unexpected token ILLEGAL");return v.lastIndex=C.lastIndex,c.lastIndex=C.lastIndex,k}}var wv={IdentifierName:[["Identifier"]],Literal:[["NullLiteral"],["BooleanLiteral"],["NumericLiteral"],["StringLiteral"],["RegularExpressionLiteral"]],PrimaryExpression:[["Identifier"],["Literal"],["(","Expression",")"]],CallExpression:[["PrimaryExpression","Arguments"],["CallExpression","Arguments"]],Arguments:[["(",")"],["(","ArgumentList",")"]],ArgumentList:[["ConditionalExpression"],["ArgumentList",",","ConditionalExpression"]],LeftHandSideExpression:[["PrimaryExpression"],["CallExpression"]],UnaryExpression:[["LeftHandSideExpression"],["void","UnaryExpression"],["+","UnaryExpression"],["-","UnaryExpression"],["~","UnaryExpression"],["!","UnaryExpression"]],ExponentiationExpression:[["UnaryExpression"],["ExponentiationExpression","**","UnaryExpression"]],MultiplicativeExpression:[["MultiplicativeExpression","/","ExponentiationExpression"],["ExponentiationExpression"],["MultiplicativeExpression","*","ExponentiationExpression"],["MultiplicativeExpression","%","ExponentiationExpression"]],AdditiveExpression:[["MultiplicativeExpression"],["AdditiveExpression","+","MultiplicativeExpression"],["AdditiveExpression","-","MultiplicativeExpression"]],ShiftExpression:[["AdditiveExpression"],["ShiftExpression","<<","AdditiveExpression"],["ShiftExpression",">>","AdditiveExpression"],["ShiftExpression",">>>","AdditiveExpression"]],RelationalExpression:[["ShiftExpression"],["RelationalExpression","<","ShiftExpression"],["RelationalExpression",">","ShiftExpression"],["RelationalExpression","<=","ShiftExpression"],["RelationalExpression",">=","ShiftExpression"],["RelationalExpression","instanceof","ShiftExpression"],["RelationalExpression","in","ShiftExpression"]],EqualityExpression:[["RelationalExpression"],["EqualityExpression","==","RelationalExpression"],["EqualityExpression","!=","RelationalExpression"],["EqualityExpression","===","RelationalExpression"],["EqualityExpression","!==","RelationalExpression"]],BitwiseANDExpression:[["EqualityExpression"],["BitwiseANDExpression","&","EqualityExpression"]],BitwiseXORExpression:[["BitwiseANDExpression"],["BitwiseXORExpression","^","BitwiseANDExpression"]],BitwiseORExpression:[["BitwiseXORExpression"],["BitwiseORExpression","|","BitwiseXORExpression"]],LogicalANDExpression:[["BitwiseORExpression"],["LogicalANDExpression","&&","BitwiseORExpression"]],LogicalORExpression:[["LogicalANDExpression"],["LogicalORExpression","||","LogicalANDExpression"]],ConditionalExpression:[["LogicalORExpression"],["LogicalORExpression","?","LogicalORExpression",":","LogicalORExpression"]],Expression:[["ConditionalExpression"],["Expression",",","ConditionalExpression"]],Program:[["Expression"]]};function yu(v,c){this.name=v,this.token=c,this.childNodes=[],this.toString=function(b){if(b||(b=""),this.childNodes.length==1)return this.childNodes[0].toString(b);for(var T=b+this.name+(this.token!=null&&this.name!=this.token?":"+this.token:"")+`
`,B=0;B<this.childNodes.length;B++)T+=this.childNodes[B].toString(b+"    ");return T}}function pN(){var v,c={Program:"$"},b={};function T(u){b[JSON.stringify(u)]=u;for(var I=Object.getOwnPropertyNames(u);I.length;){var Ge=I.shift();!wv[Ge]||wv[Ge].forEach(function(tn){u[tn[0]]||I.push(tn[0]);var A=u,se=null;tn.forEach(function(En){A[En]||(A[En]={}),se=A,A=A[En]}),u[Ge].$div&&(A.$div=!0),A.$reduce=Ge,A.$count=tn.length})}for(var At in u)typeof u[At]!="object"||At.charAt(0)=="$"||u[At].$closure||(b[JSON.stringify(u[At])]?u[At]=b[JSON.stringify(u[At])]:T(u[At]));u.$closure=!0}T(c);var B=[],C=[c],k=c;this.insertSymbol=function(I,Ge){for(;!k[I.name]&&k.$reduce;){for(var At=k.$count,tn=new yu(k.$reduce);At--;)tn.childNodes.push(B.pop()),C.pop();k=C[C.length-1],this.insertSymbol(tn)}if(k=k[I.name],B.push(I),C.push(k),!k)throw new Error;return k.$div},this.reset=function(){k=c,B=[],C=[c]},Object.defineProperty(this,"grammarTree",{get:function(){try{for(;k.$reduce;){for(var u=k.$count,I=new yu(k.$reduce);u--;)I.childNodes.push(B.pop()),C.pop();k=C[C.length-1],this.insertSymbol(I)}if(B.length>0&&k[";"])return this.insertSymbol(new yu(";",";")),this.grammarTree;if(B.length!=1||B[0].name!="Program")throw new Error}catch(Ge){throw new SyntaxError("Unexpected end of input")}return B[0]}})}function gN(){this.lexicalParser=new hN,this.syntacticalParser=new pN;var v=["NullLiteral","BooleanLiteral","NumericLiteral","StringLiteral","RegularExpressionLiteral","Identifier","**","=>","{","}","(",")","[","]",".",";",",","<",">","<=",">=","==","!=","===","!==","+","-","*","%","++","--","<<",">>",">>>","&","|","^","!","~","&&","||","?",":","=","+=","-=","*=","%=","<<=",">>=",">>>=","&=","|=","^=","/","/=","instanceof","typeof","new","void","debugger","this","delete","in"],c={};v.forEach(function(b){Object.defineProperty(c,b,{})}),this.reset=function(){this.lexicalParser.reset(),this.syntacticalParser.reset()},this.parse=function(b,T){var B,C=!1;this.lexicalParser.source=b;for(var k=!1;B=this.lexicalParser.getNextToken(k);){T&&T(B);try{if(Object.getOwnPropertyNames(B).some(u=>c.hasOwnProperty(u)?(k=this.syntacticalParser.insertSymbol(new yu(u,B),C),C=!1,!0):!1))continue;(B.Keyword||B.Punctuator||B.DivPunctuator)&&c.hasOwnProperty(B.toString())&&(k=this.syntacticalParser.insertSymbol(new yu(B.toString(),B),C))}catch(u){throw new SyntaxError("Unexpected token "+B)}}return this.syntacticalParser.grammarTree}}var Sv=new gN;function vN(v){Sv.reset(),this.tree=Sv.parse(v),this.paths=[];var c=Object.create(null),b=this,T=Object.create(null);this.isSimple,this.isConst,C(this.tree),B(this.tree),this.paths.length===0&&(this.isConst=!0),this.setter=function(I){for(var Ge=c,At=0;At<I.length-1;At++)Ge[I[At]]||(Ge[I[At]]=Object.create(null)),Ge=Ge[I[At]];return{isCompleted:function(){for(var tn in T)if(!T[tn])return!1;return!0},set:function(tn){if(T[I.join(".")]||(T[I.join(".")]=!0),Ge[I[At]]=tn,this.isCompleted())return b.exec()}}},this.valueOf=this.exec=function(){try{return function(){return(0,eval)(v)}.call(c)}catch(I){}};function B(I){for(var Ge=I;Ge.childNodes.length<=1&&Ge.name!=="MemberExpression";)Ge=Ge.childNodes[0];Ge.name==="MemberExpression"?b.isSimple=!0:b.isSimple=!1}function C(I){if(I.name==="CallExpression"&&I.childNodes[I.childNodes.length-1].name!=="CallExpression"){var Ge=k(I.childNodes[1]);C(I.childNodes[0])}else if(I.name==="NewExpression"&&I.childNodes.length===1)var Ge=k(I.childNodes[0]);else if(I.name==="MemberExpression"&&I.childNodes.length===1)var Ge=k(I);else for(var At=0;At<I.childNodes.length;At++)C(I.childNodes[At])}function k(I){if(I.childNodes[0].name==="IdentifierName"){var Ge=k(I.childNodes[2]);return Ge&&(Ge=Ge.concat(I.childNodes[0].childNodes[0].token.toString())),u(Ge),Ge}else if(I.childNodes[0].name==="PrimaryExpression")if(I.childNodes[0].childNodes[0].name==="Identifier"){var Ge=[I.childNodes[0].childNodes[0].token.toString()];return u(Ge),Ge}else return null;else{if(I.childNodes[0].name==="]")return k(I.childNodes[3]),C(I.childNodes[1]),null;if(I.childNodes[0].name==="Arguments")return C(I.childNodes[0]),C(I.childNodes[1]),null;for(var At=0;At<I.childNodes.length;At++)C(I.childNodes[At])}}function u(I){for(var Ge=c,At=0;At<I.length-1;At++)Ge[I[At]]||(Ge[I[At]]=Object.create(null)),Ge=Ge[I[At]];b.paths.push(I),T[I.join(".")]=!1}}function ec(v){var c=v.childNodes.slice().reverse(),b=c.filter(I=>!I.token||!I.token.Punctuator);if(v.name==="UnaryExpression"&&c.length===2&&c[0].name==="-"&&b.length===1){var T=ec(b[0]);return T.value=-T.value,T}if(v.name==="Arguments"){for(var B=[],C=b[0];C;)C.childNodes.length===3&&(B.unshift(C.childNodes[0]),C=C.childNodes[2]),C.childNodes.length===1&&(B.unshift(C.childNodes[0]),C=null);return{type:"Arguments",children:B.map(I=>ec(I))}}if(b&&b.length===1){var T=ec(b[0]);return T}if(v.token&&["NullLiteral","BooleanLiteral","NumericLiteral","StringLiteral","Identifier"].some(I=>v.token[I])){var k=Object.keys(v.token).filter(I=>I.match(/Literal/)||I.match(/Identifier/))[0],u={NullLiteral:null,BooleanLiteral:Boolean(v.token),NumericLiteral:Number(v.token),StringLiteral:v.token,Identifier:v.token}[k];return{type:k,value:u}}return v.name==="CallExpression"?{type:"CallExpression",children:[ec(c[0]),ec(c[1])]}:{type:c.filter(I=>I.token&&I.token.Punctuator)[0].name,children:c.filter(I=>!I.token||!I.token.Punctuator).map(I=>ec(I))}}function Cv(v){var c=new vN(v);return JSON.stringify(ec(c.tree),null)}function mN(v,c){return c==="bind"&&(v==="bindingx"||v==="binding")}function Av(v){if(!v)return;try{v=JSON.parse(v)}catch(b){}let c={};if(ji(v)?c.origin=v:v&&(c.origin=v.origin,c.transformed=v.transformed),!(!c.transformed&&!c.origin))return c.transformed=c.transformed||Cv(c.origin),c}function _N(v){return v&&(v.exitExpression=Av(v.exitExpression),v.props&&v.props.forEach(c=>{c.expression=Av(c.expression)}),v)}function bN(v){return function(c={}){if($n(v))return v({state:c.state==="end"?"exit":c.state,t:c.t!==void 0?c.t:c.deltaT})}}function Ov(v,c,b){return b&&(mN(v,c)?function(T,B=function(){}){if(!T)throw new Error("should pass options for binding");return _N(T),b(T,T&&T.eventType==="timing"?bN(B):B)}:b)}function yN(v,c){Object.defineProperty(v,"[[CurrentInstanceId]]",{value:c})}function Tv(v){return v["[[CurrentInstanceId]]"]}function EN(v,c,b){let T=jr(v);return!T||!$n(T.send)?(console.error(`[JS Framework] Failed to find taskCenter (${v}).`),null):(...B)=>T.send("module",{module:c,method:b},B)}function wN(v,c,b,T){let B=jr(v);return!B||!$n(B.send)?(console.error(`[JS Framework] Failed to find taskCenter (${v}).`),null):$n(T)?C=>B.send("module",{module:c,method:b},[C]):(console.error(`[JS Framework] ${c}.${b} must be assigned as a function.`),null)}var df=class{constructor(c,b){yN(this,String(c)),this.config=b||{},this.document=new ma(c,this.config.bundleUrl),this.requireModule=this.requireModule.bind(this),this.importScript=this.importScript.bind(this),this.isRegisteredModule=lf,this.isRegisteredComponent=pd}requireModule(c){let b=Tv(this);if(!(b&&this.document&&this.document.taskCenter)){console.error(`[JS Framework] Failed to requireModule("${c}"), instance (${b}) doesn't exist anymore.`);return}if(!lf(c)){console.warn(`[JS Framework] \u5F53\u524D\u8FD0\u884C\u7684\u57FA\u5EA7\u4E0D\u5305\u542B\u539F\u751F\u63D2\u4EF6[${c}]\uFF0C\u8BF7\u5728manifest\u4E2D\u914D\u7F6E\u8BE5\u63D2\u4EF6\uFF0C\u91CD\u65B0\u5236\u4F5C\u5305\u62EC\u8BE5\u539F\u751F\u63D2\u4EF6\u7684\u81EA\u5B9A\u4E49\u8FD0\u884C\u57FA\u5EA7`);return}let T={},B=cv(c);for(let C in B)Object.defineProperty(T,C,{enumerable:!0,configurable:!0,get:()=>Ov(c,C,EN(b,c,C)),set:k=>wN(b,c,C,k)});return T}supports(c){if(!ji(c))return null;let b=c.match(/^@(\w+)\/([\w-]+)(\.(\w+))?$/i);if(b){let T=b[1],B=b[2],C=b[4];switch(T){case"module":return lf(B,C);case"component":return pd(B)}}return null}importScript(c,b={}){let T=Tv(this),B=jr(T);return new Promise(function(C,k){if(!B||!$n(B.send))return k(new Error(`[JS Framework] Failed to import script "${c}", no taskCenter (${T}) matched.`));try{B.send("module",{module:"script",method:"importScript"},[c,b],{callback:[u=>C(u),u=>k(u)]})}catch(u){k(u)}})}};function SN(v,c){let b=Object.create(null);return b.service=Object.create(null),_l.forEach(({name:T,options:B})=>{let C=B.create;if(C)try{let k=C(v,c);di(b.service,k),di(b,k.instance)}catch(k){console.error(`[JS Runtime] Failed to create service ${T}.`)}}),delete b.service.instance,fs(b.service),b}var CN={uid:0},AN=Gg(vu),ON=Wg(vu);function Iv(v,c,b){let T=new df(v,c),B="Vue",C=SN(v,{weex:T,nvue:T,config:c,created:Date.now(),framework:B});fs(C);let k=Object.create(null);return di(k,xN(T)),di(k,C,{SharedObject:CN,weex:T,nvue:T,requireModule:u=>T.requireModule(u),__WEEX_CALL_JAVASCRIPT__:dd,services:C}),k.plus=new k.WeexPlus(T),k.VueShared=vu,k.UniShared=AN,k.VueReactivity=ON,gv(v,k),fs(k),k}function TN(v,c,b={}){let T="Vue";b=ed(b),b.env=ed(global.WXEnvironment||{}),b.bundleType=T;let B=Iv(v,b);IN(c,B)}function IN(v,c){let b=[],T=[];for(let C in c)b.push(C),T.push(c[C]);let B="(function (global) { "+v+" })(Object.create(this))";return new Function(...b,B)(...T)}function PN(v){let c=Ks(v);try{if(c&&c.body)return c.body.toJSON()}catch(b){console.error("[JS Framework] Failed to get the virtual dom tree.");return}}function NN(v){Dg(v),_l.forEach(c=>{let b=c.options.destroy;b&&b(v)})}function kN(v){Fg(v),_l.forEach(c=>{let b=c.options.refresh;b&&b(v)})}var RN={createInstance:TN,createInstanceContext:Iv,getRoot:PN,getDocument:Ks,registerService:cf,unregisterService:uf,callJS(v,c){return dd(v,c)},registerComponents:uv,registerModules:lv,destroyInstance:NN,refreshInstance:kN};function Sd(){return sv(),RN}function xN(v){if(global.setTimeout&&global.setInterval)return{setTimeout:global.setTimeout,setInterval:global.setInterval,clearTimeout:global.clearTimeout,clearInterval:global.clearInterval};let c=v.requireModule("timer");return{setTimeout:(...T)=>{let B=function(){T[0](...T.slice(2))};return c.setTimeout(B,T[1]),v.document.taskCenter.callbackManager.lastCallbackId.toString()},setInterval:(...T)=>{let B=function(){T[0](...T.slice(2))};return c.setInterval(B,T[1]),v.document.taskCenter.callbackManager.lastCallbackId.toString()},clearTimeout:T=>{c.clearTimeout(T)},clearInterval:T=>{c.clearInterval(T)}}}var Pv={Document:ma,Element:wo,Comment:Ql,Listener:Vc,TaskCenter:Lc,sendTasks(...v){return $n(callNative)?callNative(...v):(global.callNative||(()=>{}))(...v)}};ma.handler=Pv.sendTasks;var tc=Pv;function BN(){fs(tc.Comment),fs(tc.Listener),fs(tc.Document.prototype),fs(tc.Comment.prototype),fs(tc.Listener.prototype)}var hf={service:{register:cf,unregister:uf,has:gd},freezePrototype:BN,init:Sd,config:tc};var Cd=class{constructor(c,b={}){this.type=c||"message",this.data=b.data||null,this.origin=b.origin||"",this.source=b.source||null,this.ports=b.ports||[],this.target=null,this.timeStamp=Date.now()}};var bl={},Eu={};function Ad(){}Ad.prototype.postMessage=function(v){if(this._closed)throw new Error(`BroadcastChannel "${this.name}" is closed.`);let c=bl[this.name];if(c&&c.length)for(let b=0;b<c.length;++b){let T=c[b];T._closed||T===this||$n(T.onmessage)&&T.onmessage(new Cd("message",{data:v}))}};Ad.prototype.close=function(){if(!this._closed&&(this._closed=!0,bl[this.name])){let v=bl[this.name].filter(c=>c!==this);v.length?bl[this.name]=v:delete bl[this.name]}};var Nv={create:v=>{if(Eu[v]=[],$n(global.BroadcastChannel))return{};let c={BroadcastChannel:function(b){Object.defineProperty(this,"name",{configurable:!1,enumerable:!0,writable:!1,value:String(b)}),this._closed=!1,this.onmessage=null,bl[this.name]||(bl[this.name]=[]),bl[this.name].push(this),Eu[v].push(this)}};return c.BroadcastChannel.prototype=Ad.prototype,{instance:c}},destroy:v=>{Eu[v]&&(Eu[v].forEach(c=>c.close()),delete Eu[v])}};function Od(){let{init:v}=hf;hf.service.register("BroadcastChannel",Nv),hf.freezePrototype();let c=v();for(let b in c)global[b]=(...T)=>{let B=c[b](...T);return B instanceof Error&&console.error(B.toString()),B}}var CR=global.console;function kv(){if(qg(),global.WXEnvironment&&global.WXEnvironment.platform!=="Web")global.console={debug:(...v)=>{Xn("debug")&&global.nativeLog(...wu(v),"__DEBUG")},log:(...v)=>{Xn("log")&&global.nativeLog(...wu(v),"__LOG")},info:(...v)=>{Xn("info")&&global.nativeLog(...wu(v),"__INFO")},warn:(...v)=>{Xn("warn")&&global.nativeLog(...wu(v),"__WARN")},error:(...v)=>{Xn("error")&&global.nativeLog(...wu(v),"__ERROR")}};else{let{debug:v,log:c,info:b,warn:T,error:B}=console;console.__ori__={debug:v,log:c,info:b,warn:T,error:B},console.debug=(...C)=>{Xn("debug")&&console.__ori__.debug.apply(console,C)},console.log=(...C)=>{Xn("log")&&console.__ori__.log.apply(console,C)},console.info=(...C)=>{Xn("info")&&console.__ori__.info.apply(console,C)},console.warn=(...C)=>{Xn("warn")&&console.__ori__.warn.apply(console,C)},console.error=(...C)=>{Xn("error")&&console.__ori__.error.apply(console,C)}}}function wu(v){return v.map(c=>{if(qs(c).toLowerCase()==="[object object]")try{c=JSON.stringify(c)}catch(T){c="[object object]"}else c=String(c);return c})}kv();Od();})();

    3.