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

uni-jsframework-vue3.js 651 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 wP=Object.defineProperty;var SP=(g,l)=>{for(var _ in l)wP(g,_,{get:l[_],enumerable:!0})};var ma=Object.freeze;function dc({getCurrentPages:g,uni:l,UniShared:_,Vue:A,VueShared:k}){var S=function(N,f,T,ze){"use strict";function xt(){let Ue=g(),it=Ue.length;if(it)return Ue[it-1]}function pn(){let Ue=xt();if(Ue)return Ue.$vm}function B(Ue,it,vt){if(f.isString(Ue))vt=it,it=Ue,Ue=pn();else if(typeof Ue=="number"){let nn=g().find(Qt=>Qt.$page.id===Ue);nn?Ue=nn.$vm:Ue=pn()}if(!Ue)return;if(Ue.__call_hook)return Ue.__call_hook(it,vt);let qt=Ue.$[it];return qt&&T.invokeArrayFns(qt,vt)}function gt(Ue,it,vt,qt){f.isFunction(it)&&ze.injectHook(Ue,it.bind(vt),qt)}function vn(Ue,it,vt){let qt=Ue.mpType||vt.$mpType;if(!!qt&&(Object.keys(Ue).forEach(nn=>{if(nn.indexOf("on")===0){let Qt=Ue[nn];f.isArray(Qt)?Qt.forEach(ir=>gt(nn,ir,vt,it)):gt(nn,Qt,vt,it)}}),qt==="page")){it.__isVisible=!0;try{B(vt,T.ON_LOAD,it.attrs.__pageQuery),delete it.attrs.__pageQuery,B(vt,T.ON_SHOW)}catch(nn){console.error(nn.message+T.LINEFEED+nn.stack)}}}function Vn(Ue,it){st(it,Ue.$renderjs,Ue["$"+T.RENDERJS_MODULES])}function st(Ue,it,vt={}){if(!f.isArray(it))return;let qt=Ue.uid,nn=Ue.$wxsModules||(Ue.$wxsModules=[]),Qt=Ue.ctx;it.forEach(ir=>{vt[ir]&&(Qt[ir]=Y(qt,vt[ir],ir),nn.push(ir))})}function Y(Ue,it,vt){let qt={};return new Proxy(qt,{get(nn,Qt){return qt[Qt]||(qt[Qt]=te(Ue,it,vt,Qt))}})}function te(Ue,it,vt,qt){let nn=()=>{},Qt=()=>T.WXS_PROTOCOL+JSON.stringify([Ue,it,vt+"."+qt]);return new Proxy(nn,{get(ir,lr){return lr==="toJSON"?Qt:nn[lr]||(nn[lr]=te(Ue,it,vt+"."+qt,lr))},apply(ir,lr,Li){return T.WXS_PROTOCOL+JSON.stringify([Ue,it,vt+"."+qt,[...Li]])}})}function En(Ue,it){st(it,Ue.$wxs,Ue["$"+T.WXS_MODULES])}function yn(Ue,it,vt){En(Ue,it),Vn(Ue,it),vn(Ue,it,vt)}function ln(Ue,it,vt){return Ue[it]=vt}function $n(Ue){return function(vt,qt,nn){if(!qt)throw vt;let Qt=Ue._instance;if(!Qt||!Qt.proxy)throw vt;B(Qt.proxy,T.ON_ERROR,vt)}}function an(Ue,it){return Ue?[...new Set([].concat(Ue,it))]:it}function kn(Ue){T.UniLifecycleHooks.forEach(it=>{Ue[it]=an})}let Un,mn="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",sn=/^(?:[A-Za-z\d+/]{4})*?(?:[A-Za-z\d+/]{2}(?:==)?|[A-Za-z\d+/]{3}=?)?$/;typeof atob!="function"?Un=function(Ue){if(Ue=String(Ue).replace(/[\t\n\f\r ]+/g,""),!sn.test(Ue))throw new Error("Failed to execute 'atob' on 'Window': The string to be decoded is not correctly encoded.");Ue+="==".slice(2-(Ue.length&3));for(var it,vt="",qt,nn,Qt=0;Qt<Ue.length;)it=mn.indexOf(Ue.charAt(Qt++))<<18|mn.indexOf(Ue.charAt(Qt++))<<12|(qt=mn.indexOf(Ue.charAt(Qt++)))<<6|(nn=mn.indexOf(Ue.charAt(Qt++))),vt+=qt===64?String.fromCharCode(it>>16&255):nn===64?String.fromCharCode(it>>16&255,it>>8&255):String.fromCharCode(it>>16&255,it>>8&255,it&255);return vt}:Un=atob;function _n(Ue){return decodeURIComponent(Un(Ue).split("").map(function(it){return"%"+("00"+it.charCodeAt(0).toString(16)).slice(-2)}).join(""))}function Rn(){let Ue=l.getStorageSync("uni_id_token")||"",it=Ue.split(".");if(!Ue||it.length!==3)return{uid:null,role:[],permission:[],tokenExpired:0};let vt;try{vt=JSON.parse(_n(it[1]))}catch(qt){throw new Error("\u83B7\u53D6\u5F53\u524D\u7528\u6237\u4FE1\u606F\u51FA\u9519\uFF0C\u8BE6\u7EC6\u9519\u8BEF\u4FE1\u606F\u4E3A\uFF1A"+qt.message)}return vt.tokenExpired=vt.exp*1e3,delete vt.exp,delete vt.iat,vt}function kr(Ue){Ue.uniIDHasRole=function(it){let{role:vt}=Rn();return vt.indexOf(it)>-1},Ue.uniIDHasPermission=function(it){let{permission:vt}=Rn();return this.uniIDHasRole("admin")||vt.indexOf(it)>-1},Ue.uniIDTokenValid=function(){let{tokenExpired:it}=Rn();return it>Date.now()}}function Zr(Ue){let it=Ue._context.config;f.isFunction(Ue._component.onError)&&(it.errorHandler=$n(Ue)),kn(it.optionMergeStrategies);let vt=it.globalProperties;kr(vt),vt.$set=ln,vt.$applyOptions=yn,T.invokeCreateVueAppHook(Ue)}return N.initApp=Zr,Object.defineProperty(N,"__esModule",{value:!0}),N}({},k,_,A);return S}function eu(g,{nvue:l,UniShared:_,VueShared:A,VueReactivity:k}){let S={platform:l.config.env.platform,UniShared:_,VueShared:A,VueReactivity:k};return g(S,l.document)}function AP({setTimeout:g,clearTimeout:l,uni:_,getCurrentPages:A,Vue:k,weex:S,plus:N,BroadcastChannel:f,UniViewJSBridge:T,VueShared:ze,UniShared:xt}){var pn=function(B,gt,vn){"use strict";let Vn=["navigate","redirect","switchTab","reLaunch","navigateBack"],st=["slide-in-right","slide-in-left","slide-in-top","slide-in-bottom","fade-in","zoom-out","zoom-fade-out","pop-in","none"],Y=["slide-out-right","slide-out-left","slide-out-top","slide-out-bottom","fade-out","zoom-in","zoom-fade-in","pop-out","none"],te={hoverClass:{type:String,default:"navigator-hover"},url:{type:String,default:""},openType:{type:String,default:"navigate",validator(m){return Boolean(~Vn.indexOf(m))}},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(m){return!m||st.concat(Y).includes(m)}},animationDuration:{type:[String,Number],default:300}};function En(m){return()=>{if(m.openType!=="navigateBack"&&!m.url){console.error("<navigator/> should have url attribute when using navigateTo, redirectTo, reLaunch or switchTab");return}let R=parseInt(m.animationDuration);switch(m.openType){case"navigate":_.navigateTo({url:m.url,animationType:m.animationType||"pop-in",animationDuration:R});break;case"redirect":_.redirectTo({url:m.url,exists:m.exists});break;case"switchTab":_.switchTab({url:m.url});break;case"reLaunch":_.reLaunch({url:m.url});break;case"navigateBack":_.navigateBack({delta:m.delta,animationType:m.animationType||"pop-out",animationDuration:R});break}}}function yn(m){if(m.hoverClass&&m.hoverClass!=="none"){let R={hoverClass:m.hoverClass};return gt.hasOwn(m,"hoverStartTime")&&(R.hoverStartTime=m.hoverStartTime),gt.hasOwn(m,"hoverStayTime")&&(R.hoverStayTime=m.hoverStayTime),gt.hasOwn(m,"hoverStopPropagation")&&(R.hoverStopPropagation=m.hoverStopPropagation),R}return{}}function ln(m,R){return B.createElementVNode("u-text",gt.extend({appendAsTree:!0},R),m)}let $n=[{"navigator-hover":{"":{backgroundColor:"rgba(0,0,0,0.1)",opacity:.7}}}];var an=B.defineComponent({name:"Navigator",props:te,styles:$n,setup(m,{slots:R}){let z=En(m);return()=>B.createVNode("view",B.mergeProps(yn(m),{onClick:z}),[R.default&&R.default()])}});function kn(m){return Symbol(m)}function Un(){return B.getCurrentInstance().root.proxy.$page.id}let mn,sn,_n;function Rn(){return typeof window=="object"&&typeof navigator=="object"&&typeof document=="object"?"webview":"v8"}function kr(){return mn.webview.currentWebview().id}let Zr,Ue,it={};function vt(m){let R=m.data&&m.data.__message;if(!R||!R.__page)return;let z=R.__page,j=it[z];j&&j(R),R.keep||delete it[z]}function qt(m,R){Rn()==="v8"?_n?(Zr&&Zr.close(),Zr=new _n(kr()),Zr.onmessage=vt):Ue||(Ue=sn.requireModule("globalEvent"),Ue.addEventListener("plusMessage",vt)):window.__plusMessage=vt,it[m]=R}class nn{constructor(R){this.webview=R}sendMessage(R){let z=JSON.parse(JSON.stringify({__message:{data:R}})),j=this.webview.id;_n?new _n(j).postMessage(z):mn.webview.postMessageToUniNView&&mn.webview.postMessageToUniNView(z,j)}close(){this.webview.close()}}function Qt({context:m={},url:R,data:z={},style:j={},onMessage:Z,onClose:Q}){mn=m.plus||N,sn=m.weex||(typeof S=="object"?S:null),_n=m.BroadcastChannel||(typeof f=="object"?f:null);let ce={autoBackButton:!0,titleSize:"17px"},be=`page${Date.now()}`;j=gt.extend({},j),j.titleNView!==!1&&j.titleNView!=="none"&&(j.titleNView=gt.extend(ce,j.titleNView));let Oe={top:0,bottom:0,usingComponents:{},popGesture:"close",scrollIndicator:"none",animationType:"pop-in",animationDuration:200,uniNView:{path:`/${R}.js`,defaultFontSize:16,viewport:mn.screen.resolutionWidth}};j=gt.extend(Oe,j);let Ne=mn.webview.create("",be,j,{extras:{from:kr(),runtime:Rn(),data:z,useGlobalEvent:!_n}});return Ne.addEventListener("close",Q),qt(be,ve=>{gt.isFunction(Z)&&Z(ve.data),ve.keep||Ne.close("auto")}),Ne.show(j.animationType,j.animationDuration),new nn(Ne)}let ir={for:{type:String,default:""}},lr=kn("ul");function Li(){let m=[];return B.provide(lr,{addHandler(R){m.push(R)},removeHandler(R){m.splice(m.indexOf(R),1)}}),m}var Di=B.defineComponent({name:"Label",props:ir,styles:[],setup(m,{slots:R}){let z=Un(),j=Li(),Z=Q=>{m.for?T.emit(`uni-label-click-${z}-${m.for}`,Q,!0):j.length&&j[0](Q,!0)};return()=>B.createVNode("view",{onClick:Z},[R.default&&R.default()])}});function xn(m,R){wr(m.id,R),B.watch(()=>m.id,(z,j)=>{Ur(j,R,!0),wr(z,R,!0)}),B.onUnmounted(()=>{Ur(m.id,R)})}function wr(m,R,z){let j=Un();z&&!m||!gt.isPlainObject(R)||Object.keys(R).forEach(Z=>{z?Z.indexOf("@")!==0&&Z.indexOf("uni-")!==0&&T.on(`uni-${Z}-${j}-${m}`,R[Z]):Z.indexOf("uni-")===0?T.on(Z,R[Z]):m&&T.on(`uni-${Z}-${j}-${m}`,R[Z])})}function Ur(m,R,z){let j=Un();z&&!m||!gt.isPlainObject(R)||Object.keys(R).forEach(Z=>{z?Z.indexOf("@")!==0&&Z.indexOf("uni-")!==0&&T.off(`uni-${Z}-${j}-${m}`,R[Z]):Z.indexOf("uni-")===0?T.off(Z,R[Z]):m&&T.off(`uni-${Z}-${j}-${m}`,R[Z])})}function Hr(m){return Object.keys(m).map(R=>[R,m[R]])}let Zi=["class","style"],Xi=/^on[A-Z]+/,Oo=(m={})=>{let{excludeListeners:R=!1,excludeKeys:z=[]}=m,j=B.getCurrentInstance(),Z=B.shallowRef({}),Q=B.shallowRef({}),ce=B.shallowRef({}),be=z.concat(Zi);return j.attrs=B.reactive(j.attrs),B.watchEffect(()=>{let Oe=Hr(j.attrs).reduce((Ne,[ve,Fe])=>(be.includes(ve)?Ne.exclude[ve]=Fe:Xi.test(ve)?(R||(Ne.attrs[ve]=Fe),Ne.listeners[ve]=Fe):Ne.attrs[ve]=Fe,Ne),{exclude:{},attrs:{},listeners:{}});Z.value=Oe.attrs,Q.value=Oe.listeners,ce.value=Oe.exclude}),{$attrs:Z,$listeners:Q,$excludeAttrs:ce}},To={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}},hr=kn("uf"),Cn=[{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)"}}}],On={default:"d",primary:"p",warn:"w"};var ci=B.defineComponent({inheritAttrs:!1,name:"Button",props:gt.extend(To,{type:{type:String,default:"default"},size:{type:String,default:"default"}}),styles:Cn,setup(m,{slots:R,attrs:z}){let{$attrs:j,$excludeAttrs:Z,$listeners:Q}=Oo({excludeListeners:!0}),ce=m.type,be=B.ref(null),Oe=B.inject(hr,!1),Ne=(nt,Ge)=>{let ut=Q.value.onClick||(()=>{});if(m.disabled)return;ut(nt);let Vt=m.formType;if(Vt){if(!Oe)return;Vt==="submit"?Oe.submit(nt):Vt==="reset"&&Oe.reset(nt)}},ve=nt=>{let Ge="ub-"+On[ce]+nt;return m.disabled&&(Ge+="-d"),m.plain&&(Ge+="-plain"),m.size==="mini"&&nt==="-t"&&(Ge+=" ub-mini"),Ge},Fe=nt=>{if(m.disabled)return"";let Ge="ub-"+On[ce]+nt+"-hover";return m.plain&&(Ge+="-plain"),Ge},rt=B.inject(lr,!1);rt&&(rt.addHandler(Ne),B.onBeforeUnmount(()=>{rt.removeHandler(Ne)})),xn(m,{"label-click":Ne});let bt=B.computed(()=>{let nt={};for(let Ge in Q.value){let ut=Q.value[Ge];Ge!=="onClick"&&(nt[Ge]=ut)}return nt}),Wt=()=>{if(!R.default)return[];let nt=R.default();return nt.length===1&&nt[0].type===B.Text?[ln(nt[0].children,{class:"ub-t "+ve("-t")})]:nt};return()=>{let nt=gt.extend({},yn(m),{hoverClass:Fe("")},j.value,Z.value,bt.value);return B.createVNode("view",B.mergeProps({ref:be,class:["ub",ve("")],onClick:Ne},nt),[m.loading?B.createVNode("loading-indicator",B.mergeProps({class:["ub-loading",`ub-${On[ce]}-loading`]},{arrow:"false",animating:"true"}),null):null,...Wt()])}}});let Qi={scaleArea:{type:Boolean,default:!1}};function eo(m){let R=[];return gt.isArray(m)&&m.forEach(z=>{B.isVNode(z)?z.type===B.Fragment?R.push(...eo(z.children)):R.push(z):gt.isArray(z)&&R.push(...eo(z))}),R}function go(m){let R=Object.create(null);return function(j){return R[j]||(R[j]=m(j))}}let Si=go(function(m){let R={},z=/;(?![^(]*\))/g,j=/:(.+)/;return m.split(z).forEach(function(Z){if(Z){let Q=Z.split(j);Q.length>1&&(R[Q[0].trim()]=Q[1].trim())}}),R}),cr=m=>new Promise((R,z)=>{if(!m)return R({width:0,height:0,top:0,left:0});S.requireModule("dom").getComponentRect(m,({size:Z})=>{R(Z)})});var jr=B.defineComponent({name:"MovableArea",props:Qi,styles:[{"uni-movable-area":{"":{overflow:"hidden",width:"10px",height:"10px"}}}],setup(m,{slots:R}){let z=B.ref(0),j=B.ref(0),Z=B.ref(0),Q=B.ref(0),ce=B.ref(!1),be=B.ref(null),Oe=[],Ne=null,ve=Ge=>{Ne=Ge},Fe=()=>cr(be.value).then(({width:Ge,height:ut,top:Vt,left:pt})=>{z.value=Ge,j.value=ut,Z.value=Vt,Q.value=pt}),rt=()=>{Fe().then(()=>{Oe.forEach(function(Ge){Ge.setParent()})})};B.onMounted(()=>{g(()=>{ce.value=!0,rt()},200)});let bt={onPanstart(Ge){Ne&&Ne.touchstart(Ge)},onPanmove(Ge){Ge.stopPropagation(),Ne&&Ne.touchmove(Ge)},onPanend(Ge){Ne&&Ne.touchend(Ge),Ne=null}},Wt=Ge=>{Oe.push(Ge)},nt=Ge=>{let ut=Oe.indexOf(Ge);ut>=0&&Oe.splice(ut,1)};return B.provide("_isMounted",ce),B.provide("parentSize",{width:z,height:j,top:Z,left:Q}),B.provide("addMovableViewContext",Wt),B.provide("removeMovableViewContext",nt),B.provide("setTouchMovableViewContext",ve),()=>{let Ge=R.default&&R.default(),ut=eo(Ge);return B.createVNode("view",B.mergeProps({ref:be,class:"uni-movable-area"},bt),[ut])}}});function Sr(m){let R={};function z(ve,Fe){R[ve]&&R[ve](Fe)}function j(ve,Fe){R[ve]=function(rt){gt.isFunction(Fe)&&(rt.touches=rt.changedTouches,Fe(rt)===!1&&rt.stopPropagation())}}let Z=0,Q=0,ce=0,be=0,Oe=function(ve,Fe,rt,bt){if(m({target:ve.target,currentTarget:ve.currentTarget,stopPropagation:ve.stopPropagation.bind(ve),touches:ve.touches,changedTouches:ve.changedTouches,detail:{state:Fe,x:rt,y:bt,dx:rt-Z,dy:bt-Q,ddx:rt-ce,ddy:bt-be,timeStamp:ve.timeStamp||Date.now()}})===!1)return!1},Ne=null;return j("touchstart",function(ve){if(!Ne)return Ne=ve,Z=ce=ve.touches[0].pageX,Q=be=ve.touches[0].pageY,Oe(ve,"start",Z,Q)}),j("touchmove",function(ve){if(Ne){let Fe=Oe(ve,"move",ve.touches[0].pageX,ve.touches[0].pageY);return ce=ve.touches[0].pageX,be=ve.touches[0].pageY,Fe}}),j("touchend",function(ve){if(Ne)return Ne=null,Oe(ve,"end",ve.changedTouches[0].pageX,ve.changedTouches[0].pageY)}),{touchstart:function(ve){z("touchstart",ve)},touchmove:function(ve){z("touchmove",ve)},touchend:function(ve){z("touchend",ve)}}}function gr(m,R){return(z,j)=>{m.value&&R(z,Po(z,m.value,j||{}))}}function Po(m,R,z={}){return R=po(R),{type:m,timeStamp:Date.now(),target:R,currentTarget:R,detail:z}}let Io=vn.cacheStringFunction(m=>m.charAt(0).toLowerCase()+m.slice(1));function po(m){let{offsetLeft:R,offsetTop:z}=m,j=m.attr,Z={};return Object.keys(j||{}).forEach(Q=>{Q.indexOf("data")===0&&(Z[Io(Q.replace("data",""))]=j[Q])}),{id:j&&j.id||"",dataset:Z,offsetLeft:R||0,offsetTop:z||0}}function Rr(m,R,z){return m>R-z&&m<R+z}function ur(m,R){return Rr(m,0,R)}function Ar(){}Ar.prototype.x=function(m){return Math.sqrt(m)};function Xr(m,R){this._m=m,this._f=1e3*R,this._startTime=0,this._v=0}Xr.prototype.setV=function(m,R){let z=Math.pow(Math.pow(m,2)+Math.pow(R,2),.5);this._x_v=m,this._y_v=R,this._x_a=-this._f*this._x_v/z,this._y_a=-this._f*this._y_v/z,this._t=Math.abs(m/this._x_a)||Math.abs(R/this._y_a),this._lastDt=null,this._startTime=new Date().getTime()},Xr.prototype.setS=function(m,R){this._x_s=m,this._y_s=R},Xr.prototype.s=function(m){m===void 0&&(m=(new Date().getTime()-this._startTime)/1e3),m>this._t&&(m=this._t,this._lastDt=m);let R=this._x_v*m+.5*this._x_a*Math.pow(m,2)+this._x_s,z=this._y_v*m+.5*this._y_a*Math.pow(m,2)+this._y_s;return(this._x_a>0&&R<this._endPositionX||this._x_a<0&&R>this._endPositionX)&&(R=this._endPositionX),(this._y_a>0&&z<this._endPositionY||this._y_a<0&&z>this._endPositionY)&&(z=this._endPositionY),{x:R,y:z}},Xr.prototype.ds=function(m){return m===void 0&&(m=(new Date().getTime()-this._startTime)/1e3),m>this._t&&(m=this._t),{dx:this._x_v+this._x_a*m,dy:this._y_v+this._y_a*m}},Xr.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}},Xr.prototype.dt=function(){return-this._x_v/this._x_a},Xr.prototype.done=function(){let m=Rr(this.s().x,this._endPositionX)||Rr(this.s().y,this._endPositionY)||this._lastDt===this._t;return this._lastDt=null,m},Xr.prototype.setEnd=function(m,R){this._endPositionX=m,this._endPositionY=R},Xr.prototype.reconfigure=function(m,R){this._m=m,this._f=1e3*R};function zn(m,R,z){this._m=m,this._k=R,this._c=z,this._solution=null,this._endPosition=0,this._startTime=0}zn.prototype._solve=function(m,R){let z=this._c,j=this._m,Z=this._k,Q=z*z-4*j*Z;if(Q===0){let ve=-z/(2*j),Fe=m,rt=R/(ve*m);return{x:function(bt){return(Fe+rt*bt)*Math.pow(Math.E,ve*bt)},dx:function(bt){let Wt=Math.pow(Math.E,ve*bt);return ve*(Fe+rt*bt)*Wt+rt*Wt}}}if(Q>0){let ve=(-z-Math.sqrt(Q))/(2*j),Fe=(-z+Math.sqrt(Q))/(2*j),rt=(R-ve*m)/(Fe-ve),bt=m-rt;return{x:function(Wt){let nt,Ge;return Wt===this._t&&(nt=this._powER1T,Ge=this._powER2T),this._t=Wt,nt||(nt=this._powER1T=Math.pow(Math.E,ve*Wt)),Ge||(Ge=this._powER2T=Math.pow(Math.E,Fe*Wt)),bt*nt+rt*Ge},dx:function(Wt){let nt,Ge;return Wt===this._t&&(nt=this._powER1T,Ge=this._powER2T),this._t=Wt,nt||(nt=this._powER1T=Math.pow(Math.E,ve*Wt)),Ge||(Ge=this._powER2T=Math.pow(Math.E,Fe*Wt)),bt*ve*nt+rt*Fe*Ge}}}let ce=Math.sqrt(4*j*Z-z*z)/(2*j),be=-z/2*j,Oe=m,Ne=(R-be*m)/ce;return{x:function(ve){return Math.pow(Math.E,be*ve)*(Oe*Math.cos(ce*ve)+Ne*Math.sin(ce*ve))},dx:function(ve){let Fe=Math.pow(Math.E,be*ve),rt=Math.cos(ce*ve),bt=Math.sin(ce*ve);return Fe*(Ne*ce*rt-Oe*ce*bt)+be*Fe*(Ne*bt+Oe*rt)}}},zn.prototype.x=function(m){return m===void 0&&(m=(new Date().getTime()-this._startTime)/1e3),this._solution?this._endPosition+this._solution.x(m):0},zn.prototype.dx=function(m){return m===void 0&&(m=(new Date().getTime()-this._startTime)/1e3),this._solution?this._solution.dx(m):0},zn.prototype.setEnd=function(m,R,z){if(z||(z=new Date().getTime()),m!==this._endPosition||!ur(R,.1)){R=R||0;let j=this._endPosition;this._solution&&(ur(R,.1)&&(R=this._solution.dx((z-this._startTime)/1e3)),j=this._solution.x((z-this._startTime)/1e3),ur(R,.1)&&(R=0),ur(j,.1)&&(j=0),j+=this._endPosition),this._solution&&ur(j-m,.1)&&ur(R,.1)||(this._endPosition=m,this._solution=this._solve(j-this._endPosition,R),this._startTime=z)}},zn.prototype.snap=function(m){this._startTime=new Date().getTime(),this._endPosition=m,this._solution={x:function(){return 0},dx:function(){return 0}}},zn.prototype.done=function(m){return m||(m=new Date().getTime()),Rr(this.x(),this._endPosition,.1)&&ur(this.dx(),.1)},zn.prototype.reconfigure=function(m,R,z){this._m=m,this._k=R,this._c=z,this.done()||(this._solution=this._solve(this.x()-this._endPosition,this.dx()),this._startTime=new Date().getTime())},zn.prototype.springConstant=function(){return this._k},zn.prototype.damping=function(){return this._c},zn.prototype.configuration=function(){function m(z,j){z.reconfigure(1,j,z.damping())}function R(z,j){z.reconfigure(1,z.springConstant(),j)}return[{label:"Spring Constant",read:this.springConstant.bind(this),write:m.bind(this,this),min:100,max:1e3},{label:"Damping",read:this.damping.bind(this),write:R.bind(this,this),min:1,max:500}]};function zr(m,R,z){this._springX=new zn(m,R,z),this._springY=new zn(m,R,z),this._springScale=new zn(m,R,z),this._startTime=0}zr.prototype.setEnd=function(m,R,z,j){let Z=new Date().getTime();this._springX.setEnd(m,j,Z),this._springY.setEnd(R,j,Z),this._springScale.setEnd(z,j,Z),this._startTime=Z},zr.prototype.x=function(){let m=(new Date().getTime()-this._startTime)/1e3;return{x:this._springX.x(m),y:this._springY.x(m),scale:this._springScale.x(m)}},zr.prototype.done=function(){let m=new Date().getTime();return this._springX.done(m)&&this._springY.done(m)&&this._springScale.done(m)},zr.prototype.reconfigure=function(m,R,z){this._springX.reconfigure(m,R,z),this._springY.reconfigure(m,R,z),this._springScale.reconfigure(m,R,z)};let to={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 Fi(m,R){return+((1e3*m-1e3*R)/1e3).toFixed(1)}function xr(m,R,z){let j={id:0,cancelled:!1},Z=function(ce){ce&&ce.id&&Qr(ce.id),ce&&(ce.cancelled=!0)};function Q(ce,be,Oe,Ne){if(!ce||!ce.cancelled){Oe(be);let ve=be.done();ve||ce.cancelled||(ce.id=_o(Q.bind(null,ce,be,Oe,Ne))),ve&&Ne&&Ne(be)}}return Q(j,m,R,z),{cancel:Z.bind(null,j),model:m}}let vo=!1;function mo(m){vo||(vo=!0,_o(function(){m(),vo=!1}))}function _o(m){return g(m,16)}function Qr(m){l(m)}let ei=S.requireModule("animation");var Ai=B.defineComponent({name:"MovableView",props:to,emits:["change","scale"],styles:[{"uni-movable-view":{"":{position:"absolute",top:"0px",left:"0px",width:"10px",height:"10px"}}}],setup(m,{emit:R,slots:z}){let j=B.ref(null),Z=gr(j,R),Q=B.inject("setTouchMovableViewContext",()=>{}),ce=ui(m,Z,j,Q);return()=>{let be={preventGesture:!0};return B.createVNode("view",B.mergeProps({ref:j,onTouchstart:ce,class:"uni-movable-view",style:"transform-origin: center;"},be),[z.default&&z.default()])}}});function ui(m,R,z,j){let Z=B.inject("_isMounted",B.ref(!1)),Q=B.inject("parentSize",{width:B.ref(0),height:B.ref(0),top:B.ref(0),left:B.ref(0)}),ce=B.inject("addMovableViewContext",()=>{}),be=B.inject("removeMovableViewContext",()=>{}),Oe={touchstart:()=>{},touchmove:()=>{},touchend:()=>{}};function Ne(Ve){return Number(Ve)||0}function ve(Ve){return Ve=Number(Ve),isNaN(Ve)?1:Ve}let Fe=B.ref(Ne(m.x)),rt=B.ref(Ne(m.y)),bt=B.ref(ve(Number(m.scaleValue))),Wt=B.ref(0),nt=B.ref(0),Ge=B.ref(0),ut=B.ref(0),Vt=B.ref(0),pt=B.ref(0),Ze=null,Ot=null,wn={x:0,y:0},un={x:0,y:0},rn=1,Sn=0,Ht=0,Ln=!1,mi,or,Er=null,Bo=null,Wi={top:0,left:0,width:0,height:0},Mo=new Ar,Lo=new Ar,Lt={historyX:[0,0],historyY:[0,0],historyT:[0,0]},fn=B.computed(()=>{let Ve=Number(m.damping);return isNaN(Ve)?20:Ve}),co=B.computed(()=>{let Ve=Number(m.friction);return isNaN(Ve)||Ve<=0?2:Ve}),qr=B.computed(()=>{let Ve=Number(m.scaleMin);return isNaN(Ve)?.5:Ve}),ii=B.computed(()=>{let Ve=Number(m.scaleMax);return isNaN(Ve)?10:Ve}),Do=B.computed(()=>m.direction==="all"||m.direction==="horizontal"),uo=B.computed(()=>m.direction==="all"||m.direction==="vertical"),Xn=new zr(1,9*Math.pow(fn.value,2)/40,fn.value),Yt=new Xr(1,co.value);B.watch(()=>m.x,Ve=>{Fe.value=Ne(Ve)}),B.watch(()=>m.y,Ve=>{rt.value=Ne(Ve)}),B.watch(()=>m.scaleValue,Ve=>{bt.value=ve(Number(Ve))}),B.watch(Fe,Aa),B.watch(rt,Pr),B.watch(bt,Ts),B.watch(qr,Dr),B.watch(ii,Dr);function oi(){Ot&&Ot.cancel(),Ze&&Ze.cancel()}function Aa(Ve){if(Do.value){if(Ve+un.x===Sn)return Sn;Ze&&Ze.cancel(),Gi(Ve+un.x,rt.value+un.y,rn)}return Ve}function Pr(Ve){if(uo.value){if(Ve+un.y===Ht)return Ht;Ze&&Ze.cancel(),Gi(Fe.value+un.x,Ve+un.y,rn)}return Ve}function Dr(){if(!m.scale)return!1;Ca(rn,!0)}function Ts(Ve){return m.scale?(Ve=Yo(Ve),Ca(Ve,!0),Ve):!1}function rs(){m.disabled||(oi(),Lt.historyX=[0,0],Lt.historyY=[0,0],Lt.historyT=[0,0],Do.value&&(mi=Sn),uo.value&&(or=Ht),Er=null,Bo=null,Ln=!0)}function Gn(Ve){if(!m.disabled&&Ln){let Tt=Sn,Rt=Ht;if(Bo===null&&(Bo=Math.abs(Ve.detail.dx/Ve.detail.dy)>1?"htouchmove":"vtouchmove"),Do.value&&(Tt=Ve.detail.dx+mi,Lt.historyX.shift(),Lt.historyX.push(Tt),!uo.value&&Er===null&&(Er=Math.abs(Ve.detail.dx/Ve.detail.dy)<1)),uo.value&&(Rt=Ve.detail.dy+or,Lt.historyY.shift(),Lt.historyY.push(Rt),!Do.value&&Er===null&&(Er=Math.abs(Ve.detail.dy/Ve.detail.dx)<1)),Lt.historyT.shift(),Lt.historyT.push(Ve.detail.timeStamp),!Er){let Tn="touch";Tt<Ge.value?m.outOfBounds?(Tn="touch-out-of-bounds",Tt=Ge.value-Mo.x(Ge.value-Tt)):Tt=Ge.value:Tt>Vt.value&&(m.outOfBounds?(Tn="touch-out-of-bounds",Tt=Vt.value+Mo.x(Tt-Vt.value)):Tt=Vt.value),Rt<ut.value?m.outOfBounds?(Tn="touch-out-of-bounds",Rt=ut.value-Lo.x(ut.value-Rt)):Rt=ut.value:Rt>pt.value&&(m.outOfBounds?(Tn="touch-out-of-bounds",Rt=pt.value+Lo.x(Rt-pt.value)):Rt=pt.value),mo(function(){qi(Tt,Rt,rn,Tn)})}}}function An(){if(!m.disabled&&Ln&&(Ln=!1,!Er&&!Yi("out-of-bounds")&&m.inertia)){let Ve=1e3*(Lt.historyX[1]-Lt.historyX[0])/(Lt.historyT[1]-Lt.historyT[0]),Tt=1e3*(Lt.historyY[1]-Lt.historyY[0])/(Lt.historyT[1]-Lt.historyT[0]);Yt.setV(Ve,Tt),Yt.setS(Sn,Ht);let Rt=Yt.delta().x,Tn=Yt.delta().y,er=Rt+Sn,St=Tn+Ht;er<Ge.value?(er=Ge.value,St=Ht+(Ge.value-Sn)*Tn/Rt):er>Vt.value&&(er=Vt.value,St=Ht+(Vt.value-Sn)*Tn/Rt),St<ut.value?(St=ut.value,er=Sn+(ut.value-Ht)*Rt/Tn):St>pt.value&&(St=pt.value,er=Sn+(pt.value-Ht)*Rt/Tn),Yt.setEnd(er,St),Ot=xr(Yt,function(){let yo=Yt.s(),Fo=yo.x,ca=yo.y;qi(Fo,ca,rn,"friction")},function(){Ot.cancel()})}}function Qn(Ve,Tt){let Rt=!1;return Ve>Vt.value?(Ve=Vt.value,Rt=!0):Ve<Ge.value&&(Ve=Ge.value,Rt=!0),Tt>pt.value?(Tt=pt.value,Rt=!0):Tt<ut.value&&(Tt=ut.value,Rt=!0),{x:Ve,y:Tt,outOfBounds:Rt}}function Fr(){wn.x=Wi.left-Q.left.value,wn.y=Wi.top-Q.top.value}function ki(Ve){Ve=Ve||rn,Ve=Yo(Ve),nt.value=Wi.height/rn,Wt.value=Wi.width/rn;let Tt=nt.value*Ve,Rt=Wt.value*Ve;un.x=(Rt-Wt.value)/2,un.y=(Tt-nt.value)/2}function ai(){let Ve=0-wn.x+un.x,Tt=Q.width.value-Wt.value-wn.x-un.x;Ge.value=Math.min(Ve,Tt),Vt.value=Math.max(Ve,Tt);let Rt=0-wn.y+un.y,Tn=Q.height.value-nt.value-wn.y-un.y;ut.value=Math.min(Rt,Tn),pt.value=Math.max(Rt,Tn)}function Ca(Ve,Tt){if(m.scale){Ve=Yo(Ve),ki(Ve),ai();let Rt=Qn(Sn,Ht),Tn=Rt.x,er=Rt.y;Tt?Gi(Tn,er,Ve,"",!0,!0):mo(function(){qi(Tn,er,Ve,"",!0,!0)})}}function Yo(Ve){return Ve=Math.max(.5,qr.value,Ve),Ve=Math.min(10,ii.value,Ve),Ve}function Gi(Ve,Tt,Rt,Tn,er,St){oi(),Do.value||(Ve=Sn),uo.value||(Tt=Ht),m.scale||(Rt=rn);let yo=Qn(Ve,Tt);if(Ve=yo.x,Tt=yo.y,!m.animation){qi(Ve,Tt,Rt,Tn,er,St);return}Xn._springX._solution=null,Xn._springY._solution=null,Xn._springScale._solution=null,Xn._springX._endPosition=Sn,Xn._springY._endPosition=Ht,Xn._springScale._endPosition=rn,Xn.setEnd(Ve,Tt,Rt,1),Ze=xr(Xn,function(){let Fo=Xn.x(),ca=Fo.x,Ps=Fo.y,qo=Fo.scale;qi(ca,Ps,qo,Tn,er,St)},function(){Ze.cancel()})}function Yi(Ve){let Tt=Qn(Sn,Ht),Rt=Tt.x,Tn=Tt.y,er=Tt.outOfBounds;return er&&Gi(Rt,Tn,rn,Ve),er}function qi(Ve,Tt,Rt,Tn="",er,St){Ve!==null&&Ve.toString()!=="NaN"&&typeof Ve=="number"||(Ve=Sn||0),Tt!==null&&Tt.toString()!=="NaN"&&typeof Tt=="number"||(Tt=Ht||0),Ve=Number(Ve.toFixed(1)),Tt=Number(Tt.toFixed(1)),Rt=Number(Rt.toFixed(1)),Sn===Ve&&Ht===Tt||er||R("change",{x:Fi(Ve,un.x),y:Fi(Tt,un.y),source:Tn}),m.scale||(Rt=rn),Rt=Yo(Rt),Rt=+Rt.toFixed(3),St&&Rt!==rn&&R("scale",{x:Ve,y:Tt,scale:Rt});let yo=`translate(${Ve}px, ${Tt}px) scale(${Rt})`;ei.transition(z.value,{styles:{transform:yo},duration:0,delay:0}),Sn=Ve,Ht=Tt,rn=Rt}function Oa(){return cr(z.value).then(Ve=>{Wi=Ve})}function Da(){if(!Z.value)return;oi();let Ve=m.scale?bt.value:1;Fr(),ki(Ve),ai(),Sn=Fe.value+un.x,Ht=rt.value+un.y;let Tt=Qn(Sn,Ht),Rt=Tt.x,Tn=Tt.y;qi(Rt,Tn,Ve,"",!0)}return B.onMounted(()=>{Oe=Sr(Tt=>{switch(Tt.detail.state){case"start":rs();break;case"move":Gn(Tt);break;case"end":An()}}),g(()=>{Oa().then(()=>{Da()})},100),Yt.reconfigure(1,co.value),Xn.reconfigure(1,9*Math.pow(fn.value,2)/40,fn.value);let Ve={setParent:Da};ce(Ve),B.onUnmounted(()=>{be(Ve)})}),B.onUnmounted(()=>{oi()}),()=>{j(Oe)}}let qn=16,Cr={activeColor:vn.PRIMARY_COLOR,backgroundColor:"#EBEBEB",activeMode:"backwards"},Vi={percent:{type:[Number,String],default:0,validator(m){return!isNaN(parseFloat(m))}},fontSize:{type:[String,Number],default:qn},showInfo:{type:[Boolean,String],default:!1},strokeWidth:{type:[Number,String],default:6,validator(m){return!isNaN(parseFloat(m))}},color:{type:String,default:Cr.activeColor},activeColor:{type:String,default:Cr.activeColor},backgroundColor:{type:String,default:Cr.backgroundColor},active:{type:[Boolean,String],default:!1},activeMode:{type:String,default:Cr.activeMode},duration:{type:[Number,String],default:30,validator(m){return!isNaN(parseFloat(m))}},borderRadius:{type:[Number,String],default:0}},Mt=[{"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 ye=B.defineComponent({name:"Progress",props:Vi,styles:Mt,emits:["activeend"],setup(m,{emit:R}){let z=B.ref(null),j=B.ref(null),Z=gr(z,R),Q=Ci(m);return B.watch(()=>Q.realPercent,(ce,be)=>{Q.lastPercent=be||0,$i(Q,m,Z)}),B.onMounted(()=>{g(()=>{cr(j.value).then(({width:ce})=>{Q.progressWidth=ce||0,$i(Q,m,Z)})},50)}),()=>{let{showInfo:ce,fontSize:be}=m,{outerBarStyle:Oe,innerBarStyle:Ne,currentPercent:ve}=Q;return B.createVNode("div",{ref:z,class:"uni-progress"},[B.createVNode("div",{ref:j,style:Oe,class:"uni-progress-bar"},[B.createVNode("div",{style:Ne,class:"uni-progress-inner-bar"},null)]),ce?ln(ve+"%",{class:"uni-progress-info",style:{fontSize:be}}):null])}}});function Ci(m){let R=B.ref(0),z=B.ref(0),j=B.computed(()=>({backgroundColor:m.backgroundColor,borderRadius:m.borderRadius,height:m.strokeWidth})),Z=B.computed(()=>{let be=m.color!==Cr.activeColor&&m.activeColor===Cr.activeColor?m.color:m.activeColor;return{width:R.value*z.value/100,height:m.strokeWidth,backgroundColor:be,borderRadius:m.borderRadius}}),Q=B.computed(()=>{let be=parseFloat(m.percent);return be<0&&(be=0),be>100&&(be=100),be});return B.reactive({outerBarStyle:j,innerBarStyle:Z,realPercent:Q,currentPercent:R,strokeTimer:0,lastPercent:0,progressWidth:z})}function $i(m,R,z){m.strokeTimer&&clearInterval(m.strokeTimer),R.active?(m.currentPercent=R.activeMode===Cr.activeMode?0:m.lastPercent,m.strokeTimer=setInterval(()=>{m.currentPercent+1>m.realPercent?(m.currentPercent=m.realPercent,m.strokeTimer&&clearInterval(m.strokeTimer),z("activeend",{})):m.currentPercent+=1},parseFloat(R.duration))):m.currentPercent=m.realPercent}let Wr={value:{type:Array,default(){return[]},validator:function(m){return gt.isArray(m)&&m.filter(R=>typeof R=="number").length===m.length}},indicatorStyle:{type:String,default:""},indicatorClass:{type:String,default:""},maskStyle:{type:String,default:""},maskClass:{type:String,default:""}},Br=gt.extend({},Wr,{height:{type:[Number,String],default:0}});var Hn=B.defineComponent({name:"PickerView",props:Br,emits:["change","update:value"],setup(m,{slots:R,emit:z}){let j=B.ref(null),Z=Bn(m),Q=gr(j,z),ce=[],be=Ne=>Array.prototype.indexOf.call(ce,Ne),Oe=Ne=>B.computed({get(){let ve=be(Ne.vnode);return Z.value[ve]||0},set(ve){if(!Ne.data._isMounted)return;let Fe=be(Ne.vnode);if(Fe<0)return;if(Z.value[Fe]!==ve){Z.value[Fe]=ve;let bt=Z.value.map(Wt=>Wt);z("update:value",bt),Q("change",{value:bt})}}});return B.provide("getPickerViewColumn",Oe),B.provide("pickerViewProps",m),()=>{let Ne=R.default&&R.default();ce=eo(Ne);let ve=m.height?{height:`${parseFloat(m.height)}px`}:{};return B.createVNode("view",B.mergeProps({ref:j,class:"uni-picker-view",style:ve},{preventGesture:!0}),[B.createVNode("view",{class:"uni-picker-view-wrapper"},[Ne])])}},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 Bn(m){let R=B.reactive([...m.value]),z=B.reactive({value:R});return B.watch(()=>m.value,j=>{z.value.length=j.length,j.forEach((Z,Q)=>{Z!==z.value[Q]&&z.value.splice(Q,1,Z)})}),z}let No=S.requireModule("dom"),Oi=S.config.env.platform.toLowerCase()==="android";function Ut(m){return gt.extend({},gt.isString(m)?Si(m):m)}var fi=B.defineComponent({name:"PickerViewColumn",props:{length:{type:[Number,String],default:0}},data:()=>({_isMounted:!1}),setup(m,{slots:R}){let z=B.getCurrentInstance(),j=B.ref(null),Z=B.ref(null),Q=B.ref(null),ce=B.ref(null),be=B.inject("pickerViewProps"),Ne=B.inject("getPickerViewColumn")(z),ve=B.computed(()=>Ut(be.indicatorStyle)),Fe=B.computed(()=>Ut(be.maskStyle)),rt=B.ref(0);rt.value=di(ve.value);let bt=B.ref(0);bt.value=parseFloat(be.height),B.watch(()=>m.length,()=>{g(()=>{nt(Ne.value,!0,!0)},150)});let Wt,nt=(pt,Ze=!0,Ot)=>{Ne.value===pt&&!Ot||(No.scrollToElement(Z.value,{offset:pt*rt.value,animated:Ze}),Ne.value=pt,Ze&&(Wt=Date.now()))},Ge=pt=>{if(Date.now()-Wt<340)return;let Ze=pt.detail.contentOffset.y,Ot=Math.round(Ze/rt.value);Ze%rt.value?nt(Ot,!0,!0):Ne.value=Ot},ut=()=>{let pt,Ze;g(()=>{Promise.all([cr(j.value).then(({height:Ot})=>{pt=bt.value=Ot}),Oi&&m.length?cr(Q.value).then(({height:Ot})=>{Ze=rt.value=Ot/parseFloat(m.length)}):cr(ce.value).then(({height:Ot})=>{Ze=rt.value=Ot})]).then(()=>{pt&&Ze?g(()=>{z.data._isMounted=!0,nt(Ne.value,!1,!0)},50):ut()})},50)};B.onMounted(ut);let Vt=pt=>pt?Oi?B.createVNode("div",{ref:Q,style:"flex-direction:column;"},[pt]):pt:null;return()=>{let pt=R.default&&R.default(),Ze=(bt.value-rt.value)/2,Ot=`${bt.value-Ze}px`,wn={showScrollbar:!1,scrollToBegin:!1,decelerationRate:.3,scrollY:!0};return Oi||(wn.scrollTop=Ne.value*rt.value),B.createVNode("view",{ref:j,class:"uni-picker-view-column"},[B.createVNode("scroll-view",B.mergeProps({class:"uni-picker-view-group",style:"flex-direction:column;",onScrollend:Ge},wn),[B.createVNode("view",{ref:Z,class:"uni-picker-view-content",style:{paddingTop:`${Ze}px`,paddingBottom:`${Ze}px`}},[Vt(pt)])]),B.createVNode("u-scalable",{class:"uni-picker-view-mask",style:Fe.value},[B.createVNode("u-scalable",{class:"uni-picker-view-mask uni-picker-view-mask-top",style:{bottom:Ot}},null),B.createVNode("u-scalable",{class:"uni-picker-view-mask uni-picker-view-mask-bottom",style:{top:Ot}},null)]),B.createVNode("u-scalable",{ref:ce,class:"uni-picker-view-indicator",style:gt.extend({},ve.value,{top:`${Ze}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 di(m){let z=(m.height||m.lineHeight||"").match(/(-?[\d\.]+)px/),j=0;return z&&(j=parseFloat(z[1])),j}let Kt={SELECTOR:"selector",MULTISELECTOR:"multiSelector",TIME:"time",DATE:"date"},Wn={YEAR:"year",MONTH:"month",DAY:"day"};function Or(m){return m>9?m:`0${m}`}function In(m,R){m=String(m||"");let z=new Date;if(R===Kt.TIME){let j=m.split(":");j.length===2&&z.setHours(parseInt(j[0]),parseInt(j[1]))}else{let j=m.split("-");j.length===3&&z.setFullYear(parseInt(j[0]),parseInt(String(parseFloat(j[1])-1)),parseInt(j[2]))}return z}function Ti(m){if(m.mode===Kt.TIME)return"00:00";if(m.mode===Kt.DATE){let R=new Date().getFullYear()-100;switch(m.fields){case Wn.YEAR:return R;case Wn.MONTH:return R+"-01";default:return R+"-01-01"}}return""}function ko(m){if(m.mode===Kt.TIME)return"23:59";if(m.mode===Kt.DATE){let R=new Date().getFullYear()+100;switch(m.fields){case Wn.YEAR:return R;case Wn.MONTH:return R+"-12";default:return R+"-12-31"}}return""}let hi={name:{type:String,default:""},range:{type:Array,default(){return[]}},rangeKey:{type:String,default:""},value:{type:[Number,String,Array],default:0},mode:{type:String,default:Kt.SELECTOR,validator(m){return Object.values(Kt).indexOf(m)>=0}},fields:{type:String,default:""},start:{type:String,default:Ti},end:{type:String,default:ko},disabled:{type:[Boolean,String],default:!1}};var no=B.defineComponent({name:"Picker",props:hi,emits:["change","cancel","columnchange"],setup(m,{slots:R,emit:z}){let j=B.ref(null),Z=gr(j,z),Q=B.ref(null),ce=B.ref(null),be=()=>{let nt=m.value;switch(m.mode){case Kt.MULTISELECTOR:{gt.isArray(nt)||(nt=[]),gt.isArray(Q.value)||(Q.value=[]);let Ge=Q.value.length=Math.max(nt.length,m.range.length);for(let ut=0;ut<Ge;ut++){let Vt=Number(nt[ut]),pt=Number(Q.value[ut]),Ze=isNaN(Vt)?isNaN(pt)?0:pt:Vt;Q.value.splice(ut,1,Ze<0?0:Ze)}}break;case Kt.TIME:case Kt.DATE:Q.value=String(nt);break;default:{let Ge=Number(nt);Q.value=Ge<0?0:Ge;break}}},Oe=nt=>{ce.value&&ce.value.sendMessage(nt)},Ne=nt=>{let Ge={event:"cancel"};ce.value=Qt({url:"__uniapppicker",data:nt,style:{titleNView:!1,animationType:"none",animationDuration:0,background:"rgba(0,0,0,0)",popGesture:"none"},onMessage:ut=>{let Vt=ut.event;if(Vt==="created"){Oe(nt);return}if(Vt==="columnchange"){delete ut.event,Z(Vt,ut);return}Ge=ut},onClose:()=>{ce.value=null;let ut=Ge.event;delete Ge.event,ut&&Z(ut,Ge)}})},ve=nt=>{N.nativeUI[m.mode===Kt.TIME?"pickTime":"pickDate"](Ge=>{let ut=Ge.date;Z("change",{value:m.mode===Kt.TIME?`${Or(ut.getHours())}:${Or(ut.getMinutes())}`:`${ut.getFullYear()}-${Or(ut.getMonth()+1)}-${Or(ut.getDate())}`})},()=>{Z("cancel",{})},m.mode===Kt.TIME?{time:In(m.value,Kt.TIME)}:{date:In(m.value,Kt.DATE),minDate:In(m.start,Kt.DATE),maxDate:In(m.end,Kt.DATE)})},Fe=nt=>{(nt.mode===Kt.TIME||nt.mode===Kt.DATE)&&!nt.fields?ve():(nt.fields=Object.values(Wn).includes(nt.fields)?nt.fields:Wn.DAY,Ne(nt))},rt=nt=>{m.disabled||Fe(gt.extend({},m,{value:Q.value,locale:_.getLocale()}))},bt=B.inject(hr,!1),Wt={submit:()=>[m.name,Q.value],reset:()=>{switch(m.mode){case Kt.SELECTOR:Q.value=0;break;case Kt.MULTISELECTOR:gt.isArray(m.value)&&(Q.value=m.value.map(nt=>0));break;case Kt.DATE:case Kt.TIME:Q.value="";break}}};return bt&&(bt.addField(Wt),B.onBeforeUnmount(()=>bt.removeField(Wt))),Object.keys(m).forEach(nt=>{B.watch(()=>m[nt],Ge=>{let ut={};ut[nt]=Ge,Oe(ut)},{deep:!0})}),B.watch(()=>m.value,be,{deep:!0}),be(),()=>B.createVNode("view",{ref:j,onClick:rt},[R.default&&R.default()])}});let Qo={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}},Ui=[{"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 Kn=B.defineComponent({name:"USlider",props:Qo,styles:Ui,setup(m,{emit:R}){let z=B.ref(null),j=B.ref(null),Z=gr(z,R),Q=pr(m),ce=Jn(m,Q,Z);return Mr(m,Q),B.watch(()=>m.value,be=>{Q.sliderValue=Number(be)}),B.onMounted(()=>{g(()=>{cr(z.value).then(({width:be})=>{Q.sliderWidth=be||0,Q.sliderValue=Number(m.value)})},100)}),()=>{let{showValue:be}=m,{trackStyle:Oe,trackActiveStyle:Ne,thumbStyle:ve,sliderValue:Fe}=Q;return B.createVNode("div",{class:"uni-slider",ref:z},[B.createVNode("div",{class:"uni-slider-wrapper"},[B.createVNode("div",B.mergeProps({class:"uni-slider-tap-area"},ce),[B.createVNode("div",{class:"uni-slider-handle-wrapper",ref:j,style:Oe},[B.createVNode("div",{class:"uni-slider-track",style:Ne},null)]),B.createVNode("div",{class:"uni-slider-thumb",style:ve},null)]),be?ln(Fe+"",{class:"uni-slider-value"}):null])])}}});function pr(m){let R=B.ref(0),z=B.ref(0),j=()=>m.backgroundColor!=="#e9e9e9"?m.backgroundColor:m.color!=="#007aff"?m.color:"#007aff",Z=()=>m.activeColor!=="#007aff"?m.activeColor:m.selectedColor!=="#e9e9e9"?m.selectedColor:"#e9e9e9",Q=()=>{let be=Number(m.max),Oe=Number(m.min);return(z.value-Oe)/(be-Oe)*R.value};return B.reactive({sliderWidth:R,sliderValue:z,trackStyle:B.computed(()=>({backgroundColor:j()})),trackActiveStyle:B.computed(()=>({backgroundColor:Z(),width:Q()})),thumbStyle:B.computed(()=>({width:m.blockSize,height:m.blockSize,marginTop:-m.blockSize/2,left:Q(),backgroundColor:m.blockColor}))})}function Jn(m,R,z){let j=null;function Z(be,Oe){m.disabled||(be==="move"?(Q(Oe),z("changing",{value:R.sliderValue})):be==="end"&&(Q(Oe),z("change",{value:R.sliderValue})))}function Q(be){be<0&&(be=0),be>R.sliderWidth&&(be=R.sliderWidth);let Oe=Number(m.max),Ne=Number(m.min),ve=Number(m.step),Fe=be/R.sliderWidth*Oe-Ne;ve>0&&Fe>ve&&Fe%ve/ve!==0&&(Fe-=Fe%ve),R.sliderValue=Fe+Ne}return{onTouchstart(be){be.changedTouches.length===1&&!j&&(j=be,Z("start",be.changedTouches[0].pageX))},onTouchmove(be){be.changedTouches.length===1&&j&&Z("move",be.changedTouches[0].pageX)},onTouchend(be){be.changedTouches.length===1&&j&&(j=null,Z("end",be.changedTouches[0].pageX))}}}function Mr(m,R){let z=B.inject(hr,!1),j={submit:()=>{let Z=["",null];return m.name&&(Z[0]=m.name,Z[1]=R.sliderValue),Z},reset:()=>{R.sliderValue=Number(m.value)}};z&&(z.addField(j),B.onUnmounted(()=>{z.removeField(j)}))}let Tr={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"}},Hi={switch:"switch",checkbox:"checkbox"},ti={width:52,height:32};var vr=B.defineComponent({name:"Switch",props:Tr,emits:["change"],setup(m,{emit:R}){let z=B.ref(null),j=B.ref(m.checked),Z=Gr(m,j),Q=gr(z,R);B.watch(()=>m.checked,Oe=>{j.value=Oe});let ce={onChange(Oe){j.value=Oe.detail.value,Q("change",{value:j.value})}},be=(Oe,Ne)=>{m.disabled||(j.value=!j.value,Q("change",{value:j.value}))};return Z&&(Z.addHandler(be),B.onBeforeUnmount(()=>{Z.removeHandler(be)})),xn(m,{"label-click":be}),()=>{let{color:Oe,type:Ne}=m;return B.createVNode("div",{ref:z},[Ne===Hi.switch?B.createVNode("dc-switch",B.mergeProps({dataUncType:"uni-switch"},ce,{checked:j.value,color:Oe},{style:ti}),null):null,Ne===Hi.checkbox?B.createVNode(B.resolveComponent("checkbox"),B.mergeProps({style:{color:Oe}},{checked:j.value},ce),null):null])}}});function Gr(m,R){let z=B.inject(hr,!1),j=B.inject(lr,!1),Z={submit:()=>{let Q=["",null];return m.name&&(Q[0]=m.name,Q[1]=R.value),Q},reset:()=>{R.value=!1}};return z&&(z.addField(Z),B.onUnmounted(()=>{z.removeField(Z)})),j}let Pi={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:""}},gi=kn("ucg"),pi={name:{type:String,default:""}},Yr=[{"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 vi=B.defineComponent({name:"Checkbox",props:Pi,styles:Yr,setup(m,{slots:R}){let z=B.ref(null),j=B.ref(m.checked),Z=B.ref(m.value),Q=B.computed(()=>m.disabled?"#adadad":m.color),ce=()=>{j.value=!1},be=(Fe,rt)=>{m.disabled||(j.value=!j.value,Oe&&Oe.checkboxChange(Fe))},{uniCheckGroup:Oe,uniLabel:Ne}=ro(j,Z,ce);Ne&&(Ne.addHandler(be),B.onBeforeUnmount(()=>{Ne.removeHandler(be)})),xn(m,{"label-click":be}),B.watch([()=>m.checked,()=>m.value],([Fe,rt])=>{j.value=Fe,Z.value=rt});let ve=()=>{if(!R.default)return[];let Fe=R.default();return Fe.length===1&&Fe[0].type===Text?[ln(Fe[0].children,{class:"uni-checkbox-slot"})]:Fe};return()=>B.createVNode("div",B.mergeProps({ref:z},{dataUncType:"uni-checkbox"},{onClick:be,class:"uni-checkbox"}),[B.createVNode("div",{class:["uni-checkbox-input",{"uni-checkbox-input-disabled":m.disabled}]},[j.value?ln("\uEA08",{class:"uni-icon",style:{color:Q.value}}):null]),...ve()])}});function ro(m,R,z){let j=B.computed(()=>({checkboxChecked:Boolean(m.value),value:R.value})),Z={reset:z},Q=B.inject(gi,!1);Q&&Q.addField(j);let ce=B.inject(hr,!1);ce&&ce.addField(Z);let be=B.inject(lr,!1);return B.onBeforeUnmount(()=>{Q&&Q.removeField(j),ce&&ce.removeField(Z)}),{uniCheckGroup:Q,uniForm:ce,uniLabel:be}}var ji=B.defineComponent({name:"CheckboxGroup",props:pi,emits:["change"],setup(m,{slots:R,emit:z}){let j=B.ref(null),Z=gr(j,z);return io(m,Z),()=>B.createVNode("div",{ref:j,class:"uni-checkbox-group"},[R.default&&R.default()])}});function io(m,R){let z=[],j=()=>z.reduce((Q,ce)=>(ce.value.checkboxChecked&&Q.push(ce.value.value),Q),new Array);B.provide(gi,{addField(Q){z.push(Q)},removeField(Q){z.splice(z.indexOf(Q),1)},checkboxChange(Q){R("change",{value:j()})}});let Z=B.inject(hr,!1);return Z&&Z.addField({submit:()=>{let Q=["",null];return m.name!==""&&(Q[0]=m.name,Q[1]=j()),Q}}),j}let x={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:""}},ne=kn("ucg"),de={name:{type:String,default:""}},H=[{"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 M=B.defineComponent({name:"Radio",props:x,styles:H,emits:["change"],setup(m,{slots:R}){let z=B.ref(null),j=B.ref(m.checked),Z=B.ref(m.value),Q=B.computed(()=>{let rt=m.disabled?"#adadad":m.color;return j.value?{backgroundColor:rt,borderColor:rt}:{borderColor:"#d1d1d1"}}),ce=()=>{j.value=!1},{uniCheckGroup:be,uniLabel:Oe,field:Ne}=J(j,Z,ce),ve=(rt,bt)=>{m.disabled||(j.value=!j.value,be&&be.radioChange(rt,Ne))};Oe&&(Oe.addHandler(ve),B.onBeforeUnmount(()=>{Oe.removeHandler(ve)})),xn(m,{"label-click":ve}),B.watch([()=>m.checked,()=>m.value],([rt,bt])=>{j.value=rt,Z.value=bt});let Fe=()=>{if(!R.default)return[];let rt=R.default();return rt.length===1&&rt[0].type===Text?[ln(rt[0].children,{class:"uni-radio-slot"})]:rt};return()=>{let{disabled:rt}=m;return B.createVNode("div",B.mergeProps({ref:z},{dataUncType:"uni-radio"},{onClick:ve,class:"uni-radio"}),[B.createVNode("div",{style:Q.value,class:["uni-radio-input",{"uni-radio-input-disabled":rt}]},[j.value?ln("\uEA08",{class:"uni-radio-input-icon"}):null]),...Fe()])}}});function J(m,R,z){let j=B.computed({get:()=>({radioChecked:Boolean(m.value),value:R.value}),set:({radioChecked:Oe})=>{m.value=Oe}}),Z={reset:z},Q=B.inject(ne,!1);Q&&Q.addField(j);let ce=B.inject(hr,!1);ce&&ce.addField(Z);let be=B.inject(lr,!1);return B.onBeforeUnmount(()=>{Q&&Q.removeField(j),ce&&ce.removeField(Z)}),{uniCheckGroup:Q,uniForm:ce,uniLabel:be,field:j}}var X=B.defineComponent({name:"RadioGroup",props:de,emits:["change"],setup(m,{slots:R,emit:z}){let j=B.ref(null),Z=gr(j,z);return ue(m,Z),()=>B.createVNode("div",{ref:j},[R.default&&R.default()])}});function ue(m,R){let z=[];B.onMounted(()=>{be(z.length-1)});let j=()=>{var Oe;return(Oe=z.find(Ne=>Ne.value.radioChecked))==null?void 0:Oe.value.value};B.provide(ne,{addField(Oe){z.push(Oe)},removeField(Oe){z.splice(z.indexOf(Oe),1)},radioChange(Oe,Ne){let ve=z.indexOf(Ne);be(ve,!0),R("change",{value:j()})}});let Z=B.inject(hr,!1),Q={submit:()=>{let Oe=["",null];return m.name!==""&&(Oe[0]=m.name,Oe[1]=j()),Oe}};Z&&(Z.addField(Q),B.onBeforeUnmount(()=>{Z.removeField(Q)}));function ce(Oe,Ne){Oe.value={radioChecked:Ne,value:Oe.value.value}}function be(Oe,Ne){z.forEach((ve,Fe)=>{Fe!==Oe&&Ne&&ce(z[Fe],!1)})}return z}let tn=["u-input","u-textarea"];var Mn=B.defineComponent({name:"Form",emits:["submit","reset"],setup({},{slots:m,emit:R}){let z=B.ref(null),j=gr(z,R),Z=[],Q;return B.provide(hr,{addField(ce){Z.push(ce)},removeField(ce){Z.splice(Z.indexOf(ce),1)},submit(ce){let be={};Q&&Q(be);let Oe=Z.reduce((Ne,ve)=>{if(ve.submit){let[Fe,rt]=ve.submit();Fe&&(Ne[Fe]=rt)}return Ne},Object.create(null));Object.assign(be,Oe),j("submit",{value:be})},reset(ce){Q&&Q(),Z.forEach(be=>be.reset&&be.reset()),j("reset",ce)}}),()=>{let ce=m.default&&m.default();return Q=cn(ce),B.createVNode("view",{ref:z},[ce])}}});function cn(m){let R=S.requireModule("plus"),z=(j,Z)=>{(Z||m||[]).forEach(function(Q){tn.indexOf(String(Q.type))>=0&&Q.el&&Q.el.attr&&Q.el.attr.name&&(j?j[Q.el.attr.name]=R.getValue(Q.el.nodeId):Q.el.setValue("")),gt.isArray(Q.children)&&Q.children&&Q.children.length&&z(j,Q.children)})};return z}let ni={type:{type:String,default:""},size:{type:[String,Number],default:23},color:{type:String,default:""}},mr={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"},ea={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"},zo=[{"uni-icon":{"":{fontFamily:"unincomponents"}}}];var ta=B.defineComponent({name:"Icon",props:ni,styles:zo,setup(m,{}){return()=>ln(ea[m.type],{class:"uni-icon",style:{color:m.color||mr[m.type],fontSize:m.size}})}});let Ro={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}},bo=S.config.env.platform.toLowerCase()==="android",oo=[{"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 Ra=B.defineComponent({name:"Swiper",props:Ro,styles:oo,emits:["change","transition","animationfinish"],setup(m,{slots:R,emit:z}){let j=B.ref(null),Z=[],Q=gr(j,z),ce=na(m),be=_a(ce,m,Z,Q);return B.watch([()=>m.current,()=>m.currentItemId],([Oe,Ne])=>{ts(ce,m,Z)}),B.onMounted(()=>{g(()=>{cr(j.value).then(({width:Oe,height:Ne})=>{ce.swiperWidth=Oe,ce.swiperHeight=Ne})},50)}),()=>{let Oe=R.default&&R.default(),{indicatorStyle:Ne,currentSync:ve}=ce;return Z=eo(Oe),B.createVNode("div",{ref:j,class:"uni-swiper"},[B.createVNode("slider",B.mergeProps({class:"uni-swiper-slider"},{autoPlay:m.autoplay,interval:m.interval,index:ve,keepIndex:!0,showIndicators:m.indicatorDots,infinite:m.circular,vertical:m.vertical,scrollable:!m.disableTouch},be),[Z,B.createVNode("indicator",{class:"uni-swiper-dots",style:Ne},null)])])}}});function na(m){let R=B.ref(0),z=B.ref(0),j=B.ref(m.current),Z=B.ref("autoplay"),Q=B.computed(()=>({itemColor:m.indicatorColor,itemSelectedColor:m.indicatorActiveColor,itemSize:8,opacity:m.indicatorDots?1:0}));return B.reactive({swiperWidth:R,swiperHeight:z,indicatorStyle:Q,currentSync:j,currentChangeSource:Z})}function _a(m,R,z,j){let Z=0,Q=ve=>{let Fe=ve.detail,rt=R.vertical,bt=(rt?Fe.offsetYRatio:Fe.offsetXRatio)||0;if((ve.drag||ve.drag)&&(m.currentChangeSource="touch"),bt===0){let Wt=Math.abs(Z);if(Wt===1)return;Wt>.5&&(bt=1)}Z=bt,j("transition",{dx:rt?0:-m.swiperWidth*bt,dy:rt?-m.swiperHeight*bt:0})},ce=ve=>{let Fe=()=>{j("animationfinish",Oe()),m.currentChangeSource="autoplay"};bo?Fe():g(Fe,50)},be=ve=>{gt.isString(ve.detail.source)&&(m.currentChangeSource=ve.detail.source),m.currentSync=ve.detail.index,Z=0};function Oe(){let ve=Number(m.currentSync),Fe=z[ve]||{},rt=Fe.componentInstance&&Fe.componentInstance.itemId||"";return{current:ve,currentItemId:rt,source:m.currentChangeSource}}return B.watch(()=>m.currentSync,ve=>{j("change",Oe())}),{onScroll:Q,onScrollend:ce,onChange:be}}function ts(m,R,z){let j=-1;if(R.currentItemId)for(let Z=0,Q=z;Z<Q.length;Z++){let ce=Q[Z].componentInstance;if(ce&&ce.itemId===R.currentItemId){j=Z;break}}j<0&&(j=Math.round(Number(R.current))||0),j=j<0?0:j,m.currentSync!==j&&(m.currentChangeSource="",m.currentSync=j)}let ra={itemId:{type:String,default:""}};var xa=B.defineComponent({name:"SwiperItem",props:ra,setup(m,{slots:R}){return()=>B.createVNode("div",{class:"uni-swiper-item",style:{position:"absolute",left:0,top:0,right:0,bottom:0,overflow:"hidden"}},[R.default&&R.default()])}}),fr=/^<([-A-Za-z0-9_]+)((?:\s+[a-zA-Z_:][-a-zA-Z0-9_:.]*(?:\s*=\s*(?:(?:"[^"]*")|(?:'[^']*')|[^>\s]+))?)*)\s*(\/?)>/,_r=/^<\/([-A-Za-z0-9_]+)[^>]*>/,ia=/([a-zA-Z_:][-a-zA-Z0-9_:.]*)(?:\s*=\s*(?:(?:"((?:\\.|[^"])*)")|(?:'((?:\\.|[^'])*)')|([^>\s]+)))?/g,Ba=Wo("area,base,basefont,br,col,frame,hr,img,input,link,meta,param,embed,command,keygen,source,track,wbr"),Lr=Wo("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"),Ma=Wo("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"),br=Wo("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr"),Zn=Wo("checked,compact,declare,defer,disabled,ismap,multiple,nohref,noresize,noshade,nowrap,readonly,selected"),xo=Wo("script,style");function Cs(m,R){var z,j,Z,Q=[],ce=m;for(Q.last=function(){return this[this.length-1]};m;){if(j=!0,!Q.last()||!xo[Q.last()]){if(m.indexOf("<!--")==0?(z=m.indexOf("-->"),z>=0&&(R.comment&&R.comment(m.substring(4,z)),m=m.substring(z+3),j=!1)):m.indexOf("</")==0?(Z=m.match(_r),Z&&(m=m.substring(Z[0].length),Z[0].replace(_r,Ne),j=!1)):m.indexOf("<")==0&&(Z=m.match(fr),Z&&(m=m.substring(Z[0].length),Z[0].replace(fr,Oe),j=!1)),j){z=m.indexOf("<");var be=z<0?m:m.substring(0,z);m=z<0?"":m.substring(z),R.chars&&R.chars(be)}}else m=m.replace(new RegExp("([\\s\\S]*?)</"+Q.last()+"[^>]*>"),function(ve,Fe){return Fe=Fe.replace(/<!--([\s\S]*?)-->|<!\[CDATA\[([\s\S]*?)]]>/g,"$1$2"),R.chars&&R.chars(Fe),""}),Ne("",Q.last());if(m==ce)throw"Parse Error: "+m;ce=m}Ne();function Oe(ve,Fe,rt,bt){if(Fe=Fe.toLowerCase(),Lr[Fe])for(;Q.last()&&Ma[Q.last()];)Ne("",Q.last());if(br[Fe]&&Q.last()==Fe&&Ne("",Fe),bt=Ba[Fe]||!!bt,bt||Q.push(Fe),R.start){var Wt=[];rt.replace(ia,function(nt,Ge){var ut=arguments[2]?arguments[2]:arguments[3]?arguments[3]:arguments[4]?arguments[4]:Zn[Ge]?Ge:"";Wt.push({name:Ge,value:ut,escaped:ut.replace(/(^|[^\\])"/g,'$1\\"')})}),R.start&&R.start(Fe,Wt,bt)}}function Ne(ve,Fe){if(Fe)for(var rt=Q.length-1;rt>=0&&Q[rt]!=Fe;rt--);else var rt=0;if(rt>=0){for(var bt=Q.length-1;bt>=rt;bt--)R.end&&R.end(Q[bt]);Q.length=rt}}}function Wo(m){for(var R={},z=m.split(","),j=0;j<z.length;j++)R[z[j]]=!0;return R}function ns(m){return m.replace(/<\?xml.*\?>\n/,"").replace(/<!doctype.*>\n/,"").replace(/<!DOCTYPE.*>\n/,"")}function jn(m){return m.reduce(function(R,z){let j=z.value,Z=z.name;return j.match(/ /)&&["style","src"].indexOf(Z)===-1&&(j=j.split(" ")),R[Z]?Array.isArray(R[Z])?R[Z].push(j):R[Z]=[R[Z],j]:R[Z]=j,R},{})}function ba(m){m=ns(m);let R=[],z={node:"root",children:[]};return Cs(m,{start:function(j,Z,Q){let ce={name:j};if(Z.length!==0&&(ce.attrs=jn(Z)),Q){let be=R[0]||z;be.children||(be.children=[]),be.children.push(ce)}else R.unshift(ce)},end:function(j){let Z=R.shift();if(Z.name!==j&&console.error("invalid state: mismatch end tag"),R.length===0)z.children.push(Z);else{let Q=R[0];Q.children||(Q.children=[]),Q.children.push(Z)}},chars:function(j){let Z={type:"text",text:j};if(R.length===0)z.children.push(Z);else{let Q=R[0];Q.children||(Q.children=[]),Q.children.push(Z)}},comment:function(j){let Z={node:"comment",text:j},Q=R[0];Q.children||(Q.children=[]),Q.children.push(Z)}}),z.children}let Go={nodes:{type:[Array,String],default:function(){return[]}}},Ii=16;var Ea=B.defineComponent({name:"RichText",props:Go,setup(m){let R=B.getCurrentInstance();return()=>{let z=m.nodes;return gt.isString(z)&&(z=ba(z)),B.createVNode("u-rich-text",{value:La(z||[],R.root,{defaultFontSize:Ii})},null)}}});function La(m,R,z){let j=["span","a","image","img"],Z={blockquote:Fe,br:nt,div:Fe,dl:Fe,h1:bt(2),h2:bt(1.5),h3:bt(1.17),h4:bt(1),h5:bt(.83),h6:bt(.67),hr:Fe,ol:Fe,p:Fe,strong:Wt,table:Fe,tbody:Fe,tfoot:Fe,thead:Fe,ul:Fe},Q=/&(amp|gt|lt|nbsp|quot|apos);/g,ce={amp:"&",gt:">",lt:"<",nbsp:" ",quot:'"',apos:"'"},be={type:"span",__type:"break",attr:{value:`
`}},Oe={__block:!0,__break:!0,children:[]},Ne=null;function ve(Ze){let Ot=Object.create(null);if(Ze.attrs){let wn=(Ze.attrs.class||"").split(" ");Object.assign(Ot,B.parseClassList(wn,R),Si(Ze.attrs.style||""))}if(Ze.name==="img"||Ze.name==="image"){let wn=Ze.attrs;Ot.width=Ot.width||wn.width,Ot.height=Ot.height||wn.height}return Ot}function Fe(Ze){return Ze.__block=!0,Ze}function rt(Ze,Ot){return Ze.style&&!Ze.style.fontSize&&(Ze.style.fontSize=z.defaultFontSize*Ot),Fe(Wt(Ze))}function bt(Ze){return function(Ot){return rt(Ot,Ze)}}function Wt(Ze){return Ze.style&&!Ze.style.fontWeight&&(Ze.style.fontWeight="bold"),Ze}function nt(Ze){return Ze.__value=" ",Fe(Ze)}function Ge(Ze){return Ze.replace(Q,function(Ot,wn){return ce[wn]})}function ut(Ze){let Ot=(Ze.name||"").toLowerCase(),wn=Ot,un=Z[Ot];j.indexOf(Ot)===-1&&(Ot="span"),Ot==="img"&&(Ot="image");let rn={type:Ot,__type:wn,attr:Object.create(null)};return(Ze.type==="text"||Ze.text)&&(rn.__value=rn.attr.value=Ge((Ze.text||"").trim())),Ze.attrs&&Object.keys(Ze.attrs).forEach(Sn=>{Sn!=="class"&&Sn!=="style"&&(rn.attr[Sn]=Ze.attrs[Sn])}),rn.style=ve(Ze),un&&un(rn),(Oe.__block||rn.__block)&&(Ne||(Oe.children.push(be),Ne=[Oe,be])),Oe=rn,(Oe.__value||Oe.type==="image"&&Oe.attr.src)&&(Ne=null),rn.children=Vt(Ze.children),Oe=rn,Oe.__block&&Oe.style.height&&!/^0(px)?$/.test(Oe.style.height)&&(Ne=null),rn}function Vt(Ze){return gt.isArray(Ze)?Ze.map(Ot=>ut(Ot)):[]}let pt=Vt(m);if(Ne){let[Ze,Ot]=Ne,wn=Ze.children,un=wn.indexOf(Ot);wn.splice(un,1)}return pt}let ao={};function oa(m,R,z){let{adpid:j,width:Z}=m,Q=j+"-"+Z,ce=ao[Q];if(ce&&ce.length>0){R(ce.splice(0,1)[0]);return}N.ad.getAds(m,be=>{let Oe=be.ads;R(Oe.splice(0,1)[0]),ao[Q]=ce?ce.concat(Oe):Oe},be=>{z({errCode:be.code,errMsg:be.message})})}let Eo={adpid:{type:[Number,String],default:""},data:{type:String,default:""},width:{type:String,default:""},channel:{type:String,default:""}},zi={load:"load",close:"close",error:"error",downloadchange:"downloadchange"};var ya=B.defineComponent({name:"Ad",props:Eo,emits:[zi.load,zi.close,zi.error,zi.downloadchange],setup(m,{emit:R}){let z=B.ref(null),j=gr(z,R),Z=aa();B.watch(()=>m.adpid,ce=>{wa(Z,m,j)}),B.watch(()=>m.data,ce=>{Z.data=ce}),B.onMounted(()=>{g(()=>{cr(z.value).then(({width:ce})=>{Z.width=ce===0?-1:ce,wa(Z,m,j)})},50)});let Q={onDownloadchange(ce){j(zi.downloadchange,ce)},onDislike(ce){j(zi.close,ce)}};return()=>B.createVNode("u-ad",B.mergeProps({ref:z},{data:Z.data,rendering:!0},Q),null)}});function aa(m){let R=B.ref("");return B.reactive({width:0,data:R})}function wa(m,R,z){oa({adpid:R.adpid,width:m.width},j=>{m.data=j,z(zi.load,{})},j=>{z(zi.error,j)})}let sa={};function Sa(m,R,z,j,Z){let Q=m+"-"+R,ce=sa[Q];if(ce&&ce.length>0){j(ce.splice(0,1)[0]);return}N.ad.getDrawAds({adpid:String(m),count:3,width:R},be=>{let Oe=be.ads;j(Oe.splice(0,1)[0]),sa[Q]=ce?ce.concat(Oe):Oe},be=>{Z({errCode:be.code,errMsg:be.message})})}let Os={adpid:{type:[Number,String],default:""},data:{type:String,default:""},width:{type:String,default:""}},so={load:"load",close:"close",error:"error"};var ri=B.defineComponent({name:"AdDraw",props:Os,emits:[so.load,so.close,so.error],setup(m,{emit:R}){let z=B.ref(null),j=gr(z,R),Z=Ni();B.watch(()=>m.adpid,ce=>{lo(Z,m,j)}),B.watch(()=>m.data,ce=>{Z.data=ce});let Q={onDislike(ce){j(so.close,ce)}};return B.onMounted(()=>{g(()=>{cr(z.value).then(({width:ce,height:be})=>{Z.width=ce===0?-1:ce,Z.height=be===0?-1:be,lo(Z,m,j)})},50)}),()=>{let{data:ce}=Z;return B.createVNode("u-ad-draw",B.mergeProps({ref:z},{data:ce,rendering:!0},Q),null)}}});function Ni(m){let R=B.ref("");return B.reactive({width:0,height:0,data:R})}function lo(m,R,z){Sa(R.adpid,m.width,m.height,j=>{m.data=j,z(so.load,{})},j=>{z(so.error,j)})}var la={Navigator:an,Label:Di,Button:ci,MovableArea:jr,MovableView:Ai,Progress:ye,PickerView:Hn,PickerViewColumn:fi,Picker:no,USlider:Kn,Switch:vr,Checkbox:vi,CheckboxGroup:ji,Radio:M,RadioGroup:X,Form:Mn,Icon:ta,Swiper:Ra,SwiperItem:xa,RichText:Ea,Ad:ya,AdDraw:ri};return la}(k,ze,xt);return pn}function CP(g,l){let{UniShared:_,Vue:A}=l;function k(N,f,T){let ze=N.$[f];return ze&&_.invokeArrayFns(ze,T)}let S=g.setup;return g.inheritAttrs=!1,g.setup=(N,f)=>{let{attrs:{__pageId:T,__pagePath:ze,__pageQuery:xt}}=f,pn=l.__uniRoutes.find(vn=>vn.meta.route===ze),B=A.getCurrentInstance(),gt=B.proxy;if(pn&&(pn.meta.isSubNVue||OP(gt,l,{__pageId:T,__pagePath:ze})),A.onMounted(()=>{A.nextTick(()=>{k(gt,_.ON_READY)}),B.onPageScroll&&gt.$el.addEvent("scroll",vn=>{vn.scrollTop=vn.detail.scrollTop,k(gt,_.ON_PAGE_SCROLL,vn)}),B.onReachBottom&&gt.$el.addEvent("scrolltolower",vn=>{k(gt,_.ON_REACH_BOTTOM,vn)})}),A.onBeforeUnmount(()=>{k(gt,_.ON_UNLOAD)}),S)return S(xt,f)},g}function OP(g,l,{__pageId:_,__pagePath:A}){let k=l.getCurrentPages(),S=k[k.length-1];if(S&&S.__setup)S.__setup(g,S);else{let N="/"+A;return l.__registerPage({url:N,path:N,query:{},openType:"launch",webview:{id:_+""},nvuePageVm:g})}}var Fl={},ap;function sp(g){ap=g}var tu;function TP(g){if(tu)return tu;let l=new g.Emitter;return tu={on(_,A){return l.on(_,A)},once(_,A){return l.once(_,A)},off(_,A){return l.off(_,A)},emit(_,...A){return l.emit(_,...A)}},tu}function PP(g){return(l,_,A)=>{let{nvue:k}=_,S=eu(g,_);_.Vue=S,Fl[l]={instanceId:l,config:k.config,document:k.document,data:A};let{createApp:N}=S;S.createVueApp=S.createApp=(f,T)=>(_.__uniConfig.styles=f.styles||[],N(f,T).use(IP,l,_)),S.createPageApp=(f,T)=>{CP(f,_);let ze=T.$store;delete T.$store;let xt=N(f,T);return ze&&xt.use(ze),xt.use(kP,S,l,_)}}}var IP={install(g,l,_){dc(_).initApp(g),NP(g,l,_)}};function NP(g,l,_){let{mount:A}=g,k=Fl[l];return g.mount=S=>{let N=S==="#app",f=k.app=A(lp(k.document,{isRoot:N}));return N&&_.__registerApp(f),f},g}var kP={install(g,l,_,A){let{weex:k,plus:S,BroadcastChannel:N,VueShared:f,UniShared:T,getCurrentPages:ze,setTimeout:xt,clearTimeout:pn}=A;g.config.globalProperties.$requireNativePlugin=k.requireModule;let B=AP({uni:ap,Vue:l,weex:k,plus:S,BroadcastChannel:N,UniViewJSBridge:TP(T),VueShared:f,UniShared:T,getCurrentPages:ze,setTimeout:xt,clearTimeout:pn});Object.keys(B).forEach(gt=>{g.component(l.hyphenate(gt),B[gt])}),dc(A).initApp(g),RP(g,_,A)}};function RP(g,l,{nvue:_}){let{config:{compilerOptions:A},mount:k}=g;A.isCustomElement=N=>!!_.supports(`@component/${N}`);let S=Fl[l];return g.mount=N=>{let f=N==="#root",T=S.app=k(lp(S.document,{isRoot:f}));if(f)try{_.document.taskCenter.send("dom",{action:"createFinish"},[])}catch(ze){}return T},g}function lp(g,{isRoot:l}){if(l)return g.documentElement;let _=g.createComment("root");return g.documentElement.appendChild(_),_}function cp(g){let l=Fl[g];if(l&&l.app&&l.document){try{l.app.$.appContext.app.unmount(),l.document.destroy()}catch(_){}delete l.document,delete l.app}delete Fl[g]}function up(g){let l=Fl[g];if(!l||!l.app)return new Error(`refreshInstance: instance ${g} not found!`);l.document.taskCenter.send("dom",{action:"refreshFinish"},[])}function xP(g,l){let{UniShared:_,VueShared:A,VueReactivity:k}=g;var S=function(N,f,T,ze){"use strict";var xt=[];function pn(o){T.pauseTracking();for(var c=xt.length?xt[xt.length-1].component:null,v=c&&c.appContext.config.warnHandler,E=B(),P=arguments.length,C=new Array(P>1?P-1:0),V=1;V<P;V++)C[V-1]=arguments[V];if(v)Y(v,c,11,[o+C.join(""),c&&c.proxy,E.map(q=>{var{vnode:ae}=q;return"at <".concat(St(c,ae.type),">")}).join(`
`),E]);else{var G=["[Vue warn]: ".concat(o),...C];E.length&&G.push(`
`,...gt(E)),console.warn(...G)}T.resetTracking()}function B(){var o=xt[xt.length-1];if(!o)return[];for(var c=[];o;){var v=c[0];v&&v.vnode===o?v.recurseCount++:c.push({vnode:o,recurseCount:0});var E=o.component&&o.component.parent;o=E&&E.vnode}return c}function gt(o){var c=[];return o.forEach((v,E)=>{c.push(...E===0?[]:[`
`],...vn(v))}),c}function vn(o){var{vnode:c,recurseCount:v}=o,E=v>0?"... (".concat(v," recursive calls)"):"",P=c.component?c.component.parent==null:!1,C=" at <".concat(St(c.component,c.type,P)),V=">"+E;return c.props?[C,...Vn(c.props),V]:[C+V]}function Vn(o){var c=[],v=Object.keys(o);return v.slice(0,3).forEach(E=>{c.push(...st(E,o[E]))}),v.length>3&&c.push(" ..."),c}function st(o,c,v){return f.isString(c)?(c=JSON.stringify(c),v?c:["".concat(o,"=").concat(c)]):typeof c=="number"||typeof c=="boolean"||c==null?v?c:["".concat(o,"=").concat(c)]:T.isRef(c)?(c=st(o,T.toRaw(c.value),!0),v?c:["".concat(o,"=Ref<"),c,">"]):f.isFunction(c)?["".concat(o,"=fn").concat(c.name?"<".concat(c.name,">"):"")]:(c=T.toRaw(c),v?c:["".concat(o,"="),c])}function Y(o,c,v,E){var P;try{P=E?o(...E):o()}catch(C){En(C,c,v)}return P}function te(o,c,v,E){if(f.isFunction(o)){var P=Y(o,c,v,E);return P&&f.isPromise(P)&&P.catch(G=>{En(G,c,v)}),P}for(var C=[],V=0;V<o.length;V++)C.push(te(o[V],c,v,E));return C}function En(o,c,v){if(c&&c.vnode,c){for(var E=c.parent,P=c.proxy,C=v;E;){var V=E.ec;if(V){for(var G=0;G<V.length;G++)if(V[G](o,P,C)===!1)return}E=E.parent}var q=c.appContext.config.errorHandler;if(q){Y(q,null,10,[o,P,C]);return}}yn(o)}function yn(o,c,v){console.error(o)}var ln=!1,$n=!1,an=[],kn=0,Un=[],mn=null,sn=0,_n=[],Rn=null,kr=0,Zr=Promise.resolve(),Ue=null,it=null;function vt(o){var c=Ue||Zr;return o?c.then(this?o.bind(this):o):c}function qt(o){for(var c=kn+1,v=an.length;c<v;){var E=c+v>>>1,P=Ur(an[E]);P<o?c=E+1:v=E}return c}function nn(o){(!an.length||!an.includes(o,ln&&o.allowRecurse?kn+1:kn))&&o!==it&&(o.id==null?an.push(o):an.splice(qt(o.id),0,o),Qt())}function Qt(){!ln&&!$n&&($n=!0,Ue=Zr.then(Hr))}function ir(o){var c=an.indexOf(o);c>kn&&an.splice(c,1)}function lr(o,c,v,E){f.isArray(o)?v.push(...o):(!c||!c.includes(o,o.allowRecurse?E+1:E))&&v.push(o),Qt()}function Li(o){lr(o,mn,Un,sn)}function Di(o){lr(o,Rn,_n,kr)}function xn(o){var c=arguments.length>1&&arguments[1]!==void 0?arguments[1]:null;if(Un.length){for(it=c,mn=[...new Set(Un)],Un.length=0,sn=0;sn<mn.length;sn++)mn[sn]();mn=null,sn=0,it=null,xn(o,c)}}function wr(o){if(xn(),_n.length){var c=[...new Set(_n)];if(_n.length=0,Rn){Rn.push(...c);return}for(Rn=c,Rn.sort((v,E)=>Ur(v)-Ur(E)),kr=0;kr<Rn.length;kr++)Rn[kr]();Rn=null,kr=0}}var Ur=o=>o.id==null?1/0:o.id;function Hr(o){$n=!1,ln=!0,xn(o),an.sort((E,P)=>Ur(E)-Ur(P));var c=f.NOOP;try{for(kn=0;kn<an.length;kn++){var v=an[kn];v&&v.active!==!1&&Y(v,null,14)}}finally{kn=0,an.length=0,wr(),ln=!1,Ue=null,(an.length||Un.length||_n.length)&&Hr(o)}}N.devtools=void 0;var Zi=[];function Xi(o,c){var v,E;if(N.devtools=o,N.devtools)N.devtools.enabled=!0,Zi.forEach(C=>{var{event:V,args:G}=C;return N.devtools.emit(V,...G)}),Zi=[];else if(typeof window!="undefined"&&window.HTMLElement&&!((E=(v=window.navigator)===null||v===void 0?void 0:v.userAgent)===null||E===void 0?void 0:E.includes("jsdom"))){var P=c.__VUE_DEVTOOLS_HOOK_REPLAY__=c.__VUE_DEVTOOLS_HOOK_REPLAY__||[];P.push(C=>{Xi(C,c)}),setTimeout(()=>{N.devtools||(c.__VUE_DEVTOOLS_HOOK_REPLAY__=null,Zi=[])},3e3)}else Zi=[]}function Oo(o,c){if(!o.isUnmounted){for(var v=o.vnode.props||f.EMPTY_OBJ,E=arguments.length,P=new Array(E>2?E-2:0),C=2;C<E;C++)P[C-2]=arguments[C];var V=P,G=c.startsWith("update:"),q=G&&c.slice(7);if(q&&q in v){var ae="".concat(q==="modelValue"?"model":q,"Modifiers"),{number:Le,trim:Xe}=v[ae]||f.EMPTY_OBJ;Xe&&(V=P.map(_t=>_t.trim())),Le&&(V=P.map(f.toNumber))}var se,$e=v[se=f.toHandlerKey(c)]||v[se=f.toHandlerKey(f.camelize(c))];!$e&&G&&($e=v[se=f.toHandlerKey(f.hyphenate(c))]),$e&&te($e,o,6,V);var We=v[se+"Once"];if(We){if(!o.emitted)o.emitted={};else if(o.emitted[se])return;o.emitted[se]=!0,te(We,o,6,V)}}}function To(o,c){var v=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!1,E=c.emitsCache,P=E.get(o);if(P!==void 0)return P;var C=o.emits,V={},G=!1;if(!f.isFunction(o)){var q=ae=>{var Le=To(ae,c,!0);Le&&(G=!0,f.extend(V,Le))};!v&&c.mixins.length&&c.mixins.forEach(q),o.extends&&q(o.extends),o.mixins&&o.mixins.forEach(q)}return!C&&!G?(E.set(o,null),null):(f.isArray(C)?C.forEach(ae=>V[ae]=null):f.extend(V,C),E.set(o,V),V)}function hr(o,c){return!o||!f.isOn(c)?!1:(c=c.slice(2).replace(/Once$/,""),f.hasOwn(o,c[0].toLowerCase()+c.slice(1))||f.hasOwn(o,f.hyphenate(c))||f.hasOwn(o,c))}var Cn=null,On=null;function ci(o){var c=Cn;return Cn=o,On=o&&o.type.__scopeId||null,c}function Qi(o){On=o}function eo(){On=null}var go=o=>Si;function Si(o){var c=arguments.length>1&&arguments[1]!==void 0?arguments[1]:Cn;if(!c||o._n)return o;var v=function(){v._d&&rn(-1);var E=ci(c),P=o(...arguments);return ci(E),v._d&&rn(1),P};return v._n=!0,v._c=!0,v._d=!0,v}function cr(){}function jr(o){var{type:c,vnode:v,proxy:E,withProxy:P,props:C,propsOptions:[V],slots:G,attrs:q,emit:ae,render:Le,renderCache:Xe,data:se,setupState:$e,ctx:We,inheritAttrs:_t}=o,Pt,_e,fe=ci(o);try{if(v.shapeFlag&4){var Te=P||E;Pt=Xn(Le.call(Te,Te,Xe,C,$e,se,We)),_e=q}else{var i=c;Pt=Xn(i.length>1?i(C,{attrs:q,slots:G,emit:ae}):i(C,null)),_e=c.props?q:gr(q)}}catch(y){pt.length=0,En(y,o,1),Pt=Lt(ut)}var s=Pt;if(_e&&_t!==!1){var d=Object.keys(_e),{shapeFlag:p}=s;d.length&&p&(1|6)&&(V&&d.some(f.isModelListener)&&(_e=Po(_e,V)),s=qr(s,_e))}return v.dirs&&(s=qr(s),s.dirs=s.dirs?s.dirs.concat(v.dirs):v.dirs),v.transition&&(s.transition=v.transition),Pt=s,ci(fe),Pt}function Sr(o){for(var c,v=0;v<o.length;v++){var E=o[v];if(mi(E)){if(E.type!==ut||E.children==="v-if"){if(c)return;c=E}}else return}return c}var gr=o=>{var c;for(var v in o)(v==="class"||v==="style"||f.isOn(v))&&((c||(c={}))[v]=o[v]);return c},Po=(o,c)=>{var v={};for(var E in o)(!f.isModelListener(E)||!(E.slice(9)in c))&&(v[E]=o[E]);return v};function Io(o,c,v){var{props:E,children:P,component:C}=o,{props:V,children:G,patchFlag:q}=c,ae=C.emitsOptions;if(c.dirs||c.transition)return!0;if(v&&q>=0){if(q&1024)return!0;if(q&16)return E?po(E,V,ae):!!V;if(q&8)for(var Le=c.dynamicProps,Xe=0;Xe<Le.length;Xe++){var se=Le[Xe];if(V[se]!==E[se]&&!hr(ae,se))return!0}}else return(P||G)&&(!G||!G.$stable)?!0:E===V?!1:E?V?po(E,V,ae):!0:!!V;return!1}function po(o,c,v){var E=Object.keys(c);if(E.length!==Object.keys(o).length)return!0;for(var P=0;P<E.length;P++){var C=E[P];if(c[C]!==o[C]&&!hr(v,C))return!0}return!1}function Rr(o,c){for(var{vnode:v,parent:E}=o;E&&E.subTree===v;)(v=E.vnode).el=c,E=E.parent}var ur=o=>o.__isSuspense,Ar={name:"Suspense",__isSuspense:!0,process(o,c,v,E,P,C,V,G,q,ae){o==null?zr(c,v,E,P,C,V,G,q,ae):to(o,c,v,E,P,V,G,q,ae)},hydrate:xr,create:Fi,normalize:vo},Xr=Ar;function zn(o,c){var v=o.props&&o.props[c];f.isFunction(v)&&v()}function zr(o,c,v,E,P,C,V,G,q){var{p:ae,o:{createElement:Le}}=q,Xe=Le("div"),se=o.suspense=Fi(o,P,E,c,Xe,v,C,V,G,q);ae(null,se.pendingBranch=o.ssContent,Xe,null,E,se,C,V),se.deps>0?(zn(o,"onPending"),zn(o,"onFallback"),ae(null,o.ssFallback,c,v,E,null,C,V),Qr(se,o.ssFallback)):se.resolve()}function to(o,c,v,E,P,C,V,G,q){var{p:ae,um:Le,o:{createElement:Xe}}=q,se=c.suspense=o.suspense;se.vnode=c,c.el=o.el;var $e=c.ssContent,We=c.ssFallback,{activeBranch:_t,pendingBranch:Pt,isInFallback:_e,isHydrating:fe}=se;if(Pt)se.pendingBranch=$e,or($e,Pt)?(ae(Pt,$e,se.hiddenContainer,null,P,se,C,V,G),se.deps<=0?se.resolve():_e&&(ae(_t,We,v,E,P,null,C,V,G),Qr(se,We))):(se.pendingId++,fe?(se.isHydrating=!1,se.activeBranch=Pt):Le(Pt,P,se),se.deps=0,se.effects.length=0,se.hiddenContainer=Xe("div"),_e?(ae(null,$e,se.hiddenContainer,null,P,se,C,V,G),se.deps<=0?se.resolve():(ae(_t,We,v,E,P,null,C,V,G),Qr(se,We))):_t&&or($e,_t)?(ae(_t,$e,v,E,P,se,C,V,G),se.resolve(!0)):(ae(null,$e,se.hiddenContainer,null,P,se,C,V,G),se.deps<=0&&se.resolve()));else if(_t&&or($e,_t))ae(_t,$e,v,E,P,se,C,V,G),Qr(se,$e);else if(zn(c,"onPending"),se.pendingBranch=$e,se.pendingId++,ae(null,$e,se.hiddenContainer,null,P,se,C,V,G),se.deps<=0)se.resolve();else{var{timeout:Te,pendingId:i}=se;Te>0?setTimeout(()=>{se.pendingId===i&&se.fallback(We)},Te):Te===0&&se.fallback(We)}}function Fi(o,c,v,E,P,C,V,G,q,ae){var Le=arguments.length>10&&arguments[10]!==void 0?arguments[10]:!1,{p:Xe,m:se,um:$e,n:We,o:{parentNode:_t,remove:Pt}}=ae,_e=f.toNumber(o.props&&o.props.timeout),fe={vnode:o,parent:c,parentComponent:v,isSVG:V,container:E,hiddenContainer:P,anchor:C,deps:0,pendingId:0,timeout:typeof _e=="number"?_e:-1,activeBranch:null,pendingBranch:null,isInFallback:!0,isHydrating:Le,isUnmounted:!1,effects:[],resolve(){var Te=arguments.length>0&&arguments[0]!==void 0?arguments[0]:!1,{vnode:i,activeBranch:s,pendingBranch:d,pendingId:p,effects:y,parentComponent:w,container:I}=fe;if(fe.isHydrating)fe.isHydrating=!1;else if(!Te){var L=s&&d.transition&&d.transition.mode==="out-in";L&&(s.transition.afterLeave=()=>{p===fe.pendingId&&se(d,I,$,0)});var{anchor:$}=fe;s&&($=We(s),$e(s,w,fe,!0)),L||se(d,I,$,0)}Qr(fe,d),fe.pendingBranch=null,fe.isInFallback=!1;for(var ee=fe.parent,ie=!1;ee;){if(ee.pendingBranch){ee.effects.push(...y),ie=!0;break}ee=ee.parent}ie||Di(y),fe.effects=[],zn(i,"onResolve")},fallback(Te){if(!!fe.pendingBranch){var{vnode:i,activeBranch:s,parentComponent:d,container:p,isSVG:y}=fe;zn(i,"onFallback");var w=We(s),I=()=>{!fe.isInFallback||(Xe(null,Te,p,w,d,null,y,G,q),Qr(fe,Te))},L=Te.transition&&Te.transition.mode==="out-in";L&&(s.transition.afterLeave=I),fe.isInFallback=!0,$e(s,d,null,!0),L||I()}},move(Te,i,s){fe.activeBranch&&se(fe.activeBranch,Te,i,s),fe.container=Te},next(){return fe.activeBranch&&We(fe.activeBranch)},registerDep(Te,i){var s=!!fe.pendingBranch;s&&fe.deps++;var d=Te.vnode.el;Te.asyncDep.catch(p=>{En(p,Te,0)}).then(p=>{if(!(Te.isUnmounted||fe.isUnmounted||fe.pendingId!==Te.suspenseId)){Te.asyncResolved=!0;var{vnode:y}=Te;Yo(Te,p,!1),d&&(y.el=d);var w=!d&&Te.subTree.el;i(Te,y,_t(d||Te.subTree.el),d?null:We(Te.subTree),fe,V,q),w&&Pt(w),Rr(Te,y.el),s&&--fe.deps===0&&fe.resolve()}})},unmount(Te,i){fe.isUnmounted=!0,fe.activeBranch&&$e(fe.activeBranch,v,Te,i),fe.pendingBranch&&$e(fe.pendingBranch,v,Te,i)}};return fe}function xr(o,c,v,E,P,C,V,G,q){var ae=c.suspense=Fi(c,E,v,o.parentNode,l.createElement("div"),null,P,C,V,G,!0),Le=q(o,ae.pendingBranch=c.ssContent,v,ae,C,V);return ae.deps===0&&ae.resolve(),Le}function vo(o){var{shapeFlag:c,children:v}=o,E=c&32;o.ssContent=mo(E?v.default:v),o.ssFallback=E?mo(v.fallback):Lt(ut)}function mo(o){var c;if(f.isFunction(o)){var v=un&&o._c;v&&(o._d=!1,Ot()),o=o(),v&&(o._d=!0,c=Ze,wn())}if(f.isArray(o)){var E=Sr(o);o=E}return o=Xn(o),c&&!o.dynamicChildren&&(o.dynamicChildren=c.filter(P=>P!==o)),o}function _o(o,c){c&&c.pendingBranch?f.isArray(o)?c.effects.push(...o):c.effects.push(o):Di(o)}function Qr(o,c){o.activeBranch=c;var{vnode:v,parentComponent:E}=o,P=v.el=c.el;E&&E.subTree===v&&(E.vnode.el=P,Rr(E,P))}function ei(o,c){if(Gn){var v=Gn.provides,E=Gn.parent&&Gn.parent.provides;E===v&&(v=Gn.provides=Object.create(E)),v[o]=c,Gn.type.mpType==="app"&&Gn.appContext.app.provide(o,c)}}function Ai(o,c){var v=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!1,E=Gn||Cn;if(E){var P=E.parent==null?E.vnode.appContext&&E.vnode.appContext.provides:E.parent.provides;if(P&&o in P)return P[o];if(arguments.length>1)return v&&f.isFunction(c)?c.call(E.proxy):c}}function ui(o,c){return ye(o,null,c)}function qn(o,c){return ye(o,null,{flush:"post"})}function Cr(o,c){return ye(o,null,{flush:"sync"})}var Vi={};function Mt(o,c,v){return ye(o,c,v)}function ye(o,c){var{immediate:v,deep:E,flush:P,onTrack:C,onTrigger:V}=arguments.length>2&&arguments[2]!==void 0?arguments[2]:f.EMPTY_OBJ,G=Gn,q,ae=!1,Le=!1;if(T.isRef(o)?(q=()=>o.value,ae=T.isShallow(o)):T.isReactive(o)?(q=()=>o,E=!0):f.isArray(o)?(Le=!0,ae=o.some(fe=>T.isReactive(fe)||T.isShallow(fe)),q=()=>o.map(fe=>{if(T.isRef(fe))return fe.value;if(T.isReactive(fe))return Wr(fe);if(f.isFunction(fe))return Y(fe,G,2)})):f.isFunction(o)?c?q=()=>Y(o,G,2):q=()=>{if(!(G&&G.isUnmounted))return se&&se(),te(o,G,3,[$e])}:q=f.NOOP,c&&E){var Xe=q;q=()=>Wr(Xe())}var se,$e=fe=>{se=_e.onStop=()=>{Y(fe,G,4)}};if(N.isInSSRComponentSetup)return $e=f.NOOP,c?v&&te(c,G,3,[q(),Le?[]:void 0,$e]):q(),f.NOOP;var We=Le?[]:Vi,_t=()=>{if(!!_e.active)if(c){var fe=_e.run();(E||ae||(Le?fe.some((Te,i)=>f.hasChanged(Te,We[i])):f.hasChanged(fe,We)))&&(se&&se(),te(c,G,3,[fe,We===Vi?void 0:We,$e]),We=fe)}else _e.run()};_t.allowRecurse=!!c;var Pt;P==="sync"?Pt=_t:P==="post"?Pt=()=>m(_t,G&&G.suspense):Pt=()=>Li(_t);var _e=new T.ReactiveEffect(q,Pt);return c?v?_t():We=_e.run():P==="post"?m(_e.run.bind(_e),G&&G.suspense):_e.run(),()=>{_e.stop(),G&&G.scope&&f.remove(G.scope.effects,_e)}}function Ci(o,c,v){var E=this.proxy,P=f.isString(o)?o.includes(".")?$i(E,o):()=>E[o]:o.bind(E,E),C;f.isFunction(c)?C=c:(C=c.handler,v=c);var V=Gn;Qn(this);var G=ye(P,C.bind(E),v);return V?Qn(V):Fr(),G}function $i(o,c){var v=c.split(".");return()=>{for(var E=o,P=0;P<v.length&&E;P++)E=E[v[P]];return E}}function Wr(o,c){if(!f.isObject(o)||o.__v_skip||(c=c||new Set,c.has(o)))return o;if(c.add(o),T.isRef(o))Wr(o.value,c);else if(f.isArray(o))for(var v=0;v<o.length;v++)Wr(o[v],c);else if(f.isSet(o)||f.isMap(o))o.forEach(P=>{Wr(P,c)});else if(f.isPlainObject(o))for(var E in o)Wr(o[E],c);return o}function Br(){var o={isMounted:!1,isLeaving:!1,isUnmounting:!1,leavingVNodes:new Map};return Pi(()=>{o.isMounted=!0}),Yr(()=>{o.isUnmounting=!0}),o}var Hn=[Function,Array],Bn={name:"BaseTransition",props:{mode:String,appear:Boolean,persisted:Boolean,onBeforeEnter:Hn,onEnter:Hn,onAfterEnter:Hn,onEnterCancelled:Hn,onBeforeLeave:Hn,onLeave:Hn,onAfterLeave:Hn,onLeaveCancelled:Hn,onBeforeAppear:Hn,onAppear:Hn,onAfterAppear:Hn,onAppearCancelled:Hn},setup(o,c){var{slots:v}=c,E=An(),P=Br(),C;return()=>{var V=v.default&&Wn(v.default(),!0);if(!(!V||!V.length)){var G=V[0];if(V.length>1){for(var q of V)if(q.type!==ut){G=q;break}}var ae=T.toRaw(o),{mode:Le}=ae;if(P.isLeaving)return fi(G);var Xe=di(G);if(!Xe)return fi(G);var se=Ut(Xe,ae,P,E);Kt(Xe,se);var $e=E.subTree,We=$e&&di($e),_t=!1,{getTransitionKey:Pt}=Xe.type;if(Pt){var _e=Pt();C===void 0?C=_e:_e!==C&&(C=_e,_t=!0)}if(We&&We.type!==ut&&(!or(Xe,We)||_t)){var fe=Ut(We,ae,P,E);if(Kt(We,fe),Le==="out-in")return P.isLeaving=!0,fe.afterLeave=()=>{P.isLeaving=!1,E.update()},fi(G);Le==="in-out"&&Xe.type!==ut&&(fe.delayLeave=(Te,i,s)=>{var d=Oi(P,We);d[String(We.key)]=We,Te._leaveCb=()=>{i(),Te._leaveCb=void 0,delete se.delayedLeave},se.delayedLeave=s})}return G}}}},No=Bn;function Oi(o,c){var{leavingVNodes:v}=o,E=v.get(c.type);return E||(E=Object.create(null),v.set(c.type,E)),E}function Ut(o,c,v,E){var{appear:P,mode:C,persisted:V=!1,onBeforeEnter:G,onEnter:q,onAfterEnter:ae,onEnterCancelled:Le,onBeforeLeave:Xe,onLeave:se,onAfterLeave:$e,onLeaveCancelled:We,onBeforeAppear:_t,onAppear:Pt,onAfterAppear:_e,onAppearCancelled:fe}=c,Te=String(o.key),i=Oi(v,o),s=(y,w)=>{y&&te(y,E,9,w)},d=(y,w)=>{var I=w[1];s(y,w),f.isArray(y)?y.every(L=>L.length<=1)&&I():y.length<=1&&I()},p={mode:C,persisted:V,beforeEnter(y){var w=G;if(!v.isMounted)if(P)w=_t||G;else return;y._leaveCb&&y._leaveCb(!0);var I=i[Te];I&&or(o,I)&&I.el._leaveCb&&I.el._leaveCb(),s(w,[y])},enter(y){var w=q,I=ae,L=Le;if(!v.isMounted)if(P)w=Pt||q,I=_e||ae,L=fe||Le;else return;var $=!1,ee=y._enterCb=ie=>{$||($=!0,ie?s(L,[y]):s(I,[y]),p.delayedLeave&&p.delayedLeave(),y._enterCb=void 0)};w?d(w,[y,ee]):ee()},leave(y,w){var I=String(o.key);if(y._enterCb&&y._enterCb(!0),v.isUnmounting)return w();s(Xe,[y]);var L=!1,$=y._leaveCb=ee=>{L||(L=!0,w(),ee?s(We,[y]):s($e,[y]),y._leaveCb=void 0,i[I]===o&&delete i[I])};i[I]=o,se?d(se,[y,$]):$()},clone(y){return Ut(y,c,v,E)}};return p}function fi(o){if(hi(o))return o=qr(o),o.children=null,o}function di(o){return hi(o)?o.children?o.children[0]:void 0:o}function Kt(o,c){o.shapeFlag&6&&o.component?Kt(o.component.subTree,c):o.shapeFlag&128?(o.ssContent.transition=c.clone(o.ssContent),o.ssFallback.transition=c.clone(o.ssFallback)):o.transition=c}function Wn(o){for(var c=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!1,v=arguments.length>2?arguments[2]:void 0,E=[],P=0,C=0;C<o.length;C++){var V=o[C],G=v==null?V.key:String(v)+String(V.key!=null?V.key:C);V.type===nt?(V.patchFlag&128&&P++,E=E.concat(Wn(V.children,c,G))):(c||V.type!==ut)&&E.push(G!=null?qr(V,{key:G}):V)}if(P>1)for(var q=0;q<E.length;q++)E[q].patchFlag=-2;return E}function Or(o){return f.isFunction(o)?{setup:o,name:o.name}:o}var In=o=>!!o.type.__asyncLoader;function Ti(o){f.isFunction(o)&&(o={loader:o});var{loader:c,loadingComponent:v,errorComponent:E,delay:P=200,timeout:C,suspensible:V=!0,onError:G}=o,q=null,ae,Le=0,Xe=()=>(Le++,q=null,se()),se=()=>{var $e;return q||($e=q=c().catch(We=>{if(We=We instanceof Error?We:new Error(String(We)),G)return new Promise((_t,Pt)=>{var _e=()=>_t(Xe()),fe=()=>Pt(We);G(We,_e,fe,Le+1)});throw We}).then(We=>$e!==q&&q?q:(We&&(We.__esModule||We[Symbol.toStringTag]==="Module")&&(We=We.default),ae=We,We)))};return Or({name:"AsyncComponentWrapper",__asyncLoader:se,get __asyncResolved(){return ae},setup(){var $e=Gn;if(ae)return()=>ko(ae,$e);var We=fe=>{q=null,En(fe,$e,13)};if(V&&$e.suspense||N.isInSSRComponentSetup)return se().then(fe=>()=>ko(fe,$e)).catch(fe=>(We(fe),()=>E?Lt(E,{error:fe}):null));var _t=T.ref(!1),Pt=T.ref(),_e=T.ref(!!P);return P&&setTimeout(()=>{_e.value=!1},P),C!=null&&setTimeout(()=>{if(!_t.value&&!Pt.value){var fe=new Error("Async component timed out after ".concat(C,"ms."));We(fe),Pt.value=fe}},C),se().then(()=>{_t.value=!0,$e.parent&&hi($e.parent.vnode)&&nn($e.parent.update)}).catch(fe=>{We(fe),Pt.value=fe}),()=>{if(_t.value&&ae)return ko(ae,$e);if(Pt.value&&E)return Lt(E,{error:Pt.value});if(v&&!_e.value)return Lt(v)}}})}function ko(o,c){var{vnode:{ref:v,props:E,children:P,shapeFlag:C},parent:V}=c,G=Lt(o,E,P);return G.ref=v,G}var hi=o=>o.type.__isKeepAlive,no={name:"KeepAlive",__isKeepAlive:!0,props:{include:[String,RegExp,Array],exclude:[String,RegExp,Array],max:[String,Number]},setup(o,c){var{slots:v}=c,E=An(),P=E.ctx;if(!P.renderer)return()=>{var Te=v.default&&v.default();return Te&&Te.length===1?Te[0]:Te};var C=new Map,V=new Set,G=null,q=E.suspense,{renderer:{p:ae,m:Le,um:Xe,o:{createElement:se}}}=P,$e=se("div");P.activate=(Te,i,s,d,p)=>{var y=Te.component;Le(Te,i,s,0,q),ae(y.vnode,Te,i,s,y,q,d,Te.slotScopeIds,p),m(()=>{y.isDeactivated=!1,y.a&&f.invokeArrayFns(y.a);var w=Te.props&&Te.props.onVnodeMounted;w&&Pr(w,y.parent,Te)},q)},P.deactivate=Te=>{var i=Te.component;Le(Te,$e,null,1,q),m(()=>{i.da&&f.invokeArrayFns(i.da);var s=Te.props&&Te.props.onVnodeUnmounted;s&&Pr(s,i.parent,Te),i.isDeactivated=!0},q)};function We(Te){Tr(Te),Xe(Te,E,q,!0)}function _t(Te){C.forEach((i,s)=>{var d=er(i.type);d&&(!Te||!Te(d))&&Pt(s)})}function Pt(Te){var i=C.get(Te);!G||i.type!==G.type?We(i):G&&Tr(G),C.delete(Te),V.delete(Te)}Mt(()=>[o.include,o.exclude],Te=>{var[i,s]=Te;i&&_t(d=>Ui(i,d)),s&&_t(d=>!Ui(s,d))},{flush:"post",deep:!0});var _e=null,fe=()=>{_e!=null&&C.set(_e,Hi(E.subTree))};return Pi(fe),pi(fe),Yr(()=>{C.forEach(Te=>{var{subTree:i,suspense:s}=E,d=Hi(i);if(Te.type===d.type){Tr(d);var p=d.component.da;p&&m(p,s);return}We(Te)})}),()=>{if(_e=null,!v.default)return null;var Te=v.default(),i=Te[0];if(Te.length>1)return G=null,Te;if(!mi(i)||!(i.shapeFlag&4)&&!(i.shapeFlag&128))return G=null,i;var s=Hi(i),d=s.type,p=er(In(s)?s.type.__asyncResolved||{}:d),{include:y,exclude:w,max:I}=o;if(y&&(!p||!Ui(y,p))||w&&p&&Ui(w,p))return G=s,i;var L=s.key==null?d:s.key,$=C.get(L);return s.el&&(s=qr(s),i.shapeFlag&128&&(i.ssContent=s)),_e=L,$?(s.el=$.el,s.component=$.component,s.transition&&Kt(s,s.transition),s.shapeFlag|=512,V.delete(L),V.add(L)):(V.add(L),I&&V.size>parseInt(I,10)&&Pt(V.values().next().value)),s.shapeFlag|=256,G=s,ur(i.type)?i:s}}},Qo=no;function Ui(o,c){return f.isArray(o)?o.some(v=>Ui(v,c)):f.isString(o)?o.split(",").includes(c):o.test?o.test(c):!1}function Kn(o,c){Jn(o,"a",c)}function pr(o,c){Jn(o,"da",c)}function Jn(o,c){var v=arguments.length>2&&arguments[2]!==void 0?arguments[2]:Gn,E=o.__wdc||(o.__wdc=()=>{for(var C=v;C;){if(C.isDeactivated)return;C=C.parent}return o()});if(ti(c,E,v),v)for(var P=v.parent;P&&P.parent;)hi(P.parent.vnode)&&Mr(E,c,v,P),P=P.parent}function Mr(o,c,v,E){var P=ti(c,o,E,!0);vi(()=>{f.remove(E[c],P)},v)}function Tr(o){var c=o.shapeFlag;c&256&&(c-=256),c&512&&(c-=512),o.shapeFlag=c}function Hi(o){return o.shapeFlag&128?o.ssContent:o}function ti(o,c){var v=arguments.length>2&&arguments[2]!==void 0?arguments[2]:Gn,E=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1;if(v){if(ze.isRootHook(o)&&v!==v.root&&(v=v.root,ze.isRootImmediateHook(o))){var P=v.proxy;te(c.bind(P),v,o,ze.ON_LOAD===o?[P.$page.options]:[])}var C=v[o]||(v[o]=[]),V=c.__weh||(c.__weh=function(){if(!v.isUnmounted){T.pauseTracking(),Qn(v);for(var G=arguments.length,q=new Array(G),ae=0;ae<G;ae++)q[ae]=arguments[ae];var Le=te(c,v,o,q);return Fr(),T.resetTracking(),Le}});return E?C.unshift(V):C.push(V),V}}var vr=o=>function(c){var v=arguments.length>1&&arguments[1]!==void 0?arguments[1]:Gn;return(!N.isInSSRComponentSetup||o==="sp")&&ti(o,c,v)},Gr=vr("bm"),Pi=vr("m"),gi=vr("bu"),pi=vr("u"),Yr=vr("bum"),vi=vr("um"),ro=vr("sp"),ji=vr("rtg"),io=vr("rtc");function x(o){var c=arguments.length>1&&arguments[1]!==void 0?arguments[1]:Gn;ti("ec",o,c)}function ne(o,c){var v=Cn;if(v===null)return o;for(var E=Tt(v)||v.proxy,P=o.dirs||(o.dirs=[]),C=0;C<c.length;C++){var[V,G,q,ae=f.EMPTY_OBJ]=c[C];f.isFunction(V)&&(V={mounted:V,updated:V}),V.deep&&Wr(G),P.push({dir:V,instance:E,value:G,oldValue:void 0,arg:q,modifiers:ae})}return o}function de(o,c,v,E){for(var P=o.dirs,C=c&&c.dirs,V=0;V<P.length;V++){var G=P[V];C&&(G.oldValue=C[V].value);var q=G.dir[E];q&&(T.pauseTracking(),te(q,v,8,[o.el,G,o,c]),T.resetTracking())}}var H="components",M="directives";function J(o,c){return Mn(H,o,!0,c)||o}var X=Symbol();function ue(o){return f.isString(o)?Mn(H,o,!1)||o:o||X}function tn(o){return Mn(M,o)}function Mn(o,c){var v=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1,E=Cn||Gn;if(E){var P=E.type;if(o===H){var C=er(P,!1);if(C&&(C===c||C===f.camelize(c)||C===f.capitalize(f.camelize(c))))return P}var V=cn(E[o]||P[o],c)||cn(E.appContext[o],c);return!V&&v?P:V}}function cn(o,c){return o&&(o[c]||o[f.camelize(c)]||o[f.capitalize(f.camelize(c))])}function ni(o,c,v,E){var P,C=v&&v[E];if(f.isArray(o)||f.isString(o)){P=new Array(o.length);for(var V=0,G=o.length;V<G;V++)P[V]=c(o[V],V,void 0,C&&C[V])}else if(typeof o=="number"){P=new Array(o);for(var q=0;q<o;q++)P[q]=c(q+1,q,void 0,C&&C[q])}else if(f.isObject(o))if(o[Symbol.iterator])P=Array.from(o,($e,We)=>c($e,We,void 0,C&&C[We]));else{var ae=Object.keys(o);P=new Array(ae.length);for(var Le=0,Xe=ae.length;Le<Xe;Le++){var se=ae[Le];P[Le]=c(o[se],se,Le,C&&C[Le])}}else P=[];return v&&(v[E]=P),P}function mr(o,c){for(var v=0;v<c.length;v++){var E=c[v];if(f.isArray(E))for(var P=0;P<E.length;P++)o[E[P].name]=E[P].fn;else E&&(o[E.name]=E.fn)}return o}function ea(o,c){var v=arguments.length>2&&arguments[2]!==void 0?arguments[2]:{},E=arguments.length>3?arguments[3]:void 0,P=arguments.length>4?arguments[4]:void 0;if(Cn.isCE||Cn.parent&&In(Cn.parent)&&Cn.parent.isCE)return Lt("slot",c==="default"?null:{name:c},E&&E());var C=o[c];C&&C._c&&(C._d=!1),Ot();var V=C&&zo(C(v)),G=Ln(nt,{key:v.key||"_".concat(c)},V||(E?E():[]),V&&o._===1?64:-2);return!P&&G.scopeId&&(G.slotScopeIds=[G.scopeId+"-s"]),C&&C._c&&(C._d=!0),G}function zo(o){return o.some(c=>mi(c)?!(c.type===ut||c.type===nt&&!zo(c.children)):!0)?o:null}function ta(o){var c={};for(var v in o)c[f.toHandlerKey(v)]=o[v];return c}var Ro=o=>o?ki(o)?Tt(o)||o.proxy:Ro(o.parent):null,bo=f.extend(Object.create(null),{$:o=>o,$el:o=>o.vnode.el,$data:o=>o.data,$props:o=>o.props,$attrs:o=>o.attrs,$slots:o=>o.slots,$refs:o=>o.refs,$parent:o=>Ro(o.parent),$root:o=>Ro(o.root),$emit:o=>o.emit,$options:o=>fr(o),$forceUpdate:o=>o.f||(o.f=()=>nn(o.update)),$nextTick:o=>o.n||(o.n=vt.bind(o.proxy)),$watch:o=>Ci.bind(o)}),oo={get(o,c){var{_:v}=o,{ctx:E,setupState:P,data:C,props:V,accessCache:G,type:q,appContext:ae}=v,Le;if(c[0]!=="$"){var Xe=G[c];if(Xe!==void 0)switch(Xe){case 1:return P[c];case 2:return C[c];case 4:return E[c];case 3:return V[c]}else{if(P!==f.EMPTY_OBJ&&f.hasOwn(P,c))return G[c]=1,P[c];if(C!==f.EMPTY_OBJ&&f.hasOwn(C,c))return G[c]=2,C[c];if((Le=v.propsOptions[0])&&f.hasOwn(Le,c))return G[c]=3,V[c];if(E!==f.EMPTY_OBJ&&f.hasOwn(E,c))return G[c]=4,E[c];na&&(G[c]=0)}}var se=bo[c],$e,We;if(se)return c==="$attrs"&&T.track(v,"get",c),se(v);if(($e=q.__cssModules)&&($e=$e[c]))return $e;if(E!==f.EMPTY_OBJ&&f.hasOwn(E,c))return G[c]=4,E[c];if(We=ae.config.globalProperties,f.hasOwn(We,c))return We[c]},set(o,c,v){var{_:E}=o,{data:P,setupState:C,ctx:V}=E;return C!==f.EMPTY_OBJ&&f.hasOwn(C,c)?(C[c]=v,!0):P!==f.EMPTY_OBJ&&f.hasOwn(P,c)?(P[c]=v,!0):f.hasOwn(E.props,c)||c[0]==="$"&&c.slice(1)in E?!1:(V[c]=v,!0)},has(o,c){var{_:{data:v,setupState:E,accessCache:P,ctx:C,appContext:V,propsOptions:G}}=o,q;return!!P[c]||v!==f.EMPTY_OBJ&&f.hasOwn(v,c)||E!==f.EMPTY_OBJ&&f.hasOwn(E,c)||(q=G[0])&&f.hasOwn(q,c)||f.hasOwn(C,c)||f.hasOwn(bo,c)||f.hasOwn(V.config.globalProperties,c)},defineProperty(o,c,v){return v.get!=null?o._.accessCache[c]=0:f.hasOwn(v,"value")&&this.set(o,c,v.value,null),Reflect.defineProperty(o,c,v)}},Ra=f.extend({},oo,{get(o,c){if(c!==Symbol.unscopables)return oo.get(o,c,o)},has(o,c){var v=c[0]!=="_"&&!f.isGloballyWhitelisted(c);return v}}),na=!0;function _a(o){var c=fr(o),v=o.proxy,E=o.ctx;na=!1,c.beforeCreate&&ra(c.beforeCreate,o,"bc");var{data:P,computed:C,methods:V,watch:G,provide:q,inject:ae,created:Le,beforeMount:Xe,mounted:se,beforeUpdate:$e,updated:We,activated:_t,deactivated:Pt,beforeDestroy:_e,beforeUnmount:fe,destroyed:Te,unmounted:i,render:s,renderTracked:d,renderTriggered:p,errorCaptured:y,serverPrefetch:w,expose:I,inheritAttrs:L,components:$,directives:ee,filters:ie}=c,Ie=null;if(ae&&ts(ae,E,Ie,o.appContext.config.unwrapInjectedRef),V)for(var oe in V){var Ce=V[oe];f.isFunction(Ce)&&(E[oe]=Ce.bind(v))}if(P){var Be=P.call(v,v);f.isObject(Be)&&(o.data=T.reactive(Be))}if(na=!0,C){var ft=function(Re){var lt=C[Re],xe=f.isFunction(lt)?lt.bind(v,v):f.isFunction(lt.get)?lt.get.bind(v,v):f.NOOP,It=!f.isFunction(lt)&&f.isFunction(lt.set)?lt.set.bind(v):f.NOOP,Ct=Fo({get:xe,set:It});Object.defineProperty(E,Re,{enumerable:!0,configurable:!0,get:()=>Ct.value,set:Bt=>Ct.value=Bt})};for(var At in C)ft(At)}if(G)for(var me in G)xa(G[me],E,v,me);if(q){var le=f.isFunction(q)?q.call(v):q;Reflect.ownKeys(le).forEach(Re=>{ei(Re,le[Re])})}Le&&ra(Le,o,"c");function Se(Re,lt){f.isArray(lt)?lt.forEach(xe=>Re(xe.bind(v))):lt&&Re(lt.bind(v))}if(Se(Gr,Xe),Se(Pi,se),Se(gi,$e),Se(pi,We),Se(Kn,_t),Se(pr,Pt),Se(x,y),Se(io,d),Se(ji,p),Se(Yr,fe),Se(vi,i),Se(ro,w),f.isArray(I))if(I.length){var qe=o.exposed||(o.exposed={});I.forEach(Re=>{Object.defineProperty(qe,Re,{get:()=>v[Re],set:lt=>v[Re]=lt})})}else o.exposed||(o.exposed={});s&&o.render===f.NOOP&&(o.render=s),L!=null&&(o.inheritAttrs=L),$&&(o.components=$),ee&&(o.directives=ee);var He=o.appContext.config.globalProperties.$applyOptions;He&&He(c,o,v)}function ts(o,c){var v=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1;f.isArray(o)&&(o=Ma(o));var E=function(C){var V=o[C],G=void 0;f.isObject(V)?"default"in V?G=Ai(V.from||C,V.default,!0):G=Ai(V.from||C):G=Ai(V),T.isRef(G)&&v?Object.defineProperty(c,C,{enumerable:!0,configurable:!0,get:()=>G.value,set:q=>G.value=q}):c[C]=G};for(var P in o)E(P)}function ra(o,c,v){te(f.isArray(o)?o.map(E=>E.bind(c.proxy)):o.bind(c.proxy),c,v)}function xa(o,c,v,E){var P=E.includes(".")?$i(v,E):()=>v[E];if(f.isString(o)){var C=c[o];f.isFunction(C)&&Mt(P,C)}else if(f.isFunction(o))Mt(P,o.bind(v));else if(f.isObject(o))if(f.isArray(o))o.forEach(G=>xa(G,c,v,E));else{var V=f.isFunction(o.handler)?o.handler.bind(v):c[o.handler];f.isFunction(V)&&Mt(P,V,o)}}function fr(o){var c=o.type,{mixins:v,extends:E}=c,{mixins:P,optionsCache:C,config:{optionMergeStrategies:V}}=o.appContext,G=C.get(c),q;return G?q=G:!P.length&&!v&&!E?q=c:(q={},P.length&&P.forEach(ae=>_r(q,ae,V,!0)),_r(q,c,V)),C.set(c,q),q}function _r(o,c,v){var E=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1,{mixins:P,extends:C}=c;C&&_r(o,C,v,!0),P&&P.forEach(q=>_r(o,q,v,!0));for(var V in c)if(!(E&&V==="expose")){var G=ia[V]||v&&v[V];o[V]=G?G(o[V],c[V]):c[V]}return o}var ia={data:Ba,props:Zn,emits:Zn,methods:Zn,computed:Zn,beforeCreate:br,created:br,beforeMount:br,mounted:br,beforeUpdate:br,updated:br,beforeDestroy:br,beforeUnmount:br,destroyed:br,unmounted:br,activated:br,deactivated:br,errorCaptured:br,serverPrefetch:br,components:Zn,directives:Zn,watch:xo,provide:Ba,inject:Lr};function Ba(o,c){return c?o?function(){return f.extend(f.isFunction(o)?o.call(this,this):o,f.isFunction(c)?c.call(this,this):c)}:c:o}function Lr(o,c){return Zn(Ma(o),Ma(c))}function Ma(o){if(f.isArray(o)){for(var c={},v=0;v<o.length;v++)c[o[v]]=o[v];return c}return o}function br(o,c){return o?[...new Set([].concat(o,c))]:c}function Zn(o,c){return o?f.extend(f.extend(Object.create(null),o),c):c}function xo(o,c){if(!o)return c;if(!c)return o;var v=f.extend(Object.create(null),o);for(var E in c)v[E]=br(o[E],c[E]);return v}function Cs(o,c,v){var E=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1,P={},C={};f.def(C,Bo,1),o.propsDefaults=Object.create(null),ns(o,c,P,C);for(var V in o.propsOptions[0])V in P||(P[V]=void 0);v?o.props=E?P:T.shallowReactive(P):o.type.props?o.props=P:o.props=C,o.attrs=C}function Wo(o,c,v,E){var{props:P,attrs:C,vnode:{patchFlag:V}}=o,G=T.toRaw(P),[q]=o.propsOptions,ae=!1;if((E||V>0)&&!(V&16)){if(V&8)for(var Le=o.vnode.dynamicProps,Xe=0;Xe<Le.length;Xe++){var se=Le[Xe];if(!hr(o.emitsOptions,se)){var $e=c[se];if(q)if(f.hasOwn(C,se))$e!==C[se]&&(C[se]=$e,ae=!0);else{var We=f.camelize(se);P[We]=jn(q,G,We,$e,o,!1)}else $e!==C[se]&&(C[se]=$e,ae=!0)}}}else{ns(o,c,P,C)&&(ae=!0);var _t;for(var Pt in G)(!c||!f.hasOwn(c,Pt)&&((_t=f.hyphenate(Pt))===Pt||!f.hasOwn(c,_t)))&&(q?v&&(v[Pt]!==void 0||v[_t]!==void 0)&&(P[Pt]=jn(q,G,Pt,void 0,o,!0)):delete P[Pt]);if(C!==G)for(var _e in C)(!c||!f.hasOwn(c,_e)&&!0)&&(delete C[_e],ae=!0)}ae&&T.trigger(o,"set","$attrs")}function ns(o,c,v,E){var[P,C]=o.propsOptions,V=!1,G;if(c){for(var q in c)if(!f.isReservedProp(q)){var ae=c[q],Le=void 0;P&&f.hasOwn(P,Le=f.camelize(q))?!C||!C.includes(Le)?v[Le]=ae:(G||(G={}))[Le]=ae:hr(o.emitsOptions,q)||(!(q in E)||ae!==E[q])&&(E[q]=ae,V=!0)}}if(C)for(var Xe=T.toRaw(v),se=G||f.EMPTY_OBJ,$e=0;$e<C.length;$e++){var We=C[$e];v[We]=jn(P,Xe,We,se[We],o,!f.hasOwn(se,We))}return V}function jn(o,c,v,E,P,C){var V=o[v];if(V!=null){var G=f.hasOwn(V,"default");if(G&&E===void 0){var q=V.default;if(V.type!==Function&&f.isFunction(q)){var{propsDefaults:ae}=P;v in ae?E=ae[v]:(Qn(P),E=ae[v]=q.call(null,c),Fr())}else E=q}V[0]&&(C&&!G?E=!1:V[1]&&(E===""||E===f.hyphenate(v))&&(E=!0))}return E}function ba(o,c){var v=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!1,E=c.propsCache,P=E.get(o);if(P)return P;var C=o.props,V={},G=[],q=!1;if(!f.isFunction(o)){var ae=Te=>{q=!0;var[i,s]=ba(Te,c,!0);f.extend(V,i),s&&G.push(...s)};!v&&c.mixins.length&&c.mixins.forEach(ae),o.extends&&ae(o.extends),o.mixins&&o.mixins.forEach(ae)}if(!C&&!q)return E.set(o,f.EMPTY_ARR),f.EMPTY_ARR;if(f.isArray(C))for(var Le=0;Le<C.length;Le++){var Xe=f.camelize(C[Le]);Go(Xe)&&(V[Xe]=f.EMPTY_OBJ)}else if(C)for(var se in C){var $e=f.camelize(se);if(Go($e)){var We=C[se],_t=V[$e]=f.isArray(We)||f.isFunction(We)?{type:We}:We;if(_t){var Pt=La(Boolean,_t.type),_e=La(String,_t.type);_t[0]=Pt>-1,_t[1]=_e<0||Pt<_e,(Pt>-1||f.hasOwn(_t,"default"))&&G.push($e)}}}var fe=[V,G];return E.set(o,fe),fe}function Go(o){return o[0]!=="$"}function Ii(o){var c=o&&o.toString().match(/^\s*function (\w+)/);return c?c[1]:o===null?"null":""}function Ea(o,c){return Ii(o)===Ii(c)}function La(o,c){return f.isArray(c)?c.findIndex(v=>Ea(v,o)):f.isFunction(c)&&Ea(c,o)?0:-1}var ao=o=>o[0]==="_"||o==="$stable",oa=o=>f.isArray(o)?o.map(Xn):[Xn(o)],Eo=(o,c,v)=>{if(c._n)return c;var E=Si(function(){return oa(c(...arguments))},v);return E._c=!1,E},zi=(o,c,v)=>{var E=o._ctx;for(var P in o)if(!ao(P)){var C=o[P];f.isFunction(C)?c[P]=Eo(P,C,E):C!=null&&function(){var V=oa(C);c[P]=()=>V}()}},ya=(o,c)=>{var v=oa(c);o.slots.default=()=>v},aa=(o,c)=>{if(o.vnode.shapeFlag&32){var v=c._;v?(o.slots=T.toRaw(c),f.def(c,"_",v)):zi(c,o.slots={})}else o.slots={},c&&ya(o,c);f.def(o.slots,Bo,1)},wa=(o,c,v)=>{var{vnode:E,slots:P}=o,C=!0,V=f.EMPTY_OBJ;if(E.shapeFlag&32){var G=c._;G?v&&G===1?C=!1:(f.extend(P,c),!v&&G===1&&delete P._):(C=!c.$stable,zi(c,P)),V=c}else c&&(ya(o,c),V={default:1});if(C)for(var q in P)!ao(q)&&!(q in V)&&delete P[q]};function sa(){return{app:null,config:{isNativeTag:f.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 Sa=0;function Os(o,c){return function(E){var P=arguments.length>1&&arguments[1]!==void 0?arguments[1]:null;f.isFunction(E)||(E=Object.assign({},E)),P!=null&&!f.isObject(P)&&(P=null);var C=sa(),V=new Set,G=!1,q=C.app={_uid:Sa++,_component:E,_props:P,_container:null,_context:C,_instance:null,version:Ns,get config(){return C.config},set config(ae){},use(ae){for(var Le=arguments.length,Xe=new Array(Le>1?Le-1:0),se=1;se<Le;se++)Xe[se-1]=arguments[se];return V.has(ae)||(ae&&f.isFunction(ae.install)?(V.add(ae),ae.install(q,...Xe)):f.isFunction(ae)&&(V.add(ae),ae(q,...Xe))),q},mixin(ae){return C.mixins.includes(ae)||C.mixins.push(ae),q},component(ae,Le){return Le?(C.components[ae]=Le,q):C.components[ae]},directive(ae,Le){return Le?(C.directives[ae]=Le,q):C.directives[ae]},mount(ae,Le,Xe){if(!G){var se=Lt(E,P);return se.appContext=C,Le&&c?c(se,ae):o(se,ae,Xe),G=!0,q._container=ae,ae.__vue_app__=q,q._instance=se.component,Tt(se.component)||se.component.proxy}},unmount(){G&&(o(null,q._container),delete q._container.__vue_app__)},provide(ae,Le){return C.provides[ae]=Le,q}};return q}}function so(o,c,v,E){var P=arguments.length>4&&arguments[4]!==void 0?arguments[4]:!1;if(f.isArray(o)){o.forEach((_t,Pt)=>so(_t,c&&(f.isArray(c)?c[Pt]:c),v,E,P));return}if(!(In(E)&&!P)){var C=E.shapeFlag&4?Tt(E.component)||E.component.proxy:E.el,V=P?null:C,{i:G,r:q}=o,ae=c&&c.r,Le=G.refs===f.EMPTY_OBJ?G.refs={}:G.refs,Xe=G.setupState;if(ae!=null&&ae!==q&&(f.isString(ae)?(Le[ae]=null,f.hasOwn(Xe,ae)&&(Xe[ae]=null)):T.isRef(ae)&&(ae.value=null)),f.isFunction(q))Y(q,G,12,[V,Le]);else{var se=f.isString(q),$e=T.isRef(q);if(se||$e){var We=()=>{if(o.f){var _t=se?Le[q]:q.value;P?f.isArray(_t)&&f.remove(_t,C):f.isArray(_t)?_t.includes(C)||_t.push(C):se?(Le[q]=[C],f.hasOwn(Xe,q)&&(Xe[q]=Le[q])):(q.value=[C],o.k&&(Le[o.k]=q.value))}else se?(Le[q]=V,f.hasOwn(Xe,q)&&(Xe[q]=V)):$e&&(q.value=V,o.k&&(Le[o.k]=V))};V?(We.id=-1,m(We,v)):We()}}}}var ri=!1,Ni=o=>/svg/.test(o.namespaceURI)&&o.tagName!=="foreignObject",lo=o=>o.nodeType===8;function la(o){var{mt:c,p:v,o:{patchProp:E,createText:P,nextSibling:C,parentNode:V,remove:G,insert:q,createComment:ae}}=o,Le=(_e,fe)=>{if(!fe.hasChildNodes()){v(null,_e,fe),wr(),fe._vnode=_e;return}ri=!1,Xe(fe.firstChild,_e,null,null,null),wr(),fe._vnode=_e,ri&&console.error("Hydration completed but contains mismatches.")},Xe=function(_e,fe,Te,i,s){var d=arguments.length>5&&arguments[5]!==void 0?arguments[5]:!1,p=lo(_e)&&_e.data==="[",y=()=>_t(_e,fe,Te,i,s,p),{type:w,ref:I,shapeFlag:L,patchFlag:$}=fe,ee=_e.nodeType;fe.el=_e,$===-2&&(d=!1,fe.dynamicChildren=null);var ie=null;switch(w){case Ge:ee!==3?fe.children===""?(q(fe.el=P(""),V(_e),_e),ie=_e):ie=y():(_e.data!==fe.children&&(ri=!0,_e.data=fe.children),ie=C(_e));break;case ut:ee!==8||p?ie=y():ie=C(_e);break;case Vt:if(ee!==1&&ee!==3)ie=y();else{ie=_e;for(var Ie=!fe.children.length,oe=0;oe<fe.staticCount;oe++)Ie&&(fe.children+=ie.nodeType===1?ie.outerHTML:ie.data),oe===fe.staticCount-1&&(fe.anchor=ie),ie=C(ie);return ie}break;case nt:p?ie=We(_e,fe,Te,i,s,d):ie=y();break;default:if(L&1)ee!==1||fe.type.toLowerCase()!==_e.tagName.toLowerCase()?ie=y():ie=se(_e,fe,Te,i,s,d);else if(L&6){fe.slotScopeIds=s;var Ce=V(_e);if(c(fe,Ce,null,Te,i,Ni(Ce),d),ie=p?Pt(_e):C(_e),ie&&lo(ie)&&ie.data==="teleport end"&&(ie=C(ie)),In(fe)){var Be;p?(Be=Lt(nt),Be.anchor=ie?ie.previousSibling:Ce.lastChild):Be=_e.nodeType===3?ii(""):Lt("div"),Be.el=_e,fe.component.subTree=Be}}else L&64?ee!==8?ie=y():ie=fe.type.hydrate(_e,fe,Te,i,s,d,o,$e):L&128&&(ie=fe.type.hydrate(_e,fe,Te,i,Ni(V(_e)),s,d,o,Xe))}return I!=null&&so(I,null,i,fe),ie},se=(_e,fe,Te,i,s,d)=>{d=d||!!fe.dynamicChildren;var{type:p,props:y,patchFlag:w,shapeFlag:I,dirs:L}=fe,$=p==="input"&&L||p==="option";if($||w!==-1){if(L&&de(fe,null,Te,"created"),y)if($||!d||w&(16|32))for(var ee in y)($&&ee.endsWith("value")||f.isOn(ee)&&!f.isReservedProp(ee))&&E(_e,ee,null,y[ee],!1,void 0,Te);else y.onClick&&E(_e,"onClick",null,y.onClick,!1,void 0,Te);var ie;if((ie=y&&y.onVnodeBeforeMount)&&Pr(ie,Te,fe),L&&de(fe,null,Te,"beforeMount"),((ie=y&&y.onVnodeMounted)||L)&&_o(()=>{ie&&Pr(ie,Te,fe),L&&de(fe,null,Te,"mounted")},i),I&16&&!(y&&(y.innerHTML||y.textContent)))for(var Ie=$e(_e.firstChild,fe,_e,Te,i,s,d);Ie;){ri=!0;var oe=Ie;Ie=Ie.nextSibling,G(oe)}else I&8&&_e.textContent!==fe.children&&(ri=!0,_e.textContent=fe.children)}return _e.nextSibling},$e=(_e,fe,Te,i,s,d,p)=>{p=p||!!fe.dynamicChildren;for(var y=fe.children,w=y.length,I=0;I<w;I++){var L=p?y[I]:y[I]=Xn(y[I]);if(_e)_e=Xe(_e,L,i,s,d,p);else{if(L.type===Ge&&!L.children)continue;ri=!0,v(null,L,Te,null,i,s,Ni(Te),d)}}return _e},We=(_e,fe,Te,i,s,d)=>{var{slotScopeIds:p}=fe;p&&(s=s?s.concat(p):p);var y=V(_e),w=$e(C(_e),fe,y,Te,i,s,d);return w&&lo(w)&&w.data==="]"?C(fe.anchor=w):(ri=!0,q(fe.anchor=ae("]"),y,w),w)},_t=(_e,fe,Te,i,s,d)=>{if(ri=!0,fe.el=null,d)for(var p=Pt(_e);;){var y=C(_e);if(y&&y!==p)G(y);else break}var w=C(_e),I=V(_e);return G(_e),v(null,fe,I,w,Te,i,Ni(I),s),w},Pt=_e=>{for(var fe=0;_e;)if(_e=C(_e),_e&&lo(_e)&&(_e.data==="["&&fe++,_e.data==="]")){if(fe===0)return C(_e);fe--}return _e};return[Le,Xe]}var m=_o;function R(o){return j(o)}function z(o){return j(o,la)}function j(o,c){var v=f.getGlobalThis();v.__VUE__=!0;var{insert:E,remove:P,patchProp:C,forcePatchProp:V,createElement:G,createText:q,createComment:ae,setText:Le,setElementText:Xe,parentNode:se,nextSibling:$e,setScopeId:We=f.NOOP,cloneNode:_t,insertStaticContent:Pt}=o,_e=function(F,K,he){var pe=arguments.length>3&&arguments[3]!==void 0?arguments[3]:null,Pe=arguments.length>4&&arguments[4]!==void 0?arguments[4]:null,Ke=arguments.length>5&&arguments[5]!==void 0?arguments[5]:null,ct=arguments.length>6&&arguments[6]!==void 0?arguments[6]:!1,Qe=arguments.length>7&&arguments[7]!==void 0?arguments[7]:null,Je=arguments.length>8&&arguments[8]!==void 0?arguments[8]:!!K.dynamicChildren;if(F!==K){F&&!or(F,K)&&(pe=It(F),qe(F,Pe,Ke,!0),F=null),K.patchFlag===-2&&(Je=!1,K.dynamicChildren=null);var{type:De,ref:yt,shapeFlag:wt}=K;switch(De){case Ge:fe(F,K,he,pe);break;case ut:Te(F,K,he,pe);break;case Vt:F==null&&i(K,he,pe,ct);break;case nt:ie(F,K,he,pe,Pe,Ke,ct,Qe,Je);break;default:wt&1?p(F,K,he,pe,Pe,Ke,ct,Qe,Je):wt&6?Ie(F,K,he,pe,Pe,Ke,ct,Qe,Je):(wt&64||wt&128)&&De.process(F,K,he,pe,Pe,Ke,ct,Qe,Je,Bt)}yt!=null&&Pe&&so(yt,F&&F.ref,Ke,K||F,!K)}},fe=(F,K,he,pe)=>{if(F==null)E(K.el=q(K.children),he,pe);else{var Pe=K.el=F.el;K.children!==F.children&&Le(Pe,K.children)}},Te=(F,K,he,pe)=>{F==null?E(K.el=ae(K.children||""),he,pe):K.el=F.el},i=(F,K,he,pe)=>{[F.el,F.anchor]=Pt(F.children,K,he,pe,F.el,F.anchor)},s=(F,K,he)=>{for(var{el:pe,anchor:Pe}=F,Ke;pe&&pe!==Pe;)Ke=$e(pe),E(pe,K,he),pe=Ke;E(Pe,K,he)},d=F=>{for(var{el:K,anchor:he}=F,pe;K&&K!==he;)pe=$e(K),P(K),K=pe;P(he)},p=(F,K,he,pe,Pe,Ke,ct,Qe,Je)=>{ct=ct||K.type==="svg",F==null?y(K,he,pe,Pe,Ke,ct,Qe,Je):L(F,K,Pe,Ke,ct,Qe,Je)},y=(F,K,he,pe,Pe,Ke,ct,Qe)=>{var Je,De,{type:yt,props:wt,shapeFlag:at,transition:ot,patchFlag:dn,dirs:bn}=F;if(F.el&&_t!==void 0&&dn===-1)Je=F.el=_t(F.el);else{if(Je=F.el=G(F.type,Ke,wt&&wt.is,wt),at&8?Xe(Je,F.children):at&16&&I(F.children,Je,null,pe,Pe,Ke&&yt!=="foreignObject",ct,Qe),bn&&de(F,null,pe,"created"),wt){for(var tr in wt)tr!=="value"&&!f.isReservedProp(tr)&&C(Je,tr,null,wt[tr],Ke,F.children,pe,Pe,xe,F.hostInstance);"value"in wt&&C(Je,"value",null,wt.value,!1,[],pe,null,void 0,F.hostInstance),(De=wt.onVnodeBeforeMount)&&Pr(De,pe,F)}w(Je,F,F.scopeId,ct,pe)}bn&&de(F,null,pe,"beforeMount");var Pn=(!Pe||Pe&&!Pe.pendingBranch)&&ot&&!ot.persisted;Pn&&ot.beforeEnter(Je),E(Je,K,he),((De=wt&&wt.onVnodeMounted)||Pn||bn)&&m(()=>{De&&Pr(De,pe,F),Pn&&ot.enter(Je),bn&&de(F,null,pe,"mounted")},Pe)},w=(F,K,he,pe,Pe)=>{if(he&&We(F,he),pe)for(var Ke=0;Ke<pe.length;Ke++)We(F,pe[Ke]);if(Pe){var ct=Pe.subTree;if(K===ct){var Qe=Pe.vnode;w(F,Qe,Qe.scopeId,Qe.slotScopeIds,Pe.parent)}}},I=function(F,K,he,pe,Pe,Ke,ct,Qe){for(var Je=arguments.length>8&&arguments[8]!==void 0?arguments[8]:0,De=Je;De<F.length;De++){var yt=F[De]=Qe?Yt(F[De]):Xn(F[De]);_e(null,yt,K,he,pe,Pe,Ke,ct,Qe)}},L=(F,K,he,pe,Pe,Ke,ct)=>{var Qe=K.el=F.el,{patchFlag:Je,dynamicChildren:De,dirs:yt}=K;Je|=F.patchFlag&16;var wt=F.props||f.EMPTY_OBJ,at=K.props||f.EMPTY_OBJ,ot;he&&Z(he,!1),(ot=at.onVnodeBeforeUpdate)&&Pr(ot,he,K,F),yt&&de(K,F,he,"beforeUpdate"),he&&Z(he,!0);var dn=Pe&&K.type!=="foreignObject";if(De?$(F.dynamicChildren,De,Qe,he,pe,dn,Ke):ct||At(F,K,Qe,null,he,pe,dn,Ke,!1),Je>0){if(Je&16)ee(Qe,K,wt,at,he,pe,Pe);else if(Je&2&&wt.class!==at.class&&C(Qe,"class",null,at.class,Pe,[],he,null,void 0,K.hostInstance),Je&4&&C(Qe,"style",wt.style,at.style,Pe,[],he,null,void 0,K.hostInstance),Je&8)for(var bn=K.dynamicProps,tr=0;tr<bn.length;tr++){var Pn=bn[tr],$o=wt[Pn],So=at[Pn];(So!==$o||Pn==="value"||V&&V(Qe,Pn))&&C(Qe,Pn,$o,So,Pe,F.children,he,pe,xe,K.hostInstance)}Je&1&&F.children!==K.children&&Xe(Qe,K.children)}else!ct&&De==null&&ee(Qe,K,wt,at,he,pe,Pe);((ot=at.onVnodeUpdated)||yt)&&m(()=>{ot&&Pr(ot,he,K,F),yt&&de(K,F,he,"updated")},pe)},$=(F,K,he,pe,Pe,Ke,ct)=>{for(var Qe=0;Qe<K.length;Qe++){var Je=F[Qe],De=K[Qe],yt=Je.el&&(Je.type===nt||!or(Je,De)||Je.shapeFlag&(6|64))?se(Je.el):he;_e(Je,De,yt,null,pe,Pe,Ke,ct,!0)}},ee=(F,K,he,pe,Pe,Ke,ct)=>{if(he!==pe){for(var Qe in pe)if(!f.isReservedProp(Qe)){var Je=pe[Qe],De=he[Qe];(Je!==De&&Qe!=="value"||V&&V(F,Qe))&&C(F,Qe,De,Je,ct,K.children,Pe,Ke,xe,K.hostInstance)}if(he!==f.EMPTY_OBJ)for(var yt in he)!f.isReservedProp(yt)&&!(yt in pe)&&C(F,yt,he[yt],null,ct,K.children,Pe,Ke,xe,K.hostInstance);"value"in pe&&C(F,"value",he.value,pe.value,!1,[],Pe,null,void 0,K.hostInstance)}},ie=(F,K,he,pe,Pe,Ke,ct,Qe,Je)=>{var De=K.el=F?F.el:q(""),yt=K.anchor=F?F.anchor:q(""),{patchFlag:wt,dynamicChildren:at,slotScopeIds:ot}=K;ot&&(Qe=Qe?Qe.concat(ot):ot),F==null?(E(De,he,pe),E(yt,he,pe),I(K.children,he,yt,Pe,Ke,ct,Qe,Je)):wt>0&&wt&64&&at&&F.dynamicChildren?($(F.dynamicChildren,at,he,Pe,Ke,ct,Qe),(K.key!=null||Pe&&K===Pe.subTree)&&Q(F,K,!0)):At(F,K,he,yt,Pe,Ke,ct,Qe,Je)},Ie=(F,K,he,pe,Pe,Ke,ct,Qe,Je)=>{K.slotScopeIds=Qe,F==null?K.shapeFlag&512?Pe.ctx.activate(K,he,pe,ct,Je):oe(K,he,pe,Pe,Ke,ct,Je):Ce(F,K,Je)},oe=(F,K,he,pe,Pe,Ke,ct)=>{var Qe=F.component=rs(F,pe,Pe);if(hi(F)&&(Qe.ctx.renderer=Bt),ai(Qe),Qe.asyncDep){if(Pe&&Pe.registerDep(Qe,Be),!F.el){var Je=Qe.subTree=Lt(ut);Te(null,Je,K,he)}return}Be(Qe,F,K,he,Pe,Ke,ct)},Ce=(F,K,he)=>{var pe=K.component=F.component;if(Io(F,K,he))if(pe.asyncDep&&!pe.asyncResolved){ft(pe,K,he);return}else pe.next=K,ir(pe.update),pe.update();else K.el=F.el,pe.vnode=K},Be=(F,K,he,pe,Pe,Ke,ct)=>{var Qe=()=>{if(F.isMounted){var{next:W,bu:re,u:Ee,parent:Ae,vnode:Me}=F,tt=W,ht;Z(F,!1),W?(W.el=Me.el,ft(F,W,ct)):W=Me,re&&f.invokeArrayFns(re),(ht=W.props&&W.props.onVnodeBeforeUpdate)&&Pr(ht,Ae,W,Me),Z(F,!0);var Ye=jr(F),et=F.subTree;F.subTree=Ye,_e(et,Ye,se(et.el),It(et),F,Pe,Ke),W.el=Ye.el,tt===null&&Rr(F,Ye.el),Ee&&m(Ee,Pe),(ht=W.props&&W.props.onVnodeUpdated)&&m(()=>Pr(ht,Ae,W,Me),Pe)}else{var yt,{el:wt,props:at}=K,{bm:ot,m:dn,parent:bn}=F,tr=In(K);if(Z(F,!1),ot&&f.invokeArrayFns(ot),!tr&&(yt=at&&at.onVnodeBeforeMount)&&Pr(yt,bn,K),Z(F,!0),wt&&dt){var Pn=()=>{F.subTree=jr(F),dt(wt,F.subTree,F,Pe,null)};tr?K.type.__asyncLoader().then(()=>!F.isUnmounted&&Pn()):Pn()}else{var $o=F.subTree=jr(F);_e(null,$o,he,pe,F,Pe,Ke),K.el=$o.el}if(dn&&m(dn,Pe),!tr&&(yt=at&&at.onVnodeMounted)){var So=K;m(()=>Pr(yt,bn,So),Pe)}(K.shapeFlag&256||bn&&In(bn.vnode)&&bn.vnode.shapeFlag&256)&&F.a&&m(F.a,Pe),F.isMounted=!0,K=he=pe=null}},Je=F.effect=new T.ReactiveEffect(Qe,()=>nn(De),F.scope),De=F.update=()=>Je.run();De.id=F.uid,Z(F,!0),De()},ft=(F,K,he)=>{K.component=F;var pe=F.vnode.props;F.vnode=K,F.next=null,Wo(F,K.props,pe,he),wa(F,K.children,he),T.pauseTracking(),xn(void 0,F.update),T.resetTracking()},At=function(F,K,he,pe,Pe,Ke,ct,Qe){var Je=arguments.length>8&&arguments[8]!==void 0?arguments[8]:!1,De=F&&F.children,yt=F?F.shapeFlag:0,wt=K.children,{patchFlag:at,shapeFlag:ot}=K;if(at>0){if(at&128){le(De,wt,he,pe,Pe,Ke,ct,Qe,Je);return}else if(at&256){me(De,wt,he,pe,Pe,Ke,ct,Qe,Je);return}}ot&8?(yt&16&&xe(De,Pe,Ke),wt!==De&&Xe(he,wt)):yt&16?ot&16?le(De,wt,he,pe,Pe,Ke,ct,Qe,Je):xe(De,Pe,Ke,!0):(yt&8&&Xe(he,""),ot&16&&I(wt,he,pe,Pe,Ke,ct,Qe,Je))},me=(F,K,he,pe,Pe,Ke,ct,Qe,Je)=>{F=F||f.EMPTY_ARR,K=K||f.EMPTY_ARR;var De=F.length,yt=K.length,wt=Math.min(De,yt),at;for(at=0;at<wt;at++){var ot=K[at]=Je?Yt(K[at]):Xn(K[at]);_e(F[at],ot,he,null,Pe,Ke,ct,Qe,Je)}De>yt?xe(F,Pe,Ke,!0,!1,wt):I(K,he,pe,Pe,Ke,ct,Qe,Je,wt)},le=(F,K,he,pe,Pe,Ke,ct,Qe,Je)=>{for(var De=0,yt=K.length,wt=F.length-1,at=yt-1;De<=wt&&De<=at;){var ot=F[De],dn=K[De]=Je?Yt(K[De]):Xn(K[De]);if(or(ot,dn))_e(ot,dn,he,null,Pe,Ke,ct,Qe,Je);else break;De++}for(;De<=wt&&De<=at;){var bn=F[wt],tr=K[at]=Je?Yt(K[at]):Xn(K[at]);if(or(bn,tr))_e(bn,tr,he,null,Pe,Ke,ct,Qe,Je);else break;wt--,at--}if(De>wt){if(De<=at)for(var Pn=at+1,$o=Pn<yt?K[Pn].el:pe;De<=at;)_e(null,K[De]=Je?Yt(K[De]):Xn(K[De]),he,$o,Pe,Ke,ct,Qe,Je),De++}else if(De>at)for(;De<=wt;)qe(F[De],Pe,Ke,!0),De++;else{var So=De,W=De,re=new Map;for(De=W;De<=at;De++){var Ee=K[De]=Je?Yt(K[De]):Xn(K[De]);Ee.key!=null&&re.set(Ee.key,De)}var Ae,Me=0,tt=at-W+1,ht=!1,Ye=0,et=new Array(tt);for(De=0;De<tt;De++)et[De]=0;for(De=So;De<=wt;De++){var je=F[De];if(Me>=tt){qe(je,Pe,Ke,!0);continue}var Nt=void 0;if(je.key!=null)Nt=re.get(je.key);else for(Ae=W;Ae<=at;Ae++)if(et[Ae-W]===0&&or(je,K[Ae])){Nt=Ae;break}Nt===void 0?qe(je,Pe,Ke,!0):(et[Nt-W]=De+1,Nt>=Ye?Ye=Nt:ht=!0,_e(je,K[Nt],he,null,Pe,Ke,ct,Qe,Je),Me++)}var Dt=ht?ce(et):f.EMPTY_ARR;for(Ae=Dt.length-1,De=tt-1;De>=0;De--){var Ft=W+De,on=K[Ft],Vr=Ft+1<yt?K[Ft+1].el:pe;et[De]===0?_e(null,on,he,Vr,Pe,Ke,ct,Qe,Je):ht&&(Ae<0||De!==Dt[Ae]?Se(on,he,Vr,2):Ae--)}}},Se=function(F,K,he,pe){var Pe=arguments.length>4&&arguments[4]!==void 0?arguments[4]:null,{el:Ke,type:ct,transition:Qe,children:Je,shapeFlag:De}=F;if(De&6){Se(F.component.subTree,K,he,pe);return}if(De&128){F.suspense.move(K,he,pe);return}if(De&64){ct.move(F,K,he,Bt);return}if(ct===nt){E(Ke,K,he);for(var yt=0;yt<Je.length;yt++)Se(Je[yt],K,he,pe);E(F.anchor,K,he);return}if(ct===Vt){s(F,K,he);return}var wt=pe!==2&&De&1&&Qe;if(wt)if(pe===0)Qe.beforeEnter(Ke),E(Ke,K,he),m(()=>Qe.enter(Ke),Pe);else{var{leave:at,delayLeave:ot,afterLeave:dn}=Qe,bn=()=>E(Ke,K,he),tr=()=>{at(Ke,()=>{bn(),dn&&dn()})};ot?ot(Ke,bn,tr):tr()}else E(Ke,K,he)},qe=function(F,K,he){var pe=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1,Pe=arguments.length>4&&arguments[4]!==void 0?arguments[4]:!1,{type:Ke,props:ct,ref:Qe,children:Je,dynamicChildren:De,shapeFlag:yt,patchFlag:wt,dirs:at}=F;if(Qe!=null&&so(Qe,null,he,F,!0),yt&256){K.ctx.deactivate(F);return}var ot=yt&1&&at,dn=!In(F),bn;if(dn&&(bn=ct&&ct.onVnodeBeforeUnmount)&&Pr(bn,K,F),yt&6)lt(F.component,he,pe);else{if(yt&128){F.suspense.unmount(he,pe);return}ot&&de(F,null,K,"beforeUnmount"),yt&64?F.type.remove(F,K,he,Pe,Bt,pe):De&&(Ke!==nt||wt>0&&wt&64)?xe(De,K,he,!1,!0):(Ke===nt&&wt&(128|256)||!Pe&&yt&16)&&xe(Je,K,he),pe&&He(F)}(dn&&(bn=ct&&ct.onVnodeUnmounted)||ot)&&m(()=>{bn&&Pr(bn,K,F),ot&&de(F,null,K,"unmounted")},he)},He=F=>{var{type:K,el:he,anchor:pe,transition:Pe}=F;if(K===nt){Re(he,pe);return}if(K===Vt){d(F);return}var Ke=()=>{P(he),Pe&&!Pe.persisted&&Pe.afterLeave&&Pe.afterLeave()};if(F.shapeFlag&1&&Pe&&!Pe.persisted){var{leave:ct,delayLeave:Qe}=Pe,Je=()=>ct(he,Ke);Qe?Qe(F.el,Ke,Je):Je()}else Ke()},Re=(F,K)=>{for(var he;F!==K;)he=$e(F),P(F),F=he;P(K)},lt=(F,K,he)=>{var{bum:pe,scope:Pe,update:Ke,subTree:ct,um:Qe}=F;pe&&f.invokeArrayFns(pe),Pe.stop(),Ke&&(Ke.active=!1,qe(ct,F,K,he)),Qe&&m(Qe,K),m(()=>{F.isUnmounted=!0},K),K&&K.pendingBranch&&!K.isUnmounted&&F.asyncDep&&!F.asyncResolved&&F.suspenseId===K.pendingId&&(K.deps--,K.deps===0&&K.resolve())},xe=function(F,K,he){for(var pe=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1,Pe=arguments.length>4&&arguments[4]!==void 0?arguments[4]:!1,Ke=arguments.length>5&&arguments[5]!==void 0?arguments[5]:0,ct=Ke;ct<F.length;ct++)qe(F[ct],K,he,pe,Pe)},It=F=>F.shapeFlag&6?It(F.component.subTree):F.shapeFlag&128?F.suspense.next():$e(F.anchor||F.el),Ct=(F,K,he)=>{F==null?K._vnode&&qe(K._vnode,null,null,!0):_e(K._vnode||null,F,K,null,null,null,he),wr(),K._vnode=F},Bt={p:_e,um:qe,m:Se,r:He,mt:oe,mc:I,pc:At,pbc:$,n:It,o},Jt,dt;return c&&([Jt,dt]=c(Bt)),{render:Ct,hydrate:Jt,createApp:Os(Ct,Jt)}}function Z(o,c){var{effect:v,update:E}=o;v.allowRecurse=E.allowRecurse=c}function Q(o,c){var v=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!1,E=o.children,P=c.children;if(f.isArray(E)&&f.isArray(P))for(var C=0;C<E.length;C++){var V=E[C],G=P[C];G.shapeFlag&1&&!G.dynamicChildren&&((G.patchFlag<=0||G.patchFlag===32)&&(G=P[C]=Yt(P[C]),G.el=V.el),v||Q(V,G))}}function ce(o){var c=o.slice(),v=[0],E,P,C,V,G,q=o.length;for(E=0;E<q;E++){var ae=o[E];if(ae!==0){if(P=v[v.length-1],o[P]<ae){c[E]=P,v.push(E);continue}for(C=0,V=v.length-1;C<V;)G=C+V>>1,o[v[G]]<ae?C=G+1:V=G;ae<o[v[C]]&&(C>0&&(c[E]=v[C-1]),v[C]=E)}}for(C=v.length,V=v[C-1];C-- >0;)v[C]=V,V=c[V];return v}var be=o=>o.__isTeleport,Oe=o=>o&&(o.disabled||o.disabled===""),Ne=o=>typeof SVGElement!="undefined"&&o instanceof SVGElement,ve=(o,c)=>{var v=o&&o.to;if(f.isString(v))if(c){var E=c(v);return E}else return null;else return v},Fe={__isTeleport:!0,process(o,c,v,E,P,C,V,G,q,ae){var{mc:Le,pc:Xe,pbc:se,o:{insert:$e,querySelector:We,createText:_t,createComment:Pt}}=ae,_e=Oe(c.props),{shapeFlag:fe,children:Te,dynamicChildren:i}=c;if(o==null){var s=c.el=_t(""),d=c.anchor=_t("");$e(s,v,E),$e(d,v,E);var p=c.target=ve(c.props,We),y=c.targetAnchor=_t("");p&&($e(y,p),V=V||Ne(p));var w=(Ce,Be)=>{fe&16&&Le(Te,Ce,Be,P,C,V,G,q)};_e?w(v,d):p&&w(p,y)}else{c.el=o.el;var I=c.anchor=o.anchor,L=c.target=o.target,$=c.targetAnchor=o.targetAnchor,ee=Oe(o.props),ie=ee?v:L,Ie=ee?I:$;if(V=V||Ne(L),i?(se(o.dynamicChildren,i,ie,P,C,V,G),Q(o,c,!0)):q||Xe(o,c,ie,Ie,P,C,V,G,!1),_e)ee||rt(c,v,I,ae,1);else if((c.props&&c.props.to)!==(o.props&&o.props.to)){var oe=c.target=ve(c.props,We);oe&&rt(c,oe,null,ae,0)}else ee&&rt(c,L,$,ae,1)}},remove(o,c,v,E,P,C){var{um:V,o:{remove:G}}=P,{shapeFlag:q,children:ae,anchor:Le,targetAnchor:Xe,target:se,props:$e}=o;if(se&&G(Xe),(C||!Oe($e))&&(G(Le),q&16))for(var We=0;We<ae.length;We++){var _t=ae[We];V(_t,c,v,!0,!!_t.dynamicChildren)}},move:rt,hydrate:bt};function rt(o,c,v,E){var{o:{insert:P},m:C}=E,V=arguments.length>4&&arguments[4]!==void 0?arguments[4]:2;V===0&&P(o.targetAnchor,c,v);var{el:G,anchor:q,shapeFlag:ae,children:Le,props:Xe}=o,se=V===2;if(se&&P(G,c,v),(!se||Oe(Xe))&&ae&16)for(var $e=0;$e<Le.length;$e++)C(Le[$e],c,v,2);se&&P(q,c,v)}function bt(o,c,v,E,P,C,V,G){var{o:{nextSibling:q,parentNode:ae,querySelector:Le}}=V,Xe=c.target=ve(c.props,Le);if(Xe){var se=Xe._lpa||Xe.firstChild;if(c.shapeFlag&16)if(Oe(c.props))c.anchor=G(q(o),c,ae(o),v,E,P,C),c.targetAnchor=se;else{c.anchor=q(o);for(var $e=se;$e;)if($e=q($e),$e&&$e.nodeType===8&&$e.data==="teleport anchor"){c.targetAnchor=$e,Xe._lpa=c.targetAnchor&&q(c.targetAnchor);break}G(se,c,Xe,v,E,P,C)}}return c.anchor&&q(c.anchor)}var Wt=Fe,nt=Symbol(void 0),Ge=Symbol(void 0),ut=Symbol(void 0),Vt=Symbol(void 0),pt=[],Ze=null;function Ot(){var o=arguments.length>0&&arguments[0]!==void 0?arguments[0]:!1;pt.push(Ze=o?null:[])}function wn(){pt.pop(),Ze=pt[pt.length-1]||null}var un=1;function rn(o){un+=o}function Sn(o){return o.dynamicChildren=un>0?Ze||f.EMPTY_ARR:null,wn(),un>0&&Ze&&Ze.push(o),o}function Ht(o,c,v,E,P,C){return Sn(Lo(o,c,v,E,P,C,!0))}function Ln(o,c,v,E,P){return Sn(Lt(o,c,v,E,P,!0))}function mi(o){return o?o.__v_isVNode===!0:!1}function or(o,c){return o.type===c.type&&o.key===c.key}function Er(o){}var Bo="__vInternal",Wi=o=>{var{key:c}=o;return c!=null?c:null},Mo=o=>{var{ref:c,ref_key:v,ref_for:E}=o;return c!=null?f.isString(c)||T.isRef(c)||f.isFunction(c)?{i:Cn,r:c,k:v,f:!!E}:c:null};function Lo(o){var c=arguments.length>1&&arguments[1]!==void 0?arguments[1]:null,v=arguments.length>2&&arguments[2]!==void 0?arguments[2]:null,E=arguments.length>3&&arguments[3]!==void 0?arguments[3]:0,P=arguments.length>4&&arguments[4]!==void 0?arguments[4]:null,C=arguments.length>5&&arguments[5]!==void 0?arguments[5]:o===nt?0:1,V=arguments.length>6&&arguments[6]!==void 0?arguments[6]:!1,G=arguments.length>7&&arguments[7]!==void 0?arguments[7]:!1,q={__v_isVNode:!0,__v_skip:!0,type:o,props:c,key:c&&Wi(c),ref:c&&Mo(c),scopeId:On,slotScopeIds:null,children:v,component:null,suspense:null,ssContent:null,ssFallback:null,dirs:null,transition:null,el:null,anchor:null,target:null,targetAnchor:null,staticCount:0,shapeFlag:C,patchFlag:E,dynamicProps:P,dynamicChildren:null,appContext:null,hostInstance:Cn};return G?(oi(q,v),C&128&&o.normalize(q)):v&&(q.shapeFlag|=f.isString(v)?8:16),un>0&&!V&&Ze&&(q.patchFlag>0||C&6)&&q.patchFlag!==32&&Ze.push(q),q}var Lt=fn;function fn(o){var c=arguments.length>1&&arguments[1]!==void 0?arguments[1]:null,v=arguments.length>2&&arguments[2]!==void 0?arguments[2]:null,E=arguments.length>3&&arguments[3]!==void 0?arguments[3]:0,P=arguments.length>4&&arguments[4]!==void 0?arguments[4]:null,C=arguments.length>5&&arguments[5]!==void 0?arguments[5]:!1;if((!o||o===X)&&(o=ut),mi(o)){var V=qr(o,c,!0);return v&&oi(V,v),un>0&&!C&&Ze&&(V.shapeFlag&6?Ze[Ze.indexOf(o)]=V:Ze.push(V)),V.patchFlag|=-2,V}if(yo(o)&&(o=o.__vccOpts),c){c=co(c);var{class:G,style:q}=c;G&&!f.isString(G)&&(c.class=f.normalizeClass(G)),f.isObject(q)&&(T.isProxy(q)&&!f.isArray(q)&&(q=f.extend({},q)),c.style=f.normalizeStyle(q))}var ae=f.isString(o)?1:ur(o)?128:be(o)?64:f.isObject(o)?4:f.isFunction(o)?2:0;return Lo(o,c,v,E,P,ae,C,!0)}function co(o){return o?T.isProxy(o)||Bo in o?f.extend({},o):o:null}function qr(o,c){var v=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!1,{props:E,ref:P,patchFlag:C,children:V}=o,G=c?Aa(E||{},c):E,q={__v_isVNode:!0,__v_skip:!0,type:o.type,props:G,key:G&&Wi(G),ref:c&&c.ref?v&&P?f.isArray(P)?P.concat(Mo(c)):[P,Mo(c)]:Mo(c):P,scopeId:o.scopeId,slotScopeIds:o.slotScopeIds,children:V,target:o.target,targetAnchor:o.targetAnchor,staticCount:o.staticCount,shapeFlag:o.shapeFlag,patchFlag:c&&o.type!==nt?C===-1?16:C|16:C,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&&qr(o.ssContent),ssFallback:o.ssFallback&&qr(o.ssFallback),el:o.el,anchor:o.anchor};return q}function ii(){var o=arguments.length>0&&arguments[0]!==void 0?arguments[0]:" ",c=arguments.length>1&&arguments[1]!==void 0?arguments[1]:0;return Lt(Ge,null,o,c)}function Do(o,c){var v=Lt(Vt,null,o);return v.staticCount=c,v}function uo(){var o=arguments.length>0&&arguments[0]!==void 0?arguments[0]:"",c=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!1;return c?(Ot(),Ln(ut,null,o)):Lt(ut,null,o)}function Xn(o){return o==null||typeof o=="boolean"?Lt(ut):f.isArray(o)?Lt(nt,null,o.slice()):typeof o=="object"?Yt(o):Lt(Ge,null,String(o))}function Yt(o){return o.el===null||o.memo?o:qr(o)}function oi(o,c){var v=0,{shapeFlag:E}=o;if(c==null)c=null;else if(f.isArray(c))v=16;else if(typeof c=="object")if(E&(1|64)){var P=c.default;P&&(P._c&&(P._d=!1),oi(o,P()),P._c&&(P._d=!0));return}else{v=32;var C=c._;!C&&!(Bo in c)?c._ctx=Cn:C===3&&Cn&&(Cn.slots._===1?c._=1:(c._=2,o.patchFlag|=1024))}else f.isFunction(c)?(c={default:c,_ctx:Cn},v=32):(c=String(c),E&64?(v=16,c=[ii(c)]):v=8);o.children=c,o.shapeFlag|=v}function Aa(){for(var o={},c=0;c<arguments.length;c++){var v=c<0||arguments.length<=c?void 0:arguments[c];for(var E in v)if(E==="class")o.class!==v.class&&(o.class=f.normalizeClass([o.class,v.class]));else if(E==="style")o.style=f.normalizeStyle([o.style,v.style]);else if(f.isOn(E)){var P=o[E],C=v[E];C&&P!==C&&!(f.isArray(P)&&P.includes(C))&&(o[E]=P?[].concat(P,C):C)}else E!==""&&(o[E]=v[E])}return o}function Pr(o,c,v){var E=arguments.length>3&&arguments[3]!==void 0?arguments[3]:null;te(o,c,7,[v,E])}var Dr=sa(),Ts=0;function rs(o,c,v){var E=o.type,P=(c?c.appContext:o.appContext)||Dr,C={uid:Ts++,vnode:o,type:E,parent:c,appContext:P,root:null,next:null,subTree:null,effect:null,update:null,scope:new T.EffectScope(!0),render:null,proxy:null,exposed:null,exposeProxy:null,withProxy:null,provides:c?c.provides:Object.create(P.provides),accessCache:null,renderCache:[],components:null,directives:null,propsOptions:ba(E,P),emitsOptions:To(E,P),emit:null,emitted:null,propsDefaults:f.EMPTY_OBJ,inheritAttrs:E.inheritAttrs,ctx:f.EMPTY_OBJ,data:f.EMPTY_OBJ,props:f.EMPTY_OBJ,attrs:f.EMPTY_OBJ,slots:f.EMPTY_OBJ,refs:f.EMPTY_OBJ,setupState:f.EMPTY_OBJ,setupContext:null,suspense:v,suspenseId:v?v.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 C.ctx={_:C},C.root=c?c.root:C,C.emit=Oo.bind(null,C),o.ce&&o.ce(C),C}var Gn=null,An=()=>Gn||Cn,Qn=o=>{Gn=o,o.scope.on()},Fr=()=>{Gn&&Gn.scope.off(),Gn=null};function ki(o){return o.vnode.shapeFlag&4}N.isInSSRComponentSetup=!1;function ai(o){var c=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!1;N.isInSSRComponentSetup=c;var{props:v,children:E}=o.vnode,P=ki(o);Cs(o,v,P,c),aa(o,E);var C=P?Ca(o,c):void 0;return N.isInSSRComponentSetup=!1,C}function Ca(o,c){var v=o.type;o.accessCache=Object.create(null),o.proxy=T.markRaw(new Proxy(o.ctx,oo));var{setup:E}=v;if(E){var P=o.setupContext=E.length>1?Ve(o):null;Qn(o),T.pauseTracking();var C=Y(E,o,0,[o.props,P]);if(T.resetTracking(),Fr(),f.isPromise(C)){if(C.then(Fr,Fr),c)return C.then(V=>{Yo(o,V,c)}).catch(V=>{En(V,o,0)});o.asyncDep=C}else Yo(o,C,c)}else Da(o,c)}function Yo(o,c,v){f.isFunction(c)?o.type.__ssrInlineRender?o.ssrRender=c:o.render=c:f.isObject(c)&&(o.setupState=T.proxyRefs(c)),Da(o,v)}var Gi,Yi;function qi(o){Gi=o,Yi=c=>{c.render._rc&&(c.withProxy=new Proxy(c.ctx,Ra))}}var Oa=()=>!Gi;function Da(o,c,v){var E=o.type;if(!o.render){if(!c&&Gi&&!E.render){var P=E.template;if(P){var{isCustomElement:C,compilerOptions:V}=o.appContext.config,{delimiters:G,compilerOptions:q}=E,ae=f.extend(f.extend({isCustomElement:C,delimiters:G},V),q);E.render=Gi(P,ae)}}o.render=E.render||f.NOOP,Yi&&Yi(o)}Qn(o),T.pauseTracking(),_a(o),T.resetTracking(),Fr()}function is(o){return new Proxy(o.attrs,{get(c,v){return T.track(o,"get","$attrs"),c[v]}})}function Ve(o){var c=E=>{o.exposed=E||{}},v;return{get attrs(){return v||(v=is(o))},slots:o.slots,emit:o.emit,expose:c}}function Tt(o){if(o.exposed)return o.exposeProxy||(o.exposeProxy=new Proxy(T.proxyRefs(T.markRaw(o.exposed)),{get(c,v){if(v in c)return c[v];if(v in bo)return bo[v](o)}}))}var Rt=/(?:^|[-_])(\w)/g,Tn=o=>o.replace(Rt,c=>c.toUpperCase()).replace(/[-_]/g,"");function er(o){var c=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!0;return f.isFunction(o)?o.displayName||o.name:o.name||c&&o.__name}function St(o,c){var v=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!1,E=er(c);if(!E&&c.__file){var P=c.__file.match(/([^/\\]+)\.\w+$/);P&&(E=P[1])}if(!E&&o&&o.parent){var C=V=>{for(var G in V)if(V[G]===c)return G};E=C(o.components||o.parent.type.components)||C(o.appContext.components)}return E?Tn(E):v?"App":"Anonymous"}function yo(o){return f.isFunction(o)&&"__vccOpts"in o}var Fo=(o,c)=>T.computed(o,c,N.isInSSRComponentSetup);function ca(){return null}function Ps(){return null}function qo(o){}function zl(o,c){return null}function al(){return sl().slots}function Wl(){return sl().attrs}function sl(){var o=An();return o.setupContext||(o.setupContext=Ve(o))}function ll(o,c){var v=f.isArray(o)?o.reduce((C,V)=>(C[V]={},C),{}):o;for(var E in c){var P=v[E];P?f.isArray(P)||f.isFunction(P)?v[E]={type:P,default:c[E]}:P.default=c[E]:P===null&&(v[E]={default:c[E]})}return v}function Is(o,c){var v={},E=function(C){c.includes(C)||Object.defineProperty(v,C,{enumerable:!0,get:()=>o[C]})};for(var P in o)E(P);return v}function Fa(o){var c=An(),v=o();return Fr(),f.isPromise(v)&&(v=v.catch(E=>{throw Qn(c),E})),[v,()=>Qn(c)]}function Va(o,c,v){var E=arguments.length;return E===2?f.isObject(c)&&!f.isArray(c)?mi(c)?Lt(o,null,[c]):Lt(o,c):Lt(o,null,c):(E>3?v=Array.prototype.slice.call(arguments,2):E===3&&mi(v)&&(v=[v]),Lt(o,c,v))}var Ko=Symbol(""),os=()=>{{var o=Ai(Ko);return o||pn("Server rendering context not provided. Make sure to only call useSSRContext() conditionally in the server build."),o}};function cl(){}function ua(o,c,v,E){var P=v[E];if(P&&as(P,o))return P;var C=c();return C.memo=o.slice(),v[E]=C}function as(o,c){var v=o.memo;if(v.length!=c.length)return!1;for(var E=0;E<v.length;E++)if(f.hasChanged(v[E],c[E]))return!1;return un>0&&Ze&&Ze.push(o),!0}var Ns="3.2.37",ss=null,ul=null,fl={insert:(o,c,v)=>v?c.insertBefore(o,v):c.appendChild(o),remove:o=>{var c=o.parentNode;c&&c.removeChild(o)},createElement:o=>l.createElement(o),createText:o=>l.createText(o),createComment:o=>l.createComment(o),setText:(o,c)=>{o.setAttr("value",c)},setElementText:(o,c)=>{o.setAttr("value",c)},parentNode:o=>o.parentNode,nextSibling:o=>o.nextSibling};function Ta(o){return Object.keys(o)}function $a(o){var c={};return f.isArray(o)&&o.forEach(v=>{Ta(v).forEach(E=>{var P=v[E],C=c[E]||(c[E]={});Ta(P).forEach(V=>{var G=P[V],q=C[V]||(C[V]={});Ta(G).forEach(ae=>{ae[0]==="!"?(q[ae]=G[ae],delete q[ae.slice(1)]):f.hasOwn(q,"!"+ae)||(q[ae]=G[ae])})})})}),c}function fa(o,c){var v=c&&c.classList;return v&&v.includes(o)}var dl=/[+~> ]$/,Ua="parentNode",ks="previousSibling";function wo(o,c){for(var v=o.split("."),E=v.length-1;E>0;E--){var P=v[E],C=P[P.length-1],V=P.replace(dl,"");if(C==="~"||C===" "){for(var G=C==="~"?ks:Ua;c&&(c=c[G],!fa(V,c)););if(!c)return!1}else if(C===">"?c=c&&c[Ua]:C==="+"&&(c=c&&c[ks]),!fa(V,c))return!1}return!0}var Ha=1e3;function ja(o,c,v){var{styles:E,weights:P}=o;Ta(c).forEach(C=>{if(!(C&&v&&!wo(C,v))){var V=C.split(".").length,G=c[C];Ta(G).forEach(q=>{var ae=G[q],Le=q[0]==="!";Le&&(q=q.slice(1));var Xe=P[q]||0,se=V+(Le?Ha:0);se>=Xe&&(P[q]=se,E[q]=ae)})}})}function Pa(o,c){var v=arguments.length>2&&arguments[2]!==void 0?arguments[2]:null,E={styles:{},weights:{}};return o.forEach(P=>{var C=c[P];C&&ja(E,C,v)}),E.styles}function ls(o){return Pa(o.classList,o.styleSheet,o)}function za(o,c){var v=arguments.length>2&&arguments[2]!==void 0?arguments[2]:null;return Pa(o,cs(c),v)}function cs(o){var{type:c,appContext:v}=o,E=c;if(!E.__styles)if(v&&f.isArray(v.provides.__globalStyles)&&(v.provides.__globalStyles=$a(v.provides.__globalStyles)),E.mpType==="page"&&v)E.__styles=v.provides.__globalStyles;else{var P=[];v&&P.push(v.provides.__globalStyles),f.isArray(E.styles)&&E.styles.forEach(C=>P.push(C)),E.__styles=$a(P)}return E.__styles}function Rs(o,c,v){var E=arguments.length>3&&arguments[3]!==void 0?arguments[3]:null;E&&([c,v]=Jo(o,c,v,E)),o.setAttr(c,v)}var us="hoverClass",xs="placeholderClass",fs="placeholderStyle",hl="indicatorClass",Wa="indicatorStyle",_i="maskClass",Ki="maskStyle",Bs={view:{class:[us],style:[]},button:{class:[us],style:[]},navigator:{class:[us],style:[]},"u-input":{class:[xs],style:[fs]},"u-textarea":{class:[xs],style:[fs]},"picker-view":{class:[hl,_i],style:[Wa,Ki]}};function Jo(o,c,v,E){if(!v)return[c,v];var P=Bs[o.type];if(P){var C=f.camelize(c);if(P.class.indexOf(C)>-1)return[C,za([v],E,o)];if(P.style.indexOf(c)>-1)return f.isString(v)?[C,f.parseStringStyle(v)]:[C,f.normalizeStyle(v)]}return[c,v]}function Ga(o,c,v){var E=arguments.length>3&&arguments[3]!==void 0?arguments[3]:null;if(!!E){var P=v?v.split(" "):[];o.setClassList(P),o.setStyleSheet(cs(E))}}function ds(o,c,v,E){o.addEvent(c,v)}function gl(o,c){o.removeEvent(c)}function pl(o,c,v,E){var P=arguments.length>4&&arguments[4]!==void 0?arguments[4]:null,C=o._vei||(o._vei={}),V=C[c];if(E&&V)V.value=E;else{var[G,q]=Ms(c);if(E){var ae=C[c]=Ls(E,P);ds(o,G,ae)}else V&&(gl(o,G),C[c]=void 0)}}var Vo=/(?:Once|Passive|Capture)$/;function vl(o){return o==="on-post-message"?"onPostMessage":o}function Ms(o){var c;if(Vo.test(o)){c={};for(var v;v=o.match(Vo);)o=o.slice(0,o.length-v[0].length),c[v[0].toLowerCase()]=!0}return o=o.slice(2),[vl(f.hyphenate(o)),c]}function Ls(o,c){var v=P=>{te(v.value,c,5,[P])};v.value=o;var E=new Set;return f.isArray(v.value)?v.value.forEach(P=>{P.modifiers&&P.modifiers.forEach(C=>{E.add(C)})}):(v.value.modifiers&&v.value.modifiers.forEach(P=>{E.add(P)}),hs(v,c)),v.modifiers=[...E],v}function hs(o,c){if(!!c){var{$wxsModules:v}=c;if(!!v){var E=o.value.toString();!v.find(P=>E.indexOf("."+P+".")>-1)||(o.wxsEvent=o.value())}}}function fo(o,c,v){if(!!v){f.isString(v)&&(v=f.parseStringStyle(v));var E={},P=c&&!f.isString(c);if(P){for(var C in c)v[C]==null&&(E[f.camelize(C)]="");for(var V in v){var G=v[V];G!==c[V]&&(E[f.camelize(V)]=G)}}else for(var q in v)E[f.camelize(q)]=v[q];o.setStyles(E)}}var Zo=["u-input","u-textarea"],Ds=function(o,c,v,E){var P=arguments.length>6?arguments[6]:void 0,C=arguments.length>9?arguments[9]:void 0;c==="class"?Ga(o,v,E,C||P):c==="style"?fo(o,v,E):f.isOn(c)?f.isModelListener(c)||pl(o,c,v,E,P):c==="modelValue"&&Zo.includes(o.type)?o.setAttrs({modelValue:E,value:E}):Rs(o,c,E,P)};function Gl(){var o=arguments.length>0&&arguments[0]!==void 0?arguments[0]:"$style";{var c=An();if(!c)return f.EMPTY_OBJ;var v=c.type.__cssModules;if(!v)return f.EMPTY_OBJ;var E=v[o];return E||f.EMPTY_OBJ}}function ml(o){var c=An();if(!!c){var v=()=>gs(c.subTree,o(c.proxy));Pi(()=>ui(v,{flush:"post"})),pi(v)}}function gs(o,c){if(o.shapeFlag&128){var v=o.suspense;o=v.activeBranch,v.pendingBranch&&!v.isHydrating&&v.effects.push(()=>{gs(v.activeBranch,c)})}for(;o.component;)o=o.component.subTree;if(o.shapeFlag&1&&o.el){var E=o.el.style;for(var P in c)E.setProperty("--".concat(P),c[P])}else o.type===nt&&o.children.forEach(C=>gs(C,c))}var Fs=["ctrl","shift","alt","meta"],_l={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,c)=>Fs.some(v=>o["".concat(v,"Key")]&&!c.includes(v))},Vs=(o,c)=>function(v){for(var E=0;E<c.length;E++){var P=_l[c[E]];if(P&&P(v,c))return}for(var C=arguments.length,V=new Array(C>1?C-1:0),G=1;G<C;G++)V[G-1]=arguments[G];return o(v,...V)},bl=(o,c)=>v=>{if("key"in v){var E=f.hyphenate(v.key);if(c.some(P=>P===E))return o(v)}},El=f.extend({patchProp:Ds},fl),yl;function wl(){return yl||(yl=R(El))}var Yl=function(){wl().render(...arguments)},ql=function(){var o=wl().createApp(...arguments),{mount:c}=o;return o.mount=v=>c(v),o};return Object.defineProperty(N,"camelize",{enumerable:!0,get:function(){return f.camelize}}),Object.defineProperty(N,"capitalize",{enumerable:!0,get:function(){return f.capitalize}}),Object.defineProperty(N,"hyphenate",{enumerable:!0,get:function(){return f.hyphenate}}),Object.defineProperty(N,"normalizeClass",{enumerable:!0,get:function(){return f.normalizeClass}}),Object.defineProperty(N,"normalizeProps",{enumerable:!0,get:function(){return f.normalizeProps}}),Object.defineProperty(N,"normalizeStyle",{enumerable:!0,get:function(){return f.normalizeStyle}}),Object.defineProperty(N,"toDisplayString",{enumerable:!0,get:function(){return f.toDisplayString}}),Object.defineProperty(N,"toHandlerKey",{enumerable:!0,get:function(){return f.toHandlerKey}}),Object.defineProperty(N,"EffectScope",{enumerable:!0,get:function(){return T.EffectScope}}),Object.defineProperty(N,"ReactiveEffect",{enumerable:!0,get:function(){return T.ReactiveEffect}}),Object.defineProperty(N,"customRef",{enumerable:!0,get:function(){return T.customRef}}),Object.defineProperty(N,"effect",{enumerable:!0,get:function(){return T.effect}}),Object.defineProperty(N,"effectScope",{enumerable:!0,get:function(){return T.effectScope}}),Object.defineProperty(N,"getCurrentScope",{enumerable:!0,get:function(){return T.getCurrentScope}}),Object.defineProperty(N,"isProxy",{enumerable:!0,get:function(){return T.isProxy}}),Object.defineProperty(N,"isReactive",{enumerable:!0,get:function(){return T.isReactive}}),Object.defineProperty(N,"isReadonly",{enumerable:!0,get:function(){return T.isReadonly}}),Object.defineProperty(N,"isRef",{enumerable:!0,get:function(){return T.isRef}}),Object.defineProperty(N,"isShallow",{enumerable:!0,get:function(){return T.isShallow}}),Object.defineProperty(N,"markRaw",{enumerable:!0,get:function(){return T.markRaw}}),Object.defineProperty(N,"onScopeDispose",{enumerable:!0,get:function(){return T.onScopeDispose}}),Object.defineProperty(N,"proxyRefs",{enumerable:!0,get:function(){return T.proxyRefs}}),Object.defineProperty(N,"reactive",{enumerable:!0,get:function(){return T.reactive}}),Object.defineProperty(N,"readonly",{enumerable:!0,get:function(){return T.readonly}}),Object.defineProperty(N,"ref",{enumerable:!0,get:function(){return T.ref}}),Object.defineProperty(N,"shallowReactive",{enumerable:!0,get:function(){return T.shallowReactive}}),Object.defineProperty(N,"shallowReadonly",{enumerable:!0,get:function(){return T.shallowReadonly}}),Object.defineProperty(N,"shallowRef",{enumerable:!0,get:function(){return T.shallowRef}}),Object.defineProperty(N,"stop",{enumerable:!0,get:function(){return T.stop}}),Object.defineProperty(N,"toRaw",{enumerable:!0,get:function(){return T.toRaw}}),Object.defineProperty(N,"toRef",{enumerable:!0,get:function(){return T.toRef}}),Object.defineProperty(N,"toRefs",{enumerable:!0,get:function(){return T.toRefs}}),Object.defineProperty(N,"triggerRef",{enumerable:!0,get:function(){return T.triggerRef}}),Object.defineProperty(N,"unref",{enumerable:!0,get:function(){return T.unref}}),N.BaseTransition=No,N.Comment=ut,N.Fragment=nt,N.KeepAlive=Qo,N.Static=Vt,N.Suspense=Xr,N.Teleport=Wt,N.Text=Ge,N.callWithAsyncErrorHandling=te,N.callWithErrorHandling=Y,N.cloneVNode=qr,N.compatUtils=ul,N.computed=Fo,N.createApp=ql,N.createBlock=Ln,N.createCommentVNode=uo,N.createElementBlock=Ht,N.createElementVNode=Lo,N.createHydrationRenderer=z,N.createPropsRestProxy=Is,N.createRenderer=R,N.createSlots=mr,N.createStaticVNode=Do,N.createTextVNode=ii,N.createVNode=Lt,N.defineAsyncComponent=Ti,N.defineComponent=Or,N.defineEmits=Ps,N.defineExpose=qo,N.defineProps=ca,N.getCurrentInstance=An,N.getTransitionRawChildren=Wn,N.guardReactiveProps=co,N.h=Va,N.handleError=En,N.initCustomFormatter=cl,N.inject=Ai,N.injectHook=ti,N.isMemoSame=as,N.isRuntimeOnly=Oa,N.isVNode=mi,N.mergeDefaults=ll,N.mergeProps=Aa,N.nextTick=vt,N.onActivated=Kn,N.onBeforeMount=Gr,N.onBeforeUnmount=Yr,N.onBeforeUpdate=gi,N.onDeactivated=pr,N.onErrorCaptured=x,N.onMounted=Pi,N.onRenderTracked=io,N.onRenderTriggered=ji,N.onServerPrefetch=ro,N.onUnmounted=vi,N.onUpdated=pi,N.openBlock=Ot,N.parseClassList=za,N.parseClassStyles=ls,N.popScopeId=eo,N.provide=ei,N.pushScopeId=Qi,N.queuePostFlushCb=Di,N.registerRuntimeCompiler=qi,N.render=Yl,N.renderList=ni,N.renderSlot=ea,N.resolveComponent=J,N.resolveDirective=tn,N.resolveDynamicComponent=ue,N.resolveFilter=ss,N.resolveTransitionHooks=Ut,N.setBlockTracking=rn,N.setDevtoolsHook=Xi,N.setTransitionHooks=Kt,N.ssrContextKey=Ko,N.toHandlers=ta,N.transformVNodeArgs=Er,N.useAttrs=Wl,N.useCssModule=Gl,N.useCssStyles=$a,N.useCssVars=ml,N.useSSRContext=os,N.useSlots=al,N.useTransitionState=Br,N.version=Ns,N.warn=pn,N.watch=Mt,N.watchEffect=ui,N.watchPostEffect=qn,N.watchSyncEffect=Cr,N.withAsyncContext=Fa,N.withCtx=Si,N.withDefaults=zl,N.withDirectives=ne,N.withKeys=bl,N.withMemo=ua,N.withModifiers=Vs,N.withScopeId=go,Object.defineProperty(N,"__esModule",{value:!0}),N}({},A,k,_);return S.__TYPE__="nvue",S}var fp=PP(xP);var hc={};SP(hc,{EMPTY_ARR:()=>GP,EMPTY_OBJ:()=>WP,NO:()=>qP,NOOP:()=>YP,camelize:()=>s1,capitalize:()=>ru,def:()=>d1,extend:()=>Jr,getGlobalThis:()=>g1,hasChanged:()=>u1,hasOwn:()=>Xs,hyphenate:()=>rf,invokeArrayFns:()=>f1,isArray:()=>yi,isBuiltInDirective:()=>o1,isFunction:()=>Fn,isGloballyWhitelisted:()=>LP,isHTMLTag:()=>HP,isIntegerKey:()=>r1,isMap:()=>gp,isModelListener:()=>ZP,isObject:()=>$l,isOn:()=>JP,isPlainObject:()=>Ul,isPromise:()=>t1,isReservedProp:()=>i1,isSVGTag:()=>jP,isSet:()=>pp,isString:()=>wi,isSymbol:()=>e1,makeMap:()=>Vl,normalizeClass:()=>nf,normalizeProps:()=>VP,normalizeStyle:()=>tf,parseStringStyle:()=>dp,remove:()=>XP,toDisplayString:()=>zP,toHandlerKey:()=>c1,toNumber:()=>h1,toRawType:()=>n1,toTypeString:()=>Xa});function Vl(g,l){let _=Object.create(null),A=g.split(",");for(let k=0;k<A.length;k++)_[A[k]]=!0;return l?k=>!!_[k.toLowerCase()]:k=>!!_[k]}var MP="Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt",LP=Vl(MP);function tf(g){if(yi(g)){let l={};for(let _=0;_<g.length;_++){let A=g[_],k=wi(A)?dp(A):tf(A);if(k)for(let S in k)l[S]=k[S]}return l}else{if(wi(g))return g;if($l(g))return g}}var DP=/;(?![^(]*\))/g,FP=/:(.+)/;function dp(g){let l={};return g.split(DP).forEach(_=>{if(_){let A=_.split(FP);A.length>1&&(l[A[0].trim()]=A[1].trim())}}),l}function nf(g){let l="";if(wi(g))l=g;else if(yi(g))for(let _=0;_<g.length;_++){let A=nf(g[_]);A&&(l+=A+" ")}else if($l(g))for(let _ in g)g[_]&&(l+=_+" ");return l.trim()}function VP(g){if(!g)return null;let{class:l,style:_}=g;return l&&!wi(l)&&(g.class=nf(l)),_&&(g.style=tf(_)),g}var $P="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",UP="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",HP=Vl($P),jP=Vl(UP),zP=g=>wi(g)?g:g==null?"":yi(g)||$l(g)&&(g.toString===vp||!Fn(g.toString))?JSON.stringify(g,hp,2):String(g),hp=(g,l)=>l&&l.__v_isRef?hp(g,l.value):gp(l)?{[`Map(${l.size})`]:[...l.entries()].reduce((_,[A,k])=>(_[`${A} =>`]=k,_),{})}:pp(l)?{[`Set(${l.size})`]:[...l.values()]}:$l(l)&&!yi(l)&&!Ul(l)?String(l):l,WP={},GP=[],YP=()=>{},qP=()=>!1,KP=/^on[^a-z]/,JP=g=>KP.test(g),ZP=g=>g.startsWith("onUpdate:"),Jr=Object.assign,XP=(g,l)=>{let _=g.indexOf(l);_>-1&&g.splice(_,1)},QP=Object.prototype.hasOwnProperty,Xs=(g,l)=>QP.call(g,l),yi=Array.isArray,gp=g=>Xa(g)==="[object Map]",pp=g=>Xa(g)==="[object Set]",Fn=g=>typeof g=="function",wi=g=>typeof g=="string",e1=g=>typeof g=="symbol",$l=g=>g!==null&&typeof g=="object",t1=g=>$l(g)&&Fn(g.then)&&Fn(g.catch),vp=Object.prototype.toString,Xa=g=>vp.call(g),n1=g=>Xa(g).slice(8,-1),Ul=g=>Xa(g)==="[object Object]",r1=g=>wi(g)&&g!=="NaN"&&g[0]!=="-"&&""+parseInt(g,10)===g,i1=Vl(",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted"),o1=Vl("bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text,memo"),nu=g=>{let l=Object.create(null);return _=>l[_]||(l[_]=g(_))},a1=/-(\w)/g,s1=nu(g=>g.replace(a1,(l,_)=>_?_.toUpperCase():"")),l1=/\B([A-Z])/g,rf=nu(g=>g.replace(l1,"-$1").toLowerCase()),ru=nu(g=>g.charAt(0).toUpperCase()+g.slice(1)),c1=nu(g=>g?`on${ru(g)}`:""),u1=(g,l)=>!Object.is(g,l),f1=(g,l)=>{for(let _=0;_<g.length;_++)g[_](l)},d1=(g,l,_)=>{Object.defineProperty(g,l,{configurable:!0,enumerable:!1,value:_})},h1=g=>{let l=parseFloat(g);return isNaN(l)?g:l},mp,g1=()=>mp||(mp=typeof globalThis!="undefined"?globalThis:typeof self!="undefined"?self:typeof window!="undefined"?window:typeof global!="undefined"?global:{});function _p(g){var l=function(_,A){"use strict";function k(x,...ne){console.warn(`[Vue warn] ${x}`,...ne)}let S;class N{constructor(ne=!1){this.active=!0,this.effects=[],this.cleanups=[],!ne&&S&&(this.parent=S,this.index=(S.scopes||(S.scopes=[])).push(this)-1)}run(ne){if(this.active){let de=S;try{return S=this,ne()}finally{S=de}}}on(){S=this}off(){S=this.parent}stop(ne){if(this.active){let de,H;for(de=0,H=this.effects.length;de<H;de++)this.effects[de].stop();for(de=0,H=this.cleanups.length;de<H;de++)this.cleanups[de]();if(this.scopes)for(de=0,H=this.scopes.length;de<H;de++)this.scopes[de].stop(!0);if(this.parent&&!ne){let M=this.parent.scopes.pop();M&&M!==this&&(this.parent.scopes[this.index]=M,M.index=this.index)}this.active=!1}}}function f(x){return new N(x)}function T(x,ne=S){ne&&ne.active&&ne.effects.push(x)}function ze(){return S}function xt(x){S&&S.cleanups.push(x)}let pn=x=>{let ne=new Set(x);return ne.w=0,ne.n=0,ne},B=x=>(x.w&te)>0,gt=x=>(x.n&te)>0,vn=({deps:x})=>{if(x.length)for(let ne=0;ne<x.length;ne++)x[ne].w|=te},Vn=x=>{let{deps:ne}=x;if(ne.length){let de=0;for(let H=0;H<ne.length;H++){let M=ne[H];B(M)&&!gt(M)?M.delete(x):ne[de++]=M,M.w&=~te,M.n&=~te}ne.length=de}},st=new WeakMap,Y=0,te=1,En=30,yn,ln=Symbol(""),$n=Symbol("");class an{constructor(ne,de=null,H){this.fn=ne,this.scheduler=de,this.active=!0,this.deps=[],this.parent=void 0,T(this,H)}run(){if(!this.active)return this.fn();let ne=yn,de=sn;for(;ne;){if(ne===this)return;ne=ne.parent}try{return this.parent=yn,yn=this,sn=!0,te=1<<++Y,Y<=En?vn(this):kn(this),this.fn()}finally{Y<=En&&Vn(this),te=1<<--Y,yn=this.parent,sn=de,this.parent=void 0,this.deferStop&&this.stop()}}stop(){yn===this?this.deferStop=!0:this.active&&(kn(this),this.onStop&&this.onStop(),this.active=!1)}}function kn(x){let{deps:ne}=x;if(ne.length){for(let de=0;de<ne.length;de++)ne[de].delete(x);ne.length=0}}function Un(x,ne){x.effect&&(x=x.effect.fn);let de=new an(x);ne&&(A.extend(de,ne),ne.scope&&T(de,ne.scope)),(!ne||!ne.lazy)&&de.run();let H=de.run.bind(de);return H.effect=de,H}function mn(x){x.effect.stop()}let sn=!0,_n=[];function Rn(){_n.push(sn),sn=!1}function kr(){_n.push(sn),sn=!0}function Zr(){let x=_n.pop();sn=x===void 0?!0:x}function Ue(x,ne,de){if(sn&&yn){let H=st.get(x);H||st.set(x,H=new Map);let M=H.get(de);M||H.set(de,M=pn()),it(M,void 0)}}function it(x,ne){let de=!1;Y<=En?gt(x)||(x.n|=te,de=!B(x)):de=!x.has(yn),de&&(x.add(yn),yn.deps.push(x))}function vt(x,ne,de,H,M,J){let X=st.get(x);if(!X)return;let ue=[];if(ne==="clear")ue=[...X.values()];else if(de==="length"&&A.isArray(x))X.forEach((Mn,cn)=>{(cn==="length"||cn>=H)&&ue.push(Mn)});else switch(de!==void 0&&ue.push(X.get(de)),ne){case"add":A.isArray(x)?A.isIntegerKey(de)&&ue.push(X.get("length")):(ue.push(X.get(ln)),A.isMap(x)&&ue.push(X.get($n)));break;case"delete":A.isArray(x)||(ue.push(X.get(ln)),A.isMap(x)&&ue.push(X.get($n)));break;case"set":A.isMap(x)&&ue.push(X.get(ln));break}let tn=void 0;if(ue.length===1)ue[0]&&qt(ue[0]);else{let Mn=[];for(let cn of ue)cn&&Mn.push(...cn);qt(pn(Mn))}}function qt(x,ne){let de=A.isArray(x)?x:[...x];for(let H of de)H.computed&&nn(H,ne);for(let H of de)H.computed||nn(H,ne)}function nn(x,ne){(x!==yn||x.allowRecurse)&&(x.scheduler?x.scheduler():x.run())}let Qt=A.makeMap("__proto__,__v_isRef,__isVue"),ir=new Set(Object.getOwnPropertyNames(Symbol).filter(x=>x!=="arguments"&&x!=="caller").map(x=>Symbol[x]).filter(A.isSymbol)),lr=Hr(),Li=Hr(!1,!0),Di=Hr(!0),xn=Hr(!0,!0),wr=Ur();function Ur(){let x={};return["includes","indexOf","lastIndexOf"].forEach(ne=>{x[ne]=function(...de){let H=Ut(this);for(let J=0,X=this.length;J<X;J++)Ue(H,"get",J+"");let M=H[ne](...de);return M===-1||M===!1?H[ne](...de.map(Ut)):M}}),["push","pop","shift","unshift","splice"].forEach(ne=>{x[ne]=function(...de){Rn();let H=Ut(this)[ne].apply(this,de);return Zr(),H}}),x}function Hr(x=!1,ne=!1){return function(H,M,J){if(M==="__v_isReactive")return!x;if(M==="__v_isReadonly")return x;if(M==="__v_isShallow")return ne;if(M==="__v_raw"&&J===(x?ne?Cr:qn:ne?ui:Ai).get(H))return H;let X=A.isArray(H);if(!x&&X&&A.hasOwn(wr,M))return Reflect.get(wr,M,J);let ue=Reflect.get(H,M,J);return(A.isSymbol(M)?ir.has(M):Qt(M))||(x||Ue(H,"get",M),ne)?ue:In(ue)?X&&A.isIntegerKey(M)?ue:ue.value:A.isObject(ue)?x?$i(ue):ye(ue):ue}}let Zi=Oo(),Xi=Oo(!0);function Oo(x=!1){return function(de,H,M,J){let X=de[H];if(Bn(X)&&In(X)&&!In(M))return!1;if(!x&&!Bn(M)&&(No(M)||(M=Ut(M),X=Ut(X)),!A.isArray(de)&&In(X)&&!In(M)))return X.value=M,!0;let ue=A.isArray(de)&&A.isIntegerKey(H)?Number(H)<de.length:A.hasOwn(de,H),tn=Reflect.set(de,H,M,J);return de===Ut(J)&&(ue?A.hasChanged(M,X)&&vt(de,"set",H,M,X):vt(de,"add",H,M)),tn}}function To(x,ne){let de=A.hasOwn(x,ne),H=x[ne],M=Reflect.deleteProperty(x,ne);return M&&de&&vt(x,"delete",ne,void 0,H),M}function hr(x,ne){let de=Reflect.has(x,ne);return(!A.isSymbol(ne)||!ir.has(ne))&&Ue(x,"has",ne),de}function Cn(x){return Ue(x,"iterate",A.isArray(x)?"length":ln),Reflect.ownKeys(x)}let On={get:lr,set:Zi,deleteProperty:To,has:hr,ownKeys:Cn},ci={get:Di,set(x,ne){return!0},deleteProperty(x,ne){return!0}},Qi=A.extend({},On,{get:Li,set:Xi}),eo=A.extend({},ci,{get:xn}),go=x=>x,Si=x=>Reflect.getPrototypeOf(x);function cr(x,ne,de=!1,H=!1){x=x.__v_raw;let M=Ut(x),J=Ut(ne);de||(ne!==J&&Ue(M,"get",ne),Ue(M,"get",J));let{has:X}=Si(M),ue=H?go:de?Kt:di;if(X.call(M,ne))return ue(x.get(ne));if(X.call(M,J))return ue(x.get(J));x!==M&&x.get(ne)}function jr(x,ne=!1){let de=this.__v_raw,H=Ut(de),M=Ut(x);return ne||(x!==M&&Ue(H,"has",x),Ue(H,"has",M)),x===M?de.has(x):de.has(x)||de.has(M)}function Sr(x,ne=!1){return x=x.__v_raw,!ne&&Ue(Ut(x),"iterate",ln),Reflect.get(x,"size",x)}function gr(x){x=Ut(x);let ne=Ut(this);return Si(ne).has.call(ne,x)||(ne.add(x),vt(ne,"add",x,x)),this}function Po(x,ne){ne=Ut(ne);let de=Ut(this),{has:H,get:M}=Si(de),J=H.call(de,x);J||(x=Ut(x),J=H.call(de,x));let X=M.call(de,x);return de.set(x,ne),J?A.hasChanged(ne,X)&&vt(de,"set",x,ne,X):vt(de,"add",x,ne),this}function Io(x){let ne=Ut(this),{has:de,get:H}=Si(ne),M=de.call(ne,x);M||(x=Ut(x),M=de.call(ne,x));let J=H?H.call(ne,x):void 0,X=ne.delete(x);return M&&vt(ne,"delete",x,void 0,J),X}function po(){let x=Ut(this),ne=x.size!==0,de=void 0,H=x.clear();return ne&&vt(x,"clear",void 0,void 0,de),H}function Rr(x,ne){return function(H,M){let J=this,X=J.__v_raw,ue=Ut(X),tn=ne?go:x?Kt:di;return!x&&Ue(ue,"iterate",ln),X.forEach((Mn,cn)=>H.call(M,tn(Mn),tn(cn),J))}}function ur(x,ne,de){return function(...H){let M=this.__v_raw,J=Ut(M),X=A.isMap(J),ue=x==="entries"||x===Symbol.iterator&&X,tn=x==="keys"&&X,Mn=M[x](...H),cn=de?go:ne?Kt:di;return!ne&&Ue(J,"iterate",tn?$n:ln),{next(){let{value:ni,done:mr}=Mn.next();return mr?{value:ni,done:mr}:{value:ue?[cn(ni[0]),cn(ni[1])]:cn(ni),done:mr}},[Symbol.iterator](){return this}}}}function Ar(x){return function(...ne){return x==="delete"?!1:this}}function Xr(){let x={get(J){return cr(this,J)},get size(){return Sr(this)},has:jr,add:gr,set:Po,delete:Io,clear:po,forEach:Rr(!1,!1)},ne={get(J){return cr(this,J,!1,!0)},get size(){return Sr(this)},has:jr,add:gr,set:Po,delete:Io,clear:po,forEach:Rr(!1,!0)},de={get(J){return cr(this,J,!0)},get size(){return Sr(this,!0)},has(J){return jr.call(this,J,!0)},add:Ar("add"),set:Ar("set"),delete:Ar("delete"),clear:Ar("clear"),forEach:Rr(!0,!1)},H={get(J){return cr(this,J,!0,!0)},get size(){return Sr(this,!0)},has(J){return jr.call(this,J,!0)},add:Ar("add"),set:Ar("set"),delete:Ar("delete"),clear:Ar("clear"),forEach:Rr(!0,!0)};return["keys","values","entries",Symbol.iterator].forEach(J=>{x[J]=ur(J,!1,!1),de[J]=ur(J,!0,!1),ne[J]=ur(J,!1,!0),H[J]=ur(J,!0,!0)}),[x,de,ne,H]}let[zn,zr,to,Fi]=Xr();function xr(x,ne){let de=ne?x?Fi:to:x?zr:zn;return(H,M,J)=>M==="__v_isReactive"?!x:M==="__v_isReadonly"?x:M==="__v_raw"?H:Reflect.get(A.hasOwn(de,M)&&M in H?de:H,M,J)}let vo={get:xr(!1,!1)},mo={get:xr(!1,!0)},_o={get:xr(!0,!1)},Qr={get:xr(!0,!0)};function ei(x,ne,de){let H=Ut(de);if(H!==de&&ne.call(x,H)){let M=A.toRawType(x);console.warn(`Reactive ${M} contains both the raw and reactive versions of the same object${M==="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 Ai=new WeakMap,ui=new WeakMap,qn=new WeakMap,Cr=new WeakMap;function Vi(x){switch(x){case"Object":case"Array":return 1;case"Map":case"Set":case"WeakMap":case"WeakSet":return 2;default:return 0}}function Mt(x){return x.__v_skip||!Object.isExtensible(x)?0:Vi(A.toRawType(x))}function ye(x){return Bn(x)?x:Br(x,!1,On,vo,Ai)}function Ci(x){return Br(x,!1,Qi,mo,ui)}function $i(x){return Br(x,!0,ci,_o,qn)}function Wr(x){return Br(x,!0,eo,Qr,Cr)}function Br(x,ne,de,H,M){if(!A.isObject(x)||x.__v_raw&&!(ne&&x.__v_isReactive))return x;let J=M.get(x);if(J)return J;let X=Mt(x);if(X===0)return x;let ue=new Proxy(x,X===2?H:de);return M.set(x,ue),ue}function Hn(x){return Bn(x)?Hn(x.__v_raw):!!(x&&x.__v_isReactive)}function Bn(x){return!!(x&&x.__v_isReadonly)}function No(x){return!!(x&&x.__v_isShallow)}function Oi(x){return Hn(x)||Bn(x)}function Ut(x){let ne=x&&x.__v_raw;return ne?Ut(ne):x}function fi(x){return A.def(x,"__v_skip",!0),x}let di=x=>A.isObject(x)?ye(x):x,Kt=x=>A.isObject(x)?$i(x):x;function Wn(x){sn&&yn&&(x=Ut(x),it(x.dep||(x.dep=pn())))}function Or(x,ne){x=Ut(x),x.dep&&qt(x.dep)}function In(x){return!!(x&&x.__v_isRef===!0)}function Ti(x){return hi(x,!1)}function ko(x){return hi(x,!0)}function hi(x,ne){return In(x)?x:new no(x,ne)}class no{constructor(ne,de){this.__v_isShallow=de,this.dep=void 0,this.__v_isRef=!0,this._rawValue=de?ne:Ut(ne),this._value=de?ne:di(ne)}get value(){return Wn(this),this._value}set value(ne){ne=this.__v_isShallow?ne:Ut(ne),A.hasChanged(ne,this._rawValue)&&(this._rawValue=ne,this._value=this.__v_isShallow?ne:di(ne),Or(this,ne))}}function Qo(x){Or(x,void 0)}function Ui(x){return In(x)?x.value:x}let Kn={get:(x,ne,de)=>Ui(Reflect.get(x,ne,de)),set:(x,ne,de,H)=>{let M=x[ne];return In(M)&&!In(de)?(M.value=de,!0):Reflect.set(x,ne,de,H)}};function pr(x){return Hn(x)?x:new Proxy(x,Kn)}class Jn{constructor(ne){this.dep=void 0,this.__v_isRef=!0;let{get:de,set:H}=ne(()=>Wn(this),()=>Or(this));this._get=de,this._set=H}get value(){return this._get()}set value(ne){this._set(ne)}}function Mr(x){return new Jn(x)}function Tr(x){let ne=A.isArray(x)?new Array(x.length):{};for(let de in x)ne[de]=ti(x,de);return ne}class Hi{constructor(ne,de,H){this._object=ne,this._key=de,this._defaultValue=H,this.__v_isRef=!0}get value(){let ne=this._object[this._key];return ne===void 0?this._defaultValue:ne}set value(ne){this._object[this._key]=ne}}function ti(x,ne,de){let H=x[ne];return In(H)?H:new Hi(x,ne,de)}class vr{constructor(ne,de,H,M){this._setter=de,this.dep=void 0,this.__v_isRef=!0,this._dirty=!0,this.effect=new an(ne,()=>{this._dirty||(this._dirty=!0,Or(this))}),this.effect.computed=this,this.effect.active=this._cacheable=!M,this.__v_isReadonly=H}get value(){let ne=Ut(this);return Wn(ne),(ne._dirty||!ne._cacheable)&&(ne._dirty=!1,ne._value=ne.effect.run()),ne._value}set value(ne){this._setter(ne)}}function Gr(x,ne,de=!1){let H,M,J=A.isFunction(x);return J?(H=x,M=A.NOOP):(H=x.get,M=x.set),new vr(H,M,J||!M,de)}var Pi;let gi=Promise.resolve(),pi=[],Yr=!1,vi=x=>{pi.push(x),Yr||(Yr=!0,gi.then(ro))},ro=()=>{for(let x=0;x<pi.length;x++)pi[x]();pi.length=0,Yr=!1};class ji{constructor(ne){this.dep=void 0,this._dirty=!0,this.__v_isRef=!0,this[Pi]=!0;let de,H=!1,M=!1;this.effect=new an(ne,J=>{if(this.dep){if(J)de=this._value,H=!0;else if(!M){let X=H?de:this._value;M=!0,H=!1,vi(()=>{this.effect.active&&this._get()!==X&&Or(this),M=!1})}for(let X of this.dep)X.computed instanceof ji&&X.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 Wn(this),Ut(this)._get()}}Pi="__v_isReadonly";function io(x){return new ji(x)}return _.EffectScope=N,_.ITERATE_KEY=ln,_.ReactiveEffect=an,_.computed=Gr,_.customRef=Mr,_.deferredComputed=io,_.effect=Un,_.effectScope=f,_.enableTracking=kr,_.getCurrentScope=ze,_.isProxy=Oi,_.isReactive=Hn,_.isReadonly=Bn,_.isRef=In,_.isShallow=No,_.markRaw=fi,_.onScopeDispose=xt,_.pauseTracking=Rn,_.proxyRefs=pr,_.reactive=ye,_.readonly=$i,_.ref=Ti,_.resetTracking=Zr,_.shallowReactive=Ci,_.shallowReadonly=Wr,_.shallowRef=ko,_.stop=mn,_.toRaw=Ut,_.toRef=ti,_.toRefs=Tr,_.track=Ue,_.trigger=vt,_.triggerRef=Qo,_.unref=Ui,Object.defineProperty(_,"__esModule",{value:!0}),_}({},g);return l}function bp(g){var l=function(_){"use strict";let A=`
`,k=44,S=50,N=50,f=["%","%"],T="#007aff",ze="#f7f7f7",xt=/^([a-z-]+:)?\/\//i,pn=/^data:.*,.*/,B="WEB_INVOKE_APPSERVICE",gt="wxs://",vn="json://",Vn="wxsModules",st="renderjsModules",Y="onShow",te="onHide",En="onLaunch",yn="onError",ln="onThemeChange",$n="onKeyboardHeightChange",an="onPageNotFound",kn="onUnhandledRejection",Un="onLoad",mn="onReady",sn="onUnload",_n="onInit",Rn="onSaveExitState",kr="onResize",Zr="onBackPress",Ue="onPageScroll",it="onTabItemTap",vt="onReachBottom",qt="onPullDownRefresh",nn="onShareTimeline",Qt="onAddToFavorites",ir="onShareAppMessage",lr="onNavigationBarButtonTap",Li="onNavigationBarSearchInputClicked",Di="onNavigationBarSearchInputChanged",xn="onNavigationBarSearchInputConfirmed",wr="onNavigationBarSearchInputFocusChanged",Ur="onAppEnterForeground",Hr="onAppEnterBackground",Zi="onWxsInvokeCallMethod";function Xi(H){return!!H.appContext}function Oo(H){return H&&(Xi(H)?H.proxy:H)}function To(H){return H.nodeType===1}function hr(H){let{vnode:M}=H;if(To(M.el))return M.el;let{subTree:J}=H;if(J.shapeFlag&16){let X=J.children.find(ue=>ue.el&&To(ue.el));if(X)return X.el}return M.el}let Cn=0;function On(H,...M){let J=Date.now(),X=Cn?J-Cn:0;return Cn=J,`[${J}][${X}ms][${H}]\uFF1A${M.map(ue=>JSON.stringify(ue)).join(" ")}`}function ci(H){let M=Object.create(null);return J=>M[J]||(M[J]=H(J))}function Qi(H){return ci(H)}function eo(H=""){return(""+H).replace(/[^\x00-\xff]/g,"**").length}function go(H){return H.indexOf("/")===0}function Si(H){return go(H)?H:"/"+H}function cr(H){return go(H)?H.slice(1):H}let jr=(H,M)=>{let J;for(let X=0;X<H.length;X++)J=H[X](M);return J};function Sr(H,M=null){let J;return(...X)=>(H&&(J=H.apply(M,X),H=null),J)}function gr(H,M){H=H||{},_.isString(M)&&(M={errMsg:M}),/:ok$/.test(M.errMsg)?_.isFunction(H.success)&&H.success(M):_.isFunction(H.fail)&&H.fail(M),_.isFunction(H.complete)&&H.complete(M)}function Po(H){let M={};return _.isPlainObject(H)&&Object.keys(H).sort().forEach(J=>{let X=J;M[X]=H[X]}),Object.keys(M)?M:H}let Io=encodeURIComponent;function po(H,M=Io){let J=H?Object.keys(H).map(X=>{let ue=H[X];return typeof ue===void 0||ue===null?ue="":_.isPlainObject(ue)&&(ue=JSON.stringify(ue)),M(X)+"="+M(ue)}).filter(X=>X.length>0).join("&"):null;return J?`?${J}`:""}function Rr(H){try{return decodeURIComponent(""+H)}catch(M){}return""+H}let ur=/\+/g;function Ar(H){let M={};if(H===""||H==="?")return M;let X=(H[0]==="?"?H.slice(1):H).split("&");for(let ue=0;ue<X.length;++ue){let tn=X[ue].replace(ur," "),Mn=tn.indexOf("="),cn=Rr(Mn<0?tn:tn.slice(0,Mn)),ni=Mn<0?null:Rr(tn.slice(Mn+1));if(cn in M){let mr=M[cn];_.isArray(mr)||(mr=M[cn]=[mr]),mr.push(ni)}else M[cn]=ni}return M}function Xr(H){let[M,J]=H.split("?",2);return{path:M,query:Ar(J||"")}}function zn(H){let M={};return H&&Object.keys(H).forEach(J=>{J.indexOf("data-")===0&&(M[J.replace("data-","")]=H[J])}),M}class zr extends Error{constructor(M){super(M);this.name="DOMException"}}function to(H,M){return M&&(M.capture&&(H+="Capture"),M.once&&(H+="Once"),M.passive&&(H+="Passive")),`on${_.capitalize(_.camelize(H))}`}class Fi{constructor(M,J){this.defaultPrevented=!1,this.timeStamp=Date.now(),this._stop=!1,this._end=!1,this.type=M,this.bubbles=!!J.bubbles,this.cancelable=!!J.cancelable}preventDefault(){this.defaultPrevented=!0}stopImmediatePropagation(){this._end=this._stop=!0}stopPropagation(){this._stop=!0}}function xr(H){if(H instanceof Fi)return H;let[M]=_o(H.type),J=new Fi(M,{bubbles:!1,cancelable:!1});return _.extend(J,H),J}class vo{constructor(){this.listeners=Object.create(null)}dispatchEvent(M){let J=this.listeners[M.type];if(!J)return!1;let X=xr(M),ue=J.length;for(let tn=0;tn<ue&&(J[tn].call(this,X),!X._end);tn++);return X.cancelable&&X.defaultPrevented}addEventListener(M,J,X){M=to(M,X),(this.listeners[M]||(this.listeners[M]=[])).push(J)}removeEventListener(M,J,X){M=to(M,X);let ue=this.listeners[M];if(!ue)return;let tn=ue.indexOf(J);tn>-1&&ue.splice(tn,1)}}let mo=/(?:Once|Passive|Capture)$/;function _o(H){let M;if(mo.test(H)){M={};let J;for(;J=H.match(mo);)H=H.slice(0,H.length-J[0].length),M[J[0].toLowerCase()]=!0}return[_.hyphenate(H.slice(2)),M]}let Qr=(()=>({stop:1,prevent:1<<1,self:1<<2}))();function ei(H){let M=0;return H.includes("stop")&&(M|=Qr.stop),H.includes("prevent")&&(M|=Qr.prevent),H.includes("self")&&(M|=Qr.self),M}let Ai=0,ui=1,qn=3,Cr=8;function Vi(H,M){let{parentNode:J}=H;if(!J)return null;let{childNodes:X}=J;return X[X.indexOf(H)+(M==="n"?1:-1)]||null}function Mt(H){let{parentNode:M}=H;M&&M.removeChild(H)}function ye(H){!H.nodeId&&H.pageNode&&(H.nodeId=H.pageNode.genId())}class Ci extends vo{constructor(M,J,X){super();if(this.pageNode=null,this.parentNode=null,this._text=null,X){let{pageNode:ue}=X;ue&&(this.pageNode=ue,this.nodeId=ue.genId(),!ue.isUnmounted&&ue.onCreate(this,J))}this.nodeType=M,this.nodeName=J,this.childNodes=[]}get firstChild(){return this.childNodes[0]||null}get lastChild(){let{childNodes:M}=this,J=M.length;return J?M[J-1]:null}get nextSibling(){return Vi(this,"n")}get nodeValue(){return null}set nodeValue(M){}get textContent(){return this._text||""}set textContent(M){this._text=M,this.pageNode&&!this.pageNode.isUnmounted&&this.pageNode.onTextContent(this,M)}get parentElement(){let{parentNode:M}=this;return M&&M.nodeType===ui?M:null}get previousSibling(){return Vi(this,"p")}appendChild(M){return this.insertBefore(M,null)}cloneNode(M){let J=_.extend(Object.create(Object.getPrototypeOf(this)),this),{attributes:X}=J;return X&&(J.attributes=_.extend({},X)),M&&(J.childNodes=J.childNodes.map(ue=>ue.cloneNode(!0))),J}insertBefore(M,J){Mt(M),M.pageNode=this.pageNode,M.parentNode=this,ye(M);let{childNodes:X}=this;if(J){let ue=X.indexOf(J);if(ue===-1)throw new zr("Failed to execute 'insertBefore' on 'Node': The node before which the new node is to be inserted is not a child of this node.");X.splice(ue,0,M)}else X.push(M);return this.pageNode&&!this.pageNode.isUnmounted?this.pageNode.onInsertBefore(this,M,J):M}removeChild(M){let{childNodes:J}=this,X=J.indexOf(M);if(X===-1)throw new zr("Failed to execute 'removeChild' on 'Node': The node to be removed is not a child of this node.");return M.parentNode=null,J.splice(X,1),this.pageNode&&!this.pageNode.isUnmounted?this.pageNode.onRemoveChild(M):M}}let $i="class",Wr="style",Br=".vOwnerId",Hn=".vRenderjs";class Bn extends Ci{constructor(M,J,X){super(M,J,X);this.attributes=Object.create(null),this.style=null,this.vShow=null,this._html=null}get className(){return this.attributes[$i]||""}set className(M){this.setAttribute($i,M)}get innerHTML(){return""}set innerHTML(M){this._html=M}addEventListener(M,J,X){super.addEventListener(M,J,X),this.pageNode&&!this.pageNode.isUnmounted&&(J.wxsEvent?this.pageNode.onAddWxsEvent(this,to(M,X),J.wxsEvent,ei(J.modifiers||[])):this.pageNode.onAddEvent(this,to(M,X),ei(J.modifiers||[])))}removeEventListener(M,J,X){super.removeEventListener(M,J,X),this.pageNode&&!this.pageNode.isUnmounted&&this.pageNode.onRemoveEvent(this,to(M,X))}getAttribute(M){return M===Wr?this.style:this.attributes[M]}removeAttribute(M){M==Wr?this.style=null:delete this.attributes[M],this.pageNode&&!this.pageNode.isUnmounted&&this.pageNode.onRemoveAttribute(this,M)}setAttribute(M,J){M===Wr?this.style=J:this.attributes[M]=J,this.pageNode&&!this.pageNode.isUnmounted&&this.pageNode.onSetAttribute(this,M,J)}toJSON({attr:M,normalize:J}={}){let{attributes:X,style:ue,listeners:tn,_text:Mn}=this,cn={};Object.keys(X).length&&(cn.a=J?J(X):X);let ni=Object.keys(tn);if(ni.length){let mr,ea={};ni.forEach(zo=>{let ta=tn[zo];if(ta.length){let{wxsEvent:Ro,modifiers:bo}=ta[0],oo=ei(bo||[]);Ro?(mr||(mr={}),mr[zo]=[J?J(Ro):Ro,oo]):ea[zo]=oo}}),cn.e=J?J(ea,!1):ea,mr&&(cn.w=J?J(mr,!1):mr)}return ue!==null&&(cn.s=J?J(ue):ue),M||(cn.i=this.nodeId,cn.n=this.nodeName),Mn!==null&&(cn.t=J?J(Mn):Mn),cn}}class No extends Ci{constructor(M,J){super(Cr,"#comment",J);this._text=""}toJSON(M={}){return M.attr?{}:{i:this.nodeId}}}class Oi extends Bn{constructor(M,J){super(ui,M.toUpperCase(),J);this.tagName=this.nodeName}}class Ut extends Oi{get value(){return this.getAttribute("value")}set value(M){this.setAttribute("value",M)}}class fi extends Ut{}class di extends Bn{constructor(M,J){super(qn,"#text",J);this._text=M}get nodeValue(){return this._text||""}set nodeValue(M){this._text=M,this.pageNode&&!this.pageNode.isUnmounted&&this.pageNode.onNodeValue(this,M)}}let Kt={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"]},Wn=["animation"],Or=(H,M)=>{if(Wn.indexOf(M)>-1)return!0;let J=Kt[H.nodeName];return!!(J&&J.indexOf(M)>-1)},In=1,Ti=2,ko=3,hi=4,no=5,Qo=6,Ui=7,Kn=8,pr=9,Jn=10,Mr=12,Tr=15,Hi=20;function ti(H,M,{clearTimeout:J,setTimeout:X}){let ue,tn=function(){J(ue),ue=X(()=>H.apply(this,arguments),M)};return tn.cancel=function(){J(ue)},tn}class vr{constructor(M,J){this.id=M,this.listener={},this.emitCache={},J&&Object.keys(J).forEach(X=>{this.on(X,J[X])})}emit(M,...J){let X=this.listener[M];if(!X)return(this.emitCache[M]||(this.emitCache[M]=[])).push(J);X.forEach(ue=>{ue.fn.apply(ue.fn,J)}),this.listener[M]=X.filter(ue=>ue.type!=="once")}on(M,J){this._addListener(M,"on",J),this._clearCache(M)}once(M,J){this._addListener(M,"once",J),this._clearCache(M)}off(M,J){let X=this.listener[M];if(!!X)if(J)for(let ue=0;ue<X.length;)X[ue].fn===J&&(X.splice(ue,1),ue--),ue++;else delete this.listener[M]}_clearCache(M){let J=this.emitCache[M];if(J)for(;J.length>0;)this.emit.apply(this,[M,...J.shift()])}_addListener(M,J,X){(this.listener[M]||(this.listener[M]=[])).push({fn:X,type:J})}}let Gr=[_n,Un,Y,te,sn,Zr,Ue,it,vt,qt,nn,ir,Qt,Rn,lr,Li,Di,xn,wr],Pi=[Un,Y];function gi(H){return Pi.indexOf(H)>-1}function pi(H){return Gr.indexOf(H)>-1}let Yr=[Y,te,En,yn,ln,an,kn,_n,Un,mn,sn,kr,Zr,Ue,it,vt,qt,nn,Qt,ir,Rn,lr,Li,Di,xn,wr],vi,ro=[];function ji(H){if(vi)return H(vi);ro.push(H)}function io(H){vi=H,ro.forEach(M=>M(H))}let x=function(){};x.prototype={on:function(H,M,J){var X=this.e||(this.e={});return(X[H]||(X[H]=[])).push({fn:M,ctx:J}),this},once:function(H,M,J){var X=this;function ue(){X.off(H,ue),M.apply(J,arguments)}return ue._=M,this.on(H,ue,J)},emit:function(H){var M=[].slice.call(arguments,1),J=((this.e||(this.e={}))[H]||[]).slice(),X=0,ue=J.length;for(X;X<ue;X++)J[X].fn.apply(J[X].ctx,M);return this},off:function(H,M){var J=this.e||(this.e={}),X=J[H],ue=[];if(X&&M)for(var tn=0,Mn=X.length;tn<Mn;tn++)X[tn].fn!==M&&X[tn].fn._!==M&&ue.push(X[tn]);return ue.length?J[H]=ue:delete J[H],this}};var ne=x,de={invokeArrayFns:jr,ON_LOAD:Un,ON_SHOW:Y,LINEFEED:A,RENDERJS_MODULES:st,WXS_PROTOCOL:gt,formatLog:On,WXS_MODULES:Vn,ON_ERROR:yn,UniLifecycleHooks:Yr,invokeCreateVueAppHook:io,parseNVueDataset:zn,once:Sr,I18N_JSON_DELIMITERS:f,Emitter:ne,addLeadingSlash:Si,resolveComponentInstance:Oo,removeLeadingSlash:cr,ON_RESIZE:kr,ON_APP_ENTER_FOREGROUND:Ur,ON_APP_ENTER_BACKGROUND:Hr,ON_HIDE:te,ON_PAGE_SCROLL:Ue,ON_REACH_BOTTOM:vt,SCHEME_RE:xt,DATA_RE:pn,cacheStringFunction:Qi,parseQuery:Ar,callOptions:gr,ON_UNHANDLE_REJECTION:kn,ON_PAGE_NOT_FOUND:an,PRIMARY_COLOR:T,getLen:eo,TABBAR_HEIGHT:S,NAVBAR_HEIGHT:k,sortObject:Po,ON_THEME_CHANGE:ln,ON_KEYBOARD_HEIGHT_CHANGE:$n,BACKGROUND_COLOR:ze,ON_NAVIGATION_BAR_BUTTON_TAP:lr,stringifyQuery:po,debounce:ti,ON_PULL_DOWN_REFRESH:qt,ON_NAVIGATION_BAR_SEARCH_INPUT_CHANGED:Di,ON_NAVIGATION_BAR_SEARCH_INPUT_CONFIRMED:xn,ON_NAVIGATION_BAR_SEARCH_INPUT_CLICKED:Li,ON_NAVIGATION_BAR_SEARCH_INPUT_FOCUS_CHANGED:wr,ON_BACK_PRESS:Zr,UniNode:Ci,NODE_TYPE_PAGE:Ai,ACTION_TYPE_PAGE_CREATE:In,ACTION_TYPE_PAGE_CREATED:Ti,ACTION_TYPE_PAGE_SCROLL:Tr,ACTION_TYPE_INSERT:hi,ACTION_TYPE_CREATE:ko,ACTION_TYPE_REMOVE:no,ACTION_TYPE_ADD_EVENT:Kn,ACTION_TYPE_ADD_WXS_EVENT:Mr,ACTION_TYPE_REMOVE_EVENT:pr,ACTION_TYPE_SET_ATTRIBUTE:Qo,ACTION_TYPE_REMOVE_ATTRIBUTE:Ui,ACTION_TYPE_SET_TEXT:Jn,ON_READY:mn,ON_UNLOAD:sn,EventChannel:vr,ON_REACH_BOTTOM_DISTANCE:N,parseUrl:Xr,onCreateVueApp:ji,ON_TAB_ITEM_TAP:it,ON_LAUNCH:En,ACTION_TYPE_EVENT:Hi,createUniEvent:xr,ON_WXS_INVOKE_CALL_METHOD:Zi,WEB_INVOKE_APPSERVICE:B,isRootHook:pi,isRootImmediateHook:gi,UniInputElement:Ut,UniTextAreaElement:fi,UniElement:Oi,UniTextNode:di,UniCommentNode:No,forcePatchProp:Or,resolveOwnerEl:hr,ATTR_V_OWNER_ID:Br,ATTR_V_RENDERJS:Hn,JSON_PROTOCOL:vn};return de}(g);return l}var p1=1;function Ep(){return(p1++).toString()}var of=g=>g&&JSON.parse(JSON.stringify(g))||g;function gc(g){let l=Xa(g);return l.substring(8,l.length-1)}function af(g){if(!Fn(btoa))return"";let l=Array.prototype.map.call(new Uint8Array(g),_=>String.fromCharCode(_)).join("");return btoa(l)}function pc(g){if(!g||typeof g!="object")return!0;for(let l in g)if(Xs(g,l))return!1;return!0}var iu=["off","error","warn","info","log","debug"],ou={};function yp(){iu.forEach(g=>{let l=iu.indexOf(g);ou[g]={},iu.forEach(_=>{iu.indexOf(_)<=l&&(ou[g][_]=!0)})})}function Yn(g){let l=global.WXEnvironment&&global.WXEnvironment.logLevel||"log";return ou[l]&&ou[l][g]}function Mi(g){global.nativeLog("wxInteractionAnalyzer: [jsfm]"+g,"__DEBUG")}function wp(g,l,_){return`${l}@${_}#${g}`}var au=class{constructor(l){this.instanceId=String(l),this.lastCallbackId=0,this.callbacks={},this.hooks={}}add(l){return this.lastCallbackId++,this.callbacks[this.lastCallbackId]=l,this.lastCallbackId}remove(l){let _=this.callbacks[l];return delete this.callbacks[l],_}registerHook(l,_,A,k){let S=wp(l,_,A);this.hooks[S]&&console.warn(`[JS Framework] Override an existing component hook "${S}".`),this.hooks[S]=k}triggerHook(l,_,A,k){let S=wp(l,_,A),N=this.hooks[S];if(!Fn(N))return console.error(`[JS Framework] Invalid hook function type (${typeof N}) on "${S}".`),null;let f=null;try{f=N.apply(null,k||[])}catch(T){throw console.error(`[JS Framework] Failed to execute the hook function on "${S}".`),T}return f}consume(l,_,A){let k=this.callbacks[l];if((typeof A=="undefined"||A===!1)&&delete this.callbacks[l],Fn(k))try{return k.call(null,_,A)}catch(S){throw console.error(`[JS Framework] Failed to execute the callback function:
 ${S.toString()}`),S}return new Error(`invalid callback id "${l}"`)}close(){this.callbacks={},this.hooks={}}};var su={};function Sp(g,l){g&&(su[g]=l)}function Qa(g){return su[g]}function Ap(g){delete su[g]}function Nr(g){if(g){let l=su[g];if(l&&l.taskCenter)return l.taskCenter}return null}function v1(g){g.calcClassList&&g.calcClassList()}function sf(g,l,_){let{documentElement:A}=g;if(A.pureChildren.length>0||l.parentNode)return;let k=A.children,S=_?k.indexOf(_):-1;S<0?k.push(l):k.splice(S,0,l),l.nodeType===1?(l.role==="body"?(l.docId=g.id,l.ownerDocument=g,l.parentNode=A,Qs(l,A)):(l.children.forEach(N=>{N.parentNode=l}),lf(g,l),Qs(l,A),delete g.nodeMap[l.nodeId]),A.pureChildren.push(l),m1(g,l)):(l.parentNode=A,g.nodeMap[l.ref]=l)}function m1(g,l){let _=l.toJSON();g&&g.taskCenter&&Fn(g.taskCenter.send)&&g.taskCenter.send("dom",{action:"createBody"},[_])}function lf(g,l){l.role="body",l.depth=1,delete g.nodeMap[l.nodeId],l.ref="_root",g.nodeMap._root=l,g.body=l}function Qs(g,l){g.parentNode=l,v1(g),l.docId&&(g.docId=l.docId,g.ownerDocument=l.ownerDocument,g.ownerDocument.nodeMap[g.nodeId]=g,g.depth=l.depth+1),g.children.forEach(_=>{Qs(_,g)})}function cf(g){for(;g;){if(g.nodeType===1)return g;g=g.nextSibling}}function uf(g){for(;g;){if(g.nodeType===1)return g;g=g.previousSibling}}function el(g,l,_,A=!1){_<0&&(_=0);let k=l[_-1],S=l[_];return l.splice(_,0,g),A&&(k&&(k.nextSibling=g),g.previousSibling=k,g.nextSibling=S,S&&(S.previousSibling=g)),_}function tl(g,l,_,A=!1){let k=l.indexOf(g);if(k<0)return-1;if(A){let T=l[k-1],ze=l[k+1];T&&(T.nextSibling=ze),ze&&(ze.previousSibling=T)}l.splice(k,1);let S=_;k<=_&&(S=_-1);let N=l[S-1],f=l[S];return l.splice(S,0,g),A&&(N&&(N.nextSibling=g),g.previousSibling=N,g.nextSibling=f,f&&(f.previousSibling=g)),k===S?-1:_}function ff(g,l,_=!1){let A=l.indexOf(g);if(!(A<0)){if(_){let k=l[A-1],S=l[A+1];k&&(k.nextSibling=S),S&&(S.previousSibling=k)}l.splice(A,1)}}var nl=class{constructor(){this.depth=0;this.nodeId=Ep(),this.ref=this.nodeId,this.children=[],this.pureChildren=[],this.parentNode=null,this.nextSibling=null,this.previousSibling=null}destroy(){let l=Qa(this.docId);l&&(delete this.docId,delete l.nodeMap[this.nodeId]),this.children.forEach(_=>{_.destroy()})}};var Cp={};function df(g,l){if(!yi(l)||!l.length)return;class _ extends Ji{}l.forEach(A=>{_.prototype[A]=function(...k){let S=Nr(this.docId);if(S)return S.send("component",{ref:this.ref,component:g,method:A},k)}}),Cp[g]=_}function Op(g){return Cp[g]}function yr(g,l,_,A,k){return{type:"decl",prop:g,value:l+(_?" !important":""),raws:A,source:k}}var _1="backgroundColor",b1="backgroundImage",E1=g=>{let{value:l,important:_,raws:A,source:k}=g;return/^#?\S+$/.test(l)||/^rgba?(.+)$/.test(l)?[yr(_1,l,_,A,k)]:/^linear-gradient(.+)$/.test(l)?[yr(b1,l,_,A,k)]:[g]},y1="Width",w1="Style",S1="Color",vc=g=>{let{prop:l,value:_,important:A,raws:k,source:S}=g,N=_.replace(/\s*,\s*/g,",").split(/\s+/),f=[/^[\d\.]+\S*$/,/^(solid|dashed|dotted)$/,/\S+/].map(T=>{let ze=N.findIndex(xt=>T.test(xt));return ze<0?null:N.splice(ze,1)[0]});return N.length?[g]:[yr(l+y1,(f[0]||"0").trim(),A,k,S),yr(l+w1,(f[1]||"solid").trim(),A,k,S),yr(l+S1,(f[2]||"#000000").trim(),A,k,S)]},A1="borderTop",C1="borderRight",O1="borderBottom",T1="borderLeft",hf=g=>{let{prop:l,value:_,important:A,raws:k,source:S}=g,N=rf(l).split("-")[1];N=ru(N);let f=_.replace(/\s*,\s*/g,",").split(/\s+/);switch(f.length){case 1:return[g];case 2:f.push(f[0],f[1]);break;case 3:f.push(f[1]);break}return[yr(A1+N,f[0],A,k,S),yr(C1+N,f[1],A,k,S),yr(O1+N,f[2],A,k,S),yr(T1+N,f[3],A,k,S)]},P1="borderTopLeftRadius",I1="borderTopRightRadius",N1="borderBottomRightRadius",k1="borderBottomLeftRadius",R1=g=>{let{value:l,important:_,raws:A,source:k}=g,S=l.split(/\s+/);if(l.includes("/"))return[g];switch(S.length){case 1:return[g];case 2:S.push(S[0],S[1]);break;case 3:S.push(S[1]);break}return[yr(P1,S[0],_,A,k),yr(I1,S[1],_,A,k),yr(N1,S[2],_,A,k),yr(k1,S[3],_,A,k)]},x1=hf,B1=hf,M1="flexDirection",L1="flexWrap",D1=g=>{let{value:l,important:_,raws:A,source:k}=g,S=l.split(/\s+/),N=[/^(column|column-reverse|row|row-reverse)$/,/^(nowrap|wrap|wrap-reverse)$/].map(f=>{let T=S.findIndex(ze=>f.test(ze));return T<0?null:S.splice(T,1)[0]});return S.length?[g]:[yr(M1,N[0]||"column",_,A,k),yr(L1,N[1]||"nowrap",_,A,k)]},F1="Top",V1="Right",$1="Bottom",U1="Left",Tp=g=>l=>{let{value:_,important:A,raws:k,source:S}=l,N=_.split(/\s+/);switch(N.length){case 1:N.push(N[0],N[0],N[0]);break;case 2:N.push(N[0],N[1]);break;case 3:N.push(N[1]);break}return[yr(g+F1,N[0],A,k,S),yr(g+V1,N[1],A,k,S),yr(g+$1,N[2],A,k,S),yr(g+U1,N[3],A,k,S)]},H1=Tp("margin"),j1=Tp("padding"),z1="transitionProperty",W1="transitionDuration",G1="transitionTimingFunction",Y1="transitionDelay",q1=g=>{let l=/^(\S*)?\s*(\d*\.?\d+(?:ms|s)?)?\s*(\S*)?\s*(\d*\.?\d+(?:ms|s)?)?$/,{value:_,important:A,raws:k,source:S}=g,N=[],f=_.match(l);return f&&(f[1]&&N.push(yr(z1,f[1],A,k,S)),f[2]&&N.push(yr(W1,f[2],A,k,S)),f[3]&&N.push(yr(G1,f[3],A,k,S)),f[4]&&N.push(yr(Y1,f[4],A,k,S))),N},Pp={transition:q1,margin:H1,padding:j1,border:vc,background:E1};Jr(Pp,{borderTop:vc,borderRight:vc,borderBottom:vc,borderLeft:vc,borderStyle:x1,borderWidth:B1,borderColor:hf,borderRadius:R1,flexFlow:D1});var Ip=Symbol("expanded"),Np={postcssPlugin:"nvue:expand",Declaration(g){if(g[Ip])return;let l=Pp[g.prop];if(l){let _=l(g);_.length===1&&_[0]===g||g.replaceWith(_)}g[Ip]=!0}};var K1=Np.Declaration;function gf(g,l){let _=Jr({replaceWith(k){A=k}},J1(g,l)),A=[_];return K1(_),A}function J1(g,l){let _=l+"";return _.includes("!important")?{prop:g,value:_.replace(/\s*!important/,""),important:!0}:{prop:g,value:_,important:!1}}var Z1="view",X1=["click","longpress","touchstart","touchmove","touchend","panstart","panmove","panend","horizontalpan","verticalpan","swipe"];function pf(g,l){let _=Qa(g);_.nodeMap[l.nodeId]=l}var vf;function kp(g){vf||(vf=g)}var Ji=class extends nl{constructor(l=Z1,_={},A){super();let k=Op(l);if(k&&!A)return new k(l,_,!0);this.nodeType=1,this.type=l,this.attr=_.attr||{},this.style=_.style||{},this.classStyle=_.classStyle||{},this.classList=_.classList||[],this.styleSheet=_.styleSheet||{},this.event={}}appendChild(l){if(!(l.parentNode&&l.parentNode!==this)){if(l.parentNode){if(Yn("debug")&&Mi(`[appendChild](${this.docId},${l.type},${l.ref}) Move <${l.type}> to ${this.children.length} of <${this.type}> (${this.ref}).`),tl(l,this.children,this.children.length,!0),l.nodeType===1){let _=tl(l,this.pureChildren,this.pureChildren.length),A=Nr(this.docId);if(A&&_>=0)return A.send("dom",{action:"moveElement"},[l.ref,this.ref,_])}}else if(Yn("debug")&&Mi(`[appendChild](${this.docId},${l.type},${l.ref}) Append <${l.type}> to <${this.type}> (${this.ref}).`),Qs(l,this),el(l,this.children,this.children.length,!0),this.docId&&pf(this.docId,l),l.nodeType===1){el(l,this.pureChildren,this.pureChildren.length);let _=Nr(this.docId);if(_)return _.send("dom",{action:"addElement"},[this.ref,l.toJSON(),-1])}}}insertBefore(l,_){if(!(l.parentNode&&l.parentNode!==this)&&!(l===_||l.nextSibling&&l.nextSibling===_)){if(l.parentNode){if(tl(l,this.children,this.children.indexOf(_),!0),l.nodeType===1){let A=cf(_),k=tl(l,this.pureChildren,A?this.pureChildren.indexOf(A):this.pureChildren.length),S=Nr(this.docId);if(S&&k>=0)return S.send("dom",{action:"moveElement"},[l.ref,this.ref,k])}}else if(Yn("debug")&&Mi(`[insertBefore](${this.docId},${l.type},${l.ref}) Insert <${l.type}> to <${this.type}> (${this.ref}), before (${_.ref}).`),Qs(l,this),el(l,this.children,this.children.indexOf(_),!0),this.docId&&pf(this.docId,l),l.nodeType===1){let A=cf(_),k=el(l,this.pureChildren,A?this.pureChildren.indexOf(A):this.pureChildren.length),S=Nr(this.docId);if(S)return S.send("dom",{action:"addElement"},[this.ref,l.toJSON(),k])}}}insertAfter(l,_){if(!(l.parentNode&&l.parentNode!==this)&&!(l===_||l.previousSibling&&l.previousSibling===_)){if(l.parentNode){if(tl(l,this.children,this.children.indexOf(_)+1,!0),l.nodeType===1){let A=tl(l,this.pureChildren,this.pureChildren.indexOf(uf(_))+1),k=Nr(this.docId);if(k&&A>=0)return k.send("dom",{action:"moveElement"},[l.ref,this.ref,A])}}else if(Yn("debug")&&Mi(`[insertAfter](${this.docId},${l.type},${l.ref}) Insert <${l.type}> to <${this.type}> (${this.ref}), after (${_.ref}).`),Qs(l,this),el(l,this.children,this.children.indexOf(_)+1,!0),this.docId&&pf(this.docId,l),l.nodeType===1){let A=el(l,this.pureChildren,this.pureChildren.indexOf(uf(_))+1),k=Nr(this.docId);if(k)return k.send("dom",{action:"addElement"},[this.ref,l.toJSON(),A])}}}removeChild(l,_){if(l.parentNode&&(ff(l,this.children,!0),l.nodeType===1)){Yn("debug")&&Mi(`[removeChild](${this.docId},${l.type},${l.ref}) Remove <${l.type}> from <${this.type}> (${this.ref}).`),ff(l,this.pureChildren);let A=Nr(this.docId);A&&A.send("dom",{action:"removeElement"},[l.ref])}_||l.destroy()}clear(){let l=Nr(this.docId);l&&this.pureChildren.forEach(_=>{l.send("dom",{action:"removeElement"},[_.ref])}),this.children.forEach(_=>{_.destroy()}),this.children.length=0,this.pureChildren.length=0}setAttr(l,_,A){if(this.attr[l]===_&&A!==!1)return;this.attr[l]=_;let k=Nr(this.docId);!A&&k&&k.send("dom",{action:"updateAttrs"},[this.ref,{[l]:_}])}setAttrs(l,_){if(pc(l))return;let A={};for(let k in l)this.attr[k]!==l[k]&&(this.attr[k]=l[k],A[k]=l[k]);if(!pc(A)){let k=Nr(this.docId);!_&&k&&k.send("dom",{action:"updateAttrs"},[this.ref,A])}}setStyle(l,_,A){gf(l,_).forEach(({prop:k,value:S})=>{if(this.style[k]===S&&A!==!1)return;this.style[k]=S;let N=Nr(this.docId);!A&&N&&N.send("dom",{action:"updateStyle"},[this.ref,{[k]:S}])})}setStyles(l,_){if(pc(l))return;let A={};for(let k in l)gf(k,l[k]).forEach(({prop:S,value:N})=>{this.style[S]!==N&&(this.style[S]=N,A[S]=N)});if(!pc(A)){let k=Nr(this.docId);!_&&k&&k.send("dom",{action:"updateStyle"},[this.ref,A])}}setClassStyle(l){for(let A in this.classStyle)this.classStyle[A]="";Jr(this.classStyle,l);let _=Nr(this.docId);_&&_.send("dom",{action:"updateStyle"},[this.ref,this.toStyle()])}setClassList(l){l.length===this.classList.length&&l.filter(_=>!this.classList.includes(_)).length===0||(this.classList=l,this.parentNode&&this.calcClassList())}calcClassList(){this.setClassStyle(vf(this))}setStyleSheet(l){this.styleSheet=l}addEvent(l,_,A){if(this.event||(this.event={}),!this.event[l]){Yn("debug")&&Mi(`[addEvent](${this.docId},${this.type},${this.ref}) Add "${l}" event on <${this.type}> (${this.ref}).`),this.event[l]={handler:_,params:A};let k=Nr(this.docId);k&&k.send("dom",{action:"addEvent"},[this.ref,l])}}removeEvent(l){if(this.event&&this.event[l]){Yn("debug")&&Mi(`[removeEvent](${this.docId},${this.type},${this.ref}) Remove "${l}" event on <${this.type}> (${this.ref}).`),delete this.event[l];let _=Nr(this.docId);_&&_.send("dom",{action:"removeEvent"},[this.ref,l])}}fireEvent(l,_,A,k){let S=null,N=!1,f=this.event[l];if(f&&_){Yn("debug")&&Mi(`[fireEvent](${this.docId},${this.type},${this.ref}) Fire "${l}" event on <${this.type}> (${this.ref}).`);let T=f.handler;_.stopPropagation=()=>{N=!0},_.preventDefault=()=>{};try{k&&k.params?S=T.call(this,...k.params,_):S=T.call(this,_)}catch(ze){throw console.error(`[JS Framework] Failed to invoke the event handler of "${l}" on ${this.type} (${this.ref}):
 ${ze.toString()}`),ze}}return!N&&A&&X1.indexOf(l)!==-1&&this.parentNode&&this.parentNode.fireEvent&&(_.currentTarget=this.parentNode,this.parentNode.fireEvent(l,_,A)),S}toStyle(){return Jr({},this.classStyle,this.style)}toJSON(l=!1){let _={ref:this.ref.toString(),type:this.type,attr:this.attr,style:this.toStyle()},A=[];for(let k in this.event){let{params:S}=this.event[k];S?A.push({type:k,params:S}):A.push(k)}return A.length&&(_.event=A),!l&&this.pureChildren.length&&(_.children=this.pureChildren.map(k=>k.toJSON())),_}toString(){return"<"+this.type+" attr="+JSON.stringify(this.attr)+" style="+JSON.stringify(this.toStyle())+">"+this.pureChildren.map(l=>l.toString()).join("")+"</"+this.type+">"}};function Rp(g){let l=g&&g.__v_raw;return l?Rp(l):g}function xp(g){let l=gc(g);switch(l){case"Undefined":case"Null":return"";case"RegExp":return g.toString();case"Date":return g.toISOString();case"Number":case"String":case"Boolean":case"Array":case"Object":return Rp(g);case"ArrayBuffer":return{"@type":"binary",dataType:l,base64:af(g)};case"Int8Array":case"Uint8Array":case"Uint8ClampedArray":case"Int16Array":case"Uint16Array":case"Int32Array":case"Uint32Array":case"Float32Array":case"Float64Array":return{"@type":"binary",dataType:l,base64:af(g.buffer)};default:return JSON.stringify(g)}}var lu=function(){},Hl=class{constructor(l,_){Object.defineProperty(this,"instanceId",{enumerable:!0,value:String(l)}),Object.defineProperty(this,"callbackManager",{enumerable:!0,value:new au(l)}),lu=_||function(){}}callback(l,_,A){return this.callbackManager.consume(l,_,A)}registerHook(l,_,A,k){return this.callbackManager.registerHook(l,_,A,k)}triggerHook(l,_,A,k){return this.callbackManager.triggerHook(l,_,A,k)}updateData(l,_,A){this.send("module",{module:"dom",method:"updateComponentData"},[l,_,A])}destroyCallback(){return this.callbackManager.close()}normalize(l,_=!1){let A=gc(l);if(l&&l instanceof Ji)return l.ref;if(l&&l.$el instanceof Ji)return l.$el.ref;if(A==="Function")return this.callbackManager.add(l).toString();if(_){if(A==="Object"){let k={};for(let S in l)k[S]=this.normalize(l[S],!0);return k}if(A==="Array")return l.map(k=>this.normalize(k,!0))}return l&&l.ref&&l["[[VirtualElement]]"]?l.ref:xp(l)}send(l,_,A,k){let{action:S,component:N,ref:f,module:T,method:ze}=_;switch(A=A.map(xt=>this.normalize(xt,l!=="module")),gc(k)==="Object"&&(k=this.normalize(k,!0)),l){case"dom":return Yn("debug")&&Mi(`[task](${this.instanceId},${l},${S}) ${JSON.stringify(A)}`),this[S](this.instanceId,A);case"component":return this.componentHandler(this.instanceId,f,ze,A,Jr({component:N},k));default:return Yn("debug")&&Mi(`[task](${this.instanceId},${T},${ze}) ${JSON.stringify(A)}`),this.moduleHandler(this.instanceId,T,ze,A,k)}}callDOM(l,_){return this[l](this.instanceId,_)}callComponent(l,_,A,k){return this.componentHandler(this.instanceId,l,_,A,k)}callModule(l,_,A,k){return this.moduleHandler(this.instanceId,l,_,A,k)}};function Bp(){let g={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},l=Hl.prototype;for(let _ in g){let A=g[_];l[_]=A?(k,S)=>A(k,...S):(k,S)=>lu(k,[{module:"dom",method:_,args:S}],"-1")}l.componentHandler=global.callNativeComponent||((_,A,k,S,N)=>lu(_,[{component:N.component,ref:A,method:k,args:S}])),l.moduleHandler=global.callNativeModule||((_,A,k,S)=>lu(_,[{module:A,method:k,args:S}]))}function Q1(g,l,_,A,k,S){let N=g.getRef(l);if(N)return g.fireEvent(N,_,A,k,S);if(A)return A._nodeId=l,g.fireEvent(g.getRef("_documentElement"),_,A,k,S)}function eI(g,l,_,A){return g.taskCenter.callback(l,_,A)}function tI(g,l,_,A,k){if(!g||!g.taskCenter)return console.error(`[JS Framework] Can't find "document" or "taskCenter".`),null;let S=null;try{S=g.taskCenter.triggerHook(l,_,A,k)}catch(N){throw console.error(`[JS Framework] Failed to trigger the "${_}@${A}" hook on ${l}.`),N}return S}function mf(g,l){let _=Qa(g);if(!_)return new Error(`[JS Framework] Failed to receiveTasks, instance (${g}) is not available.`);if(yi(l))return l.map(A=>{switch(A.method){case"callback":return eI(_,...A.args);case"fireEventSync":case"fireEvent":return Q1(_,...A.args);case"componentHook":return tI(_,...A.args)}})}var ws={};function Mp(g={}){for(let l in g)Xs(ws,l)||(ws[l]={}),!!yi(g[l])&&g[l].forEach(_=>{wi(_)?ws[l][_]=!0:Ul(_)&&wi(_.name)&&(ws[l][_.name]=_.args||[])})}function cu(g,l){return wi(l)?!!(ws[g]&&ws[g][l]):!!ws[g]}function Lp(g){return ws[g]}var _f={};function Dp(g){!yi(g)||g.forEach(l=>{!l||(wi(l)?_f[l]=!0:Ul(l)&&wi(l.type)&&(_f[l.type]=l,df(l.type,l.methods)))})}function bf(g){return!!_f[g]}var Ss=[];function uu(g,l){Ef(g)?console.warn(`Service "${g}" has been registered already!`):(l=Jr({},l),Ss.push({name:g,options:l}))}function fu(g){Ss.some((l,_)=>{if(l.name===g)return Ss.splice(_,1),!0})}function Ef(g){return nI(g)>=0}function nI(g){return Ss.map(l=>l.name).indexOf(g)}function rI(g){return l=>{let _=eu(g,l),{createApp:A}=_;_.createVueApp=_.createApp=(k,S)=>A(k,S).use(iI,l),l.Vue=_}}var iI={install(g,l){oI(g,l),dc(l).initApp(g)}};function oI(g,l){let{mount:_}=g;g.mount=A=>{let k=_(A);return A==="#app"&&l.__registerApp(k),k}}function aI(g){let{UniShared:l,VueShared:_,VueReactivity:A}=g;var k=function(S,N,f,T){"use strict";var ze=[];function xt(i){T.pauseTracking();for(var s=ze.length?ze[ze.length-1].component:null,d=s&&s.appContext.config.warnHandler,p=pn(),y=arguments.length,w=new Array(y>1?y-1:0),I=1;I<y;I++)w[I-1]=arguments[I];if(d)st(d,s,11,[i+w.join(""),s&&s.proxy,p.map($=>{var{vnode:ee}=$;return"at <".concat(yo(s,ee.type),">")}).join(`
`),p]);else{var L=["[Vue warn]: ".concat(i),...w];p.length&&L.push(`
`,...B(p)),console.warn(...L)}T.resetTracking()}function pn(){var i=ze[ze.length-1];if(!i)return[];for(var s=[];i;){var d=s[0];d&&d.vnode===i?d.recurseCount++:s.push({vnode:i,recurseCount:0});var p=i.component&&i.component.parent;i=p&&p.vnode}return s}function B(i){var s=[];return i.forEach((d,p)=>{s.push(...p===0?[]:[`
`],...gt(d))}),s}function gt(i){var{vnode:s,recurseCount:d}=i,p=d>0?"... (".concat(d," recursive calls)"):"",y=s.component?s.component.parent==null:!1,w=" at <".concat(yo(s.component,s.type,y)),I=">"+p;return s.props?[w,...vn(s.props),I]:[w+I]}function vn(i){var s=[],d=Object.keys(i);return d.slice(0,3).forEach(p=>{s.push(...Vn(p,i[p]))}),d.length>3&&s.push(" ..."),s}function Vn(i,s,d){return f.isString(s)?(s=JSON.stringify(s),d?s:["".concat(i,"=").concat(s)]):typeof s=="number"||typeof s=="boolean"||s==null?d?s:["".concat(i,"=").concat(s)]:T.isRef(s)?(s=Vn(i,T.toRaw(s.value),!0),d?s:["".concat(i,"=Ref<"),s,">"]):f.isFunction(s)?["".concat(i,"=fn").concat(s.name?"<".concat(s.name,">"):"")]:(s=T.toRaw(s),d?s:["".concat(i,"="),s])}function st(i,s,d,p){var y;try{y=p?i(...p):i()}catch(w){te(w,s,d)}return y}function Y(i,s,d,p){if(f.isFunction(i)){var y=st(i,s,d,p);return y&&f.isPromise(y)&&y.catch(L=>{te(L,s,d)}),y}for(var w=[],I=0;I<i.length;I++)w.push(Y(i[I],s,d,p));return w}function te(i,s,d){if(s&&s.vnode,s){for(var p=s.parent,y=s.proxy,w=d;p;){var I=p.ec;if(I){for(var L=0;L<I.length;L++)if(I[L](i,y,w)===!1)return}p=p.parent}var $=s.appContext.config.errorHandler;if($){st($,null,10,[i,y,w]);return}}En(i)}function En(i,s,d){console.error(i)}var yn=!1,ln=!1,$n=[],an=0,kn=[],Un=null,mn=0,sn=[],_n=null,Rn=0,kr={then(i){setTimeout(()=>i(),0)}},Zr=S.platform==="iOS",Ue=Zr?kr:Promise.resolve(),it=null,vt=null;function qt(i){var s=it||Ue;return i?s.then(this?i.bind(this):i):s}function nn(i){for(var s=an+1,d=$n.length;s<d;){var p=s+d>>>1,y=Hr($n[p]);y<i?s=p+1:d=p}return s}function Qt(i){(!$n.length||!$n.includes(i,yn&&i.allowRecurse?an+1:an))&&i!==vt&&(i.id==null?$n.push(i):$n.splice(nn(i.id),0,i),ir())}function ir(){!yn&&!ln&&(ln=!0,it=Ue.then(Zi))}function lr(i){var s=$n.indexOf(i);s>an&&$n.splice(s,1)}function Li(i,s,d,p){f.isArray(i)?d.push(...i):(!s||!s.includes(i,i.allowRecurse?p+1:p))&&d.push(i),ir()}function Di(i){Li(i,Un,kn,mn)}function xn(i){Li(i,_n,sn,Rn)}function wr(i){var s=arguments.length>1&&arguments[1]!==void 0?arguments[1]:null;if(kn.length){for(vt=s,Un=[...new Set(kn)],kn.length=0,mn=0;mn<Un.length;mn++)Un[mn]();Un=null,mn=0,vt=null,wr(i,s)}}function Ur(i){if(wr(),sn.length){var s=[...new Set(sn)];if(sn.length=0,_n){_n.push(...s);return}for(_n=s,_n.sort((d,p)=>Hr(d)-Hr(p)),Rn=0;Rn<_n.length;Rn++)_n[Rn]();_n=null,Rn=0}}var Hr=i=>i.id==null?1/0:i.id;function Zi(i){ln=!1,yn=!0,wr(i),$n.sort((p,y)=>Hr(p)-Hr(y));var s=f.NOOP;try{for(an=0;an<$n.length;an++){var d=$n[an];d&&d.active!==!1&&st(d,null,14)}}finally{an=0,$n.length=0,Ur(),yn=!1,it=null,($n.length||kn.length||sn.length)&&Zi(i)}}S.devtools=void 0;var Xi=[];function Oo(i,s){var d,p;if(S.devtools=i,S.devtools)S.devtools.enabled=!0,Xi.forEach(w=>{var{event:I,args:L}=w;return S.devtools.emit(I,...L)}),Xi=[];else if(typeof window!="undefined"&&window.HTMLElement&&!((p=(d=window.navigator)===null||d===void 0?void 0:d.userAgent)===null||p===void 0?void 0:p.includes("jsdom"))){var y=s.__VUE_DEVTOOLS_HOOK_REPLAY__=s.__VUE_DEVTOOLS_HOOK_REPLAY__||[];y.push(w=>{Oo(w,s)}),setTimeout(()=>{S.devtools||(s.__VUE_DEVTOOLS_HOOK_REPLAY__=null,Xi=[])},3e3)}else Xi=[]}function To(i,s){if(!i.isUnmounted){for(var d=i.vnode.props||f.EMPTY_OBJ,p=arguments.length,y=new Array(p>2?p-2:0),w=2;w<p;w++)y[w-2]=arguments[w];var I=y,L=s.startsWith("update:"),$=L&&s.slice(7);if($&&$ in d){var ee="".concat($==="modelValue"?"model":$,"Modifiers"),{number:ie,trim:Ie}=d[ee]||f.EMPTY_OBJ;Ie&&(I=y.map(ft=>ft.trim())),ie&&(I=y.map(f.toNumber))}var oe,Ce=d[oe=f.toHandlerKey(s)]||d[oe=f.toHandlerKey(f.camelize(s))];!Ce&&L&&(Ce=d[oe=f.toHandlerKey(f.hyphenate(s))]),Ce&&Y(Ce,i,6,I);var Be=d[oe+"Once"];if(Be){if(!i.emitted)i.emitted={};else if(i.emitted[oe])return;i.emitted[oe]=!0,Y(Be,i,6,I)}}}function hr(i,s){var d=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!1,p=s.emitsCache,y=p.get(i);if(y!==void 0)return y;var w=i.emits,I={},L=!1;if(!f.isFunction(i)){var $=ee=>{var ie=hr(ee,s,!0);ie&&(L=!0,f.extend(I,ie))};!d&&s.mixins.length&&s.mixins.forEach($),i.extends&&$(i.extends),i.mixins&&i.mixins.forEach($)}return!w&&!L?(p.set(i,null),null):(f.isArray(w)?w.forEach(ee=>I[ee]=null):f.extend(I,w),p.set(i,I),I)}function Cn(i,s){return!i||!f.isOn(s)?!1:(s=s.slice(2).replace(/Once$/,""),f.hasOwn(i,s[0].toLowerCase()+s.slice(1))||f.hasOwn(i,f.hyphenate(s))||f.hasOwn(i,s))}var On=null,ci=null;function Qi(i){var s=On;return On=i,ci=i&&i.type.__scopeId||null,s}function eo(i){ci=i}function go(){ci=null}var Si=i=>cr;function cr(i){var s=arguments.length>1&&arguments[1]!==void 0?arguments[1]:On;if(!s||i._n)return i;var d=function(){d._d&&Sn(-1);var p=Qi(s),y=i(...arguments);return Qi(p),d._d&&Sn(1),y};return d._n=!0,d._c=!0,d._d=!0,d}function jr(){}function Sr(i){var{type:s,vnode:d,proxy:p,withProxy:y,props:w,propsOptions:[I],slots:L,attrs:$,emit:ee,render:ie,renderCache:Ie,data:oe,setupState:Ce,ctx:Be,inheritAttrs:ft}=i,At,me,le=Qi(i);try{if(d.shapeFlag&4){var Se=y||p;At=Yt(ie.call(Se,Se,Ie,w,Ce,oe,Be)),me=$}else{var qe=s;At=Yt(qe.length>1?qe(w,{attrs:$,slots:L,emit:ee}):qe(w,null)),me=s.props?$:Po($)}}catch(xe){Ze.length=0,te(xe,i,1),At=fn(Vt)}var He=At;if(me&&ft!==!1){var Re=Object.keys(me),{shapeFlag:lt}=He;Re.length&&lt&(1|6)&&(I&&Re.some(f.isModelListener)&&(me=Io(me,I)),He=ii(He,me))}return d.dirs&&(He=ii(He),He.dirs=He.dirs?He.dirs.concat(d.dirs):d.dirs),d.transition&&(He.transition=d.transition),At=He,Qi(le),At}function gr(i){for(var s,d=0;d<i.length;d++){var p=i[d];if(or(p)){if(p.type!==Vt||p.children==="v-if"){if(s)return;s=p}}else return}return s}var Po=i=>{var s;for(var d in i)(d==="class"||d==="style"||f.isOn(d))&&((s||(s={}))[d]=i[d]);return s},Io=(i,s)=>{var d={};for(var p in i)(!f.isModelListener(p)||!(p.slice(9)in s))&&(d[p]=i[p]);return d};function po(i,s,d){var{props:p,children:y,component:w}=i,{props:I,children:L,patchFlag:$}=s,ee=w.emitsOptions;if(s.dirs||s.transition)return!0;if(d&&$>=0){if($&1024)return!0;if($&16)return p?Rr(p,I,ee):!!I;if($&8)for(var ie=s.dynamicProps,Ie=0;Ie<ie.length;Ie++){var oe=ie[Ie];if(I[oe]!==p[oe]&&!Cn(ee,oe))return!0}}else return(y||L)&&(!L||!L.$stable)?!0:p===I?!1:p?I?Rr(p,I,ee):!0:!!I;return!1}function Rr(i,s,d){var p=Object.keys(s);if(p.length!==Object.keys(i).length)return!0;for(var y=0;y<p.length;y++){var w=p[y];if(s[w]!==i[w]&&!Cn(d,w))return!0}return!1}function ur(i,s){for(var{vnode:d,parent:p}=i;p&&p.subTree===d;)(d=p.vnode).el=s,p=p.parent}var Ar=i=>i.__isSuspense,Xr={name:"Suspense",__isSuspense:!0,process(i,s,d,p,y,w,I,L,$,ee){i==null?to(s,d,p,y,w,I,L,$,ee):Fi(i,s,d,p,y,I,L,$,ee)},hydrate:vo,create:xr,normalize:mo},zn=Xr;function zr(i,s){var d=i.props&&i.props[s];f.isFunction(d)&&d()}function to(i,s,d,p,y,w,I,L,$){var{p:ee,o:{createElement:ie}}=$,Ie=ie("div",s),oe=i.suspense=xr(i,y,p,s,Ie,d,w,I,L,$);ee(null,oe.pendingBranch=i.ssContent,Ie,null,p,oe,w,I),oe.deps>0?(zr(i,"onPending"),zr(i,"onFallback"),ee(null,i.ssFallback,s,d,p,null,w,I),ei(oe,i.ssFallback)):oe.resolve()}function Fi(i,s,d,p,y,w,I,L,$){var{p:ee,um:ie,o:{createElement:Ie}}=$,oe=s.suspense=i.suspense;oe.vnode=s,s.el=i.el;var Ce=s.ssContent,Be=s.ssFallback,{activeBranch:ft,pendingBranch:At,isInFallback:me,isHydrating:le}=oe;if(At)oe.pendingBranch=Ce,Er(Ce,At)?(ee(At,Ce,oe.hiddenContainer,null,y,oe,w,I,L),oe.deps<=0?oe.resolve():me&&(ee(ft,Be,d,p,y,null,w,I,L),ei(oe,Be))):(oe.pendingId++,le?(oe.isHydrating=!1,oe.activeBranch=At):ie(At,y,oe),oe.deps=0,oe.effects.length=0,oe.hiddenContainer=Ie("div",d),me?(ee(null,Ce,oe.hiddenContainer,null,y,oe,w,I,L),oe.deps<=0?oe.resolve():(ee(ft,Be,d,p,y,null,w,I,L),ei(oe,Be))):ft&&Er(Ce,ft)?(ee(ft,Ce,d,p,y,oe,w,I,L),oe.resolve(!0)):(ee(null,Ce,oe.hiddenContainer,null,y,oe,w,I,L),oe.deps<=0&&oe.resolve()));else if(ft&&Er(Ce,ft))ee(ft,Ce,d,p,y,oe,w,I,L),ei(oe,Ce);else if(zr(s,"onPending"),oe.pendingBranch=Ce,oe.pendingId++,ee(null,Ce,oe.hiddenContainer,null,y,oe,w,I,L),oe.deps<=0)oe.resolve();else{var{timeout:Se,pendingId:qe}=oe;Se>0?setTimeout(()=>{oe.pendingId===qe&&oe.fallback(Be)},Se):Se===0&&oe.fallback(Be)}}function xr(i,s,d,p,y,w,I,L,$,ee){var ie=arguments.length>10&&arguments[10]!==void 0?arguments[10]:!1,{p:Ie,m:oe,um:Ce,n:Be,o:{parentNode:ft,remove:At}}=ee,me=f.toNumber(i.props&&i.props.timeout),le={vnode:i,parent:s,parentComponent:d,isSVG:I,container:p,hiddenContainer:y,anchor:w,deps:0,pendingId:0,timeout:typeof me=="number"?me:-1,activeBranch:null,pendingBranch:null,isInFallback:!0,isHydrating:ie,isUnmounted:!1,effects:[],resolve(){var Se=arguments.length>0&&arguments[0]!==void 0?arguments[0]:!1,{vnode:qe,activeBranch:He,pendingBranch:Re,pendingId:lt,effects:xe,parentComponent:It,container:Ct}=le;if(le.isHydrating)le.isHydrating=!1;else if(!Se){var Bt=He&&Re.transition&&Re.transition.mode==="out-in";Bt&&(He.transition.afterLeave=()=>{lt===le.pendingId&&oe(Re,Ct,Jt,0)});var{anchor:Jt}=le;He&&(Jt=Be(He),Ce(He,It,le,!0)),Bt||oe(Re,Ct,Jt,0)}ei(le,Re),le.pendingBranch=null,le.isInFallback=!1;for(var dt=le.parent,F=!1;dt;){if(dt.pendingBranch){dt.effects.push(...xe),F=!0;break}dt=dt.parent}F||xn(xe),le.effects=[],zr(qe,"onResolve")},fallback(Se){if(!!le.pendingBranch){var{vnode:qe,activeBranch:He,parentComponent:Re,container:lt,isSVG:xe}=le;zr(qe,"onFallback");var It=Be(He),Ct=()=>{!le.isInFallback||(Ie(null,Se,lt,It,Re,null,xe,L,$),ei(le,Se))},Bt=Se.transition&&Se.transition.mode==="out-in";Bt&&(He.transition.afterLeave=Ct),le.isInFallback=!0,Ce(He,Re,null,!0),Bt||Ct()}},move(Se,qe,He){le.activeBranch&&oe(le.activeBranch,Se,qe,He),le.container=Se},next(){return le.activeBranch&&Be(le.activeBranch)},registerDep(Se,qe){var He=!!le.pendingBranch;He&&le.deps++;var Re=Se.vnode.el;Se.asyncDep.catch(lt=>{te(lt,Se,0)}).then(lt=>{if(!(Se.isUnmounted||le.isUnmounted||le.pendingId!==Se.suspenseId)){Se.asyncResolved=!0;var{vnode:xe}=Se;Gi(Se,lt,!1),Re&&(xe.el=Re);var It=!Re&&Se.subTree.el;qe(Se,xe,ft(Re||Se.subTree.el),Re?null:Be(Se.subTree),le,I,$),It&&At(It),ur(Se,xe.el),He&&--le.deps===0&&le.resolve()}})},unmount(Se,qe){le.isUnmounted=!0,le.activeBranch&&Ce(le.activeBranch,d,Se,qe),le.pendingBranch&&Ce(le.pendingBranch,d,Se,qe)}};return le}function vo(i,s,d,p,y,w,I,L,$){var ee=s.suspense=xr(s,p,d,i.parentNode,document.createElement("div"),null,y,w,I,L,!0),ie=$(i,ee.pendingBranch=s.ssContent,d,ee,w,I);return ee.deps===0&&ee.resolve(),ie}function mo(i){var{shapeFlag:s,children:d}=i,p=s&32;i.ssContent=_o(p?d.default:d),i.ssFallback=p?_o(d.fallback):fn(Vt)}function _o(i){var s;if(f.isFunction(i)){var d=rn&&i._c;d&&(i._d=!1,wn()),i=i(),d&&(i._d=!0,s=Ot,un())}if(f.isArray(i)){var p=gr(i);i=p}return i=Yt(i),s&&!i.dynamicChildren&&(i.dynamicChildren=s.filter(y=>y!==i)),i}function Qr(i,s){s&&s.pendingBranch?f.isArray(i)?s.effects.push(...i):s.effects.push(i):xn(i)}function ei(i,s){i.activeBranch=s;var{vnode:d,parentComponent:p}=i,y=d.el=s.el;p&&p.subTree===d&&(p.vnode.el=y,ur(p,y))}function Ai(i,s){if(An){var d=An.provides,p=An.parent&&An.parent.provides;p===d&&(d=An.provides=Object.create(p)),d[i]=s,An.type.mpType==="app"&&An.appContext.app.provide(i,s)}}function ui(i,s){var d=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!1,p=An||On;if(p){var y=p.parent==null?p.vnode.appContext&&p.vnode.appContext.provides:p.parent.provides;if(y&&i in y)return y[i];if(arguments.length>1)return d&&f.isFunction(s)?s.call(p.proxy):s}}function qn(i,s){return Ci(i,null,s)}function Cr(i,s){return Ci(i,null,{flush:"post"})}function Vi(i,s){return Ci(i,null,{flush:"sync"})}var Mt={};function ye(i,s,d){return Ci(i,s,d)}function Ci(i,s){var{immediate:d,deep:p,flush:y,onTrack:w,onTrigger:I}=arguments.length>2&&arguments[2]!==void 0?arguments[2]:f.EMPTY_OBJ,L=An,$,ee=!1,ie=!1;if(T.isRef(i)?($=()=>i.value,ee=T.isShallow(i)):T.isReactive(i)?($=()=>i,p=!0):f.isArray(i)?(ie=!0,ee=i.some(le=>T.isReactive(le)||T.isShallow(le)),$=()=>i.map(le=>{if(T.isRef(le))return le.value;if(T.isReactive(le))return Br(le);if(f.isFunction(le))return st(le,L,2)})):f.isFunction(i)?s?$=()=>st(i,L,2):$=()=>{if(!(L&&L.isUnmounted))return oe&&oe(),Y(i,L,3,[Ce])}:$=f.NOOP,s&&p){var Ie=$;$=()=>Br(Ie())}var oe,Ce=le=>{oe=me.onStop=()=>{st(le,L,4)}};if(S.isInSSRComponentSetup)return Ce=f.NOOP,s?d&&Y(s,L,3,[$(),ie?[]:void 0,Ce]):$(),f.NOOP;var Be=ie?[]:Mt,ft=()=>{if(!!me.active)if(s){var le=me.run();(p||ee||(ie?le.some((Se,qe)=>f.hasChanged(Se,Be[qe])):f.hasChanged(le,Be)))&&(oe&&oe(),Y(s,L,3,[le,Be===Mt?void 0:Be,Ce]),Be=le)}else me.run()};ft.allowRecurse=!!s;var At;y==="sync"?At=ft:y==="post"?At=()=>R(ft,L&&L.suspense):At=()=>Di(ft);var me=new T.ReactiveEffect($,At);return s?d?ft():Be=me.run():y==="post"?R(me.run.bind(me),L&&L.suspense):me.run(),()=>{me.stop(),L&&L.scope&&f.remove(L.scope.effects,me)}}function $i(i,s,d){var p=this.proxy,y=f.isString(i)?i.includes(".")?Wr(p,i):()=>p[i]:i.bind(p,p),w;f.isFunction(s)?w=s:(w=s.handler,d=s);var I=An;Fr(this);var L=Ci(y,w.bind(p),d);return I?Fr(I):ki(),L}function Wr(i,s){var d=s.split(".");return()=>{for(var p=i,y=0;y<d.length&&p;y++)p=p[d[y]];return p}}function Br(i,s){if(!f.isObject(i)||i.__v_skip||(s=s||new Set,s.has(i)))return i;if(s.add(i),T.isRef(i))Br(i.value,s);else if(f.isArray(i))for(var d=0;d<i.length;d++)Br(i[d],s);else if(f.isSet(i)||f.isMap(i))i.forEach(y=>{Br(y,s)});else if(f.isPlainObject(i))for(var p in i)Br(i[p],s);return i}function Hn(){var i={isMounted:!1,isLeaving:!1,isUnmounting:!1,leavingVNodes:new Map};return gi(()=>{i.isMounted=!0}),vi(()=>{i.isUnmounting=!0}),i}var Bn=[Function,Array],No={name:"BaseTransition",props:{mode:String,appear:Boolean,persisted:Boolean,onBeforeEnter:Bn,onEnter:Bn,onAfterEnter:Bn,onEnterCancelled:Bn,onBeforeLeave:Bn,onLeave:Bn,onAfterLeave:Bn,onLeaveCancelled:Bn,onBeforeAppear:Bn,onAppear:Bn,onAfterAppear:Bn,onAppearCancelled:Bn},setup(i,s){var{slots:d}=s,p=Qn(),y=Hn(),w;return()=>{var I=d.default&&Or(d.default(),!0);if(!(!I||!I.length)){var L=I[0];if(I.length>1){for(var $ of I)if($.type!==Vt){L=$;break}}var ee=T.toRaw(i),{mode:ie}=ee;if(y.isLeaving)return di(L);var Ie=Kt(L);if(!Ie)return di(L);var oe=fi(Ie,ee,y,p);Wn(Ie,oe);var Ce=p.subTree,Be=Ce&&Kt(Ce),ft=!1,{getTransitionKey:At}=Ie.type;if(At){var me=At();w===void 0?w=me:me!==w&&(w=me,ft=!0)}if(Be&&Be.type!==Vt&&(!Er(Ie,Be)||ft)){var le=fi(Be,ee,y,p);if(Wn(Be,le),ie==="out-in")return y.isLeaving=!0,le.afterLeave=()=>{y.isLeaving=!1,p.update()},di(L);ie==="in-out"&&Ie.type!==Vt&&(le.delayLeave=(Se,qe,He)=>{var Re=Ut(y,Be);Re[String(Be.key)]=Be,Se._leaveCb=()=>{qe(),Se._leaveCb=void 0,delete oe.delayedLeave},oe.delayedLeave=He})}return L}}}},Oi=No;function Ut(i,s){var{leavingVNodes:d}=i,p=d.get(s.type);return p||(p=Object.create(null),d.set(s.type,p)),p}function fi(i,s,d,p){var{appear:y,mode:w,persisted:I=!1,onBeforeEnter:L,onEnter:$,onAfterEnter:ee,onEnterCancelled:ie,onBeforeLeave:Ie,onLeave:oe,onAfterLeave:Ce,onLeaveCancelled:Be,onBeforeAppear:ft,onAppear:At,onAfterAppear:me,onAppearCancelled:le}=s,Se=String(i.key),qe=Ut(d,i),He=(xe,It)=>{xe&&Y(xe,p,9,It)},Re=(xe,It)=>{var Ct=It[1];He(xe,It),f.isArray(xe)?xe.every(Bt=>Bt.length<=1)&&Ct():xe.length<=1&&Ct()},lt={mode:w,persisted:I,beforeEnter(xe){var It=L;if(!d.isMounted)if(y)It=ft||L;else return;xe._leaveCb&&xe._leaveCb(!0);var Ct=qe[Se];Ct&&Er(i,Ct)&&Ct.el._leaveCb&&Ct.el._leaveCb(),He(It,[xe])},enter(xe){var It=$,Ct=ee,Bt=ie;if(!d.isMounted)if(y)It=At||$,Ct=me||ee,Bt=le||ie;else return;var Jt=!1,dt=xe._enterCb=F=>{Jt||(Jt=!0,F?He(Bt,[xe]):He(Ct,[xe]),lt.delayedLeave&&lt.delayedLeave(),xe._enterCb=void 0)};It?Re(It,[xe,dt]):dt()},leave(xe,It){var Ct=String(i.key);if(xe._enterCb&&xe._enterCb(!0),d.isUnmounting)return It();He(Ie,[xe]);var Bt=!1,Jt=xe._leaveCb=dt=>{Bt||(Bt=!0,It(),dt?He(Be,[xe]):He(Ce,[xe]),xe._leaveCb=void 0,qe[Ct]===i&&delete qe[Ct])};qe[Ct]=i,oe?Re(oe,[xe,Jt]):Jt()},clone(xe){return fi(xe,s,d,p)}};return lt}function di(i){if(no(i))return i=ii(i),i.children=null,i}function Kt(i){return no(i)?i.children?i.children[0]:void 0:i}function Wn(i,s){i.shapeFlag&6&&i.component?Wn(i.component.subTree,s):i.shapeFlag&128?(i.ssContent.transition=s.clone(i.ssContent),i.ssFallback.transition=s.clone(i.ssFallback)):i.transition=s}function Or(i){for(var s=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!1,d=arguments.length>2?arguments[2]:void 0,p=[],y=0,w=0;w<i.length;w++){var I=i[w],L=d==null?I.key:String(d)+String(I.key!=null?I.key:w);I.type===Ge?(I.patchFlag&128&&y++,p=p.concat(Or(I.children,s,L))):(s||I.type!==Vt)&&p.push(L!=null?ii(I,{key:L}):I)}if(y>1)for(var $=0;$<p.length;$++)p[$].patchFlag=-2;return p}function In(i){return f.isFunction(i)?{setup:i,name:i.name}:i}var Ti=i=>!!i.type.__asyncLoader;function ko(i){f.isFunction(i)&&(i={loader:i});var{loader:s,loadingComponent:d,errorComponent:p,delay:y=200,timeout:w,suspensible:I=!0,onError:L}=i,$=null,ee,ie=0,Ie=()=>(ie++,$=null,oe()),oe=()=>{var Ce;return $||(Ce=$=s().catch(Be=>{if(Be=Be instanceof Error?Be:new Error(String(Be)),L)return new Promise((ft,At)=>{var me=()=>ft(Ie()),le=()=>At(Be);L(Be,me,le,ie+1)});throw Be}).then(Be=>Ce!==$&&$?$:(Be&&(Be.__esModule||Be[Symbol.toStringTag]==="Module")&&(Be=Be.default),ee=Be,Be)))};return In({name:"AsyncComponentWrapper",__asyncLoader:oe,get __asyncResolved(){return ee},setup(){var Ce=An;if(ee)return()=>hi(ee,Ce);var Be=le=>{$=null,te(le,Ce,13)};if(I&&Ce.suspense||S.isInSSRComponentSetup)return oe().then(le=>()=>hi(le,Ce)).catch(le=>(Be(le),()=>p?fn(p,{error:le}):null));var ft=T.ref(!1),At=T.ref(),me=T.ref(!!y);return y&&setTimeout(()=>{me.value=!1},y),w!=null&&setTimeout(()=>{if(!ft.value&&!At.value){var le=new Error("Async component timed out after ".concat(w,"ms."));Be(le),At.value=le}},w),oe().then(()=>{ft.value=!0,Ce.parent&&no(Ce.parent.vnode)&&Qt(Ce.parent.update)}).catch(le=>{Be(le),At.value=le}),()=>{if(ft.value&&ee)return hi(ee,Ce);if(At.value&&p)return fn(p,{error:At.value});if(d&&!me.value)return fn(d)}}})}function hi(i,s){var{vnode:{ref:d,props:p,children:y,shapeFlag:w},parent:I}=s,L=fn(i,p,y);return L.ref=d,L}var no=i=>i.type.__isKeepAlive,Qo={name:"KeepAlive",__isKeepAlive:!0,props:{include:[String,RegExp,Array],exclude:[String,RegExp,Array],max:[String,Number]},setup(i,s){var{slots:d}=s,p=Qn(),y=p.ctx;if(!y.renderer)return()=>{var Se=d.default&&d.default();return Se&&Se.length===1?Se[0]:Se};var w=new Map,I=new Set,L=null,$=p.suspense,{renderer:{p:ee,m:ie,um:Ie,o:{createElement:oe}}}=y,Ce=oe("div",null);y.activate=(Se,qe,He,Re,lt)=>{var xe=Se.component;ie(Se,qe,He,0,$),ee(xe.vnode,Se,qe,He,xe,$,Re,Se.slotScopeIds,lt),R(()=>{xe.isDeactivated=!1,xe.a&&f.invokeArrayFns(xe.a);var It=Se.props&&Se.props.onVnodeMounted;It&&Dr(It,xe.parent,Se)},$)},y.deactivate=Se=>{var qe=Se.component;ie(Se,Ce,null,1,$),R(()=>{qe.da&&f.invokeArrayFns(qe.da);var He=Se.props&&Se.props.onVnodeUnmounted;He&&Dr(He,qe.parent,Se),qe.isDeactivated=!0},$)};function Be(Se){Hi(Se),Ie(Se,p,$,!0)}function ft(Se){w.forEach((qe,He)=>{var Re=St(qe.type);Re&&(!Se||!Se(Re))&&At(He)})}function At(Se){var qe=w.get(Se);!L||qe.type!==L.type?Be(qe):L&&Hi(L),w.delete(Se),I.delete(Se)}ye(()=>[i.include,i.exclude],Se=>{var[qe,He]=Se;qe&&ft(Re=>Kn(qe,Re)),He&&ft(Re=>!Kn(He,Re))},{flush:"post",deep:!0});var me=null,le=()=>{me!=null&&w.set(me,ti(p.subTree))};return gi(le),Yr(le),vi(()=>{w.forEach(Se=>{var{subTree:qe,suspense:He}=p,Re=ti(qe);if(Se.type===Re.type){Hi(Re);var lt=Re.component.da;lt&&R(lt,He);return}Be(Se)})}),()=>{if(me=null,!d.default)return null;var Se=d.default(),qe=Se[0];if(Se.length>1)return L=null,Se;if(!or(qe)||!(qe.shapeFlag&4)&&!(qe.shapeFlag&128))return L=null,qe;var He=ti(qe),Re=He.type,lt=St(Ti(He)?He.type.__asyncResolved||{}:Re),{include:xe,exclude:It,max:Ct}=i;if(xe&&(!lt||!Kn(xe,lt))||It&&lt&&Kn(It,lt))return L=He,qe;var Bt=He.key==null?Re:He.key,Jt=w.get(Bt);return He.el&&(He=ii(He),qe.shapeFlag&128&&(qe.ssContent=He)),me=Bt,Jt?(He.el=Jt.el,He.component=Jt.component,He.transition&&Wn(He,He.transition),He.shapeFlag|=512,I.delete(Bt),I.add(Bt)):(I.add(Bt),Ct&&I.size>parseInt(Ct,10)&&At(I.values().next().value)),He.shapeFlag|=256,L=He,Ar(qe.type)?qe:He}}},Ui=Qo;function Kn(i,s){return f.isArray(i)?i.some(d=>Kn(d,s)):f.isString(i)?i.split(",").includes(s):i.test?i.test(s):!1}function pr(i,s){Mr(i,"a",s)}function Jn(i,s){Mr(i,"da",s)}function Mr(i,s){var d=arguments.length>2&&arguments[2]!==void 0?arguments[2]:An,p=i.__wdc||(i.__wdc=()=>{for(var w=d;w;){if(w.isDeactivated)return;w=w.parent}return i()});if(vr(s,p,d),d)for(var y=d.parent;y&&y.parent;)no(y.parent.vnode)&&Tr(p,s,d,y),y=y.parent}function Tr(i,s,d,p){var y=vr(s,i,p,!0);ro(()=>{f.remove(p[s],y)},d)}function Hi(i){var s=i.shapeFlag;s&256&&(s-=256),s&512&&(s-=512),i.shapeFlag=s}function ti(i){return i.shapeFlag&128?i.ssContent:i}function vr(i,s){var d=arguments.length>2&&arguments[2]!==void 0?arguments[2]:An,p=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1;if(d){if(N.isRootHook(i)&&d!==d.root&&(d=d.root,N.isRootImmediateHook(i))){var y=d.proxy;Y(s.bind(y),d,i,N.ON_LOAD===i?[y.$page.options]:[])}var{__page_container__:w}=d.root.vnode;w&&w.onInjectHook(i);var I=d[i]||(d[i]=[]),L=s.__weh||(s.__weh=function(){if(!d.isUnmounted){T.pauseTracking(),Fr(d);for(var $=arguments.length,ee=new Array($),ie=0;ie<$;ie++)ee[ie]=arguments[ie];var Ie=Y(s,d,i,ee);return ki(),T.resetTracking(),Ie}});return p?I.unshift(L):I.push(L),L}}var Gr=i=>function(s){var d=arguments.length>1&&arguments[1]!==void 0?arguments[1]:An;return(!S.isInSSRComponentSetup||i==="sp")&&vr(i,s,d)},Pi=Gr("bm"),gi=Gr("m"),pi=Gr("bu"),Yr=Gr("u"),vi=Gr("bum"),ro=Gr("um"),ji=Gr("sp"),io=Gr("rtg"),x=Gr("rtc");function ne(i){var s=arguments.length>1&&arguments[1]!==void 0?arguments[1]:An;vr("ec",i,s)}function de(i,s){var d=On;if(d===null)return i;for(var p=Rt(d)||d.proxy,y=i.dirs||(i.dirs=[]),w=0;w<s.length;w++){var[I,L,$,ee=f.EMPTY_OBJ]=s[w];f.isFunction(I)&&(I={mounted:I,updated:I}),I.deep&&Br(L),y.push({dir:I,instance:p,value:L,oldValue:void 0,arg:$,modifiers:ee})}return i}function H(i,s,d,p){for(var y=i.dirs,w=s&&s.dirs,I=0;I<y.length;I++){var L=y[I];w&&(L.oldValue=w[I].value);var $=L.dir[p];$&&(T.pauseTracking(),Y($,d,8,[i.el,L,i,s]),T.resetTracking())}}var M="components",J="directives";function X(i,s){return cn(M,i,!0,s)||i}var ue=Symbol();function tn(i){return f.isString(i)?cn(M,i,!1)||i:i||ue}function Mn(i){return cn(J,i)}function cn(i,s){var d=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1,p=On||An;if(p){var y=p.type;if(i===M){var w=St(y,!1);if(w&&(w===s||w===f.camelize(s)||w===f.capitalize(f.camelize(s))))return y}var I=ni(p[i]||y[i],s)||ni(p.appContext[i],s);return!I&&d?y:I}}function ni(i,s){return i&&(i[s]||i[f.camelize(s)]||i[f.capitalize(f.camelize(s))])}function mr(i,s,d,p){var y,w=d&&d[p];if(f.isArray(i)||f.isString(i)){y=new Array(i.length);for(var I=0,L=i.length;I<L;I++)y[I]=s(i[I],I,void 0,w&&w[I])}else if(typeof i=="number"){y=new Array(i);for(var $=0;$<i;$++)y[$]=s($+1,$,void 0,w&&w[$])}else if(f.isObject(i))if(i[Symbol.iterator])y=Array.from(i,(Ce,Be)=>s(Ce,Be,void 0,w&&w[Be]));else{var ee=Object.keys(i);y=new Array(ee.length);for(var ie=0,Ie=ee.length;ie<Ie;ie++){var oe=ee[ie];y[ie]=s(i[oe],oe,ie,w&&w[ie])}}else y=[];return d&&(d[p]=y),y}function ea(i,s){for(var d=0;d<s.length;d++){var p=s[d];if(f.isArray(p))for(var y=0;y<p.length;y++)i[p[y].name]=p[y].fn;else p&&(i[p.name]=p.fn)}return i}function zo(i,s){var d=arguments.length>2&&arguments[2]!==void 0?arguments[2]:{},p=arguments.length>3?arguments[3]:void 0,y=arguments.length>4?arguments[4]:void 0;if(On.isCE||On.parent&&Ti(On.parent)&&On.parent.isCE)return fn("slot",s==="default"?null:{name:s},p&&p());var w=i[s];w&&w._c&&(w._d=!1),wn();var I=w&&ta(w(d)),L=mi(Ge,{key:d.key||"_".concat(s)},I||(p?p():[]),I&&i._===1?64:-2);return!y&&L.scopeId&&(L.slotScopeIds=[L.scopeId+"-s"]),w&&w._c&&(w._d=!0),L}function ta(i){return i.some(s=>or(s)?!(s.type===Vt||s.type===Ge&&!ta(s.children)):!0)?i:null}function Ro(i){var s={};for(var d in i)s[f.toHandlerKey(d)]=i[d];return s}var bo=i=>i?ai(i)?Rt(i)||i.proxy:bo(i.parent):null,oo=f.extend(Object.create(null),{$:i=>i,$el:i=>i.vnode.el,$data:i=>i.data,$props:i=>i.props,$attrs:i=>i.attrs,$slots:i=>i.slots,$refs:i=>i.refs,$parent:i=>bo(i.parent),$root:i=>bo(i.root),$emit:i=>i.emit,$options:i=>_r(i),$forceUpdate:i=>i.f||(i.f=()=>Qt(i.update)),$nextTick:i=>i.n||(i.n=qt.bind(i.proxy)),$watch:i=>$i.bind(i)}),Ra={get(i,s){var{_:d}=i,{ctx:p,setupState:y,data:w,props:I,accessCache:L,type:$,appContext:ee}=d,ie;if(s[0]!=="$"){var Ie=L[s];if(Ie!==void 0)switch(Ie){case 1:return y[s];case 2:return w[s];case 4:return p[s];case 3:return I[s]}else{if(y!==f.EMPTY_OBJ&&f.hasOwn(y,s))return L[s]=1,y[s];if(w!==f.EMPTY_OBJ&&f.hasOwn(w,s))return L[s]=2,w[s];if((ie=d.propsOptions[0])&&f.hasOwn(ie,s))return L[s]=3,I[s];if(p!==f.EMPTY_OBJ&&f.hasOwn(p,s))return L[s]=4,p[s];_a&&(L[s]=0)}}var oe=oo[s],Ce,Be;if(oe)return s==="$attrs"&&T.track(d,"get",s),oe(d);if((Ce=$.__cssModules)&&(Ce=Ce[s]))return Ce;if(p!==f.EMPTY_OBJ&&f.hasOwn(p,s))return L[s]=4,p[s];if(Be=ee.config.globalProperties,f.hasOwn(Be,s))return Be[s]},set(i,s,d){var{_:p}=i,{data:y,setupState:w,ctx:I}=p;return w!==f.EMPTY_OBJ&&f.hasOwn(w,s)?(w[s]=d,!0):y!==f.EMPTY_OBJ&&f.hasOwn(y,s)?(y[s]=d,!0):f.hasOwn(p.props,s)||s[0]==="$"&&s.slice(1)in p?!1:(I[s]=d,!0)},has(i,s){var{_:{data:d,setupState:p,accessCache:y,ctx:w,appContext:I,propsOptions:L}}=i,$;return!!y[s]||d!==f.EMPTY_OBJ&&f.hasOwn(d,s)||p!==f.EMPTY_OBJ&&f.hasOwn(p,s)||($=L[0])&&f.hasOwn($,s)||f.hasOwn(w,s)||f.hasOwn(oo,s)||f.hasOwn(I.config.globalProperties,s)},defineProperty(i,s,d){return d.get!=null?i._.accessCache[s]=0:f.hasOwn(d,"value")&&this.set(i,s,d.value,null),Reflect.defineProperty(i,s,d)}},na=f.extend({},Ra,{get(i,s){if(s!==Symbol.unscopables)return Ra.get(i,s,i)},has(i,s){var d=s[0]!=="_"&&!f.isGloballyWhitelisted(s);return d}}),_a=!0;function ts(i){var s=_r(i),d=i.proxy,p=i.ctx;_a=!1,s.beforeCreate&&xa(s.beforeCreate,i,"bc");var{data:y,computed:w,methods:I,watch:L,provide:$,inject:ee,created:ie,beforeMount:Ie,mounted:oe,beforeUpdate:Ce,updated:Be,activated:ft,deactivated:At,beforeDestroy:me,beforeUnmount:le,destroyed:Se,unmounted:qe,render:He,renderTracked:Re,renderTriggered:lt,errorCaptured:xe,serverPrefetch:It,expose:Ct,inheritAttrs:Bt,components:Jt,directives:dt,filters:F}=s,K=null;if(ee&&ra(ee,p,K,i.appContext.config.unwrapInjectedRef),I)for(var he in I){var pe=I[he];f.isFunction(pe)&&(p[he]=pe.bind(d))}if(y){var Pe=y.call(d,d);f.isObject(Pe)&&(i.data=T.reactive(Pe))}if(_a=!0,w){var Ke=function(at){var ot=w[at],dn=f.isFunction(ot)?ot.bind(d,d):f.isFunction(ot.get)?ot.get.bind(d,d):f.NOOP,bn=!f.isFunction(ot)&&f.isFunction(ot.set)?ot.set.bind(d):f.NOOP,tr=ca({get:dn,set:bn});Object.defineProperty(p,at,{enumerable:!0,configurable:!0,get:()=>tr.value,set:Pn=>tr.value=Pn})};for(var ct in w)Ke(ct)}if(L)for(var Qe in L)fr(L[Qe],p,d,Qe);if($){var Je=f.isFunction($)?$.call(d):$;Reflect.ownKeys(Je).forEach(at=>{Ai(at,Je[at])})}ie&&xa(ie,i,"c");function De(at,ot){f.isArray(ot)?ot.forEach(dn=>at(dn.bind(d))):ot&&at(ot.bind(d))}if(De(Pi,Ie),De(gi,oe),De(pi,Ce),De(Yr,Be),De(pr,ft),De(Jn,At),De(ne,xe),De(x,Re),De(io,lt),De(vi,le),De(ro,qe),De(ji,It),f.isArray(Ct))if(Ct.length){var yt=i.exposed||(i.exposed={});Ct.forEach(at=>{Object.defineProperty(yt,at,{get:()=>d[at],set:ot=>d[at]=ot})})}else i.exposed||(i.exposed={});He&&i.render===f.NOOP&&(i.render=He),Bt!=null&&(i.inheritAttrs=Bt),Jt&&(i.components=Jt),dt&&(i.directives=dt);var wt=i.appContext.config.globalProperties.$applyOptions;wt&&wt(s,i,d)}function ra(i,s){var d=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1;f.isArray(i)&&(i=br(i));var p=function(w){var I=i[w],L=void 0;f.isObject(I)?"default"in I?L=ui(I.from||w,I.default,!0):L=ui(I.from||w):L=ui(I),T.isRef(L)&&d?Object.defineProperty(s,w,{enumerable:!0,configurable:!0,get:()=>L.value,set:$=>L.value=$}):s[w]=L};for(var y in i)p(y)}function xa(i,s,d){Y(f.isArray(i)?i.map(p=>p.bind(s.proxy)):i.bind(s.proxy),s,d)}function fr(i,s,d,p){var y=p.includes(".")?Wr(d,p):()=>d[p];if(f.isString(i)){var w=s[i];f.isFunction(w)&&ye(y,w)}else if(f.isFunction(i))ye(y,i.bind(d));else if(f.isObject(i))if(f.isArray(i))i.forEach(L=>fr(L,s,d,p));else{var I=f.isFunction(i.handler)?i.handler.bind(d):s[i.handler];f.isFunction(I)&&ye(y,I,i)}}function _r(i){var s=i.type,{mixins:d,extends:p}=s,{mixins:y,optionsCache:w,config:{optionMergeStrategies:I}}=i.appContext,L=w.get(s),$;return L?$=L:!y.length&&!d&&!p?$=s:($={},y.length&&y.forEach(ee=>ia($,ee,I,!0)),ia($,s,I)),w.set(s,$),$}function ia(i,s,d){var p=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1,{mixins:y,extends:w}=s;w&&ia(i,w,d,!0),y&&y.forEach($=>ia(i,$,d,!0));for(var I in s)if(!(p&&I==="expose")){var L=Ba[I]||d&&d[I];i[I]=L?L(i[I],s[I]):s[I]}return i}var Ba={data:Lr,props:xo,emits:xo,methods:xo,computed:xo,beforeCreate:Zn,created:Zn,beforeMount:Zn,mounted:Zn,beforeUpdate:Zn,updated:Zn,beforeDestroy:Zn,beforeUnmount:Zn,destroyed:Zn,unmounted:Zn,activated:Zn,deactivated:Zn,errorCaptured:Zn,serverPrefetch:Zn,components:xo,directives:xo,watch:Cs,provide:Lr,inject:Ma};function Lr(i,s){return s?i?function(){return f.extend(f.isFunction(i)?i.call(this,this):i,f.isFunction(s)?s.call(this,this):s)}:s:i}function Ma(i,s){return xo(br(i),br(s))}function br(i){if(f.isArray(i)){for(var s={},d=0;d<i.length;d++)s[i[d]]=i[d];return s}return i}function Zn(i,s){return i?[...new Set([].concat(i,s))]:s}function xo(i,s){return i?f.extend(f.extend(Object.create(null),i),s):s}function Cs(i,s){if(!i)return s;if(!s)return i;var d=f.extend(Object.create(null),i);for(var p in s)d[p]=Zn(i[p],s[p]);return d}function Wo(i,s,d){var p=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1,y={},w={};f.def(w,Wi,1),i.propsDefaults=Object.create(null),jn(i,s,y,w);for(var I in i.propsOptions[0])I in y||(y[I]=void 0);d?i.props=p?y:T.shallowReactive(y):i.type.props?i.props=y:i.props=w,i.attrs=w}function ns(i,s,d,p){var{props:y,attrs:w,vnode:{patchFlag:I}}=i,L=T.toRaw(y),[$]=i.propsOptions,ee=!1;if((p||I>0)&&!(I&16)){if(I&8)for(var ie=i.vnode.dynamicProps,Ie=0;Ie<ie.length;Ie++){var oe=ie[Ie];if(!Cn(i.emitsOptions,oe)){var Ce=s[oe];if($)if(f.hasOwn(w,oe))Ce!==w[oe]&&(w[oe]=Ce,ee=!0);else{var Be=f.camelize(oe);y[Be]=ba($,L,Be,Ce,i,!1)}else Ce!==w[oe]&&(w[oe]=Ce,ee=!0)}}}else{jn(i,s,y,w)&&(ee=!0);var ft;for(var At in L)(!s||!f.hasOwn(s,At)&&((ft=f.hyphenate(At))===At||!f.hasOwn(s,ft)))&&($?d&&(d[At]!==void 0||d[ft]!==void 0)&&(y[At]=ba($,L,At,void 0,i,!0)):delete y[At]);if(w!==L)for(var me in w)(!s||!f.hasOwn(s,me)&&!0)&&(delete w[me],ee=!0)}ee&&T.trigger(i,"set","$attrs")}function jn(i,s,d,p){var[y,w]=i.propsOptions,I=!1,L;if(s){for(var $ in s)if(!f.isReservedProp($)){var ee=s[$],ie=void 0;y&&f.hasOwn(y,ie=f.camelize($))?!w||!w.includes(ie)?d[ie]=ee:(L||(L={}))[ie]=ee:Cn(i.emitsOptions,$)||(!($ in p)||ee!==p[$])&&(p[$]=ee,I=!0)}}if(w)for(var Ie=T.toRaw(d),oe=L||f.EMPTY_OBJ,Ce=0;Ce<w.length;Ce++){var Be=w[Ce];d[Be]=ba(y,Ie,Be,oe[Be],i,!f.hasOwn(oe,Be))}return I}function ba(i,s,d,p,y,w){var I=i[d];if(I!=null){var L=f.hasOwn(I,"default");if(L&&p===void 0){var $=I.default;if(I.type!==Function&&f.isFunction($)){var{propsDefaults:ee}=y;d in ee?p=ee[d]:(Fr(y),p=ee[d]=$.call(null,s),ki())}else p=$}I[0]&&(w&&!L?p=!1:I[1]&&(p===""||p===f.hyphenate(d))&&(p=!0))}return p}function Go(i,s){var d=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!1,p=s.propsCache,y=p.get(i);if(y)return y;var w=i.props,I={},L=[],$=!1;if(!f.isFunction(i)){var ee=Se=>{$=!0;var[qe,He]=Go(Se,s,!0);f.extend(I,qe),He&&L.push(...He)};!d&&s.mixins.length&&s.mixins.forEach(ee),i.extends&&ee(i.extends),i.mixins&&i.mixins.forEach(ee)}if(!w&&!$)return p.set(i,f.EMPTY_ARR),f.EMPTY_ARR;if(f.isArray(w))for(var ie=0;ie<w.length;ie++){var Ie=f.camelize(w[ie]);Ii(Ie)&&(I[Ie]=f.EMPTY_OBJ)}else if(w)for(var oe in w){var Ce=f.camelize(oe);if(Ii(Ce)){var Be=w[oe],ft=I[Ce]=f.isArray(Be)||f.isFunction(Be)?{type:Be}:Be;if(ft){var At=ao(Boolean,ft.type),me=ao(String,ft.type);ft[0]=At>-1,ft[1]=me<0||At<me,(At>-1||f.hasOwn(ft,"default"))&&L.push(Ce)}}}var le=[I,L];return p.set(i,le),le}function Ii(i){return i[0]!=="$"}function Ea(i){var s=i&&i.toString().match(/^\s*function (\w+)/);return s?s[1]:i===null?"null":""}function La(i,s){return Ea(i)===Ea(s)}function ao(i,s){return f.isArray(s)?s.findIndex(d=>La(d,i)):f.isFunction(s)&&La(s,i)?0:-1}var oa=i=>i[0]==="_"||i==="$stable",Eo=i=>f.isArray(i)?i.map(Yt):[Yt(i)],zi=(i,s,d)=>{if(s._n)return s;var p=cr(function(){return Eo(s(...arguments))},d);return p._c=!1,p},ya=(i,s,d)=>{var p=i._ctx;for(var y in i)if(!oa(y)){var w=i[y];f.isFunction(w)?s[y]=zi(y,w,p):w!=null&&function(){var I=Eo(w);s[y]=()=>I}()}},aa=(i,s)=>{var d=Eo(s);i.slots.default=()=>d},wa=(i,s)=>{if(i.vnode.shapeFlag&32){var d=s._;d?(i.slots=T.toRaw(s),f.def(s,"_",d)):ya(s,i.slots={})}else i.slots={},s&&aa(i,s);f.def(i.slots,Wi,1)},sa=(i,s,d)=>{var{vnode:p,slots:y}=i,w=!0,I=f.EMPTY_OBJ;if(p.shapeFlag&32){var L=s._;L?d&&L===1?w=!1:(f.extend(y,s),!d&&L===1&&delete y._):(w=!s.$stable,ya(s,y)),I=s}else s&&(aa(i,s),I={default:1});if(w)for(var $ in y)!oa($)&&!($ in I)&&delete y[$]};function Sa(){return{app:null,config:{isNativeTag:f.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 Os=0;function so(i,s){return function(p){var y=arguments.length>1&&arguments[1]!==void 0?arguments[1]:null;f.isFunction(p)||(p=Object.assign({},p)),y!=null&&!f.isObject(y)&&(y=null);var w=Sa(),I=new Set,L=!1,$=w.app={_uid:Os++,_component:p,_props:y,_container:null,_context:w,_instance:null,version:ss,get config(){return w.config},set config(ee){},use(ee){for(var ie=arguments.length,Ie=new Array(ie>1?ie-1:0),oe=1;oe<ie;oe++)Ie[oe-1]=arguments[oe];return I.has(ee)||(ee&&f.isFunction(ee.install)?(I.add(ee),ee.install($,...Ie)):f.isFunction(ee)&&(I.add(ee),ee($,...Ie))),$},mixin(ee){return w.mixins.includes(ee)||w.mixins.push(ee),$},component(ee,ie){return ie?(w.components[ee]=ie,$):w.components[ee]},directive(ee,ie){return ie?(w.directives[ee]=ie,$):w.directives[ee]},mount(ee,ie,Ie){if(!L){var oe=fn(p,y);return oe.appContext=w,ie&&s?s(oe,ee):i(oe,ee,Ie),L=!0,$._container=ee,ee.__vue_app__=$,$._instance=oe.component,Rt(oe.component)||oe.component.proxy}},unmount(){L&&(i(null,$._container),delete $._container.__vue_app__)},provide(ee,ie){return w.provides[ee]=ie,$}};return $}}function ri(i,s,d,p){var y=arguments.length>4&&arguments[4]!==void 0?arguments[4]:!1;if(f.isArray(i)){i.forEach((ft,At)=>ri(ft,s&&(f.isArray(s)?s[At]:s),d,p,y));return}if(!(Ti(p)&&!y)){var w=p.shapeFlag&4?Rt(p.component)||p.component.proxy:p.el,I=y?null:w,{i:L,r:$}=i,ee=s&&s.r,ie=L.refs===f.EMPTY_OBJ?L.refs={}:L.refs,Ie=L.setupState;if(ee!=null&&ee!==$&&(f.isString(ee)?(ie[ee]=null,f.hasOwn(Ie,ee)&&(Ie[ee]=null)):T.isRef(ee)&&(ee.value=null)),f.isFunction($))st($,L,12,[I,ie]);else{var oe=f.isString($),Ce=T.isRef($);if(oe||Ce){var Be=()=>{if(i.f){var ft=oe?ie[$]:$.value;y?f.isArray(ft)&&f.remove(ft,w):f.isArray(ft)?ft.includes(w)||ft.push(w):oe?(ie[$]=[w],f.hasOwn(Ie,$)&&(Ie[$]=ie[$])):($.value=[w],i.k&&(ie[i.k]=$.value))}else oe?(ie[$]=I,f.hasOwn(Ie,$)&&(Ie[$]=I)):Ce&&($.value=I,i.k&&(ie[i.k]=I))};I?(Be.id=-1,R(Be,d)):Be()}}}}var Ni=!1,lo=i=>/svg/.test(i.namespaceURI)&&i.tagName!=="foreignObject",la=i=>i.nodeType===8;function m(i){var{mt:s,p:d,o:{patchProp:p,createText:y,nextSibling:w,parentNode:I,remove:L,insert:$,createComment:ee}}=i,ie=(me,le)=>{if(!le.hasChildNodes()){d(null,me,le),Ur(),le._vnode=me;return}Ni=!1,Ie(le.firstChild,me,null,null,null),Ur(),le._vnode=me,Ni&&console.error("Hydration completed but contains mismatches.")},Ie=function(me,le,Se,qe,He){var Re=arguments.length>5&&arguments[5]!==void 0?arguments[5]:!1,lt=la(me)&&me.data==="[",xe=()=>ft(me,le,Se,qe,He,lt),{type:It,ref:Ct,shapeFlag:Bt,patchFlag:Jt}=le,dt=me.nodeType;le.el=me,Jt===-2&&(Re=!1,le.dynamicChildren=null);var F=null;switch(It){case ut:dt!==3?le.children===""?($(le.el=y("",me.parentNode),I(me),me),F=me):F=xe():(me.data!==le.children&&(Ni=!0,me.data=le.children),F=w(me));break;case Vt:dt!==8||lt?F=xe():F=w(me);break;case pt:if(dt!==1&&dt!==3)F=xe();else{F=me;for(var K=!le.children.length,he=0;he<le.staticCount;he++)K&&(le.children+=F.nodeType===1?F.outerHTML:F.data),he===le.staticCount-1&&(le.anchor=F),F=w(F);return F}break;case Ge:lt?F=Be(me,le,Se,qe,He,Re):F=xe();break;default:if(Bt&1)dt!==1||le.type.toLowerCase()!==me.tagName.toLowerCase()?F=xe():F=oe(me,le,Se,qe,He,Re);else if(Bt&6){le.slotScopeIds=He;var pe=I(me);if(s(le,pe,null,Se,qe,lo(pe),Re),F=lt?At(me):w(me),F&&la(F)&&F.data==="teleport end"&&(F=w(F)),Ti(le)){var Pe;lt?(Pe=fn(Ge),Pe.anchor=F?F.previousSibling:pe.lastChild):Pe=me.nodeType===3?Do(""):fn("div"),Pe.el=me,le.component.subTree=Pe}}else Bt&64?dt!==8?F=xe():F=le.type.hydrate(me,le,Se,qe,He,Re,i,Ce):Bt&128&&(F=le.type.hydrate(me,le,Se,qe,lo(I(me)),He,Re,i,Ie))}return Ct!=null&&ri(Ct,null,qe,le),F},oe=(me,le,Se,qe,He,Re)=>{Re=Re||!!le.dynamicChildren;var{type:lt,props:xe,patchFlag:It,shapeFlag:Ct,dirs:Bt}=le,Jt=lt==="input"&&Bt||lt==="option";if(Jt||It!==-1){if(Bt&&H(le,null,Se,"created"),xe)if(Jt||!Re||It&(16|32))for(var dt in xe)(Jt&&dt.endsWith("value")||f.isOn(dt)&&!f.isReservedProp(dt))&&p(me,dt,null,xe[dt],!1,void 0,Se);else xe.onClick&&p(me,"onClick",null,xe.onClick,!1,void 0,Se);var F;if((F=xe&&xe.onVnodeBeforeMount)&&Dr(F,Se,le),Bt&&H(le,null,Se,"beforeMount"),((F=xe&&xe.onVnodeMounted)||Bt)&&Qr(()=>{F&&Dr(F,Se,le),Bt&&H(le,null,Se,"mounted")},qe),Ct&16&&!(xe&&(xe.innerHTML||xe.textContent)))for(var K=Ce(me.firstChild,le,me,Se,qe,He,Re);K;){Ni=!0;var he=K;K=K.nextSibling,L(he)}else Ct&8&&me.textContent!==le.children&&(Ni=!0,me.textContent=le.children)}return me.nextSibling},Ce=(me,le,Se,qe,He,Re,lt)=>{lt=lt||!!le.dynamicChildren;for(var xe=le.children,It=xe.length,Ct=0;Ct<It;Ct++){var Bt=lt?xe[Ct]:xe[Ct]=Yt(xe[Ct]);if(me)me=Ie(me,Bt,qe,He,Re,lt);else{if(Bt.type===ut&&!Bt.children)continue;Ni=!0,d(null,Bt,Se,null,qe,He,lo(Se),Re)}}return me},Be=(me,le,Se,qe,He,Re)=>{var{slotScopeIds:lt}=le;lt&&(He=He?He.concat(lt):lt);var xe=I(me),It=Ce(w(me),le,xe,Se,qe,He,Re);return It&&la(It)&&It.data==="]"?w(le.anchor=It):(Ni=!0,$(le.anchor=ee("]",xe),xe,It),It)},ft=(me,le,Se,qe,He,Re)=>{if(Ni=!0,le.el=null,Re)for(var lt=At(me);;){var xe=w(me);if(xe&&xe!==lt)L(xe);else break}var It=w(me),Ct=I(me);return L(me),d(null,le,Ct,It,Se,qe,lo(Ct),He),It},At=me=>{for(var le=0;me;)if(me=w(me),me&&la(me)&&(me.data==="["&&le++,me.data==="]")){if(le===0)return w(me);le--}return me};return[ie,Ie]}var R=Qr;function z(i){return Z(i)}function j(i){return Z(i,m)}function Z(i,s){var d=f.getGlobalThis();d.__VUE__=!0;var{insert:p,remove:y,patchProp:w,forcePatchProp:I,createElement:L,createText:$,createComment:ee,setText:ie,setElementText:Ie,parentNode:oe,nextSibling:Ce,setScopeId:Be=f.NOOP,cloneNode:ft,insertStaticContent:At}=i,me=function(W,re,Ee){var Ae=arguments.length>3&&arguments[3]!==void 0?arguments[3]:null,Me=arguments.length>4&&arguments[4]!==void 0?arguments[4]:null,tt=arguments.length>5&&arguments[5]!==void 0?arguments[5]:null,ht=arguments.length>6&&arguments[6]!==void 0?arguments[6]:!1,Ye=arguments.length>7&&arguments[7]!==void 0?arguments[7]:null,et=arguments.length>8&&arguments[8]!==void 0?arguments[8]:!!re.dynamicChildren;if(W!==re){W&&!Er(W,re)&&(Ae=bn(W),yt(W,Me,tt,!0),W=null),re.patchFlag===-2&&(et=!1,re.dynamicChildren=null);var{type:je,ref:Nt,shapeFlag:Dt}=re;switch(je){case ut:le(W,re,Ee,Ae);break;case Vt:Se(W,re,Ee,Ae);break;case pt:W==null&&qe(re,Ee,Ae,ht);break;case Ge:F(W,re,Ee,Ae,Me,tt,ht,Ye,et);break;default:Dt&1?lt(W,re,Ee,Ae,Me,tt,ht,Ye,et):Dt&6?K(W,re,Ee,Ae,Me,tt,ht,Ye,et):(Dt&64||Dt&128)&&je.process(W,re,Ee,Ae,Me,tt,ht,Ye,et,Pn)}Nt!=null&&Me&&ri(Nt,W&&W.ref,tt,re||W,!re)}},le=(W,re,Ee,Ae)=>{if(W==null)p(re.el=$(re.children,Ee),Ee,Ae);else{var Me=re.el=W.el;re.children!==W.children&&ie(Me,re.children)}},Se=(W,re,Ee,Ae)=>{W==null?p(re.el=ee(re.children||"",Ee),Ee,Ae):re.el=W.el},qe=(W,re,Ee,Ae)=>{[W.el,W.anchor]=At(W.children,re,Ee,Ae,W.el,W.anchor)},He=(W,re,Ee)=>{for(var{el:Ae,anchor:Me}=W,tt;Ae&&Ae!==Me;)tt=Ce(Ae),p(Ae,re,Ee),Ae=tt;p(Me,re,Ee)},Re=W=>{for(var{el:re,anchor:Ee}=W,Ae;re&&re!==Ee;)Ae=Ce(re),y(re),re=Ae;y(Ee)},lt=(W,re,Ee,Ae,Me,tt,ht,Ye,et)=>{ht=ht||re.type==="svg",W==null?xe(re,Ee,Ae,Me,tt,ht,Ye,et):Bt(W,re,Me,tt,ht,Ye,et)},xe=(W,re,Ee,Ae,Me,tt,ht,Ye)=>{var et,je,{type:Nt,props:Dt,shapeFlag:Ft,transition:on,patchFlag:Vr,dirs:nr}=W;if(W.el&&ft!==void 0&&Vr===-1)et=W.el=ft(W.el);else{if(et=W.el=L(W.type,re),Ft&8?Ie(et,W.children):Ft&16&&Ct(W.children,et,null,Ae,Me,tt&&Nt!=="foreignObject",ht,Ye),nr&&H(W,null,Ae,"created"),Dt){for(var Kr in Dt)Kr!=="value"&&!f.isReservedProp(Kr)&&w(et,Kr,null,Dt[Kr],tt,W.children,Ae,Me,dn);"value"in Dt&&w(et,"value",null,Dt.value),(je=Dt.onVnodeBeforeMount)&&Dr(je,Ae,W)}It(et,W,W.scopeId,ht,Ae)}Object.defineProperty(et,"__vueParentComponent",{value:Ae,enumerable:!1}),nr&&H(W,null,Ae,"beforeMount");var Ri=(!Me||Me&&!Me.pendingBranch)&&on&&!on.persisted;Ri&&on.beforeEnter(et),p(et,re,Ee),((je=Dt&&Dt.onVnodeMounted)||Ri||nr)&&R(()=>{je&&Dr(je,Ae,W),Ri&&on.enter(et),nr&&H(W,null,Ae,"mounted")},Me)},It=(W,re,Ee,Ae,Me)=>{if(Ee&&Be(W,Ee),Ae)for(var tt=0;tt<Ae.length;tt++)Be(W,Ae[tt]);if(Me){var ht=Me.subTree;if(re===ht){var Ye=Me.vnode;It(W,Ye,Ye.scopeId,Ye.slotScopeIds,Me.parent)}}},Ct=function(W,re,Ee,Ae,Me,tt,ht,Ye){for(var et=arguments.length>8&&arguments[8]!==void 0?arguments[8]:0,je=et;je<W.length;je++){var Nt=W[je]=Ye?oi(W[je]):Yt(W[je]);me(null,Nt,re,Ee,Ae,Me,tt,ht,Ye)}},Bt=(W,re,Ee,Ae,Me,tt,ht)=>{var Ye=re.el=W.el,{patchFlag:et,dynamicChildren:je,dirs:Nt}=re;et|=W.patchFlag&16;var Dt=W.props||f.EMPTY_OBJ,Ft=re.props||f.EMPTY_OBJ,on;Ee&&Q(Ee,!1),(on=Ft.onVnodeBeforeUpdate)&&Dr(on,Ee,re,W),Nt&&H(re,W,Ee,"beforeUpdate"),Ee&&Q(Ee,!0);var Vr=Me&&re.type!=="foreignObject";if(je?Jt(W.dynamicChildren,je,Ye,Ee,Ae,Vr,tt):ht||ct(W,re,Ye,null,Ee,Ae,Vr,tt,!1),et>0){if(et&16)dt(Ye,re,Dt,Ft,Ee,Ae,Me);else if(et&2&&Dt.class!==Ft.class&&w(Ye,"class",null,Ft.class,Me),et&4&&w(Ye,"style",Dt.style,Ft.style,Me),et&8)for(var nr=re.dynamicProps,Kr=0;Kr<nr.length;Kr++){var Ri=nr[Kr],Ya=Dt[Ri],ps=Ft[Ri];(ps!==Ya||Ri==="value"||I&&I(Ye,Ri))&&w(Ye,Ri,Ya,ps,Me,W.children,Ee,Ae,dn)}et&1&&W.children!==re.children&&Ie(Ye,re.children)}else!ht&&je==null&&dt(Ye,re,Dt,Ft,Ee,Ae,Me);((on=Ft.onVnodeUpdated)||Nt)&&R(()=>{on&&Dr(on,Ee,re,W),Nt&&H(re,W,Ee,"updated")},Ae)},Jt=(W,re,Ee,Ae,Me,tt,ht)=>{for(var Ye=0;Ye<re.length;Ye++){var et=W[Ye],je=re[Ye],Nt=et.el&&(et.type===Ge||!Er(et,je)||et.shapeFlag&(6|64))?oe(et.el):Ee;me(et,je,Nt,null,Ae,Me,tt,ht,!0)}},dt=(W,re,Ee,Ae,Me,tt,ht)=>{if(Ee!==Ae){for(var Ye in Ae)if(!f.isReservedProp(Ye)){var et=Ae[Ye],je=Ee[Ye];(et!==je&&Ye!=="value"||I&&I(W,Ye))&&w(W,Ye,je,et,ht,re.children,Me,tt,dn)}if(Ee!==f.EMPTY_OBJ)for(var Nt in Ee)!f.isReservedProp(Nt)&&!(Nt in Ae)&&w(W,Nt,Ee[Nt],null,ht,re.children,Me,tt,dn);"value"in Ae&&w(W,"value",Ee.value,Ae.value)}},F=(W,re,Ee,Ae,Me,tt,ht,Ye,et)=>{var je=re.el=W?W.el:$("",Ee),Nt=re.anchor=W?W.anchor:$("",Ee),{patchFlag:Dt,dynamicChildren:Ft,slotScopeIds:on}=re;on&&(Ye=Ye?Ye.concat(on):on),W==null?(p(je,Ee,Ae),p(Nt,Ee,Ae),Ct(re.children,Ee,Nt,Me,tt,ht,Ye,et)):Dt>0&&Dt&64&&Ft&&W.dynamicChildren?(Jt(W.dynamicChildren,Ft,Ee,Me,tt,ht,Ye),(re.key!=null||Me&&re===Me.subTree)&&ce(W,re,!0)):ct(W,re,Ee,Nt,Me,tt,ht,Ye,et)},K=(W,re,Ee,Ae,Me,tt,ht,Ye,et)=>{re.slotScopeIds=Ye,W==null?re.shapeFlag&512?Me.ctx.activate(re,Ee,Ae,ht,et):he(re,Ee,Ae,Me,tt,ht,et):pe(W,re,et)},he=(W,re,Ee,Ae,Me,tt,ht)=>{var Ye=W.component=Gn(W,Ae,Me);if(no(W)&&(Ye.ctx.renderer=Pn),Ca(Ye),Ye.asyncDep){if(Me&&Me.registerDep(Ye,Pe),!W.el){var et=Ye.subTree=fn(Vt);Se(null,et,re,Ee)}return}if(Pe(Ye,W,re,Ee,Me,tt,ht),Ye.$wxsModules){var je=N.resolveOwnerEl(Ye);if(je){je.setAttribute(N.ATTR_V_OWNER_ID,Ye.uid);var{$renderjsModules:Nt}=Ye.type;Nt&&je.setAttribute(N.ATTR_V_RENDERJS,Nt)}}},pe=(W,re,Ee)=>{var Ae=re.component=W.component;if(po(W,re,Ee))if(Ae.asyncDep&&!Ae.asyncResolved){Ke(Ae,re,Ee);return}else Ae.next=re,lr(Ae.update),Ae.update();else re.el=W.el,Ae.vnode=re},Pe=(W,re,Ee,Ae,Me,tt,ht)=>{var Ye=()=>{if(W.isMounted){var{next:$r,bu:$s,u:Us,parent:ho,vnode:qa}=W,Ka=$r,da;Q(W,!1),$r?($r.el=qa.el,Ke(W,$r,ht)):$r=qa,$s&&f.invokeArrayFns($s),(da=$r.props&&$r.props.onVnodeBeforeUpdate)&&Dr(da,ho,$r,qa),Q(W,!0);var Uo=Sr(W),bi=W.subTree;W.subTree=Uo,me(bi,Uo,oe(bi.el),bn(bi),W,Me,tt),$r.el=Uo.el,Ka===null&&ur(W,Uo.el),Us&&R(Us,Me),(da=$r.props&&$r.props.onVnodeUpdated)&&R(()=>Dr(da,ho,$r,qa),Me)}else{var Nt,{el:Dt,props:Ft}=re,{bm:on,m:Vr,parent:nr}=W,Kr=Ti(re);if(Q(W,!1),on&&f.invokeArrayFns(on),!Kr&&(Nt=Ft&&Ft.onVnodeBeforeMount)&&Dr(Nt,nr,re),Q(W,!0),Dt&&So){var Ri=()=>{W.subTree=Sr(W),So(Dt,W.subTree,W,Me,null)};Kr?re.type.__asyncLoader().then(()=>!W.isUnmounted&&Ri()):Ri()}else{var Ya=W.subTree=Sr(W);me(null,Ya,Ee,Ae,W,Me,tt),re.el=Ya.el}if(Vr&&R(Vr,Me),!Kr&&(Nt=Ft&&Ft.onVnodeMounted)){var ps=re;R(()=>Dr(Nt,nr,ps),Me)}(re.shapeFlag&256||nr&&Ti(nr.vnode)&&nr.vnode.shapeFlag&256)&&W.a&&R(W.a,Me),W.isMounted=!0,re=Ee=Ae=null}},et=W.effect=new T.ReactiveEffect(Ye,()=>Qt(je),W.scope),je=W.update=()=>et.run();je.id=W.uid,Q(W,!0),je()},Ke=(W,re,Ee)=>{re.component=W;var Ae=W.vnode.props;W.vnode=re,W.next=null,ns(W,re.props,Ae,Ee),sa(W,re.children,Ee),T.pauseTracking(),wr(void 0,W.update),T.resetTracking()},ct=function(W,re,Ee,Ae,Me,tt,ht,Ye){var et=arguments.length>8&&arguments[8]!==void 0?arguments[8]:!1,je=W&&W.children,Nt=W?W.shapeFlag:0,Dt=re.children,{patchFlag:Ft,shapeFlag:on}=re;if(Ft>0){if(Ft&128){Je(je,Dt,Ee,Ae,Me,tt,ht,Ye,et);return}else if(Ft&256){Qe(je,Dt,Ee,Ae,Me,tt,ht,Ye,et);return}}on&8?(Nt&16&&dn(je,Me,tt),Dt!==je&&Ie(Ee,Dt)):Nt&16?on&16?Je(je,Dt,Ee,Ae,Me,tt,ht,Ye,et):dn(je,Me,tt,!0):(Nt&8&&Ie(Ee,""),on&16&&Ct(Dt,Ee,Ae,Me,tt,ht,Ye,et))},Qe=(W,re,Ee,Ae,Me,tt,ht,Ye,et)=>{W=W||f.EMPTY_ARR,re=re||f.EMPTY_ARR;var je=W.length,Nt=re.length,Dt=Math.min(je,Nt),Ft;for(Ft=0;Ft<Dt;Ft++){var on=re[Ft]=et?oi(re[Ft]):Yt(re[Ft]);me(W[Ft],on,Ee,null,Me,tt,ht,Ye,et)}je>Nt?dn(W,Me,tt,!0,!1,Dt):Ct(re,Ee,Ae,Me,tt,ht,Ye,et,Dt)},Je=(W,re,Ee,Ae,Me,tt,ht,Ye,et)=>{for(var je=0,Nt=re.length,Dt=W.length-1,Ft=Nt-1;je<=Dt&&je<=Ft;){var on=W[je],Vr=re[je]=et?oi(re[je]):Yt(re[je]);if(Er(on,Vr))me(on,Vr,Ee,null,Me,tt,ht,Ye,et);else break;je++}for(;je<=Dt&&je<=Ft;){var nr=W[Dt],Kr=re[Ft]=et?oi(re[Ft]):Yt(re[Ft]);if(Er(nr,Kr))me(nr,Kr,Ee,null,Me,tt,ht,Ye,et);else break;Dt--,Ft--}if(je>Dt){if(je<=Ft)for(var Ri=Ft+1,Ya=Ri<Nt?re[Ri].el:Ae;je<=Ft;)me(null,re[je]=et?oi(re[je]):Yt(re[je]),Ee,Ya,Me,tt,ht,Ye,et),je++}else if(je>Ft)for(;je<=Dt;)yt(W[je],Me,tt,!0),je++;else{var ps=je,$r=je,$s=new Map;for(je=$r;je<=Ft;je++){var Us=re[je]=et?oi(re[je]):Yt(re[je]);Us.key!=null&&$s.set(Us.key,je)}var ho,qa=0,Ka=Ft-$r+1,da=!1,Uo=0,bi=new Array(Ka);for(je=0;je<Ka;je++)bi[je]=0;for(je=ps;je<=Dt;je++){var vs=W[je];if(qa>=Ka){yt(vs,Me,tt,!0);continue}var Ia=void 0;if(vs.key!=null)Ia=$s.get(vs.key);else for(ho=$r;ho<=Ft;ho++)if(bi[ho-$r]===0&&Er(vs,re[ho])){Ia=ho;break}Ia===void 0?yt(vs,Me,tt,!0):(bi[Ia-$r]=je+1,Ia>=Uo?Uo=Ia:da=!0,me(vs,re[Ia],Ee,null,Me,tt,ht,Ye,et),qa++)}var Ec=da?be(bi):f.EMPTY_ARR;for(ho=Ec.length-1,je=Ka-1;je>=0;je--){var Kl=$r+je,yc=re[Kl],wc=Kl+1<Nt?re[Kl+1].el:Ae;bi[je]===0?me(null,yc,Ee,wc,Me,tt,ht,Ye,et):da&&(ho<0||je!==Ec[ho]?De(yc,Ee,wc,2):ho--)}}},De=function(W,re,Ee,Ae){var Me=arguments.length>4&&arguments[4]!==void 0?arguments[4]:null,{el:tt,type:ht,transition:Ye,children:et,shapeFlag:je}=W;if(je&6){De(W.component.subTree,re,Ee,Ae);return}if(je&128){W.suspense.move(re,Ee,Ae);return}if(je&64){ht.move(W,re,Ee,Pn);return}if(ht===Ge){p(tt,re,Ee);for(var Nt=0;Nt<et.length;Nt++)De(et[Nt],re,Ee,Ae);p(W.anchor,re,Ee);return}if(ht===pt){He(W,re,Ee);return}var Dt=Ae!==2&&je&1&&Ye;if(Dt)if(Ae===0)Ye.beforeEnter(tt),p(tt,re,Ee),R(()=>Ye.enter(tt),Me);else{var{leave:Ft,delayLeave:on,afterLeave:Vr}=Ye,nr=()=>p(tt,re,Ee),Kr=()=>{Ft(tt,()=>{nr(),Vr&&Vr()})};on?on(tt,nr,Kr):Kr()}else p(tt,re,Ee)},yt=function(W,re,Ee){var Ae=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1,Me=arguments.length>4&&arguments[4]!==void 0?arguments[4]:!1,{type:tt,props:ht,ref:Ye,children:et,dynamicChildren:je,shapeFlag:Nt,patchFlag:Dt,dirs:Ft}=W;if(Ye!=null&&ri(Ye,null,Ee,W,!0),Nt&256){re.ctx.deactivate(W);return}var on=Nt&1&&Ft,Vr=!Ti(W),nr;if(Vr&&(nr=ht&&ht.onVnodeBeforeUnmount)&&Dr(nr,re,W),Nt&6)ot(W.component,Ee,Ae);else{if(Nt&128){W.suspense.unmount(Ee,Ae);return}on&&H(W,null,re,"beforeUnmount"),Nt&64?W.type.remove(W,re,Ee,Me,Pn,Ae):je&&(tt!==Ge||Dt>0&&Dt&64)?dn(je,re,Ee,!1,!0):(tt===Ge&&Dt&(128|256)||!Me&&Nt&16)&&dn(et,re,Ee),Ae&&wt(W)}(Vr&&(nr=ht&&ht.onVnodeUnmounted)||on)&&R(()=>{nr&&Dr(nr,re,W),on&&H(W,null,re,"unmounted")},Ee)},wt=W=>{var{type:re,el:Ee,anchor:Ae,transition:Me}=W;if(re===Ge){at(Ee,Ae);return}if(re===pt){Re(W);return}var tt=()=>{y(Ee),Me&&!Me.persisted&&Me.afterLeave&&Me.afterLeave()};if(W.shapeFlag&1&&Me&&!Me.persisted){var{leave:ht,delayLeave:Ye}=Me,et=()=>ht(Ee,tt);Ye?Ye(W.el,tt,et):et()}else tt()},at=(W,re)=>{for(var Ee;W!==re;)Ee=Ce(W),y(W),W=Ee;y(re)},ot=(W,re,Ee)=>{var{bum:Ae,scope:Me,update:tt,subTree:ht,um:Ye}=W;Ae&&f.invokeArrayFns(Ae),Me.stop(),tt&&(tt.active=!1,yt(ht,W,re,Ee)),Ye&&R(Ye,re),R(()=>{W.isUnmounted=!0},re),re&&re.pendingBranch&&!re.isUnmounted&&W.asyncDep&&!W.asyncResolved&&W.suspenseId===re.pendingId&&(re.deps--,re.deps===0&&re.resolve())},dn=function(W,re,Ee){for(var Ae=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1,Me=arguments.length>4&&arguments[4]!==void 0?arguments[4]:!1,tt=arguments.length>5&&arguments[5]!==void 0?arguments[5]:0,ht=tt;ht<W.length;ht++)yt(W[ht],re,Ee,Ae,Me)},bn=W=>W.shapeFlag&6?bn(W.component.subTree):W.shapeFlag&128?W.suspense.next():Ce(W.anchor||W.el),tr=(W,re,Ee)=>{W==null?re._vnode&&yt(re._vnode,null,null,!0):me(re._vnode||null,W,re,null,null,null,Ee),Ur(),re._vnode=W},Pn={p:me,um:yt,m:De,r:wt,mt:he,mc:Ct,pc:ct,pbc:Jt,n:bn,o:i},$o,So;return s&&([$o,So]=s(Pn)),{render:tr,hydrate:$o,createApp:so(tr,$o)}}function Q(i,s){var{effect:d,update:p}=i;d.allowRecurse=p.allowRecurse=s}function ce(i,s){var d=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!1,p=i.children,y=s.children;if(f.isArray(p)&&f.isArray(y))for(var w=0;w<p.length;w++){var I=p[w],L=y[w];L.shapeFlag&1&&!L.dynamicChildren&&((L.patchFlag<=0||L.patchFlag===32)&&(L=y[w]=oi(y[w]),L.el=I.el),d||ce(I,L))}}function be(i){var s=i.slice(),d=[0],p,y,w,I,L,$=i.length;for(p=0;p<$;p++){var ee=i[p];if(ee!==0){if(y=d[d.length-1],i[y]<ee){s[p]=y,d.push(p);continue}for(w=0,I=d.length-1;w<I;)L=w+I>>1,i[d[L]]<ee?w=L+1:I=L;ee<i[d[w]]&&(w>0&&(s[p]=d[w-1]),d[w]=p)}}for(w=d.length,I=d[w-1];w-- >0;)d[w]=I,I=s[I];return d}var Oe=i=>i.__isTeleport,Ne=i=>i&&(i.disabled||i.disabled===""),ve=i=>typeof SVGElement!="undefined"&&i instanceof SVGElement,Fe=(i,s)=>{var d=i&&i.to;if(f.isString(d))if(s){var p=s(d);return p}else return null;else return d},rt={__isTeleport:!0,process(i,s,d,p,y,w,I,L,$,ee){var{mc:ie,pc:Ie,pbc:oe,o:{insert:Ce,querySelector:Be,createText:ft,createComment:At}}=ee,me=Ne(s.props),{shapeFlag:le,children:Se,dynamicChildren:qe}=s;if(i==null){var He=s.el=ft("",d),Re=s.anchor=ft("",d);Ce(He,d,p),Ce(Re,d,p);var lt=s.target=Fe(s.props,Be),xe=s.targetAnchor=ft("",d);lt&&(Ce(xe,lt),I=I||ve(lt));var It=(pe,Pe)=>{le&16&&ie(Se,pe,Pe,y,w,I,L,$)};me?It(d,Re):lt&&It(lt,xe)}else{s.el=i.el;var Ct=s.anchor=i.anchor,Bt=s.target=i.target,Jt=s.targetAnchor=i.targetAnchor,dt=Ne(i.props),F=dt?d:Bt,K=dt?Ct:Jt;if(I=I||ve(Bt),qe?(oe(i.dynamicChildren,qe,F,y,w,I,L),ce(i,s,!0)):$||Ie(i,s,F,K,y,w,I,L,!1),me)dt||bt(s,d,Ct,ee,1);else if((s.props&&s.props.to)!==(i.props&&i.props.to)){var he=s.target=Fe(s.props,Be);he&&bt(s,he,null,ee,0)}else dt&&bt(s,Bt,Jt,ee,1)}},remove(i,s,d,p,y,w){var{um:I,o:{remove:L}}=y,{shapeFlag:$,children:ee,anchor:ie,targetAnchor:Ie,target:oe,props:Ce}=i;if(oe&&L(Ie),(w||!Ne(Ce))&&(L(ie),$&16))for(var Be=0;Be<ee.length;Be++){var ft=ee[Be];I(ft,s,d,!0,!!ft.dynamicChildren)}},move:bt,hydrate:Wt};function bt(i,s,d,p){var{o:{insert:y},m:w}=p,I=arguments.length>4&&arguments[4]!==void 0?arguments[4]:2;I===0&&y(i.targetAnchor,s,d);var{el:L,anchor:$,shapeFlag:ee,children:ie,props:Ie}=i,oe=I===2;if(oe&&y(L,s,d),(!oe||Ne(Ie))&&ee&16)for(var Ce=0;Ce<ie.length;Ce++)w(ie[Ce],s,d,2);oe&&y($,s,d)}function Wt(i,s,d,p,y,w,I,L){var{o:{nextSibling:$,parentNode:ee,querySelector:ie}}=I,Ie=s.target=Fe(s.props,ie);if(Ie){var oe=Ie._lpa||Ie.firstChild;if(s.shapeFlag&16)if(Ne(s.props))s.anchor=L($(i),s,ee(i),d,p,y,w),s.targetAnchor=oe;else{s.anchor=$(i);for(var Ce=oe;Ce;)if(Ce=$(Ce),Ce&&Ce.nodeType===8&&Ce.data==="teleport anchor"){s.targetAnchor=Ce,Ie._lpa=s.targetAnchor&&$(s.targetAnchor);break}L(oe,s,Ie,d,p,y,w)}}return s.anchor&&$(s.anchor)}var nt=rt,Ge=Symbol(void 0),ut=Symbol(void 0),Vt=Symbol(void 0),pt=Symbol(void 0),Ze=[],Ot=null;function wn(){var i=arguments.length>0&&arguments[0]!==void 0?arguments[0]:!1;Ze.push(Ot=i?null:[])}function un(){Ze.pop(),Ot=Ze[Ze.length-1]||null}var rn=1;function Sn(i){rn+=i}function Ht(i){return i.dynamicChildren=rn>0?Ot||f.EMPTY_ARR:null,un(),rn>0&&Ot&&Ot.push(i),i}function Ln(i,s,d,p,y,w){return Ht(Lt(i,s,d,p,y,w,!0))}function mi(i,s,d,p,y){return Ht(fn(i,s,d,p,y,!0))}function or(i){return i?i.__v_isVNode===!0:!1}function Er(i,s){return i.type===s.type&&i.key===s.key}function Bo(i){}var Wi="__vInternal",Mo=i=>{var{key:s}=i;return s!=null?s:null},Lo=i=>{var{ref:s,ref_key:d,ref_for:p}=i;return s!=null?f.isString(s)||T.isRef(s)||f.isFunction(s)?{i:On,r:s,k:d,f:!!p}:s:null};function Lt(i){var s=arguments.length>1&&arguments[1]!==void 0?arguments[1]:null,d=arguments.length>2&&arguments[2]!==void 0?arguments[2]:null,p=arguments.length>3&&arguments[3]!==void 0?arguments[3]:0,y=arguments.length>4&&arguments[4]!==void 0?arguments[4]:null,w=arguments.length>5&&arguments[5]!==void 0?arguments[5]:i===Ge?0:1,I=arguments.length>6&&arguments[6]!==void 0?arguments[6]:!1,L=arguments.length>7&&arguments[7]!==void 0?arguments[7]:!1,$={__v_isVNode:!0,__v_skip:!0,type:i,props:s,key:s&&Mo(s),ref:s&&Lo(s),scopeId:ci,slotScopeIds:null,children:d,component:null,suspense:null,ssContent:null,ssFallback:null,dirs:null,transition:null,el:null,anchor:null,target:null,targetAnchor:null,staticCount:0,shapeFlag:w,patchFlag:p,dynamicProps:y,dynamicChildren:null,appContext:null};return L?(Aa($,d),w&128&&i.normalize($)):d&&($.shapeFlag|=f.isString(d)?8:16),rn>0&&!I&&Ot&&($.patchFlag>0||w&6)&&$.patchFlag!==32&&Ot.push($),$}var fn=co;function co(i){var s=arguments.length>1&&arguments[1]!==void 0?arguments[1]:null,d=arguments.length>2&&arguments[2]!==void 0?arguments[2]:null,p=arguments.length>3&&arguments[3]!==void 0?arguments[3]:0,y=arguments.length>4&&arguments[4]!==void 0?arguments[4]:null,w=arguments.length>5&&arguments[5]!==void 0?arguments[5]:!1;if((!i||i===ue)&&(i=Vt),or(i)){var I=ii(i,s,!0);return d&&Aa(I,d),rn>0&&!w&&Ot&&(I.shapeFlag&6?Ot[Ot.indexOf(i)]=I:Ot.push(I)),I.patchFlag|=-2,I}if(Fo(i)&&(i=i.__vccOpts),s){s=qr(s);var{class:L,style:$}=s;L&&!f.isString(L)&&(s.class=f.normalizeClass(L)),f.isObject($)&&(T.isProxy($)&&!f.isArray($)&&($=f.extend({},$)),s.style=f.normalizeStyle($))}var ee=f.isString(i)?1:Ar(i)?128:Oe(i)?64:f.isObject(i)?4:f.isFunction(i)?2:0;return Lt(i,s,d,p,y,ee,w,!0)}function qr(i){return i?T.isProxy(i)||Wi in i?f.extend({},i):i:null}function ii(i,s){var d=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!1,{props:p,ref:y,patchFlag:w,children:I}=i,L=s?Pr(p||{},s):p,$={__v_isVNode:!0,__v_skip:!0,type:i.type,props:L,key:L&&Mo(L),ref:s&&s.ref?d&&y?f.isArray(y)?y.concat(Lo(s)):[y,Lo(s)]:Lo(s):y,scopeId:i.scopeId,slotScopeIds:i.slotScopeIds,children:I,target:i.target,targetAnchor:i.targetAnchor,staticCount:i.staticCount,shapeFlag:i.shapeFlag,patchFlag:s&&i.type!==Ge?w===-1?16:w|16:w,dynamicProps:i.dynamicProps,dynamicChildren:i.dynamicChildren,appContext:i.appContext,dirs:i.dirs,transition:i.transition,component:i.component,suspense:i.suspense,ssContent:i.ssContent&&ii(i.ssContent),ssFallback:i.ssFallback&&ii(i.ssFallback),el:i.el,anchor:i.anchor};return $}function Do(){var i=arguments.length>0&&arguments[0]!==void 0?arguments[0]:" ",s=arguments.length>1&&arguments[1]!==void 0?arguments[1]:0;return fn(ut,null,i,s)}function uo(i,s){var d=fn(pt,null,i);return d.staticCount=s,d}function Xn(){var i=arguments.length>0&&arguments[0]!==void 0?arguments[0]:"",s=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!1;return s?(wn(),mi(Vt,null,i)):fn(Vt,null,i)}function Yt(i){return i==null||typeof i=="boolean"?fn(Vt):f.isArray(i)?fn(Ge,null,i.slice()):typeof i=="object"?oi(i):fn(ut,null,String(i))}function oi(i){return i.el===null||i.memo?i:ii(i)}function Aa(i,s){var d=0,{shapeFlag:p}=i;if(s==null)s=null;else if(f.isArray(s))d=16;else if(typeof s=="object")if(p&(1|64)){var y=s.default;y&&(y._c&&(y._d=!1),Aa(i,y()),y._c&&(y._d=!0));return}else{d=32;var w=s._;!w&&!(Wi in s)?s._ctx=On:w===3&&On&&(On.slots._===1?s._=1:(s._=2,i.patchFlag|=1024))}else f.isFunction(s)?(s={default:s,_ctx:On},d=32):(s=String(s),p&64?(d=16,s=[Do(s)]):d=8);i.children=s,i.shapeFlag|=d}function Pr(){for(var i={},s=0;s<arguments.length;s++){var d=s<0||arguments.length<=s?void 0:arguments[s];for(var p in d)if(p==="class")i.class!==d.class&&(i.class=f.normalizeClass([i.class,d.class]));else if(p==="style")i.style=f.normalizeStyle([i.style,d.style]);else if(f.isOn(p)){var y=i[p],w=d[p];w&&y!==w&&!(f.isArray(y)&&y.includes(w))&&(i[p]=y?[].concat(y,w):w)}else p!==""&&(i[p]=d[p])}return i}function Dr(i,s,d){var p=arguments.length>3&&arguments[3]!==void 0?arguments[3]:null;Y(i,s,7,[d,p])}var Ts=Sa(),rs=0;function Gn(i,s,d){var p=i.type,y=(s?s.appContext:i.appContext)||Ts,w={uid:rs++,vnode:i,type:p,parent:s,appContext:y,root:null,next:null,subTree:null,effect:null,update:null,scope:new T.EffectScope(!0),render:null,proxy:null,exposed:null,exposeProxy:null,withProxy:null,provides:s?s.provides:Object.create(y.provides),accessCache:null,renderCache:[],components:null,directives:null,propsOptions:Go(p,y),emitsOptions:hr(p,y),emit:null,emitted:null,propsDefaults:f.EMPTY_OBJ,inheritAttrs:p.inheritAttrs,ctx:f.EMPTY_OBJ,data:f.EMPTY_OBJ,props:f.EMPTY_OBJ,attrs:f.EMPTY_OBJ,slots:f.EMPTY_OBJ,refs:f.EMPTY_OBJ,setupState:f.EMPTY_OBJ,setupContext:null,suspense:d,suspenseId:d?d.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 w.ctx={_:w},w.root=s?s.root:w,w.emit=To.bind(null,w),i.ce&&i.ce(w),w}var An=null,Qn=()=>An||On,Fr=i=>{An=i,i.scope.on()},ki=()=>{An&&An.scope.off(),An=null};function ai(i){return i.vnode.shapeFlag&4}S.isInSSRComponentSetup=!1;function Ca(i){var s=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!1;S.isInSSRComponentSetup=s;var{props:d,children:p}=i.vnode,y=ai(i);Wo(i,d,y,s),wa(i,p);var w=y?Yo(i,s):void 0;return S.isInSSRComponentSetup=!1,w}function Yo(i,s){var d=i.type;i.accessCache=Object.create(null),i.proxy=T.markRaw(new Proxy(i.ctx,Ra));var{setup:p}=d;if(p){var y=i.setupContext=p.length>1?Tt(i):null;Fr(i),T.pauseTracking();var w=st(p,i,0,[i.props,y]);if(T.resetTracking(),ki(),f.isPromise(w)){if(w.then(ki,ki),s)return w.then(I=>{Gi(i,I,s)}).catch(I=>{te(I,i,0)});i.asyncDep=w}else Gi(i,w,s)}else is(i,s)}function Gi(i,s,d){f.isFunction(s)?i.type.__ssrInlineRender?i.ssrRender=s:i.render=s:f.isObject(s)&&(i.setupState=T.proxyRefs(s)),is(i,d)}var Yi,qi;function Oa(i){Yi=i,qi=s=>{s.render._rc&&(s.withProxy=new Proxy(s.ctx,na))}}var Da=()=>!Yi;function is(i,s,d){var p=i.type;if(!i.render){if(!s&&Yi&&!p.render){var y=p.template;if(y){var{isCustomElement:w,compilerOptions:I}=i.appContext.config,{delimiters:L,compilerOptions:$}=p,ee=f.extend(f.extend({isCustomElement:w,delimiters:L},I),$);p.render=Yi(y,ee)}}i.render=p.render||f.NOOP,qi&&qi(i)}Fr(i),T.pauseTracking(),ts(i),T.resetTracking(),ki()}function Ve(i){return new Proxy(i.attrs,{get(s,d){return T.track(i,"get","$attrs"),s[d]}})}function Tt(i){var s=p=>{i.exposed=p||{}},d;return{get attrs(){return d||(d=Ve(i))},slots:i.slots,emit:i.emit,expose:s}}function Rt(i){if(i.exposed)return i.exposeProxy||(i.exposeProxy=new Proxy(T.proxyRefs(T.markRaw(i.exposed)),{get(s,d){if(d in s)return s[d];if(d in oo)return oo[d](i)}}))}var Tn=/(?:^|[-_])(\w)/g,er=i=>i.replace(Tn,s=>s.toUpperCase()).replace(/[-_]/g,"");function St(i){var s=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!0;return f.isFunction(i)?i.displayName||i.name:i.name||s&&i.__name}function yo(i,s){var d=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!1,p=St(s);if(!p&&s.__file){var y=s.__file.match(/([^/\\]+)\.\w+$/);y&&(p=y[1])}if(!p&&i&&i.parent){var w=I=>{for(var L in I)if(I[L]===s)return L};p=w(i.components||i.parent.type.components)||w(i.appContext.components)}return p?er(p):d?"App":"Anonymous"}function Fo(i){return f.isFunction(i)&&"__vccOpts"in i}var ca=(i,s)=>T.computed(i,s,S.isInSSRComponentSetup);function Ps(){return null}function qo(){return null}function zl(i){}function al(i,s){return null}function Wl(){return ll().slots}function sl(){return ll().attrs}function ll(){var i=Qn();return i.setupContext||(i.setupContext=Tt(i))}function Is(i,s){var d=f.isArray(i)?i.reduce((w,I)=>(w[I]={},w),{}):i;for(var p in s){var y=d[p];y?f.isArray(y)||f.isFunction(y)?d[p]={type:y,default:s[p]}:y.default=s[p]:y===null&&(d[p]={default:s[p]})}return d}function Fa(i,s){var d={},p=function(w){s.includes(w)||Object.defineProperty(d,w,{enumerable:!0,get:()=>i[w]})};for(var y in i)p(y);return d}function Va(i){var s=Qn(),d=i();return ki(),f.isPromise(d)&&(d=d.catch(p=>{throw Fr(s),p})),[d,()=>Fr(s)]}function Ko(i,s,d){var p=arguments.length;return p===2?f.isObject(s)&&!f.isArray(s)?or(s)?fn(i,null,[s]):fn(i,s):fn(i,null,s):(p>3?d=Array.prototype.slice.call(arguments,2):p===3&&or(d)&&(d=[d]),fn(i,s,d))}var os=Symbol(""),cl=()=>{{var i=ui(os);return i||xt("Server rendering context not provided. Make sure to only call useSSRContext() conditionally in the server build."),i}};function ua(){}function as(i,s,d,p){var y=d[p];if(y&&Ns(y,i))return y;var w=s();return w.memo=i.slice(),d[p]=w}function Ns(i,s){var d=i.memo;if(d.length!=s.length)return!1;for(var p=0;p<d.length;p++)if(f.hasChanged(d[p],s[p]))return!1;return rn>0&&Ot&&Ot.push(i),!0}var ss="3.2.37",ul={createComponentInstance:Gn,setupComponent:Ca,renderComponentRoot:Sr,setCurrentRenderingInstance:Qi,isVNode:or,normalizeVNode:Yt},fl=ul,Ta=null,$a=null;function fa(i,s){return i==="input"?new N.UniInputElement(i,s):i==="textarea"?new N.UniTextAreaElement(i,s):new N.UniElement(i,s)}function dl(i,s){return new N.UniTextNode(i,s)}function Ua(i,s){return new N.UniCommentNode(i,s)}var ks,wo={insert:(i,s,d)=>{s.insertBefore(i,d||null)},remove:i=>{var s=i.parentNode;s&&s.removeChild(i)},createElement:(i,s)=>fa(i,s),createText:(i,s)=>dl(i,s),createComment:(i,s)=>Ua(i,s),setText:(i,s)=>{i.nodeValue=s},setElementText:(i,s)=>{i.textContent=s},parentNode:i=>i.parentNode,nextSibling:i=>i.nextSibling,setScopeId(i,s){i.setAttribute(s,"")},cloneNode(i){var s=i.cloneNode(!0);return"_value"in i&&(s._value=i._value),s},insertStaticContent(i,s,d){var p=ks||(ks=fa("div"));p.innerHTML=i;for(var y=p.firstChild,w=y,I=w;w;)I=w,wo.insert(w,s,d),w=p.firstChild;return[y,I]}};function Ha(i,s){s==null&&(s=""),i.setAttribute("class",s)}function ja(i,s,d){if(!d)i.removeAttribute("style");else if(f.isString(d))s!==d&&i.setAttribute("style",d);else{var p={},y=s&&!f.isString(s);if(y){for(var w in s)d[w]==null&&(p[w]="");for(var I in d){var L=d[I];L!==s[I]&&(p[I]=L)}}else for(var $ in d)p[$]=d[$];Object.keys(p).length&&i.setAttribute("style",p)}}function Pa(i,s,d){d==null?i.removeAttribute(s):i.setAttribute(s,d)}function ls(i,s,d,p){i.addEventListener(s,d,p)}function za(i,s,d,p){i.removeEventListener(s,d,p)}function cs(i,s,d,p){var y=arguments.length>4&&arguments[4]!==void 0?arguments[4]:null,w=i._vei||(i._vei={}),I=w[s];if(p&&I)I.value=p;else{var[L,$]=us(s);if(p){var ee=w[s]=xs(p,y);ls(i,L,ee,$)}else I&&(za(i,L,I,$),w[s]=void 0)}}var Rs=/(?:Once|Passive|Capture)$/;function us(i){var s;if(Rs.test(i)){s={};for(var d;d=i.match(Rs);)i=i.slice(0,i.length-d[0].length),s[d[0].toLowerCase()]=!0}return[f.hyphenate(i.slice(2)),s]}function xs(i,s){var d=y=>{Y(d.value,s,5,[y])};d.value=i;var p=new Set;return f.isArray(d.value)?d.value.forEach(y=>{y.modifiers&&y.modifiers.forEach(w=>{p.add(w)})}):(d.value.modifiers&&d.value.modifiers.forEach(y=>{p.add(y)}),fs(d,s)),d.modifiers=[...p],d}function fs(i,s){if(!!s){var{$wxsModules:d}=s;if(!!d){var p=i.value.toString();!d.find(y=>p.indexOf("."+y+".")>-1)||(i.wxsEvent=i.value())}}}var hl=function(i,s,d,p){var y=arguments.length>6?arguments[6]:void 0;switch(s){case"class":Ha(i,p);break;case"style":ja(i,d,p);break;default:if(f.isOn(s))f.isModelListener(s)||cs(i,s,d,p,y);else{if(f.isObject(p)){var w=d===p;if(p=N.JSON_PROTOCOL+JSON.stringify(p),w&&i.getAttribute(s)===p)return}else if(d===p)return;Pa(i,s,p)}break}};function Wa(){var i=arguments.length>0&&arguments[0]!==void 0?arguments[0]:"$style";{var s=Qn();if(!s)return f.EMPTY_OBJ;var d=s.type.__cssModules;if(!d)return f.EMPTY_OBJ;var p=d[i];return p||f.EMPTY_OBJ}}function _i(i){var s=Qn();if(!!s){var d=()=>Ki(s.subTree,i(s.proxy));gi(()=>qn(d,{flush:"post"})),Yr(d)}}function Ki(i,s){if(i.shapeFlag&128){var d=i.suspense;i=d.activeBranch,d.pendingBranch&&!d.isHydrating&&d.effects.push(()=>{Ki(d.activeBranch,s)})}for(;i.component;)i=i.component.subTree;if(i.shapeFlag&1&&i.el)Bs(i.el,s);else if(i.type===Ge)i.children.forEach(w=>Ki(w,s));else if(i.type===pt)for(var{el:p,anchor:y}=i;p&&(Bs(p,s),p!==y);)p=p.nextSibling}function Bs(i,s){if(i.nodeType===1)for(var d in s)i.setAttribute("--".concat(d),s[d])}var Jo="transition",Ga="animation",ds=(i,s)=>{var{slots:d}=s;return Ko(Oi,Ms(i),d)};ds.displayName="Transition";var gl={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},pl=ds.props=f.extend({},Oi.props,gl),Vo=function(i){var s=arguments.length>1&&arguments[1]!==void 0?arguments[1]:[];f.isArray(i)?i.forEach(d=>d(...s)):i&&i(...s)},vl=i=>i?f.isArray(i)?i.some(s=>s.length>1):i.length>1:!1;function Ms(i){var s={};for(var d in i)d in gl||(s[d]=i[d]);if(i.css===!1)return s;var{name:p="v",type:y,duration:w,enterFromClass:I="".concat(p,"-enter-from"),enterActiveClass:L="".concat(p,"-enter-active"),enterToClass:$="".concat(p,"-enter-to"),appearFromClass:ee=I,appearActiveClass:ie=L,appearToClass:Ie=$,leaveFromClass:oe="".concat(p,"-leave-from"),leaveActiveClass:Ce="".concat(p,"-leave-active"),leaveToClass:Be="".concat(p,"-leave-to")}=i,ft=Ls(w),At=ft&&ft[0],me=ft&&ft[1],{onBeforeEnter:le,onEnter:Se,onEnterCancelled:qe,onLeave:He,onLeaveCancelled:Re,onBeforeAppear:lt=le,onAppear:xe=Se,onAppearCancelled:It=qe}=s,Ct=(dt,F,K)=>{Zo(dt,F?Ie:$),Zo(dt,F?ie:L),K&&K()},Bt=(dt,F)=>{Zo(dt,Be),Zo(dt,Ce),F&&F()},Jt=dt=>(F,K)=>{var he=dt?xe:Se,pe=()=>Ct(F,dt,K);Vo(he,[F,pe]),Ds(()=>{Zo(F,dt?ee:I),fo(F,dt?Ie:$),vl(he)||ml(F,y,At,pe)})};return f.extend(s,{onBeforeEnter(dt){Vo(le,[dt]),fo(dt,I),fo(dt,L)},onBeforeAppear(dt){Vo(lt,[dt]),fo(dt,ee),fo(dt,ie)},onEnter:Jt(!1),onAppear:Jt(!0),onLeave(dt,F){var K=()=>Bt(dt,F);fo(dt,oe),Vs(),fo(dt,Ce),Ds(()=>{Zo(dt,oe),fo(dt,Be),vl(He)||ml(dt,y,me,K)}),Vo(He,[dt,K])},onEnterCancelled(dt){Ct(dt,!1),Vo(qe,[dt])},onAppearCancelled(dt){Ct(dt,!0),Vo(It,[dt])},onLeaveCancelled(dt){Bt(dt),Vo(Re,[dt])}})}function Ls(i){if(i==null)return null;if(f.isObject(i))return[hs(i.enter),hs(i.leave)];var s=hs(i);return[s,s]}function hs(i){var s=f.toNumber(i);return s}function fo(i,s){s.split(/\s+/).forEach(d=>d&&i.classList.add(d)),(i._vtc||(i._vtc=new Set)).add(s)}function Zo(i,s){s.split(/\s+/).forEach(p=>p&&i.classList.remove(p));var{_vtc:d}=i;d&&(d.delete(s),d.size||(i._vtc=void 0))}function Ds(i){requestAnimationFrame(()=>{requestAnimationFrame(i)})}var Gl=0;function ml(i,s,d,p){var y=i._endId=++Gl,w=()=>{y===i._endId&&p()};if(d)return setTimeout(w,d);var{type:I,timeout:L,propCount:$}=gs(i,s);if(!I)return p();var ee=I+"end",ie=0,Ie=()=>{i.removeEventListener(ee,oe),w()},oe=Ce=>{Ce.target===i&&++ie>=$&&Ie()};setTimeout(()=>{ie<$&&Ie()},L+1),i.addEventListener(ee,oe)}function gs(i,s){var d=window.getComputedStyle(i),p=Be=>(d[Be]||"").split(", "),y=p(Jo+"Delay"),w=p(Jo+"Duration"),I=Fs(y,w),L=p(Ga+"Delay"),$=p(Ga+"Duration"),ee=Fs(L,$),ie=null,Ie=0,oe=0;s===Jo?I>0&&(ie=Jo,Ie=I,oe=w.length):s===Ga?ee>0&&(ie=Ga,Ie=ee,oe=$.length):(Ie=Math.max(I,ee),ie=Ie>0?I>ee?Jo:Ga:null,oe=ie?ie===Jo?w.length:$.length:0);var Ce=ie===Jo&&/\b(transform|all)(,|$)/.test(d[Jo+"Property"]);return{type:ie,timeout:Ie,propCount:oe,hasTransform:Ce}}function Fs(i,s){for(;i.length<s.length;)i=i.concat(i);return Math.max(...s.map((d,p)=>_l(d)+_l(i[p])))}function _l(i){return Number(i.slice(0,-1).replace(",","."))*1e3}function Vs(){return document.body.offsetHeight}var bl=new WeakMap,El=new WeakMap,yl={name:"TransitionGroup",props:f.extend({},pl,{tag:String,moveClass:String}),setup(i,s){var{slots:d}=s,p=Qn(),y=Hn(),w,I;return Yr(()=>{if(!!w.length){var L=i.moveClass||"".concat(i.name||"v","-move");if(!!c(w[0].el,p.vnode.el,L)){w.forEach(Yl),w.forEach(ql);var $=w.filter(o);Vs(),$.forEach(ee=>{var ie=ee.el,Ie=ie.style;fo(ie,L),Ie.transform=Ie.webkitTransform=Ie.transitionDuration="";var oe=ie._moveCb=Ce=>{Ce&&Ce.target!==ie||(!Ce||/transform$/.test(Ce.propertyName))&&(ie.removeEventListener("transitionend",oe),ie._moveCb=null,Zo(ie,L))};ie.addEventListener("transitionend",oe)})}}}),()=>{var L=T.toRaw(i),$=Ms(L),ee=L.tag||Ge;w=I,I=d.default?Or(d.default()):[];for(var ie=0;ie<I.length;ie++){var Ie=I[ie];Ie.key!=null&&Wn(Ie,fi(Ie,$,y,p))}if(w)for(var oe=0;oe<w.length;oe++){var Ce=w[oe];Wn(Ce,fi(Ce,$,y,p)),bl.set(Ce,Ce.el.getBoundingClientRect())}return fn(ee,null,I)}}},wl=yl;function Yl(i){var s=i.el;s._moveCb&&s._moveCb(),s._enterCb&&s._enterCb()}function ql(i){El.set(i,i.el.getBoundingClientRect())}function o(i){var s=bl.get(i),d=El.get(i),p=s.left-d.left,y=s.top-d.top;if(p||y){var w=i.el.style;return w.transform=w.webkitTransform="translate(".concat(p,"px,").concat(y,"px)"),w.transitionDuration="0s",i}}function c(i,s,d){var p=i.cloneNode();i._vtc&&i._vtc.forEach(I=>{I.split(/\s+/).forEach(L=>L&&p.classList.remove(L))}),d.split(/\s+/).forEach(I=>I&&p.classList.add(I)),p.style.display="none";var y=s.nodeType===1?s:s.parentNode;y.appendChild(p);var{hasTransform:w}=gs(p);return y.removeChild(p),w}var v=i=>{var s=i.props["onUpdate:modelValue"];return f.isArray(s)?d=>f.invokeArrayFns(s,d):s},E={created(i,s,d){var{value:p,modifiers:{trim:y,number:w}}=s;i.value=p==null?"":p,i._assign=v(d),ls(i,"input",I=>{var L=I.detail.value,$=i.pageNode;i.pageNode=null,i.value=L,i.pageNode=$,y?L=L.trim():w&&(L=f.toNumber(L)),i._assign(L)})},beforeUpdate(i,s,d){var{value:p}=s;i._assign=v(d);var y=p==null?"":p;i.value!==y&&(i.value=y)}},P=E,C=["ctrl","shift","alt","meta"],V={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,s)=>C.some(d=>i["".concat(d,"Key")]&&!s.includes(d))},G=(i,s)=>{var d=function(p){for(var y=0;y<s.length;y++){var w=V[s[y]];if(w&&w(p,s))return}for(var I=arguments.length,L=new Array(I>1?I-1:0),$=1;$<I;$++)L[$-1]=arguments[$];return i(p,...L)};return d.modifiers=s,d},q={esc:"escape",space:" ",up:"arrow-up",left:"arrow-left",right:"arrow-right",down:"arrow-down",delete:"backspace"},ae=(i,s)=>d=>{if("key"in d){var p=f.hyphenate(d.key);if(s.some(y=>y===p||q[y]===p))return i(d)}},Le={beforeMount(i,s){var{value:d}=s;Xe(i,d)},updated(i,s){var{value:d,oldValue:p}=s;!d!=!p&&Xe(i,d)},beforeUnmount(i,s){var{value:d}=s;Xe(i,d)}};function Xe(i,s){i.setAttribute(".vShow",!!s)}var se=f.extend({patchProp:hl,forcePatchProp:N.forcePatchProp},wo),$e;function We(){return $e||($e=z(se))}var _t=function(){We().render(...arguments)},Pt=function(){var i=We().createApp(...arguments),{mount:s}=i;return i.mount=d=>(f.isString(d)&&(d=Ua(d)),d&&s(d,!1,!1)),i},_e=Pt;function fe(){}function Te(){}return Object.defineProperty(S,"camelize",{enumerable:!0,get:function(){return f.camelize}}),Object.defineProperty(S,"capitalize",{enumerable:!0,get:function(){return f.capitalize}}),Object.defineProperty(S,"normalizeClass",{enumerable:!0,get:function(){return f.normalizeClass}}),Object.defineProperty(S,"normalizeProps",{enumerable:!0,get:function(){return f.normalizeProps}}),Object.defineProperty(S,"normalizeStyle",{enumerable:!0,get:function(){return f.normalizeStyle}}),Object.defineProperty(S,"toDisplayString",{enumerable:!0,get:function(){return f.toDisplayString}}),Object.defineProperty(S,"toHandlerKey",{enumerable:!0,get:function(){return f.toHandlerKey}}),Object.defineProperty(S,"EffectScope",{enumerable:!0,get:function(){return T.EffectScope}}),Object.defineProperty(S,"ReactiveEffect",{enumerable:!0,get:function(){return T.ReactiveEffect}}),Object.defineProperty(S,"customRef",{enumerable:!0,get:function(){return T.customRef}}),Object.defineProperty(S,"effect",{enumerable:!0,get:function(){return T.effect}}),Object.defineProperty(S,"effectScope",{enumerable:!0,get:function(){return T.effectScope}}),Object.defineProperty(S,"getCurrentScope",{enumerable:!0,get:function(){return T.getCurrentScope}}),Object.defineProperty(S,"isProxy",{enumerable:!0,get:function(){return T.isProxy}}),Object.defineProperty(S,"isReactive",{enumerable:!0,get:function(){return T.isReactive}}),Object.defineProperty(S,"isReadonly",{enumerable:!0,get:function(){return T.isReadonly}}),Object.defineProperty(S,"isRef",{enumerable:!0,get:function(){return T.isRef}}),Object.defineProperty(S,"isShallow",{enumerable:!0,get:function(){return T.isShallow}}),Object.defineProperty(S,"markRaw",{enumerable:!0,get:function(){return T.markRaw}}),Object.defineProperty(S,"onScopeDispose",{enumerable:!0,get:function(){return T.onScopeDispose}}),Object.defineProperty(S,"proxyRefs",{enumerable:!0,get:function(){return T.proxyRefs}}),Object.defineProperty(S,"reactive",{enumerable:!0,get:function(){return T.reactive}}),Object.defineProperty(S,"readonly",{enumerable:!0,get:function(){return T.readonly}}),Object.defineProperty(S,"ref",{enumerable:!0,get:function(){return T.ref}}),Object.defineProperty(S,"shallowReactive",{enumerable:!0,get:function(){return T.shallowReactive}}),Object.defineProperty(S,"shallowReadonly",{enumerable:!0,get:function(){return T.shallowReadonly}}),Object.defineProperty(S,"shallowRef",{enumerable:!0,get:function(){return T.shallowRef}}),Object.defineProperty(S,"stop",{enumerable:!0,get:function(){return T.stop}}),Object.defineProperty(S,"toRaw",{enumerable:!0,get:function(){return T.toRaw}}),Object.defineProperty(S,"toRef",{enumerable:!0,get:function(){return T.toRef}}),Object.defineProperty(S,"toRefs",{enumerable:!0,get:function(){return T.toRefs}}),Object.defineProperty(S,"triggerRef",{enumerable:!0,get:function(){return T.triggerRef}}),Object.defineProperty(S,"unref",{enumerable:!0,get:function(){return T.unref}}),S.BaseTransition=Oi,S.Comment=Vt,S.Fragment=Ge,S.KeepAlive=Ui,S.Static=pt,S.Suspense=zn,S.Teleport=nt,S.Text=ut,S.Transition=ds,S.TransitionGroup=wl,S.callWithAsyncErrorHandling=Y,S.callWithErrorHandling=st,S.cloneVNode=ii,S.compatUtils=$a,S.computed=ca,S.createApp=Pt,S.createBlock=mi,S.createComment=Ua,S.createCommentVNode=Xn,S.createElement=fa,S.createElementBlock=Ln,S.createElementVNode=Lt,S.createHydrationRenderer=j,S.createPropsRestProxy=Fa,S.createRenderer=z,S.createSSRApp=_e,S.createSlots=ea,S.createStaticVNode=uo,S.createTextNode=dl,S.createTextVNode=Do,S.createVNode=fn,S.createVueApp=Pt,S.defineAsyncComponent=ko,S.defineComponent=In,S.defineEmits=qo,S.defineExpose=zl,S.defineProps=Ps,S.getCurrentInstance=Qn,S.getTransitionRawChildren=Or,S.guardReactiveProps=qr,S.h=Ko,S.handleError=te,S.initCustomFormatter=ua,S.inject=ui,S.injectHook=vr,S.isMemoSame=Ns,S.isRuntimeOnly=Da,S.isVNode=or,S.mergeDefaults=Is,S.mergeProps=Pr,S.nextTick=qt,S.onActivated=pr,S.onBeforeActivate=fe,S.onBeforeDeactivate=Te,S.onBeforeMount=Pi,S.onBeforeUnmount=vi,S.onBeforeUpdate=pi,S.onDeactivated=Jn,S.onErrorCaptured=ne,S.onMounted=gi,S.onRenderTracked=x,S.onRenderTriggered=io,S.onServerPrefetch=ji,S.onUnmounted=ro,S.onUpdated=Yr,S.openBlock=wn,S.popScopeId=go,S.provide=Ai,S.pushScopeId=eo,S.queuePostFlushCb=xn,S.registerRuntimeCompiler=Oa,S.render=_t,S.renderList=mr,S.renderSlot=zo,S.resolveComponent=X,S.resolveDirective=Mn,S.resolveDynamicComponent=tn,S.resolveFilter=Ta,S.resolveTransitionHooks=fi,S.setBlockTracking=Sn,S.setDevtoolsHook=Oo,S.setTransitionHooks=Wn,S.ssrContextKey=os,S.ssrUtils=fl,S.toHandlers=Ro,S.transformVNodeArgs=Bo,S.useAttrs=sl,S.useCssModule=Wa,S.useCssVars=_i,S.useSSRContext=cl,S.useSlots=Wl,S.useTransitionState=Hn,S.vModelDynamic=P,S.vModelText=E,S.vShow=Le,S.version=ss,S.warn=xt,S.watch=ye,S.watchEffect=qn,S.watchPostEffect=Cr,S.watchSyncEffect=Vi,S.withAsyncContext=Va,S.withCtx=cr,S.withDefaults=al,S.withDirectives=de,S.withKeys=ae,S.withMemo=as,S.withModifiers=G,S.withScopeId=Si,Object.defineProperty(S,"__esModule",{value:!0}),S}({},l,_,A);return k.__TYPE__="vue",k}function Fp(g,l,_){let A=_.Vue,k=_.setTimeout,S=_.clearTimeout,N=_.setInterval,f=_.clearInterval,T=_.__uniConfig,ze=_.__uniRoutes,xt=_.VueShared,pn=_.UniShared;var B=function(Y,te,En){"use strict";var yn="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",ln=function(){let e=new Uint8Array(256);for(var t=0;t<yn.length;t++)e[yn.charCodeAt(t)]=t;return e}();function $n(e){var t=new Uint8Array(e),n,r=t.length,a="";for(n=0;n<r;n+=3)a+=yn[t[n]>>2],a+=yn[(t[n]&3)<<4|t[n+1]>>4],a+=yn[(t[n+1]&15)<<2|t[n+2]>>6],a+=yn[t[n+2]&63];return r%3===2?a=a.substring(0,a.length-1)+"=":r%3===1&&(a=a.substring(0,a.length-2)+"=="),a}function an(e){var t=e.length*.75,n=e.length,r,a=0,u,h,b,U;e[e.length-1]==="="&&(t--,e[e.length-2]==="="&&t--);var O=new ArrayBuffer(t),D=new Uint8Array(O);for(r=0;r<n;r+=4)u=ln[e.charCodeAt(r)],h=ln[e.charCodeAt(r+1)],b=ln[e.charCodeAt(r+2)],U=ln[e.charCodeAt(r+3)],D[a++]=u<<2|h>>4,D[a++]=(h&15)<<4|b>>2,D[a++]=(b&3)<<6|U&63;return O}let kn=["original","compressed"],Un=["album","camera"],mn=["GET","OPTIONS","HEAD","POST","PUT","DELETE","TRACE","CONNECT","PATCH"];function sn(e,t){return!e||t.indexOf(e)===-1?t[0]:e}function _n(e,t){return!Y.isArray(e)||e.length===0||e.find(n=>t.indexOf(n)===-1)?t:e}function Rn(e,t){console.warn(`${e}: ${t}`)}function kr(e,t,n,r){r||(r=Rn);for(let a in n){let u=Ue(a,t[a],n[a],!Y.hasOwn(t,a));Y.isString(u)&&r(e,u)}}function Zr(e,t,n,r){if(!n)return;if(!Y.isArray(n))return kr(e,t[0]||Object.create(null),n,r);let a=n.length,u=t.length;for(let h=0;h<a;h++){let b=n[h],U=Object.create(null);u>h&&(U[b.name]=t[h]),kr(e,U,{[b.name]:b},r)}}function Ue(e,t,n,r){Y.isPlainObject(n)||(n={type:n});let{type:a,required:u,validator:h}=n;if(u&&r)return'Missing required args: "'+e+'"';if(!(t==null&&!u)){if(a!=null){let b=!1,U=Y.isArray(a)?a:[a],O=[];for(let D=0;D<U.length&&!b;D++){let{valid:ge,expectedType:we}=vt(t,U[D]);O.push(we||""),b=ge}if(!b)return qt(e,t,O)}if(h)return h(t)}}let it=Y.makeMap("String,Number,Boolean,Function,Symbol");function vt(e,t){let n,r=nn(t);if(it(r)){let a=typeof e;n=a===r.toLowerCase(),!n&&a==="object"&&(n=e instanceof t)}else r==="Object"?n=Y.isObject(e):r==="Array"?n=Y.isArray(e):n=e instanceof t||Y.toRawType(e)===nn(t);return{valid:n,expectedType:r}}function qt(e,t,n){let r=`Invalid args: type check failed for args "${e}". Expected ${n.map(Y.capitalize).join(", ")}`,a=n[0],u=Y.toRawType(t),h=Qt(t,a),b=Qt(t,u);return n.length===1&&ir(a)&&!lr(a,u)&&(r+=` with value ${h}`),r+=`, got ${u} `,ir(u)&&(r+=`with value ${b}.`),r}function nn(e){let t=e&&e.toString().match(/^\s*function (\w+)/);return t?t[1]:""}function Qt(e,t){return t==="String"?`"${e}"`:t==="Number"?`${Number(e)}`:`${e}`}function ir(e){return["string","number","boolean"].some(n=>e.toLowerCase()===n)}function lr(...e){return e.some(t=>t.toLowerCase()==="boolean")}function Li(e){return function(){try{return e.apply(e,arguments)}catch(t){console.error(t)}}}let Di=1,xn={};function wr(e,t,n,r=!1){return xn[e]={name:t,keepAlive:r,callback:n},e}function Ur(e,t,n){if(typeof e=="number"){let r=xn[e];if(r)return r.keepAlive||delete xn[e],r.callback(t,n)}return t}function Hr(e){for(let t in xn)if(xn[t].name===e)return!0;return!1}function Zi(e,t){for(let n in xn){let r=xn[n];r.callback===t&&r.name===e&&delete xn[n]}}function Xi(e){st.off("api."+e)}function Oo(e){st.on("api."+e,t=>{for(let n in xn){let r=xn[n];r.name===e&&r.callback(t)}})}function To(e,t){return wr(Di++,e,t,!0)}let hr="success",Cn="fail",On="complete";function ci(e){let t={};for(let n in e){let r=e[n];Y.isFunction(r)&&(t[n]=Li(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 eo(e,t={},{beforeAll:n,beforeSuccess:r}={}){Y.isPlainObject(t)||(t={});let{success:a,fail:u,complete:h}=ci(t),b=Y.isFunction(a),U=Y.isFunction(u),O=Y.isFunction(h),D=Di++;return wr(D,e,ge=>{ge=ge||{},ge.errMsg=Qi(ge.errMsg,e),Y.isFunction(n)&&n(ge),ge.errMsg===e+":ok"?(Y.isFunction(r)&&r(ge,t),b&&a(ge)):U&&u(ge),O&&h(ge)}),D}let go="success",Si="fail",cr="complete",jr={},Sr={};function gr(e){return function(t){return e(t)||t}}function Po(e,t){let n=!1;for(let r=0;r<e.length;r++){let a=e[r];if(n)n=Promise.resolve(gr(a));else{let u=a(t);if(Y.isPromise(u)&&(n=Promise.resolve(u)),u===!1)return{then(){},catch(){}}}}return n||{then(r){return r(t)},catch(){}}}function Io(e,t={}){return[go,Si,cr].forEach(n=>{let r=e[n];if(!Y.isArray(r))return;let a=t[n];t[n]=function(h){Po(r,h).then(b=>Y.isFunction(a)&&a(b)||b)}}),t}function po(e,t){let n=[];Y.isArray(jr.returnValue)&&n.push(...jr.returnValue);let r=Sr[e];return r&&Y.isArray(r.returnValue)&&n.push(...r.returnValue),n.forEach(a=>{t=a(t)||t}),t}function Rr(e){let t=Object.create(null);Object.keys(jr).forEach(r=>{r!=="returnValue"&&(t[r]=jr[r].slice())});let n=Sr[e];return n&&Object.keys(n).forEach(r=>{r!=="returnValue"&&(t[r]=(t[r]||[]).concat(n[r]))}),t}function ur(e,t,n,r){let a=Rr(e);return a&&Object.keys(a).length?Y.isArray(a.invoke)?Po(a.invoke,n).then(h=>t(Io(a,h),...r)):t(Io(a,n),...r):t(n,...r)}function Ar(e){return!!(Y.isPlainObject(e)&&[hr,Cn,On].find(t=>Y.isFunction(e[t])))}function Xr(e){return e}function zn(e,t){return(n={},...r)=>Ar(n)?po(e,ur(e,t,n,r)):po(e,new Promise((a,u)=>{ur(e,t,Y.extend(n,{success:a,fail:u}),r)}))}function zr(e,t){let n=e[0];if(!t||!Y.isPlainObject(t.formatArgs)&&Y.isPlainObject(n))return;let r=t.formatArgs,a=Object.keys(r);for(let u=0;u<a.length;u++){let h=a[u],b=r[h];if(Y.isFunction(b)){let U=b(e[0][h],n);if(Y.isString(U))return U}else Y.hasOwn(n,h)||(n[h]=b)}}function to(e,t,n){return Ur(e,Y.extend(n||{},{errMsg:t+":ok"}))}function Fi(e,t,n,r){return Ur(e,Y.extend({errMsg:t+":fail"+(n?" "+n:"")},r))}function xr(e,t,n,r){if(r&&r.beforeInvoke){let u=r.beforeInvoke(t);if(Y.isString(u))return u}let a=zr(t,r);if(a)return a}function vo(e){if(!Y.isFunction(e))throw new Error('Invalid args: type check failed for args "callback". Expected Function')}function mo(e,t,n){return r=>{vo(r);let a=xr(e,[r],void 0,n);if(a)throw new Error(a);let u=!Hr(e);To(e,r),u&&(Oo(e),t())}}function _o(e,t,n){return r=>{vo(r);let a=xr(e,[r],void 0,n);if(a)throw new Error(a);e=e.replace("off","on"),Zi(e,r),Hr(e)||(Xi(e),t())}}function Qr(e){return!e||Y.isString(e)?e:e.stack?(console.error(e.message+te.LINEFEED+e.stack),e.message):e}function ei(e,t,n,r){return a=>{let u=eo(e,a,r),h=xr(e,[a],n,r);return h?Fi(u,e,h):t(a,{resolve:b=>to(u,e,b),reject:(b,U)=>Fi(u,e,Qr(b),U)})}}function Ai(e,t,n,r){return(...a)=>{let u=xr(e,a,n,r);if(u)throw new Error(u);return t.apply(null,a)}}function ui(e,t,n,r){return ei(e,t,n,r)}function qn(e,t,n){return mo(e,t,n)}function Cr(e,t,n){return _o(e,t,n)}function Vi(e,t,n,r){return zn(e,ei(e,t,void 0,r))}function Mt(e,t,n,r){return Ai(e,t,void 0,r)}function ye(e,t,n,r){return zn(e,ui(e,t,void 0,r))}let Ci="base64ToArrayBuffer",$i=[{name:"base64",type:String,required:!0}],Wr="arrayBufferToBase64",Br=[{name:"arrayBuffer",type:[ArrayBuffer,Uint8Array],required:!0}],Hn=Mt(Ci,e=>an(e),$i),Bn=Mt(Wr,e=>$n(e),Br);function No(){if(typeof __SYSTEM_INFO__!="undefined")return window.__SYSTEM_INFO__;let{resolutionWidth:e}=l.screen.getCurrentSize()||{resolutionWidth:0};return{platform:(l.os.name||"").toLowerCase(),pixelRatio:l.screen.scale,windowWidth:Math.round(e)}}function Oi(e,t,n){e.$page.meta.isNVue?fi(e,t,n):Ut(e,t,n)}function Ut(e,t,n){st.invokeViewMethod("requestComponentInfo",{reqs:t.map(r=>(r.component&&(r.component=r.component.$el.nodeId),r))},e.$page.id,n)}function fi(e,t,n){let r=di(t),a=new Array(r.length);Kt(r,e.$el,a),Wn(e.$requireNativePlugin("dom"),a,0,[],u=>{n(u)})}function di(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 Kt(e,t,n){let r=t.children;if(!Y.isArray(r))return!1;for(let a=0;a<r.length;a++){let u=r[a];if(u.attr){let h=e.indexOf(u.attr.id);if(h>=0&&(n[h]={id:e[h],ref:u.ref,dataset:te.parseNVueDataset(u.attr)},e.length===1))break}u.children&&Kt(e,u,n)}}function Wn(e,t,n,r,a){let u=t[n];e.getComponentRect(u.ref,h=>{h.size.id=u.id,h.size.dataset=u.dataset,r.push(h.size),n+=1,n<t.length?Wn(e,t,n,r,a):a(r)})}function Or(e,t){st.invokeViewMethod("setPageMeta",t,e.$page.id)}let In=e=>e!==null&&typeof e=="object",Ti=["{","}"];class ko{constructor(){this._caches=Object.create(null)}interpolate(t,n,r=Ti){if(!n)return[t];let a=this._caches[t];return a||(a=Qo(t,r),this._caches[t]=a),Ui(a,n)}}let hi=/^(?:\d)+/,no=/^(?:\w)+/;function Qo(e,[t,n]){let r=[],a=0,u="";for(;a<e.length;){let h=e[a++];if(h===t){u&&r.push({type:"text",value:u}),u="";let b="";for(h=e[a++];h!==void 0&&h!==n;)b+=h,h=e[a++];let U=h===n,O=hi.test(b)?"list":U&&no.test(b)?"named":"unknown";r.push({value:b,type:O})}else u+=h}return u&&r.push({type:"text",value:u}),r}function Ui(e,t){let n=[],r=0,a=Array.isArray(t)?"list":In(t)?"named":"unknown";if(a==="unknown")return n;for(;r<e.length;){let u=e[r];switch(u.type){case"text":n.push(u.value);break;case"list":n.push(t[parseInt(u.value,10)]);break;case"named":a==="named"&&n.push(t[u.value]);break;case"unknown":break}r++}return n}let Kn="zh-Hans",pr="zh-Hant",Jn="en",Mr="fr",Tr="es",Hi=Object.prototype.hasOwnProperty,ti=(e,t)=>Hi.call(e,t),vr=new ko;function Gr(e,t){return!!t.find(n=>e.indexOf(n)!==-1)}function Pi(e,t){return t.find(n=>e.indexOf(n)===0)}function gi(e,t){if(!e)return;if(e=e.trim().replace(/_/g,"-"),t&&t[e])return e;if(e=e.toLowerCase(),e==="chinese")return Kn;if(e.indexOf("zh")===0)return e.indexOf("-hans")>-1?Kn:e.indexOf("-hant")>-1||Gr(e,["-tw","-hk","-mo","-cht"])?pr:Kn;let n=Pi(e,[Jn,Mr,Tr]);if(n)return n}class pi{constructor({locale:t,fallbackLocale:n,messages:r,watcher:a,formater:u}){this.locale=Jn,this.fallbackLocale=Jn,this.message={},this.messages={},this.watchers=[],n&&(this.fallbackLocale=n),this.formater=u||vr,this.messages=r||{},this.setLocale(t||Jn),a&&this.watchLocale(a)}setLocale(t){let n=this.locale;this.locale=gi(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 a=this.messages[t];a?r?Object.assign(a,n):Object.keys(n).forEach(u=>{ti(a,u)||(a[u]=n[u])}):this.messages[t]=n}f(t,n,r){return this.formater.interpolate(t,n,r).join("")}t(t,n,r){let a=this.message;return typeof n=="string"?(n=gi(n,this.messages),n&&(a=this.messages[n])):r=n,ti(a,t)?this.formater.interpolate(a[t],r).join(""):(console.warn(`Cannot translate the value of keypath ${t}. Use the value of keypath as default.`),t)}}function Yr(e,t){e.$watchLocale?e.$watchLocale(n=>{t.setLocale(n)}):e.$watch(()=>e.$locale,n=>{t.setLocale(n)})}function vi(){return typeof gt!="undefined"&&gt.getLocale?gt.getLocale():typeof global!="undefined"&&global.getLocale?global.getLocale():Jn}function ro(e,t={},n,r){typeof e!="string"&&([e,t]=[t,e]),typeof e!="string"&&(e=vi()),typeof n!="string"&&(n=typeof T!="undefined"&&T.fallbackLocale||Jn);let a=new pi({locale:e,fallbackLocale:n,messages:t,watcher:r}),u=(h,b)=>{if(typeof vn!="function")u=function(U,O){return a.t(U,O)};else{let U=!1;u=function(O,D){let ge=vn().$vm;return ge&&(ge.$locale,U||(U=!0,Yr(ge,a))),a.t(O,D)}}return u(h,b)};return{i18n:a,f(h,b,U){return a.f(h,b,U)},t(h,b){return u(h,b)},add(h,b,U=!0){return a.add(h,b,U)},watch(h){return a.watchLocale(h)},getLocale(){return a.getLocale()},setLocale(h){return a.setLocale(h)}}}function ji(e,t){return e.indexOf(t[0])>-1}let io=te.once(()=>typeof T!="undefined"&&T.locales&&!!Object.keys(T.locales).length),x;function ne(){let e=gt.getLocale(),t=T.locales;return t[e]||t[T.fallbackLocale]||t.en||{}}function de(e){return ji(e,te.I18N_JSON_DELIMITERS)?X().f(e,ne(),te.I18N_JSON_DELIMITERS):e}function H(e,t){if(t.length===1){if(e){let r=e[t[0]];if(Y.isString(r)&&ji(r,te.I18N_JSON_DELIMITERS))return e}return}let n=t.shift();return H(e&&e[n],t)}function M(e,t){return t.map(n=>J(e,n))}function J(e,t){let n=H(e,t);if(!n)return!1;let r=t[t.length-1],a=n[r];return Object.defineProperty(n,r,{get(){return de(a)},set(u){a=u}}),!0}function X(){if(!x){let e;if(typeof vn=="function"?e=g.requireModule("plus").getLanguage():e=l.webview.currentWebview().getStyle().locale,x=ro(e),io()){let t=Object.keys(T.locales||{});t.length&&t.forEach(n=>x.add(n,T.locales[n])),x.setLocale(e)}}return x}function ue(e,t,n){return t.reduce((r,a,u)=>(r[e+a]=n[u],r),{})}let tn=te.once(()=>{let e="uni.app.",t=["quit"];X().add(Jn,ue(e,t,["Press back button again to exit"]),!1),X().add(Tr,ue(e,t,["Pulse otra vez para salir"]),!1),X().add(Mr,ue(e,t,["Appuyez \xE0 nouveau pour quitter l'application"]),!1),X().add(Kn,ue(e,t,["\u518D\u6309\u4E00\u6B21\u9000\u51FA\u5E94\u7528"]),!1),X().add(pr,ue(e,t,["\u518D\u6309\u4E00\u6B21\u9000\u51FA\u61C9\u7528"]),!1)}),Mn=te.once(()=>{let e="uni.showActionSheet.",t=["cancel"];X().add(Jn,ue(e,t,["Cancel"]),!1),X().add(Tr,ue(e,t,["Cancelar"]),!1),X().add(Mr,ue(e,t,["Annuler"]),!1),X().add(Kn,ue(e,t,["\u53D6\u6D88"]),!1),X().add(pr,ue(e,t,["\u53D6\u6D88"]),!1)}),cn=te.once(()=>{let e="uni.showModal.",t=["cancel","confirm"];X().add(Jn,ue(e,t,["Cancel","OK"]),!1),X().add(Tr,ue(e,t,["Cancelar","OK"]),!1),X().add(Mr,ue(e,t,["Annuler","OK"]),!1),X().add(Kn,ue(e,t,["\u53D6\u6D88","\u786E\u5B9A"]),!1),X().add(pr,ue(e,t,["\u53D6\u6D88","\u78BA\u5B9A"]),!1)}),ni=te.once(()=>{let e="uni.chooseImage.",t=["cancel","sourceType.album","sourceType.camera"];X().add(Jn,ue(e,t,["Cancel","Album","Camera"]),!1),X().add(Tr,ue(e,t,["Cancelar","\xC1lbum","C\xE1mara"]),!1),X().add(Mr,ue(e,t,["Annuler","Album","Cam\xE9ra"]),!1),X().add(Kn,ue(e,t,["\u53D6\u6D88","\u4ECE\u76F8\u518C\u9009\u62E9","\u62CD\u6444"]),!1),X().add(pr,ue(e,t,["\u53D6\u6D88","\u5F9E\u76F8\u518A\u9078\u64C7","\u62CD\u651D"]),!1)}),mr=te.once(()=>{let e="uni.chooseVideo.",t=["cancel","sourceType.album","sourceType.camera"];X().add(Jn,ue(e,t,["Cancel","Album","Camera"]),!1),X().add(Tr,ue(e,t,["Cancelar","\xC1lbum","C\xE1mara"]),!1),X().add(Mr,ue(e,t,["Annuler","Album","Cam\xE9ra"]),!1),X().add(Kn,ue(e,t,["\u53D6\u6D88","\u4ECE\u76F8\u518C\u9009\u62E9","\u62CD\u6444"]),!1),X().add(pr,ue(e,t,["\u53D6\u6D88","\u5F9E\u76F8\u518A\u9078\u64C7","\u62CD\u651D"]),!1)}),ea=te.once(()=>{let e="uni.previewImage.",t=["cancel","button.save","save.success","save.fail"];X().add(Jn,ue(e,t,["Cancel","Save Image","Saved successfully","Save failed"]),!1),X().add(Tr,ue(e,t,["Cancelar","Guardar imagen","Guardado exitosamente","Error al guardar"]),!1),X().add(Mr,ue(e,t,["Annuler","Guardar imagen","Enregistr\xE9 avec succ\xE8s","\xC9chec de la sauvegarde"]),!1),X().add(Kn,ue(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),X().add(pr,ue(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)}),zo=te.once(()=>{let e="uni.setClipboardData.",t=["success","fail"];X().add(Jn,ue(e,t,["Content copied","Copy failed, please copy manually"]),!1),X().add(Tr,ue(e,t,["Contenido copiado","Error al copiar, copie manualmente"]),!1),X().add(Mr,ue(e,t,["Contenu copi\xE9","\xC9chec de la copie, copiez manuellement"]),!1),X().add(Kn,ue(e,t,["\u5185\u5BB9\u5DF2\u590D\u5236","\u590D\u5236\u5931\u8D25\uFF0C\u8BF7\u624B\u52A8\u590D\u5236"]),!1),X().add(pr,ue(e,t,["\u5167\u5BB9\u5DF2\u5FA9\u5236","\u5FA9\u5236\u5931\u6557\uFF0C\u8ACB\u624B\u52D5\u5FA9\u88FD"]),!1)}),ta=te.once(()=>{let e="uni.scanCode.",t=["title","album","fail","flash.on","flash.off"];X().add(Jn,ue(e,t,["Scan code","Album","Recognition failure","Tap to turn light on","Tap to turn light off"]),!1),X().add(Tr,ue(e,t,["C\xF3digo de escaneo","\xC1lbum","\xC9chec de la reconnaissance","Toque para encender la luz","Toque para apagar la luz"]),!1),X().add(Mr,ue(e,t,["Code d\u2019analyse","Album","Fallo de reconocimiento","Appuyez pour activer l'\xE9clairage","Appuyez pour d\xE9sactiver l'\xE9clairage"]),!1),X().add(Kn,ue(e,t,["\u626B\u7801","\u76F8\u518C","\u8BC6\u522B\u5931\u8D25","\u8F7B\u89E6\u7167\u4EAE","\u8F7B\u89E6\u5173\u95ED"]),!1),X().add(pr,ue(e,t,["\u6383\u78BC","\u76F8\u518A","\u8B58\u5225\u5931\u6557","\u8F15\u89F8\u7167\u4EAE","\u8F15\u89F8\u95DC\u9589"]),!1)}),Ro=te.once(()=>{let e="uni.startSoterAuthentication.",t=["authContent"];X().add(Jn,ue(e,t,["Fingerprint recognition"]),!1),X().add(Tr,ue(e,t,["Reconocimiento de huellas dactilares"]),!1),X().add(Mr,ue(e,t,["Reconnaissance de l'empreinte digitale"]),!1),X().add(Kn,ue(e,t,["\u6307\u7EB9\u8BC6\u522B\u4E2D..."]),!1),X().add(pr,ue(e,t,["\u6307\u7D0B\u8B58\u5225\u4E2D..."]),!1)});function bo(e){if(io())return M(e,[["titleText"],["searchInput","placeholder"]])}function oo(e){if(io()){let t="caption";return M(e,[["contentdown",t],["contentover",t],["contentrefresh",t]])}}function Ra(e){let t=new te.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,a=!1){t[a?"once":"on"](`${e}.${n}`,r)},unsubscribe(n,r){t.off(`${e}.${n}`,r)},subscribeHandler(n,r,a){t.emit(`${e}.${n}`,r,a)}}}let na="invokeViewApi",_a="invokeServiceApi";function ts(e){return e=e+"",e.indexOf("rpx")!==-1||e.indexOf("upx")!==-1}function ra(e,t=!1){if(t)return xa(e);if(Y.isString(e)){let n=parseInt(e)||0;return ts(e)?gt.upx2px(n):n}return e}function xa(e){return ts(e)?e.replace(/(\d+(\.\d+)?)[ru]px/g,(t,n)=>gt.upx2px(parseFloat(n))+"px"):e}function fr(e){let t=te.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 _r(){let e=Vn(),t=e.length;if(t)return e[t-1]}function ia(){let e=_r();if(e)return e.$page.meta}function Ba(){let e=ia();return e?e.id:-1}function Lr(){let e=_r();if(e)return e.$vm}let Ma=["navigationBar","pullToRefresh"];function br(){return JSON.parse(JSON.stringify(T.globalStyle||{}))}function Zn(e,t){let n=br(),r=Y.extend({id:t},n,e);Ma.forEach(u=>{r[u]=Y.extend({},n[u],e[u])});let{navigationBar:a}=r;return a.titleText&&a.titleImage&&(a.titleText=""),r}function xo(e){return JSON.parse(ra(JSON.stringify(e),!0))}function Cs(e){return e.offset&&(e.offset=ra(e.offset)),e.height&&(e.height=ra(e.height)),e.range&&(e.range=ra(e.range)),e}function Wo(e,t,n,r,a){let{id:u,route:h}=r;return{id:u,path:te.addLeadingSlash(h),route:h,fullPath:t,options:n,meta:r,openType:e,eventChannel:a,statusBarStyle:r.navigationBar.titleColor==="#000000"?"dark":"light"}}function ns(e,t,n){let r=e.$[t];!Y.isArray(r)||n.__weh&&Y.remove(r,n.__weh)}function jn(e,t,n){if(Y.isString(e))n=t,t=e,e=Lr();else if(typeof e=="number"){let a=Vn().find(u=>u.$page.id===e);a?e=a.$vm:e=Lr()}if(!e)return;if(e.__call_hook)return e.__call_hook(t,n);let r=e.$[t];return r&&te.invokeArrayFns(r,n)}function ba(e){if(e.indexOf("/")===0)return e;let t="",n=Vn();return n.length&&(t=n[n.length-1].$page.route),Go(t,e)}function Go(e,t){if(t.indexOf("/")===0)return t;if(t.indexOf("./")===0)return Go(e,t.slice(2));let n=t.split("/"),r=n.length,a=0;for(;a<r&&n[a]==="..";a++);n.splice(0,a),t=n.join("/");let u=e.length>0?e.split("/"):[];return u.splice(u.length-a-1,a+1),te.addLeadingSlash(u.concat(n).join("/"))}function Ii(e,t=!1){return t?ze.find(n=>n.path===e||n.alias===e):ze.find(n=>n.path===e)}function Ea(e){let t=Ii(e);if(t)return t.meta}function La(e,t,n){let r=Ii(te.addLeadingSlash(t));if(r){let{meta:u}=r;delete u.tabBarIndex,u.isQuit=u.isTabBar=!1}let a=Ii(te.addLeadingSlash(n));if(a){let{meta:u}=a;u.tabBarIndex=e,u.isQuit=u.isTabBar=!0;let h=T.tabBar;h&&h.list&&h.list[e]&&(h.list[e].pagePath=te.removeLeadingSlash(n))}}let ao,oa,Eo;function zi(){return typeof window=="object"&&typeof navigator=="object"&&typeof document=="object"?"webview":"v8"}function ya(){return ao.webview.currentWebview().id}let aa,wa,sa={};function Sa(e){let t=e.data&&e.data.__message;if(!t||!t.__page)return;let n=t.__page,r=sa[n];r&&r(t),t.keep||delete sa[n]}function Os(e,t){zi()==="v8"?Eo?(aa&&aa.close(),aa=new Eo(ya()),aa.onmessage=Sa):wa||(wa=oa.requireModule("globalEvent"),wa.addEventListener("plusMessage",Sa)):window.__plusMessage=Sa,sa[e]=t}class so{constructor(t){this.webview=t}sendMessage(t){let n=JSON.parse(JSON.stringify({__message:{data:t}})),r=this.webview.id;Eo?new Eo(r).postMessage(n):ao.webview.postMessageToUniNView&&ao.webview.postMessageToUniNView(n,r)}close(){this.webview.close()}}function ri({context:e={},url:t,data:n={},style:r={},onMessage:a,onClose:u}){ao=e.plus||l,oa=e.weex||(typeof g=="object"?g:null),Eo=e.BroadcastChannel||(typeof BroadcastChannel=="object"?BroadcastChannel:null);let h={autoBackButton:!0,titleSize:"17px"},b=`page${Date.now()}`;r=Y.extend({},r),r.titleNView!==!1&&r.titleNView!=="none"&&(r.titleNView=Y.extend(h,r.titleNView));let U={top:0,bottom:0,usingComponents:{},popGesture:"close",scrollIndicator:"none",animationType:"pop-in",animationDuration:200,uniNView:{path:`/${t}.js`,defaultFontSize:16,viewport:ao.screen.resolutionWidth}};r=Y.extend(U,r);let O=ao.webview.create("",b,r,{extras:{from:ya(),runtime:zi(),data:n,useGlobalEvent:!Eo}});return O.addEventListener("close",u),Os(b,D=>{Y.isFunction(a)&&a(D.data),D.keep||O.close("auto")}),O.show(r.animationType,r.animationDuration),new so(O)}let Ni=(e,t)=>st.emit("api."+e,t),lo=1;function la(){return Ba()+"."+na}let m=(e,t,n,r)=>{let{subscribe:a,publishHandler:u}=st,h=r?lo++:0;r&&a(na+"."+h,r,!0),u(la(),{id:h,name:e,args:t},n)},R=(e,t,n,r)=>{let{subscribe:a,unsubscribe:u,publishHandler:h}=st,b=lo++,U=na+"."+b;return a(U,n),h(la(),{id:b,name:e,args:t},r),()=>{u(U)}},z=Object.create(null);function j(){st.subscribe(_a,Q)}function Z(e,t){z[e]||(z[e]=t)}function Q({id:e,name:t,args:n},r){let a=h=>{e&&st.publishHandler(_a+"."+e,h,r)},u=z[t];u?u(n,a):a({})}let ce=Y.extend(Ra("view"),{invokeOnCallback:Ni,invokeViewMethod:m,invokeViewMethodKeepAlive:R});function be(){let{on:e}=st;e(te.ON_RESIZE,Oe),e(te.ON_APP_ENTER_FOREGROUND,Ne),e(te.ON_APP_ENTER_BACKGROUND,ve)}function Oe(e){jn(_r(),te.ON_RESIZE,e),st.invokeOnCallback("onWindowResize",e)}function Ne(e){let t=_r();jn(vn(),te.ON_SHOW,e),jn(t,te.ON_SHOW)}function ve(){jn(vn(),te.ON_HIDE),jn(_r(),te.ON_HIDE)}let Fe=[te.ON_PAGE_SCROLL,te.ON_REACH_BOTTOM];function rt(){Fe.forEach(e=>st.subscribe(e,bt(e)))}function bt(e){return(t,n)=>{jn(parseInt(n),e,t)}}function Wt(){be(),rt()}function nt(e){e.$vm=e,e.$mpType="app";let t=En.ref(X().getLocale());Object.defineProperty(e,"$locale",{get(){return t.value},set(n){t.value=n}})}function Ge(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 ut(){return{path:"",query:{},scene:1001,referrerInfo:{appId:"",extraData:{}}}}function Vt(e,t){let n=e.$options||{};n.globalData=Y.extend(n.globalData||{},t),Object.defineProperty(e,"globalData",{get(){return n.globalData},set(r){n.globalData=r}})}function pt(e){if(e.indexOf("//")===0)return"https:"+e;if(te.SCHEME_RE.test(e)||te.DATA_RE.test(e))return e;if(Ot(e))return"file://"+Ze(e);let t="file://"+Ze("_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+Go(te.addLeadingSlash(__id__),e);{let n=_r();if(n)return t+Go(te.addLeadingSlash(n.route),e)}}return e}let Ze=te.cacheStringFunction(e=>l.io.convertLocalFileSystemURL(e).replace(/^\/?apps\//,"/android_asset/apps/").replace(/\/$/,""));function Ot(e){return e.indexOf("_www")===0||e.indexOf("_doc")===0||e.indexOf("_documents")===0||e.indexOf("_downloads")===0}let wn="success",un="fail",Sn=[wn,un,"complete"];function Ht(e,t,n,r){if(!e)return;if(typeof n=="undefined")return e[t]();let[,a]=Er(n,r);return Object.keys(a).length?e[t](Bo(t,a)):e[t]()}function Ln(e,t,n,r){if(!e)return;let[a,u]=Er(n,r);return Object.keys(u).length?e[t](a,Bo(t,u)):e[t](a)}function mi(e,t){let n=or(e,t.$el);return n||console.error("Can not find `"+e+"`")}function or(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,a=n.length;r<a;r++){let u=or(e,n[r]);if(u)return u}}function Er(e={},t){let n=Object.create(null),r=function(u){let h=e[u];Y.isFunction(h)&&(n[u]=h,delete e[u])};return Sn.forEach(r),t&&t.forEach(r),[e,n]}function Bo(e,t){return function(r){let a=r.type;delete r.type;let u=t[a];if(a===wn?r.errMsg=`${e}:ok`:a===un&&(r.errMsg=e+":fail "+(r.msg?" "+r.msg:"")),delete r.code,delete r.msg,Y.isFunction(u)&&u(r),a===wn||a===un){let h=t.complete;Y.isFunction(h)&&h(r)}}}let Wi;function Mo(){return Wi}function Lo(e){let t=e.$.appContext;Wi=Y.extend(t.app,{mountPage(n,r,a){let u=En.createVNode(n,r);u.appContext=t,u.__page_container__=a,En.render(u,a);let h=u.component.proxy;return h.__page_container__=a,h},unmountPage:n=>{let{__page_container__:r}=n;r&&(r.isUnmounted=!0,En.render(null,r))}})}let Lt=[];function fn(e){if(!e.$page.meta.isNVue)return Lt.push(e);let n=Lt.findIndex(r=>r.$page.id===e.$page.id);n>-1?Lt.splice(n,1,e):Lt.push(e)}function co(e){return Lt.find(t=>t.$page.id===e)}function qr(){return Lt}function ii(){let e=[];return Lt.forEach(t=>{t.$.__isTabBar?t.$.__isActive&&e.push(t):e.push(t)}),e}function Do(){let e=_r();!e||uo(e)}function uo(e){let t=Lt.findIndex(n=>n===e);t!==-1&&(e.$page.meta.isNVue||Mo().unmountPage(e),Lt.splice(t,1))}let Xn={play(e){return Ht(e,"play")},pause(e){return Ht(e,"pause")},seek(e,t){return Ln(e,"seek",t.position)},stop(e){return Ht(e,"stop")},sendDanmu(e,t){return Ln(e,"sendDanmu",t)},playbackRate(e,t){return Ln(e,"playbackRate",t.rate)},requestFullScreen(e,t={}){return Ln(e,"requestFullScreen",t)},exitFullScreen(e){return Ht(e,"exitFullScreen")},showStatusBar(e){return Ht(e,"showStatusBar")},hideStatusBar(e){return Ht(e,"hideStatusBar")}};function Yt(e,t,n,r){let a=co(t);if(a==null?void 0:a.$page.meta.isNVue){let u=a.$vm;return Xn[n](mi(e,u),r)}st.invokeViewMethod("video."+e,{videoId:e,type:n,data:r},t)}let oi={getCenterLocation(e,t){return Ht(e,"getCenterLocation",t)},moveToLocation(e,t){return Ln(e,"moveToLocation",t)},translateMarker(e,t){return Ln(e,"translateMarker",t,["animationEnd"])},includePoints(e,t){return Ln(e,"includePoints",t)},getRegion(e,t){return Ht(e,"getRegion",t)},getScale(e,t){return Ht(e,"getScale",t)},addCustomLayer(e,t){return Ln(e,"addCustomLayer",t)},removeCustomLayer(e,t){return Ln(e,"removeCustomLayer",t)},addGroundOverlay(e,t){return Ln(e,"addGroundOverlay",t)},removeGroundOverlay(e,t){return Ln(e,"removeGroundOverlay",t)},updateGroundOverlay(e,t){return Ln(e,"updateGroundOverlay",t)},initMarkerCluster(e,t){return Ln(e,"initMarkerCluster",t)},addMarkers(e,t){return Ln(e,"addMarkers",t)},removeMarkers(e,t){return Ln(e,"removeMarkers",t)},moveAlong(e,t){return Ln(e,"moveAlong",t)},openMapApp(e,t){return Ln(e,"openMapApp",t)},on(e,t){return e.on(t.name,t.callback)}};function Aa(e,t,n,r,a){let u=co(t);if(u==null?void 0:u.$page.meta.isNVue){let h=u.$vm;return oi[n](mi(e,h),r)}st.invokeViewMethod("map."+e,{type:n,data:r},t,a)}function Pr(e){return`IntersectionObserver.${e}`}function Dr({reqId:e,component:t,options:n,callback:r},a){let u=Pr(e);st.invokeViewMethod("addIntersectionObserver",{reqId:e,component:t.$el.nodeId,options:n,eventName:u},a),st.subscribe(u,r)}function Ts({reqId:e,component:t},n){st.invokeViewMethod("removeIntersectionObserver",{reqId:e,component:t.$el.nodeId},n),st.unsubscribe(Pr(e))}function rs(e){return`MediaQueryObserver.${e}`}function Gn({reqId:e,component:t,options:n,callback:r},a){let u=rs(e);st.invokeViewMethod("addMediaQueryObserver",{reqId:e,component:t.$el.nodeId,options:n,eventName:u},a),st.subscribe(u,r)}function An({reqId:e,component:t},n){st.invokeViewMethod("removeMediaQueryObserver",{reqId:e,component:t.$el.nodeId},n),st.unsubscribe(rs(e))}let Qn=200,Fr=["unknown","none","ethernet","wifi","2g","3g","4g","5g"],ki="_doc/uniapp_temp",ai=`${ki}_${Date.now()}`;function Ca(e){let t=e.split("/");return t[t.length-1]}function Yo(e){let t=e.split(".");return t.length>1?"."+t[t.length-1]:""}let Gi="backbutton";function Yi(){gt.navigateBack({from:"backbutton",success(){}})}let qi=ut(),Oa=ut();function Da(){return Y.extend({},Oa)}function is(){return Y.extend({},qi)}function Ve({path:e,query:t,referrerInfo:n}){Y.extend(qi,{path:e,query:t?te.parseQuery(t):{},referrerInfo:n||{}})}function Tt({path:e,query:t,referrerInfo:n}){return Y.extend(Oa,{path:e,query:t?te.parseQuery(t):{},referrerInfo:n||{},channel:l.runtime.channel,launcher:l.runtime.launcher}),Y.extend(qi,Oa),Y.extend({},Oa)}function Rt(){let e=g.requireModule("plus");if(e.getRedirectInfo){let{path:t,query:n,extraData:r,userAction:a,fromAppid:u}=e.getRedirectInfo()||{},h={appId:u,extraData:{}};return r&&(h.extraData=r),{path:t||"",query:n?"?"+n:"",referrerInfo:h,userAction:a}}}function Tn(e){var t={exports:{}};return e(t,t.exports),t.exports}var er=Tn(function(e,t){var n=typeof Uint8Array!="undefined"&&typeof Uint16Array!="undefined"&&typeof Int32Array!="undefined";function r(h,b){return Object.prototype.hasOwnProperty.call(h,b)}t.assign=function(h){for(var b=Array.prototype.slice.call(arguments,1);b.length;){var U=b.shift();if(!!U){if(typeof U!="object")throw new TypeError(U+"must be non-object");for(var O in U)r(U,O)&&(h[O]=U[O])}}return h},t.shrinkBuf=function(h,b){return h.length===b?h:h.subarray?h.subarray(0,b):(h.length=b,h)};var a={arraySet:function(h,b,U,O,D){if(b.subarray&&h.subarray){h.set(b.subarray(U,U+O),D);return}for(var ge=0;ge<O;ge++)h[D+ge]=b[U+ge]},flattenChunks:function(h){var b,U,O,D,ge,we;for(O=0,b=0,U=h.length;b<U;b++)O+=h[b].length;for(we=new Uint8Array(O),D=0,b=0,U=h.length;b<U;b++)ge=h[b],we.set(ge,D),D+=ge.length;return we}},u={arraySet:function(h,b,U,O,D){for(var ge=0;ge<O;ge++)h[D+ge]=b[U+ge]},flattenChunks:function(h){return[].concat.apply([],h)}};t.setTyped=function(h){h?(t.Buf8=Uint8Array,t.Buf16=Uint16Array,t.Buf32=Int32Array,t.assign(t,a)):(t.Buf8=Array,t.Buf16=Array,t.Buf32=Array,t.assign(t,u))},t.setTyped(n)}),St=er,yo=4,Fo=0,ca=1,Ps=2;function qo(e){for(var t=e.length;--t>=0;)e[t]=0}var zl=0,al=1,Wl=2,sl=3,ll=258,Is=29,Fa=256,Va=Fa+1+Is,Ko=30,os=19,cl=2*Va+1,ua=15,as=16,Ns=7,ss=256,ul=16,fl=17,Ta=18,$a=[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],fa=[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],dl=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7],Ua=[16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15],ks=512,wo=new Array((Va+2)*2);qo(wo);var Ha=new Array(Ko*2);qo(Ha);var ja=new Array(ks);qo(ja);var Pa=new Array(ll-sl+1);qo(Pa);var ls=new Array(Is);qo(ls);var za=new Array(Ko);qo(za);function cs(e,t,n,r,a){this.static_tree=e,this.extra_bits=t,this.extra_base=n,this.elems=r,this.max_length=a,this.has_stree=e&&e.length}var Rs,us,xs;function fs(e,t){this.dyn_tree=e,this.max_code=0,this.stat_desc=t}function hl(e){return e<256?ja[e]:ja[256+(e>>>7)]}function Wa(e,t){e.pending_buf[e.pending++]=t&255,e.pending_buf[e.pending++]=t>>>8&255}function _i(e,t,n){e.bi_valid>as-n?(e.bi_buf|=t<<e.bi_valid&65535,Wa(e,e.bi_buf),e.bi_buf=t>>as-e.bi_valid,e.bi_valid+=n-as):(e.bi_buf|=t<<e.bi_valid&65535,e.bi_valid+=n)}function Ki(e,t,n){_i(e,n[t*2],n[t*2+1])}function Bs(e,t){var n=0;do n|=e&1,e>>>=1,n<<=1;while(--t>0);return n>>>1}function Jo(e){e.bi_valid===16?(Wa(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 Ga(e,t){var n=t.dyn_tree,r=t.max_code,a=t.stat_desc.static_tree,u=t.stat_desc.has_stree,h=t.stat_desc.extra_bits,b=t.stat_desc.extra_base,U=t.stat_desc.max_length,O,D,ge,we,ke,Et,kt=0;for(we=0;we<=ua;we++)e.bl_count[we]=0;for(n[e.heap[e.heap_max]*2+1]=0,O=e.heap_max+1;O<cl;O++)D=e.heap[O],we=n[n[D*2+1]*2+1]+1,we>U&&(we=U,kt++),n[D*2+1]=we,!(D>r)&&(e.bl_count[we]++,ke=0,D>=b&&(ke=h[D-b]),Et=n[D*2],e.opt_len+=Et*(we+ke),u&&(e.static_len+=Et*(a[D*2+1]+ke)));if(kt!==0){do{for(we=U-1;e.bl_count[we]===0;)we--;e.bl_count[we]--,e.bl_count[we+1]+=2,e.bl_count[U]--,kt-=2}while(kt>0);for(we=U;we!==0;we--)for(D=e.bl_count[we];D!==0;)ge=e.heap[--O],!(ge>r)&&(n[ge*2+1]!==we&&(e.opt_len+=(we-n[ge*2+1])*n[ge*2],n[ge*2+1]=we),D--)}}function ds(e,t,n){var r=new Array(ua+1),a=0,u,h;for(u=1;u<=ua;u++)r[u]=a=a+n[u-1]<<1;for(h=0;h<=t;h++){var b=e[h*2+1];b!==0&&(e[h*2]=Bs(r[b]++,b))}}function gl(){var e,t,n,r,a,u=new Array(ua+1);for(n=0,r=0;r<Is-1;r++)for(ls[r]=n,e=0;e<1<<$a[r];e++)Pa[n++]=r;for(Pa[n-1]=r,a=0,r=0;r<16;r++)for(za[r]=a,e=0;e<1<<fa[r];e++)ja[a++]=r;for(a>>=7;r<Ko;r++)for(za[r]=a<<7,e=0;e<1<<fa[r]-7;e++)ja[256+a++]=r;for(t=0;t<=ua;t++)u[t]=0;for(e=0;e<=143;)wo[e*2+1]=8,e++,u[8]++;for(;e<=255;)wo[e*2+1]=9,e++,u[9]++;for(;e<=279;)wo[e*2+1]=7,e++,u[7]++;for(;e<=287;)wo[e*2+1]=8,e++,u[8]++;for(ds(wo,Va+1,u),e=0;e<Ko;e++)Ha[e*2+1]=5,Ha[e*2]=Bs(e,5);Rs=new cs(wo,$a,Fa+1,Va,ua),us=new cs(Ha,fa,0,Ko,ua),xs=new cs(new Array(0),dl,0,os,Ns)}function pl(e){var t;for(t=0;t<Va;t++)e.dyn_ltree[t*2]=0;for(t=0;t<Ko;t++)e.dyn_dtree[t*2]=0;for(t=0;t<os;t++)e.bl_tree[t*2]=0;e.dyn_ltree[ss*2]=1,e.opt_len=e.static_len=0,e.last_lit=e.matches=0}function Vo(e){e.bi_valid>8?Wa(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 vl(e,t,n,r){Vo(e),r&&(Wa(e,n),Wa(e,~n)),St.arraySet(e.pending_buf,e.window,t,n,e.pending),e.pending+=n}function Ms(e,t,n,r){var a=t*2,u=n*2;return e[a]<e[u]||e[a]===e[u]&&r[t]<=r[n]}function Ls(e,t,n){for(var r=e.heap[n],a=n<<1;a<=e.heap_len&&(a<e.heap_len&&Ms(t,e.heap[a+1],e.heap[a],e.depth)&&a++,!Ms(t,r,e.heap[a],e.depth));)e.heap[n]=e.heap[a],n=a,a<<=1;e.heap[n]=r}function hs(e,t,n){var r,a,u=0,h,b;if(e.last_lit!==0)do r=e.pending_buf[e.d_buf+u*2]<<8|e.pending_buf[e.d_buf+u*2+1],a=e.pending_buf[e.l_buf+u],u++,r===0?Ki(e,a,t):(h=Pa[a],Ki(e,h+Fa+1,t),b=$a[h],b!==0&&(a-=ls[h],_i(e,a,b)),r--,h=hl(r),Ki(e,h,n),b=fa[h],b!==0&&(r-=za[h],_i(e,r,b)));while(u<e.last_lit);Ki(e,ss,t)}function fo(e,t){var n=t.dyn_tree,r=t.stat_desc.static_tree,a=t.stat_desc.has_stree,u=t.stat_desc.elems,h,b,U=-1,O;for(e.heap_len=0,e.heap_max=cl,h=0;h<u;h++)n[h*2]!==0?(e.heap[++e.heap_len]=U=h,e.depth[h]=0):n[h*2+1]=0;for(;e.heap_len<2;)O=e.heap[++e.heap_len]=U<2?++U:0,n[O*2]=1,e.depth[O]=0,e.opt_len--,a&&(e.static_len-=r[O*2+1]);for(t.max_code=U,h=e.heap_len>>1;h>=1;h--)Ls(e,n,h);O=u;do h=e.heap[1],e.heap[1]=e.heap[e.heap_len--],Ls(e,n,1),b=e.heap[1],e.heap[--e.heap_max]=h,e.heap[--e.heap_max]=b,n[O*2]=n[h*2]+n[b*2],e.depth[O]=(e.depth[h]>=e.depth[b]?e.depth[h]:e.depth[b])+1,n[h*2+1]=n[b*2+1]=O,e.heap[1]=O++,Ls(e,n,1);while(e.heap_len>=2);e.heap[--e.heap_max]=e.heap[1],Ga(e,t),ds(n,U,e.bl_count)}function Zo(e,t,n){var r,a=-1,u,h=t[0*2+1],b=0,U=7,O=4;for(h===0&&(U=138,O=3),t[(n+1)*2+1]=65535,r=0;r<=n;r++)u=h,h=t[(r+1)*2+1],!(++b<U&&u===h)&&(b<O?e.bl_tree[u*2]+=b:u!==0?(u!==a&&e.bl_tree[u*2]++,e.bl_tree[ul*2]++):b<=10?e.bl_tree[fl*2]++:e.bl_tree[Ta*2]++,b=0,a=u,h===0?(U=138,O=3):u===h?(U=6,O=3):(U=7,O=4))}function Ds(e,t,n){var r,a=-1,u,h=t[0*2+1],b=0,U=7,O=4;for(h===0&&(U=138,O=3),r=0;r<=n;r++)if(u=h,h=t[(r+1)*2+1],!(++b<U&&u===h)){if(b<O)do Ki(e,u,e.bl_tree);while(--b!==0);else u!==0?(u!==a&&(Ki(e,u,e.bl_tree),b--),Ki(e,ul,e.bl_tree),_i(e,b-3,2)):b<=10?(Ki(e,fl,e.bl_tree),_i(e,b-3,3)):(Ki(e,Ta,e.bl_tree),_i(e,b-11,7));b=0,a=u,h===0?(U=138,O=3):u===h?(U=6,O=3):(U=7,O=4)}}function Gl(e){var t;for(Zo(e,e.dyn_ltree,e.l_desc.max_code),Zo(e,e.dyn_dtree,e.d_desc.max_code),fo(e,e.bl_desc),t=os-1;t>=3&&e.bl_tree[Ua[t]*2+1]===0;t--);return e.opt_len+=3*(t+1)+5+5+4,t}function ml(e,t,n,r){var a;for(_i(e,t-257,5),_i(e,n-1,5),_i(e,r-4,4),a=0;a<r;a++)_i(e,e.bl_tree[Ua[a]*2+1],3);Ds(e,e.dyn_ltree,t-1),Ds(e,e.dyn_dtree,n-1)}function gs(e){var t=4093624447,n;for(n=0;n<=31;n++,t>>>=1)if(t&1&&e.dyn_ltree[n*2]!==0)return Fo;if(e.dyn_ltree[9*2]!==0||e.dyn_ltree[10*2]!==0||e.dyn_ltree[13*2]!==0)return ca;for(n=32;n<Fa;n++)if(e.dyn_ltree[n*2]!==0)return ca;return Fo}var Fs=!1;function _l(e){Fs||(gl(),Fs=!0),e.l_desc=new fs(e.dyn_ltree,Rs),e.d_desc=new fs(e.dyn_dtree,us),e.bl_desc=new fs(e.bl_tree,xs),e.bi_buf=0,e.bi_valid=0,pl(e)}function Vs(e,t,n,r){_i(e,(zl<<1)+(r?1:0),3),vl(e,t,n,!0)}function bl(e){_i(e,al<<1,3),Ki(e,ss,wo),Jo(e)}function El(e,t,n,r){var a,u,h=0;e.level>0?(e.strm.data_type===Ps&&(e.strm.data_type=gs(e)),fo(e,e.l_desc),fo(e,e.d_desc),h=Gl(e),a=e.opt_len+3+7>>>3,u=e.static_len+3+7>>>3,u<=a&&(a=u)):a=u=n+5,n+4<=a&&t!==-1?Vs(e,t,n,r):e.strategy===yo||u===a?(_i(e,(al<<1)+(r?1:0),3),hs(e,wo,Ha)):(_i(e,(Wl<<1)+(r?1:0),3),ml(e,e.l_desc.max_code+1,e.d_desc.max_code+1,h+1),hs(e,e.dyn_ltree,e.dyn_dtree)),pl(e),r&&Vo(e)}function yl(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[(Pa[n]+Fa+1)*2]++,e.dyn_dtree[hl(t)*2]++),e.last_lit===e.lit_bufsize-1}var wl=_l,Yl=Vs,ql=El,o=yl,c=bl,v={_tr_init:wl,_tr_stored_block:Yl,_tr_flush_block:ql,_tr_tally:o,_tr_align:c};function E(e,t,n,r){for(var a=e&65535|0,u=e>>>16&65535|0,h=0;n!==0;){h=n>2e3?2e3:n,n-=h;do a=a+t[r++]|0,u=u+a|0;while(--h);a%=65521,u%=65521}return a|u<<16|0}var P=E;function C(){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 V=C();function G(e,t,n,r){var a=V,u=r+n;e^=-1;for(var h=r;h<u;h++)e=e>>>8^a[(e^t[h])&255];return e^-1}var q=G,ae={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"},Le=v,Xe=P,se=q,$e=ae,We=0,_t=1,Pt=3,_e=4,fe=5,Te=0,i=1,s=-2,d=-3,p=-5,y=-1,w=1,I=2,L=3,$=4,ee=0,ie=2,Ie=8,oe=9,Ce=15,Be=8,ft=29,At=256,me=At+1+ft,le=30,Se=19,qe=2*me+1,He=15,Re=3,lt=258,xe=lt+Re+1,It=32,Ct=42,Bt=69,Jt=73,dt=91,F=103,K=113,he=666,pe=1,Pe=2,Ke=3,ct=4,Qe=3;function Je(e,t){return e.msg=$e[t],t}function De(e){return(e<<1)-(e>4?9:0)}function yt(e){for(var t=e.length;--t>=0;)e[t]=0}function wt(e){var t=e.state,n=t.pending;n>e.avail_out&&(n=e.avail_out),n!==0&&(St.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 at(e,t){Le._tr_flush_block(e,e.block_start>=0?e.block_start:-1,e.strstart-e.block_start,t),e.block_start=e.strstart,wt(e.strm)}function ot(e,t){e.pending_buf[e.pending++]=t}function dn(e,t){e.pending_buf[e.pending++]=t>>>8&255,e.pending_buf[e.pending++]=t&255}function bn(e,t,n,r){var a=e.avail_in;return a>r&&(a=r),a===0?0:(e.avail_in-=a,St.arraySet(t,e.input,e.next_in,a,n),e.state.wrap===1?e.adler=Xe(e.adler,t,a,n):e.state.wrap===2&&(e.adler=se(e.adler,t,a,n)),e.next_in+=a,e.total_in+=a,a)}function tr(e,t){var n=e.max_chain_length,r=e.strstart,a,u,h=e.prev_length,b=e.nice_match,U=e.strstart>e.w_size-xe?e.strstart-(e.w_size-xe):0,O=e.window,D=e.w_mask,ge=e.prev,we=e.strstart+lt,ke=O[r+h-1],Et=O[r+h];e.prev_length>=e.good_match&&(n>>=2),b>e.lookahead&&(b=e.lookahead);do if(a=t,!(O[a+h]!==Et||O[a+h-1]!==ke||O[a]!==O[r]||O[++a]!==O[r+1])){r+=2,a++;do;while(O[++r]===O[++a]&&O[++r]===O[++a]&&O[++r]===O[++a]&&O[++r]===O[++a]&&O[++r]===O[++a]&&O[++r]===O[++a]&&O[++r]===O[++a]&&O[++r]===O[++a]&&r<we);if(u=lt-(we-r),r=we-lt,u>h){if(e.match_start=t,h=u,u>=b)break;ke=O[r+h-1],Et=O[r+h]}}while((t=ge[t&D])>U&&--n!==0);return h<=e.lookahead?h:e.lookahead}function Pn(e){var t=e.w_size,n,r,a,u,h;do{if(u=e.window_size-e.lookahead-e.strstart,e.strstart>=t+(t-xe)){St.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 a=e.head[--n],e.head[n]=a>=t?a-t:0;while(--r);r=t,n=r;do a=e.prev[--n],e.prev[n]=a>=t?a-t:0;while(--r);u+=t}if(e.strm.avail_in===0)break;if(r=bn(e.strm,e.window,e.strstart+e.lookahead,u),e.lookahead+=r,e.lookahead+e.insert>=Re)for(h=e.strstart-e.insert,e.ins_h=e.window[h],e.ins_h=(e.ins_h<<e.hash_shift^e.window[h+1])&e.hash_mask;e.insert&&(e.ins_h=(e.ins_h<<e.hash_shift^e.window[h+Re-1])&e.hash_mask,e.prev[h&e.w_mask]=e.head[e.ins_h],e.head[e.ins_h]=h,h++,e.insert--,!(e.lookahead+e.insert<Re)););}while(e.lookahead<xe&&e.strm.avail_in!==0)}function $o(e,t){var n=65535;for(n>e.pending_buf_size-5&&(n=e.pending_buf_size-5);;){if(e.lookahead<=1){if(Pn(e),e.lookahead===0&&t===We)return pe;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,at(e,!1),e.strm.avail_out===0)||e.strstart-e.block_start>=e.w_size-xe&&(at(e,!1),e.strm.avail_out===0))return pe}return e.insert=0,t===_e?(at(e,!0),e.strm.avail_out===0?Ke:ct):(e.strstart>e.block_start&&(at(e,!1),e.strm.avail_out===0),pe)}function So(e,t){for(var n,r;;){if(e.lookahead<xe){if(Pn(e),e.lookahead<xe&&t===We)return pe;if(e.lookahead===0)break}if(n=0,e.lookahead>=Re&&(e.ins_h=(e.ins_h<<e.hash_shift^e.window[e.strstart+Re-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-xe&&(e.match_length=tr(e,n)),e.match_length>=Re)if(r=Le._tr_tally(e,e.strstart-e.match_start,e.match_length-Re),e.lookahead-=e.match_length,e.match_length<=e.max_lazy_match&&e.lookahead>=Re){e.match_length--;do e.strstart++,e.ins_h=(e.ins_h<<e.hash_shift^e.window[e.strstart+Re-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=Le._tr_tally(e,0,e.window[e.strstart]),e.lookahead--,e.strstart++;if(r&&(at(e,!1),e.strm.avail_out===0))return pe}return e.insert=e.strstart<Re-1?e.strstart:Re-1,t===_e?(at(e,!0),e.strm.avail_out===0?Ke:ct):e.last_lit&&(at(e,!1),e.strm.avail_out===0)?pe:Pe}function W(e,t){for(var n,r,a;;){if(e.lookahead<xe){if(Pn(e),e.lookahead<xe&&t===We)return pe;if(e.lookahead===0)break}if(n=0,e.lookahead>=Re&&(e.ins_h=(e.ins_h<<e.hash_shift^e.window[e.strstart+Re-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=Re-1,n!==0&&e.prev_length<e.max_lazy_match&&e.strstart-n<=e.w_size-xe&&(e.match_length=tr(e,n),e.match_length<=5&&(e.strategy===w||e.match_length===Re&&e.strstart-e.match_start>4096)&&(e.match_length=Re-1)),e.prev_length>=Re&&e.match_length<=e.prev_length){a=e.strstart+e.lookahead-Re,r=Le._tr_tally(e,e.strstart-1-e.prev_match,e.prev_length-Re),e.lookahead-=e.prev_length-1,e.prev_length-=2;do++e.strstart<=a&&(e.ins_h=(e.ins_h<<e.hash_shift^e.window[e.strstart+Re-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=Re-1,e.strstart++,r&&(at(e,!1),e.strm.avail_out===0))return pe}else if(e.match_available){if(r=Le._tr_tally(e,0,e.window[e.strstart-1]),r&&at(e,!1),e.strstart++,e.lookahead--,e.strm.avail_out===0)return pe}else e.match_available=1,e.strstart++,e.lookahead--}return e.match_available&&(r=Le._tr_tally(e,0,e.window[e.strstart-1]),e.match_available=0),e.insert=e.strstart<Re-1?e.strstart:Re-1,t===_e?(at(e,!0),e.strm.avail_out===0?Ke:ct):e.last_lit&&(at(e,!1),e.strm.avail_out===0)?pe:Pe}function re(e,t){for(var n,r,a,u,h=e.window;;){if(e.lookahead<=lt){if(Pn(e),e.lookahead<=lt&&t===We)return pe;if(e.lookahead===0)break}if(e.match_length=0,e.lookahead>=Re&&e.strstart>0&&(a=e.strstart-1,r=h[a],r===h[++a]&&r===h[++a]&&r===h[++a])){u=e.strstart+lt;do;while(r===h[++a]&&r===h[++a]&&r===h[++a]&&r===h[++a]&&r===h[++a]&&r===h[++a]&&r===h[++a]&&r===h[++a]&&a<u);e.match_length=lt-(u-a),e.match_length>e.lookahead&&(e.match_length=e.lookahead)}if(e.match_length>=Re?(n=Le._tr_tally(e,1,e.match_length-Re),e.lookahead-=e.match_length,e.strstart+=e.match_length,e.match_length=0):(n=Le._tr_tally(e,0,e.window[e.strstart]),e.lookahead--,e.strstart++),n&&(at(e,!1),e.strm.avail_out===0))return pe}return e.insert=0,t===_e?(at(e,!0),e.strm.avail_out===0?Ke:ct):e.last_lit&&(at(e,!1),e.strm.avail_out===0)?pe:Pe}function Ee(e,t){for(var n;;){if(e.lookahead===0&&(Pn(e),e.lookahead===0)){if(t===We)return pe;break}if(e.match_length=0,n=Le._tr_tally(e,0,e.window[e.strstart]),e.lookahead--,e.strstart++,n&&(at(e,!1),e.strm.avail_out===0))return pe}return e.insert=0,t===_e?(at(e,!0),e.strm.avail_out===0?Ke:ct):e.last_lit&&(at(e,!1),e.strm.avail_out===0)?pe:Pe}function Ae(e,t,n,r,a){this.good_length=e,this.max_lazy=t,this.nice_length=n,this.max_chain=r,this.func=a}var Me;Me=[new Ae(0,0,0,0,$o),new Ae(4,4,8,4,So),new Ae(4,5,16,8,So),new Ae(4,6,32,32,So),new Ae(4,4,16,16,W),new Ae(8,16,32,32,W),new Ae(8,16,128,128,W),new Ae(8,32,128,256,W),new Ae(32,128,258,1024,W),new Ae(32,258,258,4096,W)];function tt(e){e.window_size=2*e.w_size,yt(e.head),e.max_lazy_match=Me[e.level].max_lazy,e.good_match=Me[e.level].good_length,e.nice_match=Me[e.level].nice_length,e.max_chain_length=Me[e.level].max_chain,e.strstart=0,e.block_start=0,e.lookahead=0,e.insert=0,e.match_length=e.prev_length=Re-1,e.match_available=0,e.ins_h=0}function ht(){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=Ie,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 St.Buf16(qe*2),this.dyn_dtree=new St.Buf16((2*le+1)*2),this.bl_tree=new St.Buf16((2*Se+1)*2),yt(this.dyn_ltree),yt(this.dyn_dtree),yt(this.bl_tree),this.l_desc=null,this.d_desc=null,this.bl_desc=null,this.bl_count=new St.Buf16(He+1),this.heap=new St.Buf16(2*me+1),yt(this.heap),this.heap_len=0,this.heap_max=0,this.depth=new St.Buf16(2*me+1),yt(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 Ye(e){var t;return!e||!e.state?Je(e,s):(e.total_in=e.total_out=0,e.data_type=ie,t=e.state,t.pending=0,t.pending_out=0,t.wrap<0&&(t.wrap=-t.wrap),t.status=t.wrap?Ct:K,e.adler=t.wrap===2?0:1,t.last_flush=We,Le._tr_init(t),Te)}function et(e){var t=Ye(e);return t===Te&&tt(e.state),t}function je(e,t){return!e||!e.state||e.state.wrap!==2?s:(e.state.gzhead=t,Te)}function Nt(e,t,n,r,a,u){if(!e)return s;var h=1;if(t===y&&(t=6),r<0?(h=0,r=-r):r>15&&(h=2,r-=16),a<1||a>oe||n!==Ie||r<8||r>15||t<0||t>9||u<0||u>$)return Je(e,s);r===8&&(r=9);var b=new ht;return e.state=b,b.strm=e,b.wrap=h,b.gzhead=null,b.w_bits=r,b.w_size=1<<b.w_bits,b.w_mask=b.w_size-1,b.hash_bits=a+7,b.hash_size=1<<b.hash_bits,b.hash_mask=b.hash_size-1,b.hash_shift=~~((b.hash_bits+Re-1)/Re),b.window=new St.Buf8(b.w_size*2),b.head=new St.Buf16(b.hash_size),b.prev=new St.Buf16(b.w_size),b.lit_bufsize=1<<a+6,b.pending_buf_size=b.lit_bufsize*4,b.pending_buf=new St.Buf8(b.pending_buf_size),b.d_buf=1*b.lit_bufsize,b.l_buf=(1+2)*b.lit_bufsize,b.level=t,b.strategy=u,b.method=n,et(e)}function Dt(e,t){return Nt(e,t,Ie,Ce,Be,ee)}function Ft(e,t){var n,r,a,u;if(!e||!e.state||t>fe||t<0)return e?Je(e,s):s;if(r=e.state,!e.output||!e.input&&e.avail_in!==0||r.status===he&&t!==_e)return Je(e,e.avail_out===0?p:s);if(r.strm=e,n=r.last_flush,r.last_flush=t,r.status===Ct)if(r.wrap===2)e.adler=0,ot(r,31),ot(r,139),ot(r,8),r.gzhead?(ot(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)),ot(r,r.gzhead.time&255),ot(r,r.gzhead.time>>8&255),ot(r,r.gzhead.time>>16&255),ot(r,r.gzhead.time>>24&255),ot(r,r.level===9?2:r.strategy>=I||r.level<2?4:0),ot(r,r.gzhead.os&255),r.gzhead.extra&&r.gzhead.extra.length&&(ot(r,r.gzhead.extra.length&255),ot(r,r.gzhead.extra.length>>8&255)),r.gzhead.hcrc&&(e.adler=se(e.adler,r.pending_buf,r.pending,0)),r.gzindex=0,r.status=Bt):(ot(r,0),ot(r,0),ot(r,0),ot(r,0),ot(r,0),ot(r,r.level===9?2:r.strategy>=I||r.level<2?4:0),ot(r,Qe),r.status=K);else{var h=Ie+(r.w_bits-8<<4)<<8,b=-1;r.strategy>=I||r.level<2?b=0:r.level<6?b=1:r.level===6?b=2:b=3,h|=b<<6,r.strstart!==0&&(h|=It),h+=31-h%31,r.status=K,dn(r,h),r.strstart!==0&&(dn(r,e.adler>>>16),dn(r,e.adler&65535)),e.adler=1}if(r.status===Bt)if(r.gzhead.extra){for(a=r.pending;r.gzindex<(r.gzhead.extra.length&65535)&&!(r.pending===r.pending_buf_size&&(r.gzhead.hcrc&&r.pending>a&&(e.adler=se(e.adler,r.pending_buf,r.pending-a,a)),wt(e),a=r.pending,r.pending===r.pending_buf_size));)ot(r,r.gzhead.extra[r.gzindex]&255),r.gzindex++;r.gzhead.hcrc&&r.pending>a&&(e.adler=se(e.adler,r.pending_buf,r.pending-a,a)),r.gzindex===r.gzhead.extra.length&&(r.gzindex=0,r.status=Jt)}else r.status=Jt;if(r.status===Jt)if(r.gzhead.name){a=r.pending;do{if(r.pending===r.pending_buf_size&&(r.gzhead.hcrc&&r.pending>a&&(e.adler=se(e.adler,r.pending_buf,r.pending-a,a)),wt(e),a=r.pending,r.pending===r.pending_buf_size)){u=1;break}r.gzindex<r.gzhead.name.length?u=r.gzhead.name.charCodeAt(r.gzindex++)&255:u=0,ot(r,u)}while(u!==0);r.gzhead.hcrc&&r.pending>a&&(e.adler=se(e.adler,r.pending_buf,r.pending-a,a)),u===0&&(r.gzindex=0,r.status=dt)}else r.status=dt;if(r.status===dt)if(r.gzhead.comment){a=r.pending;do{if(r.pending===r.pending_buf_size&&(r.gzhead.hcrc&&r.pending>a&&(e.adler=se(e.adler,r.pending_buf,r.pending-a,a)),wt(e),a=r.pending,r.pending===r.pending_buf_size)){u=1;break}r.gzindex<r.gzhead.comment.length?u=r.gzhead.comment.charCodeAt(r.gzindex++)&255:u=0,ot(r,u)}while(u!==0);r.gzhead.hcrc&&r.pending>a&&(e.adler=se(e.adler,r.pending_buf,r.pending-a,a)),u===0&&(r.status=F)}else r.status=F;if(r.status===F&&(r.gzhead.hcrc?(r.pending+2>r.pending_buf_size&&wt(e),r.pending+2<=r.pending_buf_size&&(ot(r,e.adler&255),ot(r,e.adler>>8&255),e.adler=0,r.status=K)):r.status=K),r.pending!==0){if(wt(e),e.avail_out===0)return r.last_flush=-1,Te}else if(e.avail_in===0&&De(t)<=De(n)&&t!==_e)return Je(e,p);if(r.status===he&&e.avail_in!==0)return Je(e,p);if(e.avail_in!==0||r.lookahead!==0||t!==We&&r.status!==he){var U=r.strategy===I?Ee(r,t):r.strategy===L?re(r,t):Me[r.level].func(r,t);if((U===Ke||U===ct)&&(r.status=he),U===pe||U===Ke)return e.avail_out===0&&(r.last_flush=-1),Te;if(U===Pe&&(t===_t?Le._tr_align(r):t!==fe&&(Le._tr_stored_block(r,0,0,!1),t===Pt&&(yt(r.head),r.lookahead===0&&(r.strstart=0,r.block_start=0,r.insert=0))),wt(e),e.avail_out===0))return r.last_flush=-1,Te}return t!==_e?Te:r.wrap<=0?i:(r.wrap===2?(ot(r,e.adler&255),ot(r,e.adler>>8&255),ot(r,e.adler>>16&255),ot(r,e.adler>>24&255),ot(r,e.total_in&255),ot(r,e.total_in>>8&255),ot(r,e.total_in>>16&255),ot(r,e.total_in>>24&255)):(dn(r,e.adler>>>16),dn(r,e.adler&65535)),wt(e),r.wrap>0&&(r.wrap=-r.wrap),r.pending!==0?Te:i)}function on(e){var t;return!e||!e.state?s:(t=e.state.status,t!==Ct&&t!==Bt&&t!==Jt&&t!==dt&&t!==F&&t!==K&&t!==he?Je(e,s):(e.state=null,t===K?Je(e,d):Te))}function Vr(e,t){var n=t.length,r,a,u,h,b,U,O,D;if(!e||!e.state||(r=e.state,h=r.wrap,h===2||h===1&&r.status!==Ct||r.lookahead))return s;for(h===1&&(e.adler=Xe(e.adler,t,n,0)),r.wrap=0,n>=r.w_size&&(h===0&&(yt(r.head),r.strstart=0,r.block_start=0,r.insert=0),D=new St.Buf8(r.w_size),St.arraySet(D,t,n-r.w_size,r.w_size,0),t=D,n=r.w_size),b=e.avail_in,U=e.next_in,O=e.input,e.avail_in=n,e.next_in=0,e.input=t,Pn(r);r.lookahead>=Re;){a=r.strstart,u=r.lookahead-(Re-1);do r.ins_h=(r.ins_h<<r.hash_shift^r.window[a+Re-1])&r.hash_mask,r.prev[a&r.w_mask]=r.head[r.ins_h],r.head[r.ins_h]=a,a++;while(--u);r.strstart=a,r.lookahead=Re-1,Pn(r)}return r.strstart+=r.lookahead,r.block_start=r.strstart,r.insert=r.lookahead,r.lookahead=0,r.match_length=r.prev_length=Re-1,r.match_available=0,e.next_in=U,e.input=O,e.avail_in=b,r.wrap=h,Te}var nr=Dt,Kr=Nt,Ri=et,Ya=Ye,ps=je,$r=Ft,$s=on,Us=Vr,ho="pako deflate (from Nodeca project)",qa={deflateInit:nr,deflateInit2:Kr,deflateReset:Ri,deflateResetKeep:Ya,deflateSetHeader:ps,deflate:$r,deflateEnd:$s,deflateSetDictionary:Us,deflateInfo:ho},Ka=!0,da=!0;try{String.fromCharCode.apply(null,[0])}catch(e){Ka=!1}try{String.fromCharCode.apply(null,new Uint8Array(1))}catch(e){da=!1}for(var Uo=new St.Buf8(256),bi=0;bi<256;bi++)Uo[bi]=bi>=252?6:bi>=248?5:bi>=240?4:bi>=224?3:bi>=192?2:1;Uo[254]=Uo[254]=1;var vs=function(e){var t,n,r,a,u,h=e.length,b=0;for(a=0;a<h;a++)n=e.charCodeAt(a),(n&64512)===55296&&a+1<h&&(r=e.charCodeAt(a+1),(r&64512)===56320&&(n=65536+(n-55296<<10)+(r-56320),a++)),b+=n<128?1:n<2048?2:n<65536?3:4;for(t=new St.Buf8(b),u=0,a=0;u<b;a++)n=e.charCodeAt(a),(n&64512)===55296&&a+1<h&&(r=e.charCodeAt(a+1),(r&64512)===56320&&(n=65536+(n-55296<<10)+(r-56320),a++)),n<128?t[u++]=n:n<2048?(t[u++]=192|n>>>6,t[u++]=128|n&63):n<65536?(t[u++]=224|n>>>12,t[u++]=128|n>>>6&63,t[u++]=128|n&63):(t[u++]=240|n>>>18,t[u++]=128|n>>>12&63,t[u++]=128|n>>>6&63,t[u++]=128|n&63);return t};function Ia(e,t){if(t<65534&&(e.subarray&&da||!e.subarray&&Ka))return String.fromCharCode.apply(null,St.shrinkBuf(e,t));for(var n="",r=0;r<t;r++)n+=String.fromCharCode(e[r]);return n}var Ec=function(e){return Ia(e,e.length)},Kl=function(e){for(var t=new St.Buf8(e.length),n=0,r=t.length;n<r;n++)t[n]=e.charCodeAt(n);return t},yc=function(e,t){var n,r,a,u,h=t||e.length,b=new Array(h*2);for(r=0,n=0;n<h;){if(a=e[n++],a<128){b[r++]=a;continue}if(u=Uo[a],u>4){b[r++]=65533,n+=u-1;continue}for(a&=u===2?31:u===3?15:7;u>1&&n<h;)a=a<<6|e[n++]&63,u--;if(u>1){b[r++]=65533;continue}a<65536?b[r++]=a:(a-=65536,b[r++]=55296|a>>10&1023,b[r++]=56320|a&1023)}return Ia(b,r)},wc=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+Uo[e[n]]>t?n:t},ov={string2buf:vs,buf2binstring:Ec,binstring2buf:Kl,buf2string:yc,utf8border:wc};function av(){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 sv=av,Jl=qa,Hs=ov,Rf=sv,xf=Object.prototype.toString,lv=0,pu=4,Sl=0,Bf=1,Mf=2,cv=-1,uv=0,fv=8;function js(e){if(!(this instanceof js))return new js(e);this.options=St.assign({level:cv,method:fv,chunkSize:16384,windowBits:15,memLevel:8,strategy:uv,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 Rf,this.strm.avail_out=0;var n=Jl.deflateInit2(this.strm,t.level,t.method,t.windowBits,t.memLevel,t.strategy);if(n!==Sl)throw new Error($e[n]);if(t.header&&Jl.deflateSetHeader(this.strm,t.header),t.dictionary){var r;if(typeof t.dictionary=="string"?r=Hs.string2buf(t.dictionary):xf.call(t.dictionary)==="[object ArrayBuffer]"?r=new Uint8Array(t.dictionary):r=t.dictionary,n=Jl.deflateSetDictionary(this.strm,r),n!==Sl)throw new Error($e[n]);this._dict_set=!0}}js.prototype.push=function(e,t){var n=this.strm,r=this.options.chunkSize,a,u;if(this.ended)return!1;u=t===~~t?t:t===!0?pu:lv,typeof e=="string"?n.input=Hs.string2buf(e):xf.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 St.Buf8(r),n.next_out=0,n.avail_out=r),a=Jl.deflate(n,u),a!==Bf&&a!==Sl)return this.onEnd(a),this.ended=!0,!1;(n.avail_out===0||n.avail_in===0&&(u===pu||u===Mf))&&(this.options.to==="string"?this.onData(Hs.buf2binstring(St.shrinkBuf(n.output,n.next_out))):this.onData(St.shrinkBuf(n.output,n.next_out)))}while((n.avail_in>0||n.avail_out===0)&&a!==Bf);return u===pu?(a=Jl.deflateEnd(this.strm),this.onEnd(a),this.ended=!0,a===Sl):(u===Mf&&(this.onEnd(Sl),n.avail_out=0),!0)},js.prototype.onData=function(e){this.chunks.push(e)},js.prototype.onEnd=function(e){e===Sl&&(this.options.to==="string"?this.result=this.chunks.join(""):this.result=St.flattenChunks(this.chunks)),this.chunks=[],this.err=e,this.msg=this.strm.msg};function vu(e,t){var n=new js(t);if(n.push(e,!0),n.err)throw n.msg||$e[n.err];return n.result}function dv(e,t){return t=t||{},t.raw=!0,vu(e,t)}function hv(e,t){return t=t||{},t.gzip=!0,vu(e,t)}var gv=js,pv=vu,vv=dv,mv=hv,_v={Deflate:gv,deflate:pv,deflateRaw:vv,gzip:mv},Sc=30,bv=12,Ev=function(t,n){var r,a,u,h,b,U,O,D,ge,we,ke,Et,kt,Zt,$t,Nn,Dn,en,mt,hn,Xt,jt,gn,sr,zt;r=t.state,a=t.next_in,sr=t.input,u=a+(t.avail_in-5),h=t.next_out,zt=t.output,b=h-(n-t.avail_out),U=h+(t.avail_out-257),O=r.dmax,D=r.wsize,ge=r.whave,we=r.wnext,ke=r.window,Et=r.hold,kt=r.bits,Zt=r.lencode,$t=r.distcode,Nn=(1<<r.lenbits)-1,Dn=(1<<r.distbits)-1;e:do{kt<15&&(Et+=sr[a++]<<kt,kt+=8,Et+=sr[a++]<<kt,kt+=8),en=Zt[Et&Nn];t:for(;;){if(mt=en>>>24,Et>>>=mt,kt-=mt,mt=en>>>16&255,mt===0)zt[h++]=en&65535;else if(mt&16){hn=en&65535,mt&=15,mt&&(kt<mt&&(Et+=sr[a++]<<kt,kt+=8),hn+=Et&(1<<mt)-1,Et>>>=mt,kt-=mt),kt<15&&(Et+=sr[a++]<<kt,kt+=8,Et+=sr[a++]<<kt,kt+=8),en=$t[Et&Dn];n:for(;;){if(mt=en>>>24,Et>>>=mt,kt-=mt,mt=en>>>16&255,mt&16){if(Xt=en&65535,mt&=15,kt<mt&&(Et+=sr[a++]<<kt,kt+=8,kt<mt&&(Et+=sr[a++]<<kt,kt+=8)),Xt+=Et&(1<<mt)-1,Xt>O){t.msg="invalid distance too far back",r.mode=Sc;break e}if(Et>>>=mt,kt-=mt,mt=h-b,Xt>mt){if(mt=Xt-mt,mt>ge&&r.sane){t.msg="invalid distance too far back",r.mode=Sc;break e}if(jt=0,gn=ke,we===0){if(jt+=D-mt,mt<hn){hn-=mt;do zt[h++]=ke[jt++];while(--mt);jt=h-Xt,gn=zt}}else if(we<mt){if(jt+=D+we-mt,mt-=we,mt<hn){hn-=mt;do zt[h++]=ke[jt++];while(--mt);if(jt=0,we<hn){mt=we,hn-=mt;do zt[h++]=ke[jt++];while(--mt);jt=h-Xt,gn=zt}}}else if(jt+=we-mt,mt<hn){hn-=mt;do zt[h++]=ke[jt++];while(--mt);jt=h-Xt,gn=zt}for(;hn>2;)zt[h++]=gn[jt++],zt[h++]=gn[jt++],zt[h++]=gn[jt++],hn-=3;hn&&(zt[h++]=gn[jt++],hn>1&&(zt[h++]=gn[jt++]))}else{jt=h-Xt;do zt[h++]=zt[jt++],zt[h++]=zt[jt++],zt[h++]=zt[jt++],hn-=3;while(hn>2);hn&&(zt[h++]=zt[jt++],hn>1&&(zt[h++]=zt[jt++]))}}else if((mt&64)===0){en=$t[(en&65535)+(Et&(1<<mt)-1)];continue n}else{t.msg="invalid distance code",r.mode=Sc;break e}break}}else if((mt&64)===0){en=Zt[(en&65535)+(Et&(1<<mt)-1)];continue t}else if(mt&32){r.mode=bv;break e}else{t.msg="invalid literal/length code",r.mode=Sc;break e}break}}while(a<u&&h<U);hn=kt>>3,a-=hn,kt-=hn<<3,Et&=(1<<kt)-1,t.next_in=a,t.next_out=h,t.avail_in=a<u?5+(u-a):5-(a-u),t.avail_out=h<U?257+(U-h):257-(h-U),r.hold=Et,r.bits=kt},Al=15,Lf=852,Df=592,Ff=0,mu=1,Vf=2,yv=[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],wv=[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],Sv=[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],Av=[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],Cv=function(t,n,r,a,u,h,b,U){var O=U.bits,D=0,ge=0,we=0,ke=0,Et=0,kt=0,Zt=0,$t=0,Nn=0,Dn=0,en,mt,hn,Xt,jt,gn=null,sr=0,zt,va=new St.Buf16(Al+1),Jc=new St.Buf16(Al+1),Zc=null,ip=0,op,Xc,Qc;for(D=0;D<=Al;D++)va[D]=0;for(ge=0;ge<a;ge++)va[n[r+ge]]++;for(Et=O,ke=Al;ke>=1&&va[ke]===0;ke--);if(Et>ke&&(Et=ke),ke===0)return u[h++]=1<<24|64<<16|0,u[h++]=1<<24|64<<16|0,U.bits=1,0;for(we=1;we<ke&&va[we]===0;we++);for(Et<we&&(Et=we),$t=1,D=1;D<=Al;D++)if($t<<=1,$t-=va[D],$t<0)return-1;if($t>0&&(t===Ff||ke!==1))return-1;for(Jc[1]=0,D=1;D<Al;D++)Jc[D+1]=Jc[D]+va[D];for(ge=0;ge<a;ge++)n[r+ge]!==0&&(b[Jc[n[r+ge]]++]=ge);if(t===Ff?(gn=Zc=b,zt=19):t===mu?(gn=yv,sr-=257,Zc=wv,ip-=257,zt=256):(gn=Sv,Zc=Av,zt=-1),Dn=0,ge=0,D=we,jt=h,kt=Et,Zt=0,hn=-1,Nn=1<<Et,Xt=Nn-1,t===mu&&Nn>Lf||t===Vf&&Nn>Df)return 1;for(;;){op=D-Zt,b[ge]<zt?(Xc=0,Qc=b[ge]):b[ge]>zt?(Xc=Zc[ip+b[ge]],Qc=gn[sr+b[ge]]):(Xc=32+64,Qc=0),en=1<<D-Zt,mt=1<<kt,we=mt;do mt-=en,u[jt+(Dn>>Zt)+mt]=op<<24|Xc<<16|Qc|0;while(mt!==0);for(en=1<<D-1;Dn&en;)en>>=1;if(en!==0?(Dn&=en-1,Dn+=en):Dn=0,ge++,--va[D]===0){if(D===ke)break;D=n[r+b[ge]]}if(D>Et&&(Dn&Xt)!==hn){for(Zt===0&&(Zt=Et),jt+=we,kt=D-Zt,$t=1<<kt;kt+Zt<ke&&($t-=va[kt+Zt],!($t<=0));)kt++,$t<<=1;if(Nn+=1<<kt,t===mu&&Nn>Lf||t===Vf&&Nn>Df)return 1;hn=Dn&Xt,u[hn]=Et<<24|kt<<16|jt-h|0}}return Dn!==0&&(u[jt+Dn]=D-Zt<<24|64<<16|0),U.bits=Et,0},Ov=Ev,Zl=Cv,Tv=0,$f=1,Uf=2,Hf=4,Pv=5,Ac=6,zs=0,Iv=1,Nv=2,Xo=-2,jf=-3,zf=-4,kv=-5,Wf=8,Gf=1,Yf=2,qf=3,Kf=4,Jf=5,Zf=6,Xf=7,Qf=8,ed=9,td=10,Cc=11,Ja=12,_u=13,nd=14,bu=15,rd=16,id=17,od=18,ad=19,Oc=20,Tc=21,sd=22,ld=23,cd=24,ud=25,fd=26,Eu=27,dd=28,hd=29,dr=30,gd=31,Rv=32,xv=852,Bv=592,Mv=15,Lv=Mv;function pd(e){return(e>>>24&255)+(e>>>8&65280)+((e&65280)<<8)+((e&255)<<24)}function Dv(){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 St.Buf16(320),this.work=new St.Buf16(288),this.lendyn=null,this.distdyn=null,this.sane=0,this.back=0,this.was=0}function vd(e){var t;return!e||!e.state?Xo:(t=e.state,e.total_in=e.total_out=t.total=0,e.msg="",t.wrap&&(e.adler=t.wrap&1),t.mode=Gf,t.last=0,t.havedict=0,t.dmax=32768,t.head=null,t.hold=0,t.bits=0,t.lencode=t.lendyn=new St.Buf32(xv),t.distcode=t.distdyn=new St.Buf32(Bv),t.sane=1,t.back=-1,zs)}function md(e){var t;return!e||!e.state?Xo:(t=e.state,t.wsize=0,t.whave=0,t.wnext=0,vd(e))}function _d(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))?Xo:(r.window!==null&&r.wbits!==t&&(r.window=null),r.wrap=n,r.wbits=t,md(e))}function bd(e,t){var n,r;return e?(r=new Dv,e.state=r,r.window=null,n=_d(e,t),n!==zs&&(e.state=null),n):Xo}function Fv(e){return bd(e,Lv)}var Ed=!0,yu,wu;function Vv(e){if(Ed){var t;for(yu=new St.Buf32(512),wu=new St.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(Zl($f,e.lens,0,288,yu,0,e.work,{bits:9}),t=0;t<32;)e.lens[t++]=5;Zl(Uf,e.lens,0,32,wu,0,e.work,{bits:5}),Ed=!1}e.lencode=yu,e.lenbits=9,e.distcode=wu,e.distbits=5}function yd(e,t,n,r){var a,u=e.state;return u.window===null&&(u.wsize=1<<u.wbits,u.wnext=0,u.whave=0,u.window=new St.Buf8(u.wsize)),r>=u.wsize?(St.arraySet(u.window,t,n-u.wsize,u.wsize,0),u.wnext=0,u.whave=u.wsize):(a=u.wsize-u.wnext,a>r&&(a=r),St.arraySet(u.window,t,n-r,a,u.wnext),r-=a,r?(St.arraySet(u.window,t,n-r,r,0),u.wnext=r,u.whave=u.wsize):(u.wnext+=a,u.wnext===u.wsize&&(u.wnext=0),u.whave<u.wsize&&(u.whave+=a))),0}function $v(e,t){var n,r,a,u,h,b,U,O,D,ge,we,ke,Et,kt,Zt=0,$t,Nn,Dn,en,mt,hn,Xt,jt,gn=new St.Buf8(4),sr,zt,va=[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 Xo;n=e.state,n.mode===Ja&&(n.mode=_u),h=e.next_out,a=e.output,U=e.avail_out,u=e.next_in,r=e.input,b=e.avail_in,O=n.hold,D=n.bits,ge=b,we=U,jt=zs;e:for(;;)switch(n.mode){case Gf:if(n.wrap===0){n.mode=_u;break}for(;D<16;){if(b===0)break e;b--,O+=r[u++]<<D,D+=8}if(n.wrap&2&&O===35615){n.check=0,gn[0]=O&255,gn[1]=O>>>8&255,n.check=se(n.check,gn,2,0),O=0,D=0,n.mode=Yf;break}if(n.flags=0,n.head&&(n.head.done=!1),!(n.wrap&1)||(((O&255)<<8)+(O>>8))%31){e.msg="incorrect header check",n.mode=dr;break}if((O&15)!==Wf){e.msg="unknown compression method",n.mode=dr;break}if(O>>>=4,D-=4,Xt=(O&15)+8,n.wbits===0)n.wbits=Xt;else if(Xt>n.wbits){e.msg="invalid window size",n.mode=dr;break}n.dmax=1<<Xt,e.adler=n.check=1,n.mode=O&512?td:Ja,O=0,D=0;break;case Yf:for(;D<16;){if(b===0)break e;b--,O+=r[u++]<<D,D+=8}if(n.flags=O,(n.flags&255)!==Wf){e.msg="unknown compression method",n.mode=dr;break}if(n.flags&57344){e.msg="unknown header flags set",n.mode=dr;break}n.head&&(n.head.text=O>>8&1),n.flags&512&&(gn[0]=O&255,gn[1]=O>>>8&255,n.check=se(n.check,gn,2,0)),O=0,D=0,n.mode=qf;case qf:for(;D<32;){if(b===0)break e;b--,O+=r[u++]<<D,D+=8}n.head&&(n.head.time=O),n.flags&512&&(gn[0]=O&255,gn[1]=O>>>8&255,gn[2]=O>>>16&255,gn[3]=O>>>24&255,n.check=se(n.check,gn,4,0)),O=0,D=0,n.mode=Kf;case Kf:for(;D<16;){if(b===0)break e;b--,O+=r[u++]<<D,D+=8}n.head&&(n.head.xflags=O&255,n.head.os=O>>8),n.flags&512&&(gn[0]=O&255,gn[1]=O>>>8&255,n.check=se(n.check,gn,2,0)),O=0,D=0,n.mode=Jf;case Jf:if(n.flags&1024){for(;D<16;){if(b===0)break e;b--,O+=r[u++]<<D,D+=8}n.length=O,n.head&&(n.head.extra_len=O),n.flags&512&&(gn[0]=O&255,gn[1]=O>>>8&255,n.check=se(n.check,gn,2,0)),O=0,D=0}else n.head&&(n.head.extra=null);n.mode=Zf;case Zf:if(n.flags&1024&&(ke=n.length,ke>b&&(ke=b),ke&&(n.head&&(Xt=n.head.extra_len-n.length,n.head.extra||(n.head.extra=new Array(n.head.extra_len)),St.arraySet(n.head.extra,r,u,ke,Xt)),n.flags&512&&(n.check=se(n.check,r,ke,u)),b-=ke,u+=ke,n.length-=ke),n.length))break e;n.length=0,n.mode=Xf;case Xf:if(n.flags&2048){if(b===0)break e;ke=0;do Xt=r[u+ke++],n.head&&Xt&&n.length<65536&&(n.head.name+=String.fromCharCode(Xt));while(Xt&&ke<b);if(n.flags&512&&(n.check=se(n.check,r,ke,u)),b-=ke,u+=ke,Xt)break e}else n.head&&(n.head.name=null);n.length=0,n.mode=Qf;case Qf:if(n.flags&4096){if(b===0)break e;ke=0;do Xt=r[u+ke++],n.head&&Xt&&n.length<65536&&(n.head.comment+=String.fromCharCode(Xt));while(Xt&&ke<b);if(n.flags&512&&(n.check=se(n.check,r,ke,u)),b-=ke,u+=ke,Xt)break e}else n.head&&(n.head.comment=null);n.mode=ed;case ed:if(n.flags&512){for(;D<16;){if(b===0)break e;b--,O+=r[u++]<<D,D+=8}if(O!==(n.check&65535)){e.msg="header crc mismatch",n.mode=dr;break}O=0,D=0}n.head&&(n.head.hcrc=n.flags>>9&1,n.head.done=!0),e.adler=n.check=0,n.mode=Ja;break;case td:for(;D<32;){if(b===0)break e;b--,O+=r[u++]<<D,D+=8}e.adler=n.check=pd(O),O=0,D=0,n.mode=Cc;case Cc:if(n.havedict===0)return e.next_out=h,e.avail_out=U,e.next_in=u,e.avail_in=b,n.hold=O,n.bits=D,Nv;e.adler=n.check=1,n.mode=Ja;case Ja:if(t===Pv||t===Ac)break e;case _u:if(n.last){O>>>=D&7,D-=D&7,n.mode=Eu;break}for(;D<3;){if(b===0)break e;b--,O+=r[u++]<<D,D+=8}switch(n.last=O&1,O>>>=1,D-=1,O&3){case 0:n.mode=nd;break;case 1:if(Vv(n),n.mode=Oc,t===Ac){O>>>=2,D-=2;break e}break;case 2:n.mode=id;break;case 3:e.msg="invalid block type",n.mode=dr}O>>>=2,D-=2;break;case nd:for(O>>>=D&7,D-=D&7;D<32;){if(b===0)break e;b--,O+=r[u++]<<D,D+=8}if((O&65535)!==(O>>>16^65535)){e.msg="invalid stored block lengths",n.mode=dr;break}if(n.length=O&65535,O=0,D=0,n.mode=bu,t===Ac)break e;case bu:n.mode=rd;case rd:if(ke=n.length,ke){if(ke>b&&(ke=b),ke>U&&(ke=U),ke===0)break e;St.arraySet(a,r,u,ke,h),b-=ke,u+=ke,U-=ke,h+=ke,n.length-=ke;break}n.mode=Ja;break;case id:for(;D<14;){if(b===0)break e;b--,O+=r[u++]<<D,D+=8}if(n.nlen=(O&31)+257,O>>>=5,D-=5,n.ndist=(O&31)+1,O>>>=5,D-=5,n.ncode=(O&15)+4,O>>>=4,D-=4,n.nlen>286||n.ndist>30){e.msg="too many length or distance symbols",n.mode=dr;break}n.have=0,n.mode=od;case od:for(;n.have<n.ncode;){for(;D<3;){if(b===0)break e;b--,O+=r[u++]<<D,D+=8}n.lens[va[n.have++]]=O&7,O>>>=3,D-=3}for(;n.have<19;)n.lens[va[n.have++]]=0;if(n.lencode=n.lendyn,n.lenbits=7,sr={bits:n.lenbits},jt=Zl(Tv,n.lens,0,19,n.lencode,0,n.work,sr),n.lenbits=sr.bits,jt){e.msg="invalid code lengths set",n.mode=dr;break}n.have=0,n.mode=ad;case ad:for(;n.have<n.nlen+n.ndist;){for(;Zt=n.lencode[O&(1<<n.lenbits)-1],$t=Zt>>>24,Nn=Zt>>>16&255,Dn=Zt&65535,!($t<=D);){if(b===0)break e;b--,O+=r[u++]<<D,D+=8}if(Dn<16)O>>>=$t,D-=$t,n.lens[n.have++]=Dn;else{if(Dn===16){for(zt=$t+2;D<zt;){if(b===0)break e;b--,O+=r[u++]<<D,D+=8}if(O>>>=$t,D-=$t,n.have===0){e.msg="invalid bit length repeat",n.mode=dr;break}Xt=n.lens[n.have-1],ke=3+(O&3),O>>>=2,D-=2}else if(Dn===17){for(zt=$t+3;D<zt;){if(b===0)break e;b--,O+=r[u++]<<D,D+=8}O>>>=$t,D-=$t,Xt=0,ke=3+(O&7),O>>>=3,D-=3}else{for(zt=$t+7;D<zt;){if(b===0)break e;b--,O+=r[u++]<<D,D+=8}O>>>=$t,D-=$t,Xt=0,ke=11+(O&127),O>>>=7,D-=7}if(n.have+ke>n.nlen+n.ndist){e.msg="invalid bit length repeat",n.mode=dr;break}for(;ke--;)n.lens[n.have++]=Xt}}if(n.mode===dr)break;if(n.lens[256]===0){e.msg="invalid code -- missing end-of-block",n.mode=dr;break}if(n.lenbits=9,sr={bits:n.lenbits},jt=Zl($f,n.lens,0,n.nlen,n.lencode,0,n.work,sr),n.lenbits=sr.bits,jt){e.msg="invalid literal/lengths set",n.mode=dr;break}if(n.distbits=6,n.distcode=n.distdyn,sr={bits:n.distbits},jt=Zl(Uf,n.lens,n.nlen,n.ndist,n.distcode,0,n.work,sr),n.distbits=sr.bits,jt){e.msg="invalid distances set",n.mode=dr;break}if(n.mode=Oc,t===Ac)break e;case Oc:n.mode=Tc;case Tc:if(b>=6&&U>=258){e.next_out=h,e.avail_out=U,e.next_in=u,e.avail_in=b,n.hold=O,n.bits=D,Ov(e,we),h=e.next_out,a=e.output,U=e.avail_out,u=e.next_in,r=e.input,b=e.avail_in,O=n.hold,D=n.bits,n.mode===Ja&&(n.back=-1);break}for(n.back=0;Zt=n.lencode[O&(1<<n.lenbits)-1],$t=Zt>>>24,Nn=Zt>>>16&255,Dn=Zt&65535,!($t<=D);){if(b===0)break e;b--,O+=r[u++]<<D,D+=8}if(Nn&&(Nn&240)===0){for(en=$t,mt=Nn,hn=Dn;Zt=n.lencode[hn+((O&(1<<en+mt)-1)>>en)],$t=Zt>>>24,Nn=Zt>>>16&255,Dn=Zt&65535,!(en+$t<=D);){if(b===0)break e;b--,O+=r[u++]<<D,D+=8}O>>>=en,D-=en,n.back+=en}if(O>>>=$t,D-=$t,n.back+=$t,n.length=Dn,Nn===0){n.mode=fd;break}if(Nn&32){n.back=-1,n.mode=Ja;break}if(Nn&64){e.msg="invalid literal/length code",n.mode=dr;break}n.extra=Nn&15,n.mode=sd;case sd:if(n.extra){for(zt=n.extra;D<zt;){if(b===0)break e;b--,O+=r[u++]<<D,D+=8}n.length+=O&(1<<n.extra)-1,O>>>=n.extra,D-=n.extra,n.back+=n.extra}n.was=n.length,n.mode=ld;case ld:for(;Zt=n.distcode[O&(1<<n.distbits)-1],$t=Zt>>>24,Nn=Zt>>>16&255,Dn=Zt&65535,!($t<=D);){if(b===0)break e;b--,O+=r[u++]<<D,D+=8}if((Nn&240)===0){for(en=$t,mt=Nn,hn=Dn;Zt=n.distcode[hn+((O&(1<<en+mt)-1)>>en)],$t=Zt>>>24,Nn=Zt>>>16&255,Dn=Zt&65535,!(en+$t<=D);){if(b===0)break e;b--,O+=r[u++]<<D,D+=8}O>>>=en,D-=en,n.back+=en}if(O>>>=$t,D-=$t,n.back+=$t,Nn&64){e.msg="invalid distance code",n.mode=dr;break}n.offset=Dn,n.extra=Nn&15,n.mode=cd;case cd:if(n.extra){for(zt=n.extra;D<zt;){if(b===0)break e;b--,O+=r[u++]<<D,D+=8}n.offset+=O&(1<<n.extra)-1,O>>>=n.extra,D-=n.extra,n.back+=n.extra}if(n.offset>n.dmax){e.msg="invalid distance too far back",n.mode=dr;break}n.mode=ud;case ud:if(U===0)break e;if(ke=we-U,n.offset>ke){if(ke=n.offset-ke,ke>n.whave&&n.sane){e.msg="invalid distance too far back",n.mode=dr;break}ke>n.wnext?(ke-=n.wnext,Et=n.wsize-ke):Et=n.wnext-ke,ke>n.length&&(ke=n.length),kt=n.window}else kt=a,Et=h-n.offset,ke=n.length;ke>U&&(ke=U),U-=ke,n.length-=ke;do a[h++]=kt[Et++];while(--ke);n.length===0&&(n.mode=Tc);break;case fd:if(U===0)break e;a[h++]=n.length,U--,n.mode=Tc;break;case Eu:if(n.wrap){for(;D<32;){if(b===0)break e;b--,O|=r[u++]<<D,D+=8}if(we-=U,e.total_out+=we,n.total+=we,we&&(e.adler=n.check=n.flags?se(n.check,a,we,h-we):Xe(n.check,a,we,h-we)),we=U,(n.flags?O:pd(O))!==n.check){e.msg="incorrect data check",n.mode=dr;break}O=0,D=0}n.mode=dd;case dd:if(n.wrap&&n.flags){for(;D<32;){if(b===0)break e;b--,O+=r[u++]<<D,D+=8}if(O!==(n.total&4294967295)){e.msg="incorrect length check",n.mode=dr;break}O=0,D=0}n.mode=hd;case hd:jt=Iv;break e;case dr:jt=jf;break e;case gd:return zf;case Rv:default:return Xo}return e.next_out=h,e.avail_out=U,e.next_in=u,e.avail_in=b,n.hold=O,n.bits=D,(n.wsize||we!==e.avail_out&&n.mode<dr&&(n.mode<Eu||t!==Hf))&&yd(e,e.output,e.next_out,we-e.avail_out),ge-=e.avail_in,we-=e.avail_out,e.total_in+=ge,e.total_out+=we,n.total+=we,n.wrap&&we&&(e.adler=n.check=n.flags?se(n.check,a,we,e.next_out-we):Xe(n.check,a,we,e.next_out-we)),e.data_type=n.bits+(n.last?64:0)+(n.mode===Ja?128:0)+(n.mode===Oc||n.mode===bu?256:0),(ge===0&&we===0||t===Hf)&&jt===zs&&(jt=kv),jt}function Uv(e){if(!e||!e.state)return Xo;var t=e.state;return t.window&&(t.window=null),e.state=null,zs}function Hv(e,t){var n;return!e||!e.state||(n=e.state,(n.wrap&2)===0)?Xo:(n.head=t,t.done=!1,zs)}function jv(e,t){var n=t.length,r,a,u;return!e||!e.state||(r=e.state,r.wrap!==0&&r.mode!==Cc)?Xo:r.mode===Cc&&(a=1,a=Xe(a,t,n,0),a!==r.check)?jf:(u=yd(e,t,n,n),u?(r.mode=gd,zf):(r.havedict=1,zs))}var zv=md,Wv=_d,Gv=vd,Yv=Fv,qv=bd,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,Cl=em,Ir=tm,im=rm,wd=Object.prototype.toString;function Ws(e){if(!(this instanceof Ws))return new Ws(e);this.options=St.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 Rf,this.strm.avail_out=0;var n=Cl.inflateInit2(this.strm,t.windowBits);if(n!==Ir.Z_OK)throw new Error($e[n]);if(this.header=new im,Cl.inflateGetHeader(this.strm,this.header),t.dictionary&&(typeof t.dictionary=="string"?t.dictionary=Hs.string2buf(t.dictionary):wd.call(t.dictionary)==="[object ArrayBuffer]"&&(t.dictionary=new Uint8Array(t.dictionary)),t.raw&&(n=Cl.inflateSetDictionary(this.strm,t.dictionary),n!==Ir.Z_OK)))throw new Error($e[n])}Ws.prototype.push=function(e,t){var n=this.strm,r=this.options.chunkSize,a=this.options.dictionary,u,h,b,U,O,D=!1;if(this.ended)return!1;h=t===~~t?t:t===!0?Ir.Z_FINISH:Ir.Z_NO_FLUSH,typeof e=="string"?n.input=Hs.binstring2buf(e):wd.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 St.Buf8(r),n.next_out=0,n.avail_out=r),u=Cl.inflate(n,Ir.Z_NO_FLUSH),u===Ir.Z_NEED_DICT&&a&&(u=Cl.inflateSetDictionary(this.strm,a)),u===Ir.Z_BUF_ERROR&&D===!0&&(u=Ir.Z_OK,D=!1),u!==Ir.Z_STREAM_END&&u!==Ir.Z_OK)return this.onEnd(u),this.ended=!0,!1;n.next_out&&(n.avail_out===0||u===Ir.Z_STREAM_END||n.avail_in===0&&(h===Ir.Z_FINISH||h===Ir.Z_SYNC_FLUSH))&&(this.options.to==="string"?(b=Hs.utf8border(n.output,n.next_out),U=n.next_out-b,O=Hs.buf2string(n.output,b),n.next_out=U,n.avail_out=r-U,U&&St.arraySet(n.output,n.output,b,U,0),this.onData(O)):this.onData(St.shrinkBuf(n.output,n.next_out))),n.avail_in===0&&n.avail_out===0&&(D=!0)}while((n.avail_in>0||n.avail_out===0)&&u!==Ir.Z_STREAM_END);return u===Ir.Z_STREAM_END&&(h=Ir.Z_FINISH),h===Ir.Z_FINISH?(u=Cl.inflateEnd(this.strm),this.onEnd(u),this.ended=!0,u===Ir.Z_OK):(h===Ir.Z_SYNC_FLUSH&&(this.onEnd(Ir.Z_OK),n.avail_out=0),!0)},Ws.prototype.onData=function(e){this.chunks.push(e)},Ws.prototype.onEnd=function(e){e===Ir.Z_OK&&(this.options.to==="string"?this.result=this.chunks.join(""):this.result=St.flattenChunks(this.chunks)),this.chunks=[],this.err=e,this.msg=this.strm.msg};function Su(e,t){var n=new Ws(t);if(n.push(e,!0),n.err)throw n.msg||$e[n.err];return n.result}function om(e,t){return t=t||{},t.raw=!0,Su(e,t)}var am=Ws,sm=Su,lm=om,cm=Su,um={Inflate:am,inflate:sm,inflateRaw:lm,ungzip:cm},fm=_v,dm=um,hm=St.assign,Sd={};hm(Sd,fm,dm,Ir);var Ad=Sd;let gm="upx2px",pm=[{name:"upx",type:[Number,String],required:!0}],vm=1e-4,mm=750,Cd=!1,Au=0,Od=0,Td=960,Pd=375;function _m(){let{platform:e,pixelRatio:t,windowWidth:n}=No();Au=n,Od=t,Cd=e==="ios"}function Id(e,t){let n=Number(e);return isNaN(n)?t:n}function bm(){let e=T.globalStyle||{};Td=Id(e.rpxCalcMaxDeviceWidth,960),Pd=Id(e.rpxCalcBaseDeviceWidth,375)}let Em=Mt(gm,(e,t)=>{if(Au===0&&(_m(),bm()),e=Number(e),e===0)return 0;let n=t||Au;n=n<=Td?n:Pd;let r=e/mm*n;return r<0&&(r=-r),r=Math.floor(r+vm),r===0&&(Od===1||!Cd?r=1:r=.5),e<0?-r:r},pm),ym="addInterceptor",wm="removeInterceptor",Nd=[{name:"method",type:[String,Object],required:!0}],Sm=Nd;function kd(e,t){Object.keys(t).forEach(n=>{Y.isFunction(t[n])&&(e[n]=Am(e[n],t[n]))})}function Rd(e,t){!e||!t||Object.keys(t).forEach(n=>{let r=e[n],a=t[n];Y.isArray(r)&&Y.isFunction(a)&&Y.remove(r,a)})}function Am(e,t){let n=t?e?e.concat(t):Y.isArray(t)?t:[t]:e;return n&&Cm(n)}function Cm(e){let t=[];for(let n=0;n<e.length;n++)t.indexOf(e[n])===-1&&t.push(e[n]);return t}let Om=Mt(ym,(e,t)=>{Y.isString(e)&&Y.isPlainObject(t)?kd(Sr[e]||(Sr[e]={}),t):Y.isPlainObject(e)&&kd(jr,e)},Nd),Tm=Mt(wm,(e,t)=>{Y.isString(e)?Y.isPlainObject(t)?Rd(Sr[e],t):delete Sr[e]:Y.isPlainObject(e)&&Rd(jr,e)},Sm),Pm={},Im="$on",xd=[{name:"event",type:String,required:!0},{name:"callback",type:Function,required:!0}],Nm="$once",km=xd,Rm="$off",xm=[{name:"event",type:[String,Array]},{name:"callback",type:Function}],Bm="$emit",Mm=[{name:"event",type:String,required:!0}],Gs=new te.Emitter,Lm=Mt(Im,(e,t)=>(Gs.on(e,t),()=>Gs.off(e,t)),xd),Dm=Mt(Nm,(e,t)=>(Gs.once(e,t),()=>Gs.off(e,t)),km),Fm=Mt(Rm,(e,t)=>{if(!e){Gs.e={};return}Y.isArray(e)||(e=[e]),e.forEach(n=>Gs.off(n,t))},xm),Vm=Mt(Bm,(e,...t)=>{Gs.emit(e,...t)},Mm),Bd=[{name:"id",type:String,required:!0}],$m="createVideoContext",Um="createMapContext",Hm=Bd,jm="createCanvasContext",zm=[{name:"canvasId",type:String,required:!0},{name:"componentInstance",type:Object}],Wm="createInnerAudioContext",Gm="createLivePusherContext",Ym=Bd.concat({name:"componentInstance",type:Object}),qm=[.5,.8,1,1.25,1.5,2];class Cu{constructor(t,n){this.id=t,this.pageId=n}play(){Yt(this.id,this.pageId,"play")}pause(){Yt(this.id,this.pageId,"pause")}stop(){Yt(this.id,this.pageId,"stop")}seek(t){Yt(this.id,this.pageId,"seek",{position:t})}sendDanmu(t){Yt(this.id,this.pageId,"sendDanmu",t)}playbackRate(t){~qm.indexOf(t)||(t=1),Yt(this.id,this.pageId,"playbackRate",{rate:t})}requestFullScreen(t={}){Yt(this.id,this.pageId,"requestFullScreen",t)}exitFullScreen(){Yt(this.id,this.pageId,"exitFullScreen")}showStatusBar(){Yt(this.id,this.pageId,"showStatusBar")}hideStatusBar(){Yt(this.id,this.pageId,"hideStatusBar")}}let Km=Mt($m,(e,t)=>t?new Cu(e,fr(t)):new Cu(e,fr(Lr()))),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)},xi=(e,t,n,r)=>{Aa(e,t,n,r,a=>{r&&Jm(r,a)})};class Ou{constructor(t,n){this.id=t,this.pageId=n}getCenterLocation(t){xi(this.id,this.pageId,"getCenterLocation",t)}moveToLocation(t){xi(this.id,this.pageId,"moveToLocation",t)}getScale(t){xi(this.id,this.pageId,"getScale",t)}getRegion(t){xi(this.id,this.pageId,"getRegion",t)}includePoints(t){xi(this.id,this.pageId,"includePoints",t)}translateMarker(t){xi(this.id,this.pageId,"translateMarker",t)}$getAppMap(){return l.maps.getMapById(this.pageId+"-map-"+this.id)}addCustomLayer(t){xi(this.id,this.pageId,"addCustomLayer",t)}removeCustomLayer(t){xi(this.id,this.pageId,"removeCustomLayer",t)}addGroundOverlay(t){xi(this.id,this.pageId,"addGroundOverlay",t)}removeGroundOverlay(t){xi(this.id,this.pageId,"removeGroundOverlay",t)}updateGroundOverlay(t){xi(this.id,this.pageId,"updateGroundOverlay",t)}initMarkerCluster(t){xi(this.id,this.pageId,"initMarkerCluster",t)}addMarkers(t){xi(this.id,this.pageId,"addMarkers",t)}removeMarkers(t){xi(this.id,this.pageId,"removeMarkers",t)}moveAlong(t){xi(this.id,this.pageId,"moveAlong",t)}openMapApp(t){xi(this.id,this.pageId,"openMapApp",t)}on(t){xi(this.id,this.pageId,"on",t)}}let Zm=Mt(Um,(e,t)=>t?new Ou(e,fr(t)):new Ou(e,fr(Lr())),Hm);function ms(e,t){return function(n,r){n?r[e]=Math.round(n):typeof t!="undefined"&&(r[e]=t)}}let Md=ms("width"),Ld=ms("height"),Xm="canvasGetImageData",Dd={formatArgs:{x:ms("x"),y:ms("y"),width:Md,height:Ld}},Fd={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_=Dd,t_=Y.extend({data:{type:Uint8ClampedArray,required:!0}},Fd,{height:{type:Number}}),Vd={PNG:"png",JPG:"jpg",JPEG:"jpg"},n_="canvasToTempFilePath",r_={formatArgs:{x:ms("x",0),y:ms("y",0),width:Md,height:Ld,destWidth:ms("destWidth"),destHeight:ms("destHeight"),fileType(e,t){e=(e||"").toUpperCase();let n=Vd[e];n||(n=Vd.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 Pc(e,t,n,r,a){st.invokeViewMethod(`canvas.${e}`,{type:n,data:r},t,u=>{a&&a(u)})}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 $d={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 Tu(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),a=parseInt(t[1].slice(2,4),16),u=parseInt(t[1].slice(4),16);return[r,a,u,255]}if((t=/^#([0-9|A-F|a-f]{3})$/.exec(e))!=null){let r=t[1].slice(0,1),a=t[1].slice(1,2),u=t[1].slice(2,3);return r=parseInt(r+r,16),a=parseInt(a+a,16),u=parseInt(u+u,16),[r,a,u,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,a){return a===3?Math.floor(255*parseFloat(r.trim())):Math.min(255,parseInt(r.trim()))});var n=e.toLowerCase();if(Y.hasOwn($d,n)){t=/^#([0-9|A-F|a-f]{6,8})$/.exec($d[n]);let r=parseInt(t[1].slice(0,2),16),a=parseInt(t[1].slice(2,4),16),u=parseInt(t[1].slice(4,6),16),h=parseInt(t[1].slice(6,8),16);return h=h>=0?h:255,[r,a,u,h]}return console.error("unsupported color:"+e),[0,0,0,255]}class Ud{constructor(t,n){this.type=t,this.data=n,this.colorStop=[]}addColorStop(t,n){this.colorStop.push([t,Tu(n)])}}class c_{constructor(t,n){this.type="pattern",this.data=t,this.colorStop=n}}class u_{constructor(t){this.width=t}}class Xl{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=[],Pc(this.id,this.pageId,"actionsChanged",{actions:r,reserve:t},n)}createLinearGradient(t,n,r,a){return new Ud("linear",[t,n,r,a])}createCircularGradient(t,n,r){return new Ud("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 a=l.webview.all().find(u=>u.getURL().endsWith("www/__uniappview.html"));a&&(r=Number(a.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,a){this.path.push({method:"quadraticCurveTo",data:[t,n,r,a]}),this.subpath.push([r,a])}bezierCurveTo(t,n,r,a,u,h){this.path.push({method:"bezierCurveTo",data:[t,n,r,a,u,h]}),this.subpath.push([u,h])}arc(t,n,r,a,u,h=!1){this.path.push({method:"arc",data:[t,n,r,a,u,h]}),this.subpath.push([t,n])}rect(t,n,r,a){this.path.push({method:"rect",data:[t,n,r,a]}),this.subpath=[[t,n]]}arcTo(t,n,r,a,u){this.path.push({method:"arcTo",data:[t,n,r,a,u]}),this.subpath.push([r,a])}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 a=r[1].trim().split(/\s/),u=parseFloat(r[3]),h=r[7],b=[];a.forEach(function(O,D){["italic","oblique","normal"].indexOf(O)>-1?(b.push({method:"setFontStyle",data:[O]}),n.state.fontStyle=O):["bold","normal"].indexOf(O)>-1?(b.push({method:"setFontWeight",data:[O]}),n.state.fontWeight=O):D===0?(b.push({method:"setFontStyle",data:["normal"]}),n.state.fontStyle="normal"):D===1&&U()}),a.length===1&&U(),a=b.map(function(O){return O.data[0]}).join(" "),this.state.fontSize=u,this.state.fontFamily=h,this.actions.push({method:"setFont",data:[`${a} ${u}px ${h}`]})}else console.warn("Failed to set 'font' on 'CanvasContext': invalid format.");function U(){b.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_=te.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,a,u,h){this.actions.push({method:"fillPath",data:[{method:"rect",data:[r,a,u,h]}]})};case"strokeRect":return function(r,a,u,h){this.actions.push({method:"strokePath",data:[{method:"rect",data:[r,a,u,h]}]})};case"fillText":case"strokeText":return function(r,a,u,h){var b=[r.toString(),a,u];typeof h=="number"&&b.push(h),this.actions.push({method:n,data:b})};case"drawImage":return function(r,a,u,h,b,U,O,D,ge){ge===void 0&&(U=a,O=u,D=h,ge=b,a=void 0,u=void 0,h=void 0,b=void 0);var we;function ke(Et){return typeof Et=="number"}we=ke(a)&&ke(u)&&ke(h)&&ke(b)?[r,U,O,D,ge,a,u,h,b]:ke(D)&&ke(ge)?[r,U,O,D,ge]:[r,U,O],this.actions.push({method:n,data:we})};default:return function(...r){this.actions.push({method:n,data:r})}}}Xl.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",Tu(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,a,u,h){h=Tu(h),this.actions.push({method:n,data:[r,a,u,h]}),this.state.shadowBlur=u,this.state.shadowColor=h,this.state.shadowOffsetX=r,this.state.shadowOffsetY=a};case"setLineDash":return function(r,a){r=r||[0,0],a=a||0,this.actions.push({method:n,data:[r,a]}),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})}}}Xl.prototype[e]=t(e)})}),d_=Mt(jm,(e,t)=>{if(f_(),t)return new Xl(e,fr(t));let n=fr(Lr());if(n)return new Xl(e,n);st.emit(te.ON_ERROR,"createCanvasContext:fail")},zm),h_=ye(Xm,({canvasId:e,x:t,y:n,width:r,height:a},{resolve:u,reject:h})=>{let b=fr(Lr());if(!b){h();return}function U(O){if(O.errMsg&&O.errMsg.indexOf("fail")!==-1){h("",O);return}let D=O.data;D&&D.length&&(O.compressed&&(D=Ad.inflateRaw(D)),O.data=new Uint8ClampedArray(D)),delete O.compressed,u(O)}Pc(e,b,"getImageData",{x:t,y:n,width:r,height:a},U)},Fd,Dd),g_=ye(Qm,({canvasId:e,data:t,x:n,y:r,width:a,height:u},{resolve:h,reject:b})=>{var U=fr(Lr());if(!U){b();return}let O,D=()=>{Pc(e,U,"putImageData",{data:t,x:n,y:r,width:a,height:u,compressed:O},ge=>{if(ge.errMsg&&ge.errMsg.indexOf("fail")!==-1){b();return}h(ge)})};l.os.name!=="iOS"||typeof __WEEX_DEVTOOL__=="boolean"?(t=Ad.deflateRaw(t,{to:"string"}),O=!0):t=Array.prototype.slice.call(t),D()},t_,e_),p_=ye(n_,({x:e=0,y:t=0,width:n,height:r,destWidth:a,destHeight:u,canvasId:h,fileType:b,quality:U},{resolve:O,reject:D})=>{var ge=fr(Lr());if(!ge){D();return}let we=`${ai}/canvas`;Pc(h,ge,"toTempFilePath",{x:e,y:t,width:n,height:r,destWidth:a,destHeight:u,fileType:b,quality:U,dirname:we},ke=>{if(ke.errMsg&&ke.errMsg.indexOf("fail")!==-1){D("",ke);return}O(ke)})},i_,r_),Hd=["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 jd(e={}){return __.map(t=>`${Number(e[t])||0}px`).join(" ")}class zd{constructor(t,n){this._pageId=fr(t),this._component=t,this._options=Y.extend({},m_,n)}relativeTo(t,n){return this._options.relativeToSelector=t,this._options.rootMargin=jd(n),this}relativeToViewport(t){return this._options.relativeToSelector=void 0,this._options.rootMargin=jd(t),this}observe(t,n){!Y.isFunction(n)||(this._options.selector=t,this._reqId=b_++,Dr({reqId:this._reqId,component:this._component,options:this._options,callback:n},this._pageId))}disconnect(){this._reqId&&Ts({reqId:this._reqId,component:this._component},this._pageId)}}let E_=Mt("createIntersectionObserver",(e,t)=>(e=te.resolveComponentInstance(e),e&&!fr(e)&&(t=e,e=null),e?new zd(e,t):new zd(Lr(),t))),y_=1;class Wd{constructor(t){this._pageId=t.$page&&t.$page.id,this._component=t}observe(t,n){!Y.isFunction(n)||(this._reqId=y_++,Gn({reqId:this._reqId,component:this._component,options:t,callback:n},this._pageId))}disconnect(){this._reqId&&An({reqId:this._reqId,component:this._component},this._pageId)}}let w_=Mt("createMediaQueryObserver",e=>(e=te.resolveComponentInstance(e),e&&!fr(e)&&(e=null),e?new Wd(e):new Wd(Lr()))),S_=0,Pu={};function A_(e,t,n,r){let a={options:r},u=r&&("success"in r||"fail"in r||"complete"in r);if(u){let h=String(S_++);a.callbackId=h,Pu[h]=r}st.invokeViewMethod(`editor.${e}`,{type:n,data:a},t,({callbackId:h,data:b})=>{u&&(te.callOptions(Pu[h],b),delete Pu[h])})}class C_{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){A_(this.id,this.pageId,t,n)}}let O_={canvas:Xl,map:Ou,video:Cu,editor:C_};function Gd(e){if(e&&e.contextInfo){let{id:t,type:n,page:r}=e.contextInfo,a=O_[n];e.context=new a(t,r),delete e.contextInfo}}class Iu{constructor(t,n,r,a){this._selectorQuery=t,this._component=n,this._selector=r,this._single=a}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 Oi(this._page,this._queue,n=>{let r=this._queueCb;n.forEach((a,u)=>{Y.isArray(a)?a.forEach(Gd):Gd(a);let h=r[u];Y.isFunction(h)&&h.call(this,a)}),Y.isFunction(t)&&t.call(this,n)}),this._nodesRef}in(t){return this._component=te.resolveComponentInstance(t),this}select(t){return this._nodesRef=new Iu(this,this._component,t,!0)}selectAll(t){return this._nodesRef=new Iu(this,this._component,t,!1)}selectViewport(){return this._nodesRef=new Iu(this,null,"",!0)}_push(t,n,r,a,u){this._queue.push({component:n,selector:t,single:r,fields:a}),this._queueCb.push(u)}}let P_=Mt("createSelectorQuery",e=>(e=te.resolveComponentInstance(e),e&&!fr(e)&&(e=null),new T_(e||Lr()))),I_="createAnimation",N_={formatArgs:{}},k_={duration:Number,timingFunction:String,delay:Number,transformOrigin:String},R_={duration:400,timingFunction:"linear",delay:0,transformOrigin:"50% 50% 0"};class Yd{constructor(t){this.actions=[],this.currentTransform={},this.currentStepAnimates=[],this.option=Y.extend({},R_,t)}_getOption(t){let n={transition:Y.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_=te.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=>{Yd.prototype[r]=function(...a){return t.concat(n).includes(r)?this._pushAnimates("style",[this._converType(r),n.includes(r)?this._getValue(a[0]):a[0]]):this._pushAnimates(r,a),this}})}),B_=Mt(I_,e=>(x_(),new Yd(e)),k_,N_),qd="onTabBarMidButtonTap",M_=qn(qd,()=>{}),L_="onWindowResize",D_="offWindowResize",F_=qn(L_,()=>{}),V_=Cr(D_,()=>{}),Kd="setLocale",$_="getLocale",Jd="onLocaleChange",Ql=Mt($_,()=>{let e=vn({allowDefault:!0});return e&&e.$vm?e.$vm.$locale:X().getLocale()}),U_=qn(Jd,()=>{}),H_=Mt(Kd,e=>{let t=vn();return t&&t.$vm.$locale!==e?(t.$vm.$locale=e,Vn().forEach(a=>{st.publishHandler(Kd,e,a.$page.id)}),g.requireModule("plus").setLanguage(e),st.invokeOnCallback(Jd,{locale:e}),!0):!1}),j_=ye("setPageMeta",(e,{resolve:t})=>{t(Or(Lr(),e))}),Zd="getSelectedTextRange",z_=ye(Zd,(e,{resolve:t,reject:n})=>{st.invokeViewMethod(Zd,{},Ba(),r=>{typeof r.end=="undefined"&&typeof r.start=="undefined"?n("no focused"):t(r)})}),Ic={[te.ON_UNHANDLE_REJECTION]:[],[te.ON_PAGE_NOT_FOUND]:[],[te.ON_ERROR]:[],[te.ON_SHOW]:[],[te.ON_HIDE]:[]};function ec(e,t){let n=vn({allowDefault:!0});if(n&&n.$vm)return En.injectHook(e,t,n.$vm.$);Ic[e].push(t)}function W_(e){Object.keys(Ic).forEach(t=>{Ic[t].forEach(n=>{En.injectHook(t,n,e)})})}function tc(e,t){let n=vn({allowDefault:!0});if(n&&n.$vm)return ns(n.$vm,e,t);Y.remove(Ic[e],t)}function G_(e){ec(te.ON_UNHANDLE_REJECTION,e)}function Y_(e){tc(te.ON_UNHANDLE_REJECTION,e)}function q_(e){ec(te.ON_PAGE_NOT_FOUND,e)}function K_(e){tc(te.ON_PAGE_NOT_FOUND,e)}function J_(e){ec(te.ON_ERROR,e)}function Z_(e){tc(te.ON_ERROR,e)}function X_(e){ec(te.ON_SHOW,e)}function Q_(e){tc(te.ON_SHOW,e)}function eb(e){ec(te.ON_HIDE,e)}function tb(e){tc(te.ON_HIDE,e)}let nb=Mt("getEnterOptionsSync",()=>is()),rb=Mt("getLaunchOptionsSync",()=>Da()),nc,Nu,ku,Xd;function Qd(e){try{return JSON.parse(e)}catch(t){}return e}function Ru(e){if(e.type==="enabled")ku=!0,Xd=e.offline;else if(e.type==="clientId")nc=e.cid,Nu=e.errMsg,eh(nc,e.errMsg);else if(e.type==="pushMsg"){let t={type:"receive",data:Qd(e.message)};for(let n=0;n<_s.length&&(_s[n](t),!t.stopped);n++);}else e.type==="click"&&_s.forEach(t=>{t({type:"click",data:Qd(e.message)})})}let xu=[];function eh(e,t){xu.forEach(n=>{n(e,t)}),xu.length=0}let ib=ye("getPushClientId",(e,{resolve:t,reject:n})=>{if(Xd){l.push.getClientInfoAsync(r=>{t({cid:r.clientid})},r=>{n(r.code+": "+r.message)});return}Promise.resolve().then(()=>{typeof ku=="undefined"&&(ku=!1,nc="",Nu="uniPush is not enabled"),xu.push((r,a)=>{r?t({cid:r}):n(a)}),typeof nc!="undefined"&&eh(nc,Nu)})}),_s=[],th=!1,ob=e=>{_s.indexOf(e)===-1&&_s.push(e),th||(th=!0,l.push.addEventListener("click",t=>{Ru({type:"click",message:t})}),l.push.addEventListener("receive",t=>{Ru({type:"pushMsg",message:t})}))},ab=e=>{if(!e)_s.length=0;else{let t=_s.indexOf(e);t>-1&&_s.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;"}}},gb={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},pb="getClipboardData",vb="setClipboardData",mb={formatArgs:{showToast:!0},beforeInvoke(){zo()},beforeSuccess(e,t){if(!t.showToast)return;let{t:n}=X(),r=n("uni.setClipboardData.success");r&&gt.showToast({title:r,icon:"success",mask:!1})}},_b={data:{type:String,required:!0},showToast:{type:Boolean}},nh="onAccelerometer",bb="offAccelerometer",Eb="startAccelerometer",yb="stopAccelerometer",rh="onCompass",wb="offCompass",Sb="startCompass",Ab="stopCompass",Cb="vibrateShort",Ob="vibrateLong",ih="onBluetoothDeviceFound",oh="onBluetoothAdapterStateChange",ah="onBLEConnectionStateChange",sh="onBLECharacteristicValueChange",Tb="startBluetoothDevicesDiscovery",Pb={services:Array,allowDuplicatesKey:Boolean,interval:Number},Ib="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",Lb={deviceId:{type:String,required:!0}},Db="getBLEDeviceCharacteristics",Fb={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}},lh="onBeaconUpdate",ch="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)}}},g0="getSystemSetting",p0="getAppAuthorizeSetting",v0="openAppAuthorizeSetting",m0="getStorage",uh={key:{type:String,required:!0}},_0="getStorageSync",fh=[{name:"key",type:String,required:!0}],b0="setStorage",E0={key:{type:String,required:!0},data:{required:!0}},y0="setStorageSync",w0=[{name:"key",type:String,required:!0},{name:"data",required:!0}],dh="removeStorage",S0=uh,A0=fh,C0="saveFile",O0={formatArgs:{tempFilePath(e,t){t.tempFilePath=pt(e)}}},T0={tempFilePath:{type:String,required:!0}},P0="getSavedFileList",I0="removeSavedFile",N0={formatArgs:{filePath(e,t){t.filePath=pt(e)}}},k0={filePath:{type:String,required:!0}},R0="getFileInfo",x0={formatArgs:{filePath(e,t){t.filePath=pt(e)}}},B0={filePath:{type:String,required:!0}},M0="getSavedFileInfo",L0={formatArgs:{filePath(e,t){t.filePath=pt(e)}}},D0={filePath:{type:String,required:!0}},F0="openDocument",V0={formatArgs:{filePath(e,t){t.filePath=pt(e)}}},$0={filePath:{type:String,required:!0},fileType:String},U0="hideKeyboard",H0="showKeyboard",j0="chooseLocation",z0={keyword:String,latitude:Number,longitude:Number},W0="getLocation",hh=["wgs84","gcj02"],G0={formatArgs:{type(e,t){e=(e||"").toLowerCase(),hh.indexOf(e)===-1?t.type=hh[0]:t.type=e},altitude(e,t){t.altitude=e||!1}}},Y0={type:String,altitude:Boolean},q0="openLocation",gh=(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=gh("latitude",e);if(n)return n;t.latitude=e},longitude(e,t){let n=gh("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=_n(e,kn)},sourceType(e,t){t.sourceType=_n(e,Un)},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},eE="chooseVideo",tE={formatArgs:{sourceType(e,t){t.sourceType=_n(e,Un)},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=["*"])}}},nE={sourceType:Array,compressed:Boolean,maxDuration:Number,camera:String,extension:Array},rE="getImageInfo",iE={formatArgs:{src(e,t){t.src=pt(e)}}},oE={src:{type:String,required:!0}},aE="previewImage",sE={formatArgs:{urls(e,t){t.urls=e.map(n=>Y.isString(n)&&n?pt(n):"")},current(e,t){typeof e=="number"?t.current=e>0&&e<t.urls.length?e:0:Y.isString(e)&&e&&(t.current=pt(e))}}},lE={urls:{type:Array,required:!0},current:{type:[Number,String]}},cE="closePreviewImage",uE="getVideoInfo",fE={formatArgs:{src(e,t){t.src=pt(e)}}},dE={src:{type:String,required:!0}},hE="saveImageToPhotosAlbum",gE={formatArgs:{filePath(e,t){t.filePath=pt(e)}}},pE={filePath:{type:String,required:!0}},vE="saveVideoToPhotosAlbum",mE={formatArgs:{filePath(e,t){t.filePath=pt(e)}}},_E={filePath:{type:String,required:!0}},bE="getRecorderManager",EE="compressImage",yE={formatArgs:{src(e,t){t.src=pt(e)}}},wE={src:{type:String,required:!0}},SE="compressVideo",AE={formatArgs:{src(e,t){t.src=pt(e)}}},CE={src:{type:String,required:!0},quality:String,bitrate:Number,fps:Number,resolution:Number},OE="request",TE={JSON:"json"},PE=["text","arraybuffer"],IE="text",ph=encodeURIComponent;function NE(e,t){let n=e.split("#"),r=n[1]||"";n=n[0].split("?");let a=n[1]||"";e=n[0];let u=a.split("&").filter(b=>b),h={};u.forEach(b=>{let U=b.split("=");h[U[0]]=U[1]});for(let b in t)if(Y.hasOwn(t,b)){let U=t[b];typeof U=="undefined"||U===null?U="":Y.isPlainObject(U)&&(U=JSON.stringify(U)),h[ph(b)]=ph(U)}return a=Object.keys(h).map(b=>`${b}=${h[b]}`).join("&"),e+(a?"?"+a:"")+(r?"#"+r:"")}let kE={method:String,data:[Object,String,Array,ArrayBuffer],url:{type:String,required:!0},header:Object,dataType:String,responseType:String,withCredentials:Boolean},RE={formatArgs:{method(e,t){t.method=sn((e||"").toUpperCase(),mn)},data(e,t){t.data=e||""},url(e,t){t.method===mn[0]&&Y.isPlainObject(t.data)&&Object.keys(t.data).length&&(t.url=NE(e,t.data))},header(e,t){let n=t.header=e||{};t.method!==mn[0]&&(Object.keys(n).find(r=>r.toLowerCase()==="content-type")||(n["Content-Type"]="application/json"))},dataType(e,t){t.dataType=(e||TE.JSON).toLowerCase()},responseType(e,t){t.responseType=(e||"").toLowerCase(),PE.indexOf(t.responseType)===-1&&(t.responseType=IE)}}},xE="configMTLS",BE={certificates:{type:Array,required:!0}},ME={formatArgs:{certificates(e){if(e.some(t=>Y.toRawType(t.host)!=="String"))return"\u53C2\u6570\u914D\u7F6E\u9519\u8BEF\uFF0C\u8BF7\u786E\u8BA4\u540E\u91CD\u8BD5"}}},LE="downloadFile",DE={formatArgs:{header(e,t){t.header=e||{}}}},FE={url:{type:String,required:!0},header:Object,timeout:Number},VE="uploadFile",$E={formatArgs:{filePath(e,t){e&&(t.filePath=pt(e))},header(e,t){t.header=e||{}},formData(e,t){t.formData=e||{}}}},UE={url:{type:String,required:!0},files:Array,filePath:String,name:String,header:Object,formData:Object,timeout:Number},HE="connectSocket",jE={formatArgs:{header(e,t){t.header=e||{}},method(e,t){t.method=sn((e||"").toUpperCase(),mn)},protocols(e,t){Y.isString(e)&&(t.protocols=[e])}}},zE={url:{type:String,required:!0},header:{type:Object},method:String,protocols:[Array,String]},WE="sendSocketMessage",GE={data:[String,ArrayBuffer]},YE="closeSocket",qE={code:Number,reason:String};function KE(e){if(!Y.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(a=>{let u=a.replace(/\+/g," ").split("="),h=u.shift(),b=u.length>0?u.join("="):"";r.push(h+"="+encodeURIComponent(b))}),r.length?e+"?"+r.join("&"):e}let JE=["slide-in-right","slide-in-left","slide-in-top","slide-in-bottom","fade-in","zoom-out","zoom-fade-out","pop-in","none"],ZE=["slide-out-right","slide-out-left","slide-out-top","slide-out-bottom","fade-out","zoom-in","zoom-fade-in","pop-out","none"],Ol={url:{type:String,required:!0}},Bu="navigateTo",Mu="redirectTo",vh="reLaunch",Nc="switchTab",XE="navigateBack",Lu="preloadPage",mh="unPreloadPage",QE=Y.extend({},Ol,_h(JE)),ey=Y.extend({delta:{type:Number}},_h(ZE)),ty=Ol,ny=Ol,ry=Ol,iy=Ol,oy=Ol,ay=Rc(Bu),sy=Rc(Mu),ly=Rc(vh),cy=Rc(Nc),uy={formatArgs:{delta(e,t){e=parseInt(e+"")||1,t.delta=Math.min(Vn().length-1,e)}}};function _h(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 kc;function fy(){kc=""}function Rc(e){return{formatArgs:{url:dy(e)},beforeAll:fy}}function dy(e){return function(n,r){if(!n)return'Missing required args: "url"';n=ba(n);let a=n.split("?")[0],u=Ii(a,!0);if(!u)return"page `"+n+"` is not found";if(e===Bu||e===Mu){if(u.meta.isTabBar)return`can not ${e} a tabbar page`}else if(e===Nc&&!u.meta.isTabBar)return"can not switch to no-tabBar page";if((e===Nc||e===Lu)&&u.meta.isTabBar&&r.openType!=="appLaunch"&&(n=a),u.meta.isEntry&&(n=n.replace(u.alias,"/")),r.url=KE(n),e!==mh){if(e===Lu){if(!u.meta.isNVue)return"can not preload vue page";if(u.meta.isTabBar){let h=Vn(),b=u.path.slice(1);if(h.find(U=>U.route===b))return"tabBar page `"+b+"` already exists"}return}if(kc===n&&r.openType!=="appLaunch")return`${kc} locked`;T.ready&&(kc=n)}}}let hy="hideLoading",gy="hideToast",bh="loadFontFace",py={family:{type:String,required:!0},source:{type:String,required:!0},desc:Object},vy=["#ffffff","#000000"],my="setNavigationBarColor",_y={formatArgs:{animation(e,t){e||(e={duration:0,timingFunc:"linear"}),t.animation={duration:e.duration||0,timingFunc:e.timingFunc||"linear"}}}},by={frontColor:{type:String,required:!0,validator(e){if(vy.indexOf(e)===-1)return`invalid frontColor "${e}"`}},backgroundColor:{type:String,required:!0},animation:Object},Ey="setNavigationBarTitle",yy={title:{type:String,required:!0}},wy="showNavigationBarLoading",Sy="hideNavigationBarLoading",Eh="pageScrollTo",Ay={scrollTop:Number,selector:String,duration:Number},Cy={formatArgs:{duration:300}},Oy="showActionSheet",Ty={itemList:{type:Array,required:!0},title:String,itemColor:String,popover:Object},Py={formatArgs:{itemColor:"#000"}},Iy="showLoading",Ny={title:String,mask:Boolean},ky={formatArgs:{title:"",mask:!1}},Ry="showModal",xy={title:String,content:String,showCancel:Boolean,cancelText:String,cancelColor:String,confirmText:String,confirmColor:String},By={beforeInvoke(){cn()},formatArgs:{title:"",content:"",placeholderText:"",showCancel:!0,editable:!1,cancelText(e,t){if(!Y.hasOwn(t,"cancelText")){let{t:n}=X();t.cancelText=n("uni.showModal.cancel")}},cancelColor:"#000",confirmText(e,t){if(!Y.hasOwn(t,"confirmText")){let{t:n}=X();t.confirmText=n("uni.showModal.confirm")}},confirmColor:te.PRIMARY_COLOR}},My="showToast",Ly=["success","loading","none","error"],Dy={title:String,icon:String,image:String,duration:Number,mask:Boolean},Fy={formatArgs:{title:"",icon(e,t){t.icon=sn(e,Ly)},image(e,t){e?t.image=pt(e):t.image=""},duration:1500,mask:!1}},Vy="startPullDownRefresh",$y="stopPullDownRefresh",rc={index:{type:Number,required:!0}},bs={beforeInvoke(){let e=ia();if(e&&!e.isTabBar)return"not TabBar page"},formatArgs:{index(e){if(!T.tabBar.list[e])return"tabbar item not found"}}},Uy="setTabBarItem",Hy=Y.extend({text:String,iconPath:String,selectedIconPath:String,pagePath:String},rc),jy={beforeInvoke:bs.beforeInvoke,formatArgs:Y.extend({pagePath(e,t){e&&(t.pagePath=te.removeLeadingSlash(e))}},bs.formatArgs)},zy="setTabBarStyle",Wy={color:String,selectedColor:String,backgroundColor:String,backgroundImage:String,backgroundRepeat:String,borderStyle:String},Gy=/^(linear|radial)-gradient\(.+?\);?$/,Yy={beforeInvoke:bs.beforeInvoke,formatArgs:{backgroundImage(e,t){e&&!Gy.test(e)&&(t.backgroundImage=pt(e))},borderStyle(e,t){e&&(t.borderStyle=e==="white"?"white":"black")}}},qy="hideTabBar",yh={animation:Boolean},Ky="showTabBar",Jy=yh,Zy="hideTabBarRedDot",Xy=rc,Qy=bs,ew="showTabBarRedDot",tw=rc,nw=bs,rw="removeTabBarBadge",iw=rc,ow=bs,aw="setTabBarBadge",sw=Y.extend({text:{type:String,required:!0}},rc),lw={beforeInvoke:bs.beforeInvoke,formatArgs:Y.extend({text(e,t){te.getLen(e)>=4&&(t.text="...")}},bs.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",gw={provider:String,withCredentials:Boolean,timeout:Number,lang:String},pw="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"}}},Ew={provider:{type:String,required:!0}},yw="closeAuthView",ww="getCheckBoxState",Sw="getUniverifyManager",Aw="share",wh=["WXSceneSession","WXSceneTimeline","WXSceneFavorite"],Cw={formatArgs:{scene(e,t){let{provider:n,openCustomerServiceChat:r}=t;if(n==="weixin"&&!r&&(!e||!wh.includes(e)))return`\u5206\u4EAB\u5230\u5FAE\u4FE1\u65F6\uFF0Cscene\u5FC5\u987B\u4E3A\u4EE5\u4E0B\u5176\u4E2D\u4E00\u4E2A\uFF1A${wh.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",Sh=["text","image"],Pw={formatArgs:{type(e,t){if(e&&!Sh.includes(e))return"\u5206\u4EAB\u53C2\u6570 type \u4E0D\u6B63\u786E\u3002\u53EA\u652F\u6301text\u3001image";t.type=sn(e,Sh)}}},Iw={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:""}},Lw={adpid:String,adUnitId:String},Dw="createFullScreenVideoAd",Fw={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 Ys(e,t){return function(r){delete r.code,delete r.message,Y.isFunction(t)&&(r=t(r)),e(r)}}function ar(e,t){return function(r){r=r||{},t=r.message||t||"",delete r.message,e(t,Y.extend({code:0},r))}}function Tl(e,t){return function(){e()(function(r){r&&(delete r.code,delete r.message),st.invokeOnCallback(t,r)})}}function si(e,t,n){return function(r,{resolve:a,reject:u}){e()(Y.extend({},Y.isFunction(t)?t(r):r,{success:Ys(a,n),fail:ar(u)}))}}function ic(e=""){if(!(T.tabBar&&Y.isArray(T.tabBar.list)))return!1;try{if(!e){let n=Vn();if(!n.length)return!1;let r=n[n.length-1];return r?r.$page.meta.isTabBar:!1}/^\//.test(e)||(e=te.addLeadingSlash(e));let t=Ii(e);return t&&t.meta.isTabBar}catch(t){}return!1}let ha="__TYPE",Gw="uni-storage-keys";function Du(e){let t=["object","string","number","boolean","undefined"];try{let n=Y.isString(e)?JSON.parse(e):e,r=n.type;if(t.indexOf(r)>=0){let a=Object.keys(n);if(a.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(a.length===1)return""}}catch(n){}}let Yw=Mt(y0,(e,t)=>{let n=typeof t,r=n==="string"?t:JSON.stringify({type:n,data:t});try{n==="string"&&Du(r)!==void 0?l.storage.setItem(e+ha,n):l.storage.removeItem(e+ha),l.storage.setItem(e,r)}catch(a){}},w0),qw=ye(b0,({key:e,data:t},{resolve:n,reject:r})=>{let a=typeof t,u=a==="string"?t:JSON.stringify({type:a,data:t});try{let h=l.storage;a==="string"&&Du(u)!==void 0?h.setItemAsync(e+ha,a):h.removeItemAsync(e+ha),h.setItemAsync(e,u,n,ar(r))}catch(h){r(h.message)}},E0);function Fu(e,t){let n=t;if(e!=="string"||e==="string"&&t==='{"type":"undefined"}')try{let r=JSON.parse(t),a=Du(r);if(a!==void 0)n=a;else if(e&&(n=r,Y.isString(r))){r=JSON.parse(r);let u=typeof r;u==="number"&&e==="date"?n=new Date(r):u===(["null","array"].indexOf(e)<0?e:"object")&&(n=r)}}catch(r){}return n}let Kw=Mt(_0,(e,t)=>{let n=l.storage.getItem(e),a=(l.storage.getItem(e+ha)||"").toLowerCase();return Y.isString(n)?Fu(a,n):""},fh),Jw=ye(m0,({key:e},{resolve:t,reject:n})=>{let r=l.storage;r.getItemAsync(e,function(a){r.getItemAsync(e+ha,function(u){let b=(u.data||"").toLowerCase();t({data:Fu(b,a.data)})},function(){t({data:Fu("",a.data)})})},ar(n))},uh),Zw=Mt(dh,e=>{l.storage.removeItem(e+ha),l.storage.removeItem(e)},A0),Xw=ye(dh,({key:e},{resolve:t,reject:n})=>{l.storage.removeItemAsync(e+ha),l.storage.removeItemAsync(e,t,ar(n))},S0),Qw=Mt("clearStorageSync",()=>{l.storage.clear()}),eS=ye("clearStorage",(e,{resolve:t,reject:n})=>{l.storage.clearAsync(t,ar(n))}),Ah=Mt("getStorageInfoSync",()=>{let e=l.storage.getLength()||0,t=[],n=0;for(let r=0;r<e;r++){let a=l.storage.key(r);if(a!==Gw&&(a.indexOf(ha)<0||a.indexOf(ha)+ha.length!==a.length)){let u=l.storage.getItem(a);n+=a.length+u.length,t.push(a)}}return{keys:t,currentSize:Math.ceil(n*2/1024),limitSize:Number.MAX_VALUE}}),tS=ye("getStorageInfo",(e,{resolve:t})=>{t(Ah())}),nS=ye(R0,(e,{resolve:t,reject:n})=>{l.io.getFileInfo(Y.extend(e,{success:Ys(t),fail:ar(n)}))},B0,x0),rS=0,Ch="uniapp_save",iS=`_doc/${Ch}`;function oS(e,t){t=t||function(){},l.io.requestFileSystem(l.io.PRIVATE_DOC,n=>{n.root.getDirectory(Ch,{create:!0},e,t)},t)}let aS=ye(C0,({tempFilePath:e},{resolve:t,reject:n})=>{let r=ar(n),a=`${Date.now()}${rS++}${Yo(e)}`;l.io.resolveLocalFileSystemURL(e,u=>{oS(h=>{u.copyTo(h,a,()=>{let b=iS+"/"+a;t({savedFilePath:b})},r)},r)},r)},T0,O0),sS="uniapp_save";function lS(e,t){t=t||function(){},l.io.requestFileSystem(l.io.PRIVATE_DOC,n=>{n.root.getDirectory(sS,{create:!0},e,t)},t)}let cS=ye(P0,(e,{resolve:t,reject:n})=>{let r=ar(n);lS(a=>{var u=a.createReader(),h=[];u.readEntries(b=>{b&&b.length?b.forEach(U=>{U.getMetadata(O=>{h.push({filePath:l.io.convertAbsoluteFileSystem(U.fullPath),createTime:O.modificationTime.getTime(),size:O.size}),h.length===b.length&&t({fileList:h})},r,!1)}):t({fileList:h})},r)},r)}),uS=ye(M0,({filePath:e},{resolve:t,reject:n})=>{let r=ar(n);l.io.resolveLocalFileSystemURL(e,a=>{a.getMetadata(u=>{t({createTime:u.modificationTime.getTime(),size:u.size})},r,!1)},r)},D0,L0),fS=ye(I0,({filePath:e},{resolve:t,reject:n})=>{let r=ar(n);l.io.resolveLocalFileSystemURL(e,a=>{a.remove(()=>{t()},r)},r)},k0,N0),dS=ye(F0,({filePath:e,fileType:t},{resolve:n,reject:r})=>{let a=ar(r);l.runtime.openDocument(pt(e),void 0,n,a)},$0,V0),hS=Mt(sb,e=>!!Y.hasOwn(gt,e),lb),Vu;function gS(){return Vu=Vu||l.device.uuid,Vu}let oc,$u=!0,rr;function pS(e,t,n){!rr||(e==="none"?(rr.hideTabBarRedDot({index:t}),rr.removeTabBarBadge({index:t})):e==="text"?rr.setTabBarBadge({index:t,text:n}):e==="redDot"&&rr.showTabBarRedDot({index:t}))}function vS(e,t,n,r,a,u){let h={index:e};if(t!==void 0&&(h.text=t),n&&(h.iconPath=pt(n)),r&&(h.selectedIconPath=pt(r)),u!==void 0&&(h.iconfont=u),a!==void 0){h.visible=oc.list[e].visible=a,delete h.index;let b=oc.list.map(U=>({visible:U.visible}));b[e]=h,rr&&rr.setTabBarItems({list:b})}else rr&&rr.setTabBarItem(h)}function mS(e){rr&&rr.setTabBarStyle(e)}function _S(e){$u=!1,rr&&rr.hideTabBar({animation:e})}function bS(e){$u=!0,rr&&rr.showTabBar({animation:e})}let xc=[];var li={id:"0",init(e,t){e&&e.list.length&&(oc=e);try{rr=g.requireModule("uni-tabview")}catch(n){console.log(`uni.requireNativePlugin("uni-tabview") error ${n}`)}rr.onMaskClick(()=>{xc.forEach(n=>{n()})}),rr&&rr.onClick(({index:n})=>{t(oc.list[n],n)}),rr&&rr.onMidButtonClick(()=>st.invokeOnCallback(qd))},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?(rr&&rr.switchSelect({index:t}),!0):!1},setTabBarBadge:pS,setTabBarItem:vS,setTabBarStyle:mS,hideTabBar:_S,showTabBar:bS,append(e){rr&&rr.append({id:e.id},({code:t})=>{t!==0&&k(()=>{this.append(e)},20)})},get config(){return oc||T.tabBar},get visible(){return $u},get height(){let e=this.config;return(e&&e.height?parseFloat(e.height):te.TABBAR_HEIGHT)+l.navigator.getSafeAreaInsets().deviceBottom},get cover(){let e=this.config;return e&&["extralight","light","dark"].indexOf(e.blurEffect)>=0},setStyle({mask:e}){rr.setMask({color:e})},addEventListener(e,t){xc.push(t)},removeEventListener(e,t){let n=xc.indexOf(t);xc.splice(n,1)}};function Bc(){let e=_r();return e?e.$getAppWebview():null}function Oh(e){return e?e.$getAppWebview():Bc()}let Th=null;function Ph(){return Th}function Uu(e){Th=e}function Hu(){return l.navigator.isImmersedStatusbar()?Math.round(l.os.name==="iOS"?l.navigator.getSafeAreaInsets().top:l.navigator.getStatusbarHeight()):0}function Ih(){let e=l.navigator.getStatusBarStyle();return e==="UIStatusBarStyleBlackTranslucent"||e==="UIStatusBarStyleBlackOpaque"||e==="null"?e="light":e==="UIStatusBarStyleDefault"&&(e="dark"),e}function ES(){let{resolutionWidth:e,resolutionHeight:t}=l.screen.getCurrentSize()||{resolutionWidth:0,resolutionHeight:0};return{screenWidth:Math.round(e),screenHeight:Math.round(t)}}let Nh=Mt("getWindowInfo",()=>{let e=l.os.name.toLowerCase()==="ios",{screenWidth:t,screenHeight:n}=ES(),r=Hu(),a,u={height:0,cover:!1},h=Bc();if(h){let Et=h.getStyle(),kt=Et&&Et.titleNView;kt&&kt.type&&kt.type!=="none"&&(u.height=kt.type==="transparent"?0:r+te.NAVBAR_HEIGHT,u.cover=kt.type==="transparent"||kt.type==="float"),a=h.getSafeAreaInsets()}else a=l.navigator.getSafeAreaInsets();let b={height:0,cover:!1};ic()&&(b.height=li.visible?li.height:0,b.cover=li.cover);let U=u.cover?u.height:0,O=b.cover?b.height:0,D=n-u.height-b.height,ge=n-(u.cover?0:u.height)-(b.cover?0:b.height),we=t;(!b.height||b.cover)&&!a.bottom&&a.deviceBottom&&(D-=a.deviceBottom,ge-=a.deviceBottom),a=e?a:{left:0,right:0,top:u.height&&!u.cover?0:r,bottom:0};let ke={left:a.left,right:we-a.right,top:a.top,bottom:ge-a.bottom,width:we-a.left-a.right,height:ge-a.top-a.bottom};return{pixelRatio:l.screen.scale,screenWidth:t,screenHeight:n,windowWidth:we,windowHeight:D,statusBarHeight:r,safeArea:ke,safeAreaInsets:{top:a.top,right:a.right,bottom:a.bottom,left:a.left},windowTop:U,windowBottom:O,screenTop:n-D}}),Na,Mc=!0;function ju(){if(!Mc)return;let{getSystemInfoSync:e}=g.requireModule("plus");if(Na=e(),Y.isString(Na))try{Na=JSON.parse(Na)}catch(t){}}let kh=Mt("getDeviceInfo",()=>{ju();let{deviceBrand:e="",deviceModel:t,osName:n,osVersion:r,deviceOrientation:a,deviceType:u}=Na,h=e.toLowerCase(),b=n.toLowerCase();return{brand:h,deviceBrand:h,deviceModel:t,devicePixelRatio:l.screen.scale,deviceId:gS(),deviceOrientation:a,deviceType:u,model:t,platform:b,system:`${b==="ios"?"iOS":"Android"} ${r}`}}),Rh=Mt("getAppBaseInfo",()=>{ju();let{hostPackageName:e,hostName:t,hostVersion:n,hostLanguage:r,osLanguage:a,hostTheme:u,appId:h,appName:b,appVersion:U,appVersionCode:O,appWgtVersion:D}=Na;return{appId:h,appName:b,appVersion:U,appVersionCode:O,appWgtVersion:D,appLanguage:Ql?Ql():a,enableDebug:!1,hostPackageName:e,hostName:t,hostVersion:n,hostLanguage:r,hostTheme:u,hostFontSizeSetting:void 0,hostSDKVersion:void 0,language:a,SDKVersion:"",theme:void 0,version:l.runtime.innerVersion}}),xh=Mt("getSystemInfoSync",()=>{Mc=!0,ju(),Mc=!1;let e=Nh(),t=kh(),n=Rh();Mc=!0;let r={fontSizeSetting:n.hostFontSizeSetting,osName:Na.osName.toLowerCase()};Na.hostName&&(r.hostSDKVersion=Na.uniRuntimeVersion);let a=Y.extend(Na,e,t,n,r);return delete a.screenTop,delete a.enableDebug,delete a.theme,te.sortObject(a)}),yS=ye("getSystemInfo",(e,{resolve:t})=>t(xh())),Pl=null,wS=qn(rh,()=>{Bh()}),SS=Cr(wb,()=>{Mh()}),Bh=ye(Sb,(e,{resolve:t,reject:n})=>{Pl||(Pl=l.orientation.watchOrientation(r=>{st.invokeOnCallback(rh,{direction:r.magneticHeading})},r=>{n(r.message),Pl=null},{frequency:Qn})),k(t,Qn)}),Mh=ye(Ab,(e,{resolve:t})=>{Pl&&(l.orientation.clearWatch(Pl),Pl=null),t()}),AS=ye(Cb,(e,{resolve:t})=>{l.device.vibrate(15),t()}),CS=ye(Ob,(e,{resolve:t})=>{l.device.vibrate(400),t()}),Il=null,OS=qn(nh,()=>{Lh()}),TS=Cr(bb,()=>{Dh()}),Lh=ye(Eb,(e,{resolve:t,reject:n})=>{Il||(Il=l.accelerometer.watchAcceleration(r=>{st.invokeOnCallback(nh,{x:r&&r.xAxis||0,y:r&&r.yAxis||0,z:r&&r.zAxis||0})},r=>{Il=null,n(`startAccelerometer:fail ${r.message}`)},{frequency:Qn})),k(t,Qn)}),Dh=ye(yb,(e,{resolve:t})=>{Il&&(l.accelerometer.clearWatch(Il),Il=null),t()}),PS=qn(ih,Tl(()=>l.bluetooth.onBluetoothDeviceFound.bind(l.bluetooth),ih)),IS=qn(oh,Tl(()=>l.bluetooth.onBluetoothAdapterStateChange.bind(l.bluetooth),oh)),NS=qn(ah,Tl(()=>l.bluetooth.onBLEConnectionStateChange.bind(l.bluetooth),ah)),kS=qn(sh,Tl(()=>l.bluetooth.onBLECharacteristicValueChange.bind(l.bluetooth),sh)),RS=ye("openBluetoothAdapter",si(()=>l.bluetooth.openBluetoothAdapter.bind(l.bluetooth))),xS=ye("closeBluetoothAdapter",si(()=>l.bluetooth.closeBluetoothAdapter.bind(l.bluetooth))),BS=ye("getBluetoothAdapterState",si(()=>l.bluetooth.getBluetoothAdapterState.bind(l.bluetooth))),MS=ye(Tb,si(()=>l.bluetooth.startBluetoothDevicesDiscovery.bind(l.bluetooth)),Pb),LS=ye("stopBluetoothDevicesDiscovery",si(()=>l.bluetooth.stopBluetoothDevicesDiscovery.bind(l.bluetooth))),DS=ye("getBluetoothDevices",si(()=>l.bluetooth.getBluetoothDevices.bind(l.bluetooth))),FS=ye(Ib,si(()=>l.bluetooth.getConnectedBluetoothDevices.bind(l.bluetooth)),Nb),VS=ye(kb,si(()=>l.bluetooth.createBLEConnection.bind(l.bluetooth)),Rb),$S=ye(xb,si(()=>l.bluetooth.closeBLEConnection.bind(l.bluetooth)),Bb),US=ye(Mb,si(()=>l.bluetooth.getBLEDeviceServices.bind(l.bluetooth)),Lb),HS=ye(Db,si(()=>l.bluetooth.getBLEDeviceCharacteristics.bind(l.bluetooth)),Fb),jS=ye(Vb,si(()=>l.bluetooth.notifyBLECharacteristicValueChange.bind(l.bluetooth)),$b),zS=ye(Ub,si(()=>l.bluetooth.readBLECharacteristicValue.bind(l.bluetooth)),Hb),WS=ye(jb,si(()=>l.bluetooth.writeBLECharacteristicValue.bind(l.bluetooth)),zb),GS=ye(Wb,si(()=>l.bluetooth.setBLEMTU.bind(l.bluetooth)),Gb),YS=ye(Yb,si(()=>l.bluetooth.getBLEDeviceRSSI.bind(l.bluetooth)),qb),qS=qn(lh,Tl(()=>l.ibeacon.onBeaconUpdate.bind(l.ibeacon),lh)),KS=qn(ch,Tl(()=>l.ibeacon.onBeaconServiceChange.bind(l.ibeacon),ch)),JS=ye(Kb,si(()=>l.ibeacon.getBeacons.bind(l.ibeacon))),ZS=ye(Jb,si(()=>l.ibeacon.startBeaconDiscovery.bind(l.ibeacon)),Zb),XS=ye(Xb,si(()=>l.ibeacon.stopBeaconDiscovery.bind(l.ibeacon))),QS=ye(ub,({phoneNumber:e},{resolve:t})=>(l.device.dial(e),t()),fb),eA={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"}]},tA=["type","preferred"];function zu(e,t,n){let r=0;return Object.keys(n).forEach(a=>{let u=n[a];typeof u!=="object"?tA.indexOf(a)!==-1?e[a]=n[a]:typeof t[u]!="undefined"?(r++,e[a]=t[u]):delete e[a]:u instanceof Array?(e[a]=[],u.forEach(b=>{let U={};zu(U,t,b)&&e[a].push(U)}),e[a].length?r++:delete e[a]):(e[a]={},zu(e[a],t,u)?r++:delete e[a])}),r}let nA=ye(db,(e,{resolve:t,reject:n})=>{!e.photoFilePath&&(e.photoFilePath=""),l.contacts.getAddressBook(l.contacts.ADDRESSBOOK_PHONE,r=>{let a=r.create();zu(a,e,eA),a.save(()=>t(),u=>n())},r=>n())},gb,hb);function Ho(e){return typeof g!="undefined"?g.requireModule(e):__requireNativePlugin__(e)}function Fh(e,t,n){return Ho("plus").sendNativeEvent(e,t,n)}let rA=ye(pb,(e,{resolve:t,reject:n})=>{Ho("clipboard").getString(a=>{a.result==="success"?t({data:a.data}):n("getClipboardData:fail")})}),iA=ye(vb,(e,{resolve:t})=>{Ho("clipboard").setString(e.data),t()},_b,mb),Vh="onNetworkStatusChange";function $h(){Uh().then(({networkType:e})=>{st.invokeOnCallback(Vh,{isConnected:e!=="none",networkType:e})})}let oA=qn(Vh,()=>{l.globalEvent.addEventListener("netchange",$h)}),aA=Cr("offNetworkStatusChange",()=>{l.globalEvent.removeEventListener("netchange",$h)}),Uh=ye("getNetworkType",(e,{resolve:t})=>{let n=Fr[l.networkinfo.getCurrentType()]||"unknown";return t({networkType:n})});function Hh(){if(l.os.name.toLowerCase()!=="ios")return!1;let t=Ho("faceID");return!!(t&&t.isSupport())}function jh(){return!!(l.fingerprint&&l.fingerprint.isSupport())}let zh=e=>{let t=[];return jh()&&t.push("fingerPrint"),Hh()&&t.push("facial"),e&&e({supportMode:t}),{supportMode:t,errMsg:"checkIsSupportSoterAuthentication:ok"}},sA=ye(n0,(e,{resolve:t,reject:n})=>{zh(t)}),Wh=({checkAuthMode:e,resolve:t,reject:n})=>{let r=(u,h)=>n&&n(u,h),a=u=>t&&t(u);if(e==="fingerPrint"){if(jh()){let u=l.fingerprint.isKeyguardSecure()&&l.fingerprint.isEnrolledFingerprints();return a({isEnrolled:u}),{isEnrolled:u,errMsg:"checkIsSoterEnrolledInDevice:ok"}}return r("not support",{isEnrolled:!1}),{isEnrolled:!1,errMsg:"checkIsSoterEnrolledInDevice:fail not support"}}else if(e==="facial"){if(Hh()){let u=Ho("faceID"),h=u&&u.isKeyguardSecure()&&u.isEnrolledFaceID();return a({isEnrolled:h}),{isEnrolled:h,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"}},lA=ye(r0,({checkAuthMode:e},{resolve:t,reject:n})=>{Wh({checkAuthMode:e,resolve:t,reject:n})},a0,o0),cA=ye(s0,({requestAuthModes:e,challenge:t=!1,authContent:n},{resolve:r,reject:a})=>{Ro();let{t:u}=X(),h=zh().supportMode;if(h.length===0)return{authMode:"fingerPrint",errCode:90001,errMsg:"startSoterAuthentication:fail"};let b=[];if(e.map((D,ge)=>{h.indexOf(D)>-1&&b.push(D)}),b.length===0)return{authMode:"fingerPrint",errCode:90003,errMsg:"startSoterAuthentication:fail no corresponding mode"};let U=[];if(b.map((D,ge)=>{Wh({checkAuthMode:D}).isEnrolled&&U.push(D)}),U.length===0)return{authMode:b[0],errCode:90011,errMsg:`startSoterAuthentication:fail no ${b[0]} enrolled`};let O=U[0];O==="fingerPrint"?(l.os.name.toLowerCase()==="android"&&(l.nativeUI.showWaiting(n||u("uni.startSoterAuthentication.authContent")).onclose=function(){l.fingerprint.cancel()}),l.fingerprint.authenticate(()=>{l.nativeUI.closeWaiting(),r({authMode:O,errCode:0})},D=>{let ge={authMode:O};switch(D.code){case D.AUTHENTICATE_MISMATCH:break;case D.AUTHENTICATE_OVERLIMIT:l.nativeUI.closeWaiting(),a("authenticate freeze. please try again later",Y.extend(ge,{errCode:90010}));break;case D.CANCEL:l.nativeUI.closeWaiting(),a("cancel",Y.extend(ge,{errCode:90008}));break;default:l.nativeUI.closeWaiting(),a("",Y.extend(ge,{errCode:90007}));break}},{message:n})):O==="facial"&&Ho("faceID").authenticate({message:n},ge=>{let we={authMode:O};if(ge.type==="success"&&ge.code===0)r({authMode:O,errCode:0});else switch(ge.code){case 4:a("",Y.extend(we,{errCode:90009}));break;case 5:a("authenticate freeze. please try again later",Y.extend(we,{errCode:90010}));break;case 6:a("",Y.extend(we,{errCode:90008}));break;default:a("",Y.extend(we,{errCode:90007}));break}})},c0,l0),uA=ye(u0,(e,{resolve:t,reject:n})=>{ta();let{t:r}=X(),u=Ih()!=="light",h,b=!1,U=ri({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:()=>{U.sendMessage({type:"gallery"})}}]},popGesture:"close",background:"#000000",backButtonAutoControl:"close"},onMessage({event:O,detail:D}){h=D,b=O==="marked"},onClose(){u&&l.navigator.setStatusBarStyle("dark"),h?b?(delete h.message,t(h)):n(h.message):n("cancel")}});u&&(l.navigator.setStatusBarStyle("light"),U.webview.addEventListener("popGesture",({type:O,result:D})=>{O==="start"?l.navigator.setStatusBarStyle("dark"):O==="end"&&!D&&l.navigator.setStatusBarStyle("light")}))},f0,h0),fA=qn(te.ON_THEME_CHANGE,()=>{st.on(te.ON_THEME_CHANGE,e=>{st.invokeOnCallback(te.ON_THEME_CHANGE,e)})}),dA=ye(Qb,(e,{resolve:t})=>{let n=l.screen.getBrightness(!1);t({value:n})}),hA=ye(e0,(e,{resolve:t})=>{l.screen.setBrightness(e.value,!1),t()}),gA=ye(t0,(e,{resolve:t})=>{l.device.setWakelock(!!e.keepScreenOn),t()}),pA=Mt(g0,()=>{let{getSystemSetting:e}=g.requireModule("plus"),t=e();try{typeof t=="string"&&(t=JSON.parse(t))}catch(n){}return t}),Gh=Mt(p0,()=>{let{getAppAuthorizeSetting:e}=g.requireModule("plus"),t=e();try{typeof t=="string"&&(t=JSON.parse(t))}catch(n){}for(let n in t)Y.hasOwn(t,n)&&t[n]==="undefined"&&(t[n]=void 0);return t}),vA=ye(v0,(e,{resolve:t,reject:n})=>{let{openAppAuthorizeSetting:r}=g.requireModule("plus");r(u=>{u.type==="success"?t():n()})}),mA=ye(rE,(e,{resolve:t,reject:n})=>{let r=ai+"/download/";l.io.getImageInfo(Y.extend(e,{savePath:r,filename:r,success:Ys(t),fail:ar(n)}))},oE,iE),_A=ye(uE,(e,{resolve:t,reject:n})=>{l.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:ar(n)})},dE,fE),bA=ye(aE,({current:e=0,indicator:t="number",loop:n=!1,urls:r,longPressActions:a},{resolve:u,reject:h})=>{ea();let{t:b}=X();r=r.map(O=>pt(O));let U=Number(e);isNaN(U)?(e=r.indexOf(pt(e)),e=e<0?0:e):e=U,l.nativeUI.previewImage(r,{current:e,indicator:t,loop:n,onLongPress:function(O){let D=[],ge="",we=a&&Y.isPlainObject(a);we?(D=a.itemList?a.itemList:[],ge=a.itemColor?a.itemColor:"#000000"):(D=[b("uni.previewImage.button.save")],ge="#000000");let ke={buttons:D.map(Et=>({title:Et,color:ge})),cancel:b("uni.previewImage.cancel")};l.nativeUI.actionSheet(ke,Et=>{if(Et.index>0){if(we){Y.isFunction(a.success)&&a.success({tapIndex:Et.index-1,index:O.index});return}l.gallery.save(O.url,()=>{l.nativeUI.toast(b("uni.previewImage.save.success"))},function(){l.nativeUI.toast(b("uni.previewImage.save.fail"))})}else we&&Y.isFunction(a.fail)&&a.fail({errMsg:"showActionSheet:fail cancel"})})}}),u()},lE,sE),EA=ye(cE,(e,{resolve:t,reject:n})=>{try{l.nativeUI.closePreviewImage(),t()}catch(r){n()}}),Wu,Nl=!1,Gu,kl=(e,t={})=>{yA(Y.extend({state:e},t))},ac={start({duration:e=6e4,sampleRate:t,numberOfChannels:n,encodeBitRate:r,format:a="mp3",frameSize:u}={}){if(Nl)return kl("start");Wu=l.audio.getRecorder(),Wu.record({format:a,samplerate:t?String(t):"",filename:ai+"/recorder/"},h=>kl("stop",{tempFilePath:h}),h=>kl("error",{errMsg:h.message})),Gu=k(()=>{ac.stop()},e),kl("start"),Nl=!0},stop(){Nl&&(Wu.stop(),Nl=!1,Gu&&S(Gu))},pause(){Nl&&kl("error",{errMsg:"Unsupported operation: pause"})},resume(){Nl&&kl("error",{errMsg:"Unsupported operation: resume"})}},qs={pause:null,resume:null,start:null,stop:null,error:null};function yA(e){let t=e.state;delete e.state,delete e.errMsg,t&&Y.isFunction(qs[t])&&qs[t](e)}class wA{constructor(){}onError(t){qs.error=t}onFrameRecorded(t){}onInterruptionBegin(t){}onInterruptionEnd(t){}onPause(t){qs.pause=t}onResume(t){qs.resume=t}onStart(t){qs.start=t}onStop(t){qs.stop=t}pause(){ac.pause()}resume(){ac.resume()}start(t={}){ac.start(t)}stop(){ac.stop()}}let Yh,SA=Mt(bE,()=>Yh||(Yh=new wA)),AA=ye(vE,(e,{resolve:t,reject:n})=>{l.gallery.save(e.filePath,Ys(t),ar(n))},_E,mE),CA=ye(hE,(e,{resolve:t,reject:n})=>{l.gallery.save(e.filePath,Ys(t),ar(n))},pE,gE),OA=ye(EE,(e,{resolve:t,reject:n})=>{let r=`${ai}/compressed/${Date.now()}_${Ca(e.src)}`;l.zip.compressImage(Y.extend({},e,{dst:r}),()=>{t({tempFilePath:r})},n)},wE,yE),TA=ye(SE,(e,{resolve:t,reject:n})=>{let r=`${ai}/compressed/${Date.now()}_${Ca(e.src)}`;l.zip.compressVideo(Y.extend({},e,{filename:r}),()=>{t({tempFilePath:r})},n)},CE,AE);function PA(e){return new Promise((t,n)=>{l.io.resolveLocalFileSystemURL(e,function(r){r.getMetadata(t,n,!1)},n)})}let IA=ye(Z0,({count:e,sizeType:t,sourceType:n,crop:r}={},{resolve:a,reject:u})=>{ni();let{t:h}=X(),b=ar(u);function U(ge){let we=[],ke=[];Promise.all(ge.map(Et=>PA(Et))).then(Et=>{Et.forEach((kt,Zt)=>{let $t=ge[Zt];ke.push($t),we.push({path:$t,size:kt.size})}),a({tempFilePaths:ke,tempFiles:we})}).catch(b)}function O(){l.camera.getCamera().captureImage(we=>U([we]),b,{filename:ai+"/camera/",resolution:"high",crop:r,sizeType:t})}function D(){l.gallery.pick(({files:ge})=>U(ge),b,{maximum:e,multiple:!0,system:!1,filename:ai+"/gallery/",permissionAlert:!0,crop:r,sizeType:t})}if(n.length===1){if(n.includes("album")){D();return}else if(n.includes("camera")){O();return}}l.nativeUI.actionSheet({cancel:h("uni.chooseImage.cancel"),buttons:[{title:h("uni.chooseImage.sourceType.camera")},{title:h("uni.chooseImage.sourceType.album")}]},ge=>{switch(ge.index){case 1:O();break;case 2:D();break;default:b();break}})},Q0,X0),NA=ye(eE,({sourceType:e,compressed:t,maxDuration:n,camera:r},{resolve:a,reject:u})=>{mr();let{t:h}=X(),b=ar(u);function U(ge){l.io.getVideoInfo({filePath:ge,success(we){let ke={errMsg:"chooseVideo:ok",tempFilePath:ge,size:we.size,duration:we.duration,width:we.width,height:we.height};a(ke)},fail:b})}function O(){l.gallery.pick(({files:ge})=>U(ge[0]),b,{filter:"video",system:!1,multiple:!0,maximum:1,filename:ai+"/gallery/",permissionAlert:!0,videoCompress:t})}function D(){l.camera.getCamera().startVideoCapture(U,b,{index:r==="front"?"2":"1",videoMaximumDuration:n,filename:ai+"/camera/",videoCompress:t})}if(e.length===1){if(e.includes("album")){O();return}else if(e.includes("camera")){D();return}}l.nativeUI.actionSheet({cancel:h("uni.chooseVideo.cancel"),buttons:[{title:h("uni.chooseVideo.sourceType.camera")},{title:h("uni.chooseVideo.sourceType.album")}]},ge=>{switch(ge.index){case 1:D();break;case 2:O();break;default:b();break}})},nE,tE),kA=ye(H0,(e,{resolve:t})=>{l.key.showSoftKeybord(),t()}),RA=ye(U0,(e,{resolve:t})=>{l.key.hideSoftKeybord(),t()});function qh(e){st.invokeOnCallback(te.ON_KEYBOARD_HEIGHT_CHANGE,e)}let xA=qn(te.ON_KEYBOARD_HEIGHT_CHANGE,()=>{st.on(te.ON_KEYBOARD_HEIGHT_CHANGE,qh)}),BA=Cr(te.ON_KEYBOARD_HEIGHT_CHANGE,()=>{st.off(te.ON_KEYBOARD_HEIGHT_CHANGE,qh)});class MA{constructor(t){this._callbacks=[],this._downloader=t,t.addEventListener("statechanged",(n,r)=>{n.downloadedSize&&n.totalSize&&this._callbacks.forEach(a=>{a({progress:Math.round(n.downloadedSize/n.totalSize*100),totalBytesWritten:n.downloadedSize,totalBytesExpectedToWrite:n.totalSize})})})}abort(){this._downloader.abort()}onProgressUpdate(t){!Y.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 LA=Vi(LE,({url:e,header:t,timeout:n},{resolve:r,reject:a})=>{n=(n||T.networkTimeout&&T.networkTimeout.request||60*1e3)/1e3;let u=l.downloader.createDownload(e,{timeout:n,filename:ai+"/download/",retry:0,retryInterval:0},(b,U)=>{U?r({tempFilePath:b.filename,statusCode:U}):a(`statusCode: ${U}`)}),h=new MA(u);for(let b in t)Y.hasOwn(t,b)&&u.setRequestHeader(b,t[b]);return u.start(),h},FE,DE),DA=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 a=0;a<r.length;a++)r[a].indexOf("Expires=")!==-1||r[a].indexOf("expires=")!==-1?n.push(r[a].replace(",","")):n.push(r[a]);return n=n.join(";").split(","),n};function FA(e,t){if(Y.isString(e.data)&&e.data.charCodeAt(0)===65279&&(e.data=e.data.slice(1)),e.statusCode=parseInt(String(e.statusCode),10),Y.isPlainObject(e.header)&&(e.header=Object.keys(e.header).reduce(function(n,r){let a=e.header[r];return Y.isArray(a)?n[r]=a.join(","):Y.isString(a)&&(n[r]=a),n},{})),t.dataType&&t.dataType.toLowerCase()==="json")try{e.data=JSON.parse(e.data)}catch(n){}return e}class VA{constructor(t){this._requestTask=t}abort(){this._requestTask.abort()}offHeadersReceived(){}onHeadersReceived(){}}let $A=Vi(OE,(e,{resolve:t,reject:n})=>{let{header:r,method:a,data:u,timeout:h,url:b,responseType:U,sslVerify:O,firstIpv4:D,tls:ge}=e,we;for(let mt in r)if(mt.toLowerCase()==="content-type"){we=r[mt];break}a!=="GET"&&we.indexOf("application/json")===0&&Y.isPlainObject(u)&&(u=JSON.stringify(u));let ke=Ho("stream"),Et={},kt,Zt,$t=!1;for(let mt in r)if(!$t&&mt.toLowerCase()==="content-type"){if($t=!0,Et["Content-Type"]=r[mt],a!=="GET"&&r[mt].indexOf("application/x-www-form-urlencoded")===0&&!Y.isString(u)&&!(u instanceof ArrayBuffer)){let hn=[];for(let Xt in u)Y.hasOwn(u,Xt)&&hn.push(encodeURIComponent(Xt)+"="+encodeURIComponent(u[Xt]));u=hn.join("&")}}else Et[mt]=r[mt];!$t&&a==="POST"&&(Et["Content-Type"]="application/x-www-form-urlencoded; charset=UTF-8"),h&&(kt=k(()=>{Zt=!0,n("timeout")},h+200));let Nn={method:a,url:b.trim(),headers:Et,type:U==="arraybuffer"?"base64":"text",timeout:h||6e5,sslVerify:!O,firstIpv4:D,tls:ge},Dn=!1;a!=="GET"&&(toString.call(u)==="[object ArrayBuffer]"?Dn=!0:Nn.body=Y.isString(u)?u:JSON.stringify(u));let en=({ok:mt,status:hn,data:Xt,headers:jt,errorMsg:gn})=>{if(Zt)return;kt&&S(kt);let sr=hn;if(sr>0)t(FA({data:mt&&U==="arraybuffer"?Hn(Xt):Xt,statusCode:sr,header:jt,cookies:DA(jt)},e));else{let zt="abort statusCode:"+sr;gn&&(zt=zt+" "+gn),n(zt)}};return Dn?ke.fetchWithArrayBuffer({"@type":"binary",base64:Bn(u)},Nn,en):ke.fetch(Nn,en),new VA({abort(){Zt=!0,kt&&S(kt),n("abort")}})},kE,RE),UA=ye(xE,({certificates:e},{resolve:t,reject:n})=>{Ho("stream").configMTLS(e,({type:a,code:u,message:h})=>{switch(a){case"success":t({code:u});break;case"fail":n(h,{code:u});break}})},BE,ME),Rl=[],xl={},Yu={open:"",close:"",error:"",message:""},sc;function HA(e){let t=String(Date.now()),n;try{sc||(sc=Ho("uni-webSocket"),jA(sc)),sc.WebSocket({id:t,url:e.url,protocol:Y.isArray(e.protocols)?e.protocols.join(","):e.protocols,header:e.header})}catch(r){n=r}return{socket:sc,socketId:t,errMsg:n}}function jA(e){e.onopen(t=>{let n=xl[t.id];!n||n._socketOnOpen()}),e.onmessage(t=>{let n=xl[t.id];!n||n._socketOnMessage(t)}),e.onerror(t=>{let n=xl[t.id];!n||n._socketOnError()}),e.onclose(t=>{let n=xl[t.id];!n||n._socketOnClose()})}class zA{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"?Hn(t.data.base64):t.data})}_socketOnError(){this.socketStateChange("error"),this.onErrorOrClose()}_socketOnClose(){this.socketStateChange("close"),this.onErrorOrClose()}onErrorOrClose(){this.readyState=this.CLOSED,delete xl[this.id];let t=Rl.indexOf(this);t>=0&&Rl.splice(t,1)}socketStateChange(t,n={}){let r=t==="message"?n:{};this===Rl[0]&&Yu[t]&&st.invokeOnCallback(Yu[t],r),this._callbacks[t].forEach(a=>{Y.isFunction(a)&&a(r)})}send(t,n=!0){this.readyState!==this.OPEN&&te.callOptions(t,"sendSocketMessage:fail WebSocket is not connected");try{this._socket.send({id:this.id,data:typeof t.data=="object"?{"@type":"binary",base64:Bn(t.data)}:t.data}),n&&te.callOptions(t,"sendSocketMessage:ok")}catch(r){n&&te.callOptions(t,`sendSocketMessage:fail ${r}`)}}close(t,n=!0){this.readyState=this.CLOSING;try{this._socket.close(Y.extend({id:this.id,args:t})),n&&te.callOptions(t,"closeSocket:ok")}catch(r){n&&te.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 WA=Vi(HE,({url:e,protocols:t,header:n,method:r},{resolve:a,reject:u})=>{let{socket:h,socketId:b,errMsg:U}=HA({url:e,protocols:t,header:n,method:r}),O=new zA(h,b);return U?k(()=>{u(U)},0):(Rl.push(O),xl[b]=O),k(()=>{a()},0),O},zE,jE),GA=ye(WE,(e,{resolve:t,reject:n})=>{let r=Rl[0];if(!r||r.readyState!==r.OPEN){n("WebSocket is not connected");return}r.send({data:e.data},!1),t()},GE),YA=ye(YE,(e,{resolve:t,reject:n})=>{let r=Rl[0];if(!r){n("WebSocket is not connected");return}r.readyState=r.CLOSING,r.close(e,!1),t()},qE);function Lc(e){let t=`onSocket${Y.capitalize(e)}`;return qn(t,()=>{Yu[e]=t})}let qA=Lc("open"),KA=Lc("error"),JA=Lc("message"),ZA=Lc("close");class XA{constructor(t){this._callbacks=[],this._uploader=t,t.addEventListener("statechanged",(n,r)=>{n.uploadedSize&&n.totalSize&&this._callbacks.forEach(a=>{a({progress:parseInt(String(n.uploadedSize/n.totalSize*100)),totalBytesSent:n.uploadedSize,totalBytesExpectedToSend:n.totalSize})})})}abort(){this._uploader.abort()}onProgressUpdate(t){!Y.isFunction(t)||this._callbacks.push(t)}onHeadersReceived(){}offProgressUpdate(t){let n=this._callbacks.indexOf(t);n>=0&&this._callbacks.splice(n,1)}offHeadersReceived(){}}let QA=Vi(VE,({url:e,timeout:t,header:n,formData:r,files:a,filePath:u,name:h},{resolve:b,reject:U})=>{let O=l.uploader.createUpload(e,{timeout:t,retry:0,retryInterval:0},(ge,we)=>{we?b({data:ge.responseText,statusCode:we}):U(`statusCode: ${we}`)});for(let ge in n)Y.hasOwn(n,ge)&&O.setRequestHeader(ge,String(n[ge]));for(let ge in r)Y.hasOwn(r,ge)&&O.addData(ge,String(r[ge]));a&&a.length?a.forEach(ge=>{O.addFile(pt(ge.uri),{key:ge.name||"file"})}):O.addFile(pt(u),{key:h});let D=new XA(O);return O.start(),D},UE,$E),Es={},eC=["play","canplay","ended","stop","waiting","seeking","seeked","pause"],Kh="playback",tC=e=>{let t=Es[e];!t||t.initStateChage||(t.initStateChage=!0,t.addEventListener("error",n=>{Jh({state:"error",audioId:e,errMsg:"MediaError",errCode:n.code})}),eC.forEach(n=>{t.addEventListener(n,()=>{n==="play"?t.isStopped=!1:n==="stop"&&(t.isStopped=!0),Jh({state:n,audioId:e})})}))};function nC(){let e=`${Date.now()}${Math.random()}`,t=Es[e]=l.audio.createPlayer("");return t.src="",t.volume=1,t.startTime=0,t.setSessionCategory(Kh),{errMsg:"createAudioInstance:ok",audioId:e}}function rC({audioId:e,src:t,startTime:n,autoplay:r=!1,loop:a=!1,obeyMuteSwitch:u,volume:h,sessionCategory:b=Kh,playbackRate:U}){let O=Es[e];if(O){let D={loop:a,autoplay:r};if(t){let ge=pt(t);O.src!==ge&&(O.src=D.src=ge)}n&&(O.startTime=D.startTime=n),typeof h=="number"&&(O.volume=D.volume=h),O.setStyles(D),b&&O.setSessionCategory(b),U&&O.playbackRate&&O.playbackRate(U),tC(e)}return{errMsg:"setAudioState:ok"}}function iC({audioId:e}){let t=Es[e];if(!t)return{errMsg:"getAudioState:fail"};let{src:n,startTime:r,volume:a}=t;return{errMsg:"getAudioState:ok",duration:1e3*(t.getDuration()||0),currentTime:t.isStopped?0:1e3*t.getPosition(),paused:t.isPaused(),src:n,volume:a,startTime:1e3*r,buffered:1e3*t.getBuffered()}}function oC({operationType:e,audioId:t,currentTime:n}){let r=Es[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 qu=Object.create(null),Jh=({state:e,audioId:t,errMsg:n,errCode:r})=>{let a=qu[t];if(a)if(Zh(a,e,n,r),e==="play"){let u=a.currentTime;a.__timing=N(()=>{a.currentTime!==u&&Zh(a,"timeUpdate")},200)}else(e==="pause"||e==="stop"||e==="error")&&f(a.__timing)},aC=[{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 Ku{constructor(t){this.id=t,this._callbacks={},this._options={},Hd.forEach(n=>{this._callbacks[n]=[]}),aC.forEach(n=>{let r=n.name;Object.defineProperty(this,r,{get:()=>{let a=n.cache?this._options:iC({audioId:this.id}),u=r in a?a[r]:n.default;return typeof u=="number"&&r!=="volume"?u/1e3:u},set:n.readonly?void 0:a=>{this._options[r]=a,rC(Y.extend({},this._options,{audioId:this.id}))}})}),sC()}play(){this._operate("play")}pause(){this._operate("pause")}stop(){this._operate("stop")}seek(t){this._operate("seek",{currentTime:t*1e3})}destroy(){f(this.__timing),Es[this.id]&&(Es[this.id].close(),delete Es[this.id]),delete qu[this.id]}_operate(t,n){oC(Y.extend({},n,{audioId:this.id,operationType:t}))}}let sC=te.once(()=>{Hd.forEach(e=>{Ku.prototype[e]=function(t){Y.isFunction(t)&&this._callbacks[e].push(t)}}),v_.forEach(e=>{Ku.prototype[e]=function(t){let n=this._callbacks[e],r=n.indexOf(t);r>=0&&n.splice(r,1)}})});function Zh(e,t,n,r){let a=`on${Y.capitalize(t)}`;e._callbacks[a].forEach(u=>{Y.isFunction(u)&&u(t==="error"?{errMsg:n,errCode:r}:{})})}let lC=Mt(Wm,()=>{let{audioId:e}=nC(),t=new Ku(e);return qu[e]=t,t}),cC=["canplay","play","pause","stop","ended","timeUpdate","prev","next","error","waiting"],Xh={canplay:[],play:[],pause:[],stop:[],ended:[],timeUpdate:[],prev:[],next:[],error:[],waiting:[]},Gt,Ju=null,uC=250,fC=["play","pause","ended","stop","canplay"];function dC(){Dc(),Ju=N(()=>{Bl({state:"timeUpdate"})},uC)}function Dc(){Ju!==null&&f(Ju)}function hC(){if(Gt)return;let e=st.invokeOnCallback;Gt=l.audio.createPlayer({autoplay:!0,backgroundControl:!0}),Gt.src=Gt.title=Gt.epname=Gt.singer=Gt.coverImgUrl=Gt.webUrl="",Gt.startTime=0,fC.forEach(t=>{Gt.addEventListener(t,()=>{t==="play"?(Gt.isStopped=!1,dC()):t==="stop"&&(Gt.isStopped=!0),(t==="pause"||t==="ended"||t==="stop")&&Dc();let n=`onMusic${t[0].toUpperCase()+t.slice(1)}`;e(n,{dataUrl:Gt.src,errMsg:`${n}:ok`}),Bl({state:t,dataUrl:Gt.src})})}),Gt.addEventListener("waiting",()=>{Dc(),Bl({state:"waiting",dataUrl:Gt.src})}),Gt.addEventListener("error",t=>{Dc(),e("onMusicError",{dataUrl:Gt.src,errMsg:"Error:"+t.message}),Bl({state:"error",dataUrl:Gt.src,errMsg:t.message,errCode:t.code})}),Gt.addEventListener("prev",()=>{Bl({state:"prev"})}),Gt.addEventListener("next",()=>{Bl({state:"next"})})}function gC(){let e={duration:0,currentTime:0,paused:!1,src:"",buffered:0,title:"",epname:"",singer:"",coverImgUrl:"",webUrl:"",startTime:0,errMsg:"getBackgroundAudioState:ok"};if(Gt){let t={duration:Gt.getDuration()||0,currentTime:Gt.isStopped?0:Gt.getPosition(),paused:Gt.isPaused(),src:Gt.src,buffered:Gt.getBuffered(),title:Gt.title,epname:Gt.epname,singer:Gt.singer,coverImgUrl:Gt.coverImgUrl,webUrl:Gt.webUrl,startTime:Gt.startTime};e=Y.extend(e,t)}return e}function Qh(e,t){hC();let n=["src","startTime","coverImgUrl","webUrl","singer","epname","title"];if(t==="playbackRate"){let a=e[t];Gt.playbackRate&&Gt.playbackRate(parseFloat(a));return}let r={};Object.keys(e).forEach(a=>{if(n.indexOf(a)>=0){let u=e[a];a===n[0]&&u&&(u=pt(u)),Gt[a]=r[a]=u}}),Gt.setStyles(r)}function pC({operationType:e,src:t,position:n,api:r="operateMusicPlayer",title:a,coverImgUrl:u}){var h=["resume","pause","stop"];return h.indexOf(e)>0?Gt&&Gt[e]():e==="play"?(Qh({src:t,startTime:n,title:a,coverImgUrl:u}),Gt.play()):e==="seek"&&Gt&&Gt.seekTo(n),{errMsg:`${r}:ok`}}function vC({operationType:e,src:t,startTime:n,currentTime:r}){return pC({operationType:e,src:t,position:n||r||0,api:"operateBackgroundAudio"})}function Bl({state:e,errMsg:t,errCode:n,dataUrl:r}){Xh[e].forEach(a=>{Y.isFunction(a)&&a(e==="error"?{errMsg:t,errCode:n}:{})})}let mC=te.once(()=>{cC.forEach(e=>{eg.prototype[`on${Y.capitalize(e)}`]=function(t){Xh[e].push(t)}})}),_C=[{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 eg{constructor(){this._options={},_C.forEach(t=>{let n=t.name;Object.defineProperty(this,n,{get:()=>{let r=t.cache?this._options:gC();return n in r?r[n]:t.default},set:t.readonly?void 0:r=>{this._options[n]=r,Qh(this._options,n)}})}),mC()}play(){this._operate("play")}pause(){this._operate("pause")}stop(){this._operate("stop")}seek(t){this._operate("seek",{currentTime:t})}_operate(t,n){vC(Y.extend({},n,{operationType:t}))}}let tg,bC=Mt(cb,()=>tg||(tg=new eg));class EC{constructor(t,n){this.id=t,this.ctx=n}start(t){return Ht(this.ctx,"start",t)}stop(t){return Ht(this.ctx,"stop",t)}pause(t){return Ht(this.ctx,"pause",t)}resume(t){return Ht(this.ctx,"resume",t)}switchCamera(t){return Ht(this.ctx,"switchCamera",t)}snapshot(t){return Ht(this.ctx,"snapshot",t)}toggleTorch(t){return Ht(this.ctx,"toggleTorch",t)}playBGM(t){return Ln(this.ctx,"playBGM",t)}stopBGM(t){return Ht(this.ctx,"stopBGM",t)}pauseBGM(t){return Ht(this.ctx,"pauseBGM",t)}resumeBGM(t){return Ht(this.ctx,"resumeBGM",t)}setBGMVolume(t){return Ln(this.ctx,"setBGMVolume",t)}startPreview(t){return Ht(this.ctx,"startPreview",t)}stopPreview(t){return Ht(this.ctx,"stopPreview",t)}}function ys(e,t,n,r){st.invokeViewMethod("livepusher."+e,{livePusherId:e,type:n,data:r},t)}class yC{constructor(t,n){this.id=t,this.pageId=n}start(){ys(this.id,this.pageId,"start")}stop(){ys(this.id,this.pageId,"stop")}pause(){ys(this.id,this.pageId,"pause")}resume(){ys(this.id,this.pageId,"resume")}switchCamera(){ys(this.id,this.pageId,"switchCamera")}startPreview(){ys(this.id,this.pageId,"preview")}stopPreview(){ys(this.id,this.pageId,"stop")}snapshot(){ys(this.id,this.pageId,"snapshot")}}let wC=Mt(Gm,(e,t)=>{if(t.$page.meta.isNVue){if(!t)return console.warn("uni.createLivePusherContext: 2 arguments required, but only 1 present");let n=mi(e,t);return n?new EC(e,n):console.warn("Can not find `"+e+"`")}return new yC(e,t.$page.id)},Ym),Ei=3.141592653589793,Fc=6378245,Vc=.006693421622965943;function SC(e,t){if(t=+t,e=+e,ng(e,t))return[e,t];let n=rg(e-105,t-35),r=ig(e-105,t-35),a=t/180*Ei,u=Math.sin(a);u=1-Vc*u*u;let h=Math.sqrt(u);n=n*180/(Fc*(1-Vc)/(u*h)*Ei),r=r*180/(Fc/h*Math.cos(a)*Ei);let b=t+n,U=e+r;return[e*2-U,t*2-b]}function AC(e,t){if(t=+t,e=+e,ng(e,t))return[e,t];let n=rg(e-105,t-35),r=ig(e-105,t-35),a=t/180*Ei,u=Math.sin(a);u=1-Vc*u*u;let h=Math.sqrt(u);n=n*180/(Fc*(1-Vc)/(u*h)*Ei),r=r*180/(Fc/h*Math.cos(a)*Ei);let b=t+n;return[e+r,b]}let ng=function(e,t){return e<72.004||e>137.8347||t<.8293||t>55.8271||!1},rg=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*Ei)+20*Math.sin(2*e*Ei))*2/3,n+=(20*Math.sin(t*Ei)+40*Math.sin(t/3*Ei))*2/3,n+=(160*Math.sin(t/12*Ei)+320*Math.sin(t*Ei/30))*2/3,n},ig=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*Ei)+20*Math.sin(2*e*Ei))*2/3,n+=(20*Math.sin(e*Ei)+40*Math.sin(e/3*Ei))*2/3,n+=(150*Math.sin(e/12*Ei)+300*Math.sin(e/30*Ei))*2/3,n};function og(e,t,n){let r=t.coords;if(e!==t.coordsType){let a;e==="wgs84"?a=SC(r.longitude,r.latitude):e==="gcj02"&&(a=AC(r.longitude,r.latitude)),a&&(r.longitude=a[0],r.latitude=a[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 CC=ye(W0,({type:e="wgs84",geocode:t=!1,altitude:n=!1,highAccuracyExpireTime:r,isHighAccuracy:a=!1},{resolve:u,reject:h})=>{l.geolocation.getCurrentPosition(b=>{og(e,b,u)},b=>{if(b.code===1501){og(e,b,u);return}h("getLocation:fail "+b.message)},{geocode:t,enableHighAccuracy:a||n,timeout:r,coordsType:e})},Y0,G0),OC=ye(j0,(e,{resolve:t,reject:n})=>{let a=Ih()!=="light",u,h=ri({url:"__uniappchooselocation",data:Y.extend({},e,{locale:Ql()}),style:{animationType:e.animationType||"slide-in-bottom",titleNView:!1,popGesture:"close",scrollIndicator:"none"},onMessage({event:b,detail:U}){b==="selected"&&(u=U)},onClose(){a&&l.navigator.setStatusBarStyle("dark"),u?t(u):n("cancel")}});a&&(l.navigator.setStatusBarStyle("light"),h.webview.addEventListener("popGesture",({type:b,result:U})=>{b==="start"?l.navigator.setStatusBarStyle("dark"):b==="end"&&!U&&l.navigator.setStatusBarStyle("light")}))},z0),TC=ye(q0,(e,{resolve:t,reject:n})=>(ri({url:"__uniappopenlocation",data:Y.extend({},e,{locale:Ql()}),style:{titleNView:{type:"transparent"},popGesture:"close",backButtonAutoControl:"close"},onClose(){n("cancel")}}),t()),J0,K0),PC=ye(Ry,({title:e="",content:t="",showCancel:n=!0,cancelText:r,cancelColor:a,confirmText:u,confirmColor:h,editable:b=!1,placeholderText:U=""}={},{resolve:O})=>{let D=n?[r,u]:[u],ge=b?U:D;t=t||" ",l.nativeUI[b?"prompt":"confirm"](t,we=>{if(n){let ke=we.index===1,Et={confirm:ke,cancel:we.index===0||we.index===-1};ke&&b&&(Et.content=we.value),O(Et)}else{let ke={confirm:we.index===0,cancel:!1};b&&(ke.content=we.value),O(ke)}},e,ge,D)},xy,By),IC=ye(Oy,({itemList:e=[],itemColor:t="#000000",title:n="",popover:r},{resolve:a,reject:u})=>{Mn();let{t:h}=X(),b={title:n,cancel:h("uni.showActionSheet.cancel"),buttons:e.map(U=>({title:U,color:t}))};l.nativeUI.actionSheet(Y.extend(b,{popover:r}),U=>{U.index>0?a({tapIndex:U.index-1}):u("showActionSheet:fail cancel")})},Ty,Py),lc,Zu=!1,$c="",Uc,NC=ye(Iy,(e,t)=>ag(Y.extend({},e,{type:"loading",icon:"loading"}),t),Ny,ky),ag=({title:e="",icon:t="success",image:n="",duration:r=1500,mask:a=!1,position:u,type:h="toast",style:b},{resolve:U,reject:O})=>{if(Hc(""),$c=h,["top","center","bottom"].includes(String(u)))l.nativeUI.toast(e,{verticalAlign:u}),Zu=!0;else{t&&!~["success","loading","error","none"].indexOf(t)&&(t="success");let D={modal:a,back:"transmit",padding:"10px",size:"16px"};!n&&(!t||t==="none")?D.loading={display:"none"}:(D.width="140px",D.height="112px"),n?D.loading={display:"block",height:"55px",icon:n,interval:r}:["success","error"].indexOf(t)!==-1&&(D.loading={display:"block",height:"55px",icon:t==="success"?"__uniappsuccess.png":"__uniapperror.png",interval:r});try{lc=l.nativeUI.showWaiting(e,Y.extend(D,b))}catch(ge){O(`${ge}`)}}return $c==="toast"&&(Uc=k(()=>{Hc("")},r)),U()},kC=ye(My,ag,Dy,Fy),RC=ye(gy,(e,t)=>Hc("toast",t)),xC=ye(hy,(e,t)=>Hc("loading",t));function Hc(e="toast",t){return e&&e!==$c||(Uc&&(S(Uc),Uc=null),Zu?l.nativeUI.closeToast():lc&&lc.close&&lc.close(),lc=null,Zu=!1,$c=""),t&&t.resolve()}let BC=ye(Vy,(e,{resolve:t,reject:n})=>{let r=Ph();if(r&&r.endPullToRefresh(),r=Bc(),!r)return n();r.beginPullToRefresh(),Uu(r),t()}),MC=ye($y,(e,{resolve:t,reject:n})=>{let r=Ph()||Bc();if(!r)return n();r.endPullToRefresh(),Uu(null),t()}),LC=ye(bh,(e,{resolve:t,reject:n})=>{let r=fr(Lr());st.invokeViewMethod(bh,e,r,a=>{a?n(a):t()})},py),DC=ye(Eh,(e,{resolve:t})=>{let n=fr(Lr());st.invokeViewMethod(Eh,e,n,t)},Ay,Cy),FC=ye(Ey,({__page__:e,title:t},{resolve:n,reject:r})=>{let a=Oh(e);if(a){let u=a.getStyle();u&&u.titleNView&&a.setStyle({titleNView:{titleText:t}}),n()}else r()},yy),VC=ye(wy,(e,{resolve:t})=>{l.nativeUI.showWaiting("",{modal:!1}),t()}),$C=ye(Sy,(e,{resolve:t})=>{l.nativeUI.closeWaiting(),t()});function UC(e){let t=Vn();!t.length||(t[t.length-1].$page.statusBarStyle=e)}let HC=ye(my,({__page__:e,frontColor:t,backgroundColor:n},{resolve:r,reject:a})=>{let u=Oh(e);if(u){let h={};t&&(h.titleColor=t),n&&(h.backgroundColor=n);let b=t==="#000000"?"dark":"light";l.navigator.setStatusBarStyle(b),UC(b);let U=u.getStyle();U&&U.titleNView&&(U.titleNView.autoBackButton&&(h.backButton=h.backButton||{},h.backButton.color=t),u.setStyle({titleNView:h})),r()}else a()},by,_y),jC=ye(aw,({index:e,text:t},{resolve:n,reject:r})=>{li.setTabBarBadge("text",e,t),n()},sw,lw),zC=ye(Uy,({index:e,text:t,iconPath:n,selectedIconPath:r,pagePath:a,visible:u,iconfont:h},{resolve:b})=>{if(li.setTabBarItem(e,t,n,r,u,h),a){let U=T.tabBar.list[e];if(U){let O=U.pagePath,D=te.removeLeadingSlash(a);D!==O&&La(e,O,D)}}b()},Hy,jy),WC=ye(zy,(e={},{resolve:t,reject:n})=>{if(!ic())return n("not TabBar page");let r={black:"rgba(0,0,0,0.4)",white:"rgba(255,255,255,0.4)"},a=e.borderStyle;a&&a in r&&(e.borderStyle=r[a]),li.setTabBarStyle(e),t()},Wy,Yy),GC=ye(qy,(e,{resolve:t,reject:n})=>{let r=e&&e.animation;if(!ic())return n("not TabBar page");li.hideTabBar(Boolean(r)),t()},yh),YC=ye(Ky,(e,{resolve:t,reject:n})=>{let r=e&&e.animation;if(!ic())return n("not TabBar page");li.showTabBar(Boolean(r)),t()},Jy),qC=ye(ew,({index:e},{resolve:t,reject:n})=>{li.setTabBarBadge("redDot",e),t()},tw,nw),sg=e=>li.setTabBarBadge("none",e),KC=ye(rw,({index:e},{resolve:t,reject:n})=>{sg(e),t()},iw,ow),JC=ye(Zy,({index:e},{resolve:t,reject:n})=>{sg(e),t()},Xy,Qy),lg="vdSync",ZC="__uniapp__service",Ml="onWebviewReady",XC=0,QC="webviewInserted",eO="webviewRemoved",cg="UniAppSubNVue";class tO{constructor(t,n){this.callbacks=[];let r=this.webview=l.webview.getWebviewById(t);if(this.isSub=n||!1,r.__uniapp_mask_id){let a=this.maskWebview=r.__uniapp_mask_id==="0"?{setStyle({mask:h}){Ho("uni-tabview").setMask({color:h})}}:l.webview.getWebviewById(r.__uniapp_mask_id),u=function(){a.setStyle({mask:"none"})};r.addEventListener("hide",u),r.addEventListener("close",u)}}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===cg){let a=r.data.target;a.id===this.webview.id&&a.isSub===this.isSub&&this.callbacks.forEach(u=>{u({origin:this.webview.__uniapp_host,data:r.data.data})})}};Ho("globalEvent").addEventListener("plusMessage",t),this.webview.addEventListener("close",()=>{this.callbacks.length=0})}postMessage(t){l.webview.postMessageToUniNView({type:cg,data:t,target:{id:this.webview.id,isSub:!this.isSub}},ZC)}onMessage(t){this.initMessage(),this.callbacks.push(t)}}let nO=function(e,t){return new tO(e,t)},cc,ug=l.navigator.setStatusBarStyle;function rO(e){ug=e}function fg(e){cc=e,ug(e)}l.navigator.setStatusBarStyle=fg;function Za(e){if(!e){let t=_r();if(!t||(e=t.$page.statusBarStyle,!e||e===cc))return}e!==cc&&(cc=e,l.navigator.setStatusBarStyle(e))}function iO(e,t,n,r,a,u,h){l!==n&&(A=En=e,g=t,l=n,rO(l.navigator.setStatusBarStyle),l.navigator.setStatusBarStyle=fg,k=r,S=a,N=u,f=h),T.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 dg={oauth(e){l.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){l.share.getServices(t=>{t=t;let n=[];t.forEach(({id:r})=>{n.push(r)}),e(null,n,t)},t=>{e(t)})},payment(e){l.payment.getChannels(t=>{let n=[];t.forEach(({id:r})=>{n.push(r)}),e(null,n,t)},t=>{e(t)})},push(e){if(typeof g!="undefined"||typeof l!="undefined"){let t=l.push.getClientInfo();e(null,[t.id],[t])}else e(null,[])}},aO=ye(cw,({service:e},{resolve:t,reject:n})=>{dg[e]?dg[e]((r,a=[],u=[])=>{r?n(r.message):t({service:e,provider:a,providers:u.map(h=>(typeof h.serviceReady=="boolean"&&(h.isAppExist=h.serviceReady),typeof h.nativeClient=="boolean"&&(h.isAppExist=h.nativeClient),h))})}):n("service not found")},uw),jc;function uc(e){return new Promise((t,n)=>{l.oauth.getServices(r=>{let a=r.find(({id:u})=>u===e);a?t(a):n(new Error("provider not find"))},n)})}let hg=ye(fw,(e,{resolve:t,reject:n})=>{let r=e.provider||"weixin",a=ar(n),u=r==="apple",h=u?{scope:"email"}:e.univerifyStyle?{univerifyStyle:cO(e.univerifyStyle,a)}:{};uc(r).then(b=>{function U(){if(e.onlyAuthorize&&r==="weixin"){b.authorize(({code:O})=>{t({code:O,authResult:""})},a);return}b.login(O=>{let D=O.target.authResult,ge=O.target.appleInfo;t({code:D.code,authResult:D,appleInfo:ge})},a,h)}u||r==="univerify"?U():b.logout(U,U)}).catch(a)},dw),gg=(e,{resolve:t,reject:n})=>{let r=e.provider||"weixin",a=ar(n);uc(r).then(u=>{u.getUserInfo(h=>{let b={nickName:""};if(r==="weixin"){let O=u.userInfo;O&&(b={openId:O.openid,nickName:O.nickname,gender:O.sex,city:O.city,province:O.province,country:O.country,avatarUrl:O.headimgurl,unionId:O.unionid})}else if(r==="apple"){let O=u.appleInfo;O&&(b={openId:O.user,fullName:O.fullName,email:O.email,authorizationCode:O.authorizationCode,identityToken:O.identityToken,realUserStatus:O.realUserStatus})}else b=u.userInfo,b&&(b.openId=b.openId||b.openid||u.authResult.openid,b.nickName=b.nickName||b.nickname,b.avatarUrl=b.avatarUrl||b.headimgurl);let U={};e.data&&e.data.api_name==="webapi_getuserinfo"?U.data={data:JSON.stringify(b),rawData:"",signature:"",encryptedData:"",iv:""}:U.userInfo=b,t(U)},a)}).catch(()=>{n("\u8BF7\u5148\u8C03\u7528 uni.login")})},sO=ye(hw,gg,gw),lO=ye(pw,gg,vw),pg=ye(mw,({provider:e},{resolve:t,reject:n})=>{let r=Ys(t),a=ar(n);uc(e).then(u=>u.preLogin(r,a)).catch(a)},Ew,bw),vg=()=>uc("univerify").then(e=>e.closeAuthView()),mg=Mt(yw,vg),_g=ye(ww,(e,{resolve:t,reject:n})=>{let r=Ys(t),a=ar(n);try{uc("univerify").then(u=>{let h=u.getCheckBoxState();r({state:h})})}catch(u){a(u)}});function cO(e,t){return Y.isPlainObject(e)&&Y.isPlainObject(e.buttons)&&Y.toTypeString(e.buttons.list)==="[object Array]"&&e.buttons.list.forEach((n,r)=>{e.buttons.list[r].onclick=function(){let a={code:"30008",message:"\u7528\u6237\u70B9\u51FB\u4E86\u81EA\u5B9A\u4E49\u6309\u94AE",index:r,provider:n.provider};Y.isPlainObject(jc)?jc._triggerUniverifyButtonsClick(a):vg().then(()=>{t(a)})}}),e}class uO{constructor(){this.provider="univerify",this.eventName="api.univerifyButtonsClick"}close(){return mg()}login(t){return hg(this._getOptions(t))}getCheckBoxState(t){return _g(t)}preLogin(t){return pg(this._getOptions(t))}onButtonsClick(t){st.on(this.eventName,t)}offButtonsClick(t){st.off(this.eventName,t)}_triggerUniverifyButtonsClick(t){st.emit(this.eventName,t)}_getOptions(t={}){return Y.extend({},t,{provider:this.provider})}}let fO=Mt(Sw,()=>jc||(jc=new uO)),dO=ye(Rw,(e,{resolve:t,reject:n})=>{let r=Gh();if(r.notificationAuthorized!=="authorized")return n("notificationAuthorized: "+r.notificationAuthorized);let a=Y.extend({},e);delete a.content,delete a.payload,l.push.createMessage(e.content,e.payload,a),t()},void 0,xw),hO=Mt("registerRuntime",e=>{Y.extend(jsRuntime,e)}),gO={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"}},pO=e=>{e.type=e.type||0;let{provider:t,type:n,title:r,summary:a,href:u,imageUrl:h,mediaUrl:b,scene:U,miniProgram:O,openCustomerServiceChat:D,corpid:ge,customerUrl:we}=e;Y.isString(h)&&h&&(h=pt(h));let ke=gO[n];if(ke){let Et={provider:t,type:ke.name,title:r,content:a,href:u,pictures:[h],thumbs:h?[h]:void 0,media:b,miniProgram:O,extra:{scene:U},openCustomerServiceChat:D,corpid:ge,url:we};return t==="weixin"&&(n===1||n===2)&&delete Et.thumbs,Et}return"\u5206\u4EAB\u53C2\u6570 type \u4E0D\u6B63\u786E"},bg=function(e,t,n,r,a="share"){let u=ar(r),h=t.openCustomerServiceChat?"openCustomerServiceChat":"send";try{e[h](t,()=>{n()},u)}catch(b){u({message:`${t.provider} ${h} \u65B9\u6CD5\u8C03\u7528\u5931\u8D25`})}},vO=ye(Aw,(e,{resolve:t,reject:n})=>{let r=pO(e),a=ar(n);if(Y.isString(r))return n(r);l.share.getServices(u=>{let h=u.find(({id:b})=>b===r.provider);h?h.authenticated?bg(h,r,t,n):h.authorize(()=>bg(h,r,t,n),a):n("service not found")},a)},Ow,Cw),mO=ye(Tw,({type:e,imageUrl:t,summary:n,href:r},{resolve:a,reject:u})=>{let h=ar(u);Y.isString(t)&&t&&(t=pt(t)),l.share.sendWithSystem({type:e,pictures:t?[t]:void 0,content:n,href:r},()=>a(),h)},Iw,Pw),_O=ye(Nw,(e,{resolve:t,reject:n})=>{let r=e.provider,a=ar(n);l.payment.getChannels(u=>{let h=u.find(({id:b})=>b===r);h?l.payment.request(h,e.orderInfo,b=>{t(b)},a):n("service not found")},a)},kw),Eg=Fh,bO=ye("navigateToMiniProgram",(e,{resolve:t,reject:n})=>{Eg("navigateToUniMP",e,r=>{if(r.errMsg&&r.errMsg.indexOf(":ok")===-1)return n(r.errMsg.split(" ")[1]);t()})}),yg=[];function wg(e){yg.push(e)}let EO=wg;function yO(e,t){yg.forEach(n=>n(e,t))}function wO(e,t,...n){let r=CO(e,t,n);r&&console[e](r)}function SO(){return typeof __channelId__=="string"&&__channelId__}function AO(e,t){switch(Y.toRawType(t)){case"Function":return"function() { [native code] }";default:return t}}function CO(e,t,n){return SO()?(n.push(t.replace("at ","uni-app:///")),console[e].apply(console,n)):n.map(function(a){let u=Y.toTypeString(a).toLowerCase();if(["[object object]","[object array]","[object module]"].indexOf(u)!==-1)try{a="---BEGIN:JSON---"+JSON.stringify(a,AO)+"---END:JSON---"}catch(h){a=u}else if(a===null)a="---NULL---";else if(a===void 0)a="---UNDEFINED---";else{let h=Y.toRawType(a).toUpperCase();h==="NUMBER"||h==="BOOLEAN"?a="---BEGIN:"+h+"---"+a+"---END:"+h+"---":a=String(a)}return a}).join("---COMMA---")+" "+t}let Ao={load:"load",close:"close",error:"error",adClicked:"adClicked"};class Sg{constructor(){this._callbacks={}}onLoad(t){this._addEventListener(Ao.load,t)}onClose(t){this._addEventListener(Ao.close,t)}onError(t){this._addEventListener(Ao.error,t)}offLoad(t){this._removeEventListener(Ao.load,t)}offClose(t){this._removeEventListener(Ao.close,t)}offError(t){this._removeEventListener(Ao.error,t)}_addEventListener(t,n){!Y.isFunction(n)||(this._callbacks[t]||(this._callbacks[t]=[]),this._callbacks[t].push(n))}_removeEventListener(t,n){let r=this._callbacks[t],a=r.indexOf(n);a>-1&&r.splice(a,1)}_dispatchEvent(t,n){this._callbacks[t].forEach(r=>{r(n||{})})}}class Xu extends Sg{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(Ao.load,{})}),r.onClose(a=>{this._isLoaded=!1,this._isLoading=!1,this._dispatchEvent(Ao.close,a),this.preload===!0&&this._loadAd()}),r.onError(a=>{this._isLoading=!1;let u={code:a.code,errMsg:a.message};this._dispatchEvent(Ao.error,u);let h=new Error(JSON.stringify(u));this._loadPromiseReject!=null&&(this._loadPromiseReject(h),this._loadPromiseReject=null),this._showPromiseReject!=null&&(this._showPromiseReject(h),this._showPromiseReject=null)}),r.onAdClicked&&r.onAdClicked(()=>{this._dispatchEvent(Ao.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 Xu{constructor(t){super(l.ad.createRewardedVideoAd(t),t);this._loadAd()}}let TO=Mt(Bw,e=>new OO(e),Lw,Mw);class PO extends Xu{constructor(t){super(l.ad.createFullScreenVideoAd(t),t);this.preload=!1}}let IO=Mt(Dw,e=>new PO(e),Vw,Fw);class NO extends Xu{constructor(t){super(l.ad.createInterstitialAd(t),t);this.preload=!1,this._loadAd()}}let kO=Mt($w,e=>new NO(e),Hw,Uw),ga={},Ks={};function RO(e){let t=e.provider;if(ga[t]||(ga[t]={}),typeof ga[t].plugin=="object"){e.success(ga[t].plugin);return}if(Ks[t]||(Ks[t]=[]),Ks[t].push(e),ga[t].status===!0){e.__plugin=ga[t].plugin;return}ga[t].status=!0;let n=Ho(t);if(!n||!n.initSDK){Ks[t].forEach(r=>{r.fail({code:-1,message:"provider ["+t+"] invalid"})}),Ks[t].length=0,ga[t].status=!1;return}ga[t].plugin=n,e.__plugin=n,n.initSDK(r=>{let a=r.code===1||r.code==="1";a?ga[t].plugin=n:ga[t].status=!1,Ks[t].forEach(u=>{a?u.success(u.__plugin):u.fail(r)}),Ks[t].length=0})}class xO extends Sg{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,k(()=>{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(Ao.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(Ao.load,t)},t=>{this._isLoading=!1,this._showPromiseReject!=null&&(this._showPromiseReject(this._createError(t)),this._showPromiseReject=null),this._dispatchEvent(Ao.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(Ao.error,t)})}_createError(t){return new Error(JSON.stringify(t))}}let BO=Mt(jw,e=>new xO(e),Ww,zw),Ag=l.os.name==="Android"&&parseInt(l.os.version)<6,MO=Ag?"slide-in-right":"pop-in",zc=300,Cg=Ag?"slide-out-right":"pop-out",LO="_www/__uniappview.html",DO="webviewId",FO="uniMPNativeEvent";function VO(e,t,n){n&&t.isNVue&&(e.uniNView={path:n,defaultFontSize:T.defaultFontSize,viewport:T.viewport})}let $O=/^#[a-z0-9]{6}$/i;function Og(e){return e&&($O.test(e)||e==="transparent")}function UO(e,t){let{backgroundColor:n}=t;!n||!Og(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=l.os.name==="iOS"?"appback":"none")}function jO(e,t){if(!t.enablePullDownRefresh)return;let n=Cs(Y.extend({},l.os.name==="Android"?WO:GO,t.pullToRefresh));e.pullToRefresh=zO(n,t)}function zO(e,t){let n=oo(e);if(!n)return e;let[r,a,u]=n;return(r||a||u)&&gt.onLocaleChange(()=>{let h=l.webview.getWebviewById(t.id+"");if(!h)return;let b={support:!0};r&&(b.contentdown={caption:e.contentdown.caption}),a&&(b.contentover={caption:e.contentover.caption}),u&&(b.contentrefresh={caption:e.contentrefresh.caption}),h.setStyle({pullToRefresh:b})}),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 a={autoBackButton:r};Object.keys(n).forEach(u=>{let h=n[u];u==="backgroundColor"?a.backgroundColor=Og(h)?h:te.BACKGROUND_COLOR:u==="titleImage"&&h?a.tags=KO(h):u==="buttons"&&Y.isArray(h)?a.buttons=h.map((b,U)=>(b.onclick=JO(U),b)):a[u]=h}),e.titleNView=qO(a,t)}function qO(e,t){let n=bo(e);if(!n)return e;let[r,a]=n;return(r||a)&&gt.onLocaleChange(()=>{let u=l.webview.getWebviewById(t.id+"");if(!u)return;let h={};r&&(h.titleText=e.titleText),a&&(h.searchInput={placeholder:e.searchInput.placeholder}),u.setStyle({titleNView:h})}),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,jn(te.ON_NAVIGATION_BAR_BUTTON_TAP,n)}}function Tg(e,t,n){let r={bounce:"vertical"};return Object.keys(t).forEach(a=>{ZO.indexOf(a)===-1&&(r[a]=t[a])}),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"],Pg=2;function Ig(){return Pg}function Ng(){return Pg++}function kg(e){return e}function Rg(e,t){let n=t?te.stringifyQuery(t,kg):"";return{path:e.slice(1),query:n&&n.slice(1)}}function XO(e,t,n){let r=n?te.stringifyQuery(n,kg):"";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 a=Ng(),u=Tg(e,n.meta,{id:a+""});return u.uniPageUrl=Rg(e,t),u.isTab=!!n.meta.isTabBar,l.webview.create("",String(a),u,Y.extend({nvue:!0,__path__:e,__query__:JSON.stringify(t)},r))}let Bi;function xg(e){Bi=e}function eT(){return Bi}function tT(){return(!Bi||Bi.__uniapp_route)&&(Bi=l.webview.create(LO,String(Ng()),{contentAdjust:!1})),Bi}function nT(e){let{popupSubNVueWebviews:t}=e;!t||e.addEventListener("close",()=>{Object.keys(t).forEach(n=>{t[n].close("none")})})}function Bg(e){return T.realEntryPagePath&&e.$page.route===T.entryPagePath}function Mg(){T.entryPagePath=T.realEntryPagePath,delete T.realEntryPagePath,gt.reLaunch({url:te.addLeadingSlash(T.entryPagePath)})}function rT(e){let t;e.addEventListener("popGesture",n=>{if(n.type==="start"){let r=Vn(),a=r[r.length-2];t=cc;let u=a&&a.$page.statusBarStyle;u&&Za(u)}else if(n.type==="end"&&!n.result)Za(t);else if(n.type==="end"&&n.result){let r=Vn().length,a=_r();Do(),Za(),a&&r===1&&Bg(a)?Mg():jn(te.ON_SHOW)}})}function iT(e){if(e.nvue)return;let t=e.id,{subscribe:n,unsubscribe:r}=st,a=(u,h)=>{if(t!==h)return;r(Ml,a);let b=co(parseInt(h));b&&b.__page_container__.restore()};e.addEventListener("recovery",()=>{n(Ml,a)})}function oT(e){let{emit:t}=st,n=function({width:r,height:a}){let h={deviceOrientation:Math.abs(l.navigator.getOrientation())===90?"landscape":"portrait",size:{windowWidth:Math.ceil(r),windowHeight:Math.ceil(a)}};t(te.ON_RESIZE,h,parseInt(e.id))};e.addEventListener("resize",te.debounce(n,50,{setTimeout:k,clearTimeout:S}))}let Lg={pullToRefresh:te.ON_PULL_DOWN_REFRESH,titleNViewSearchInputChanged:te.ON_NAVIGATION_BAR_SEARCH_INPUT_CHANGED,titleNViewSearchInputConfirmed:te.ON_NAVIGATION_BAR_SEARCH_INPUT_CONFIRMED,titleNViewSearchInputClicked:te.ON_NAVIGATION_BAR_SEARCH_INPUT_CLICKED,titleNViewSearchInputFocusChanged:te.ON_NAVIGATION_BAR_SEARCH_INPUT_FOCUS_CHANGED};function aT(e){let t=parseInt(e.id);Object.keys(Lg).forEach(n=>{let r=Lg[n];e.addEventListener(n,a=>{r===te.ON_PULL_DOWN_REFRESH&&Uu(e),jn(t,r,a)})}),nT(e),oT(e),l.os.name==="iOS"&&(iT(e),rT(e))}function sT(e,t,n,r){let a=Tg(t,r,e);a.uniPageUrl=Rg(t,n);let u=!!r.isTabBar;r.isNVue?a.isTab=u:a.debugRefresh=XO(u,t,n),a.locale=g.requireModule("plus").getLanguage(),e.setStyle(a)}function lT(e,t,n){(n.subNVues||[]).forEach(a=>{if(!a.path)return;let u=xo(a.style||{}),h=a.type==="navigationBar",b=a.type==="popup";u.uniNView={path:a.path.replace(".nvue",".js"),defaultFontSize:T.defaultFontSize,viewport:T.viewport};let U={__uniapp_host:t,__uniapp_origin:u.uniNView.path.split("?")[0].replace(".js",""),__uniapp_origin_id:e.id,__uniapp_origin_type:e.__uniapp_type},O;h?(u.position="dock",u.dock="top",u.top="0",u.width="100%",u.height=String(te.NAVBAR_HEIGHT+Hu()),delete u.left,delete u.right,delete u.bottom,delete u.margin):b&&(u.position="absolute",ic(t)?O=li:O=e,U.__uniapp_mask=u.mask||"rgba(0,0,0,0.5)",U.__uniapp_mask_id=O.id),delete u.mask;let D=l.webview.create("",a.id,u,U);if(b){O.popupSubNVueWebviews||(O.popupSubNVueWebviews={}),O.popupSubNVueWebviews[D.id]=D;let ge=function(){O.setStyle({mask:"none"}),D.hide("auto")};O.addEventListener("maskClick",ge);let we=!1;D.addEventListener("show",()=>{we||(l.key.removeEventListener("backbutton",Yi),l.key.addEventListener("backbutton",ge),we=!0)}),D.addEventListener("hide",()=>{we&&(l.key.removeEventListener("backbutton",ge),l.key.addEventListener("backbutton",Yi),we=!1)}),D.addEventListener("close",()=>{delete O.popupSubNVueWebviews[D.id],we&&(l.key.removeEventListener("backbutton",ge),l.key.addEventListener("backbutton",Yi),we=!1)})}else e.append(D)})}function cT(e,t,n,r){(e.id==="1"||!r.isNVue)&&sT(e,t,n,r),lT(e,t,r),aT(e)}function Dg(e){return e.routeOptions.meta.isNVue?QO(e):Ig()===2?l.webview.getLaunchWebview():eT()}function Fg(e,t){st.once(Ml+"."+e,t)}let pa=!1;function Vg(e,t,n){pa={path:e,nvue:Ea(e).isNVue,callback:t}}function $g(e,t,n){uo(e),Js(e.$getAppWebview(),t,n)}function Wc(e,t,n=!1){if(!n&&pa)return console.error(`Waiting to navigate to: ${pa.path}, do not operate continuously: ${e}.`);if(T.renderer==="native")return Vn().length===0?Vg(e,t,"waitForReady"):t();let r=!Bi||Bi&&Bi.__uniapp_route,a=Bi&&!Bi.loaded;r||a?Vg(e,t,r?"waitForCreate":"waitForReady"):t(),a&&Fg(Bi.id,Gc)}function Gc(){if(!pa)return;let{callback:e}=pa;return pa=!1,e()}function Ug(){if(T.renderer==="native")return pa&&pa.nvue?Gc():void 0;let e=tT();if(!!pa){if(pa.nvue)return Gc();e.loaded?pa.callback():Fg(e.id,Gc)}}function Js(e,t,n){e[e.__preload__?"hide":"close"](t,n)}function Yc(e,t,n,r,a){typeof a=="undefined"&&(a=e.nvue?0:100);let u=function(){u._called||(u._called=!0,r&&r(),Ug())};u._called=!1,k(()=>{let h=k(()=>{u()},n+150);e.show(t,n,()=>{u._called||S(h),u()})},a)}function uT(e,t){let n=e.children();if(!n||!n.length)return t();let r=n.find(a=>a.id.indexOf(DO)===0)||n[0];r.canBack(({canBack:a})=>{a?r.back():t()})}let fT=ye(XE,(e,{resolve:t,reject:n})=>{let r=_r();if(!r)return n("getCurrentPages is empty");if(jn(r,te.ON_BACK_PRESS,{from:e.from||"navigateBack"}))return t();if(gt.hideToast(),gt.hideLoading(),r.$page.meta.isQuit)dT();else if(Bg(r))Mg();else{let{delta:a,animationType:u,animationDuration:h}=e;hT(a,u,h)}return t()},ey,uy),qc=0;function dT(){tn(),qc?Date.now()-qc<2e3&&l.runtime.quit():(qc=Date.now(),l.nativeUI.toast(X().t("uni.app.quit")),k(()=>{qc=0},2e3))}function hT(e,t,n){let r=Vn(),a=r.length,u=r[a-1];e>1&&r.slice(a-e,a-1).reverse().forEach(U=>{Js(l.webview.getWebviewById(U.$page.id+""),"none",0)});let h=function(U){t?Js(U,t,n||zc):u.$page.openType==="redirectTo"?Js(U,Cg,zc):Js(U,"auto"),r.slice(a-e,a).forEach(O=>uo(O)),Za(),jn(te.ON_SHOW)},b=l.webview.getWebviewById(u.$page.id+"");if(!u.__uniapp_webview)return h(b);uT(b,()=>{h(b)})}class gT extends te.UniNode{constructor(t,n,r=!1){super(te.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=[te.ACTION_TYPE_PAGE_CREATE,n],this.createdAction=[te.ACTION_TYPE_PAGE_CREATED],this.normalizeDict=this._normalizeDict.bind(this),this._update=this.update.bind(this),r&&this.setup()}_normalizeDict(t,n=!0){if(!Y.isPlainObject(t))return this.addDict(t);let r=[];return Object.keys(t).forEach(a=>{let u=[this.addDict(a)],h=t[a];n?u.push(this.addDict(h)):u.push(h),r.push(u)}),r}addDict(t){let{dicts:n}=this,r=n.indexOf(t);return r>-1?r:n.push(t)-1}onInjectHook(t){(t===te.ON_PAGE_SCROLL||t===te.ON_REACH_BOTTOM)&&!this.scrollAction&&(this.scrollAction=[te.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&&ET(this,t.nodeId,n,r)}onAddWxsEvent(t,n,r,a){t.parentNode&&yT(this,t.nodeId,n,r,a)}onRemoveEvent(t,n){t.parentNode&&wT(this,t.nodeId,n)}onSetAttribute(t,n,r){t.parentNode&&AT(this,t.nodeId,n,r)}onRemoveAttribute(t,n){t.parentNode&&CT(this,t.nodeId,n)}onTextContent(t,n){t.parentNode&&jg(this,t.nodeId,n)}onNodeValue(t,n){t.parentNode&&jg(this,t.nodeId,n)}genId(){return this._id++}push(t,n){if(!this.isUnmounted){switch(t[0]){case te.ACTION_TYPE_CREATE:this._createActionMap.set(t[1],t);break;case te.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]!==te.ACTION_TYPE_INSERT&&this.updateActions.push(t),this._updating||(this._updating=!0,En.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([XC,t]),this.send(n)),this.clear()}clear(){this.dicts.length=0,this.updateActions.length=0,this._updating=!1,this._createActionMap.clear()}send(t){st.publishHandler(lg,t,this.pageId)}fireEvent(t,n){let r=Hg(t,this);r&&r.dispatchEvent(n)}}function pT(e){let t=co(e);return t?t.__page_container__:null}function Qu(e,t,n){if(typeof n=="number"&&(n=pT(n)),n[e]===t)return n;let{childNodes:r}=n;for(let a=0;a<r.length;a++){let u=Qu(e,t,r[a]);if(u)return u}return null}function Hg(e,t){return Qu("nodeId",e,t)}function vT(e,t){return Qu("nodeName",e.toUpperCase(),t)}function mT(e,t,n){e.push([te.ACTION_TYPE_CREATE,t,e.addDict(n),-1,-1])}function _T(e,t,n,r){let a=t.toJSON({attr:!0,normalize:e.normalizeDict});e.push([te.ACTION_TYPE_INSERT,t.nodeId,n,r],Object.keys(a).length?a:void 0)}function bT(e,t){e.push([te.ACTION_TYPE_REMOVE,t])}function ET(e,t,n,r){e.push([te.ACTION_TYPE_ADD_EVENT,t,e.addDict(n),r])}function yT(e,t,n,r,a){e.push([te.ACTION_TYPE_ADD_WXS_EVENT,t,e.addDict(n),e.addDict(r),a])}function wT(e,t,n){e.push([te.ACTION_TYPE_REMOVE_EVENT,t,e.addDict(n)])}function ST(e,t,n){return t==="style"&&Y.isPlainObject(n)?e.normalizeDict(n):e.addDict(n)}function AT(e,t,n,r){e.push([te.ACTION_TYPE_SET_ATTRIBUTE,t,e.addDict(n),ST(e,n,r)])}function CT(e,t,n){e.push([te.ACTION_TYPE_REMOVE_ATTRIBUTE,t,e.addDict(n)])}function jg(e,t,n){e.push([te.ACTION_TYPE_SET_TEXT,t,e.addDict(n)])}function OT(e,t,n){return new gT(e,t,n)}function zg(e){let t=e.setup;return e.inheritAttrs=!1,e.setup=(n,r)=>{let{attrs:{__pageId:a,__pagePath:u,__pageQuery:h,__pageInstance:b}}=r,O=En.getCurrentInstance().proxy;if(Ge(O,b),fn(Wg(a,O,b)),En.onMounted(()=>{En.nextTick(()=>{jn(O,te.ON_READY)})}),En.onBeforeUnmount(()=>{jn(O,te.ON_UNLOAD)}),t)return t(h,r)},e}function Wg(e,t,n){let r=()=>l.webview.getWebviewById(e+"");return t.$getAppWebview=r,t.$.ctx.$scope={$getAppWebview:r},t.getOpenerEventChannel=()=>(n.eventChannel||(n.eventChannel=new te.EventChannel(e)),n.eventChannel),t}function TT(e){return Y.isFunction(e)}let Gg=new Map;function PT(e,t){Gg.set(e,te.once(NT(t)))}function IT(e,t,n,r,a){let u=OT(e,a,!0),h=Mo(),b=Gg.get(t)(),U=O=>h.mountPage(O,{__pageId:e,__pagePath:t,__pageQuery:n,__pageInstance:r},u);return Y.isPromise(b)?b.then(O=>U(O)):U(b)}function NT(e){return()=>TT(e)?e().then(t=>zg(t)):zg(e)}let Yg=!1;function qg(){if(Yg)return;Yg=!0;let e,t;if(g.requireModule("plus").getRedirectInfo){let{path:u,query:h,referrerInfo:b}=Rt();u&&(e=u,t=h),T.referrerInfo=b}else{let u=l.runtime.arguments;if(!u)return;try{let h=JSON.parse(u);e=h.path||h.pathName,t=h.query?"?"+h.query:""}catch(h){}}if(!e||e===T.entryPagePath){t&&(T.entryPageQuery=t);return}let r=te.addLeadingSlash(e),a=Ii(r);!a||(a.meta.isTabBar||(T.realEntryPagePath=T.realEntryPagePath||T.entryPagePath),T.entryPagePath=e,T.entryPageQuery=t)}function Kg(e,t){let n=JSON.parse(JSON.stringify(Ii(e)));return n.meta=Zn(n.meta),t!=="preloadPage"&&!T.realEntryPagePath&&(t==="reLaunch"||Vn().length===0)?n.meta.isQuit=!0:n.meta.isTabBar||(n.meta.isQuit=!1),n}let ka={};function kT(e){let t=Object.keys(ka).find(n=>ka[n].id===e.id);t&&delete ka[t]}function RT({url:e}){let t=ka[e];return t&&(t.__page__&&Vn().find(n=>n===t.__page__)?t.__preload__=!1:t.close("none"),delete ka[e]),t}function xT({url:e,path:t,query:n}){if(!ka[e]){let r=Kg(t,"preloadPage");ka[e]=Dg({path:t,routeOptions:r,query:n,webviewExtras:{__preload__:!0}})}return ka[e]}function fc({url:e,path:t,query:n,openType:r,webview:a,nvuePageVm:u,eventChannel:h}){if(a&&qg(),ka[e]){a=ka[e];let we=a;if(we.__page__)if(Vn().find(ke=>ke===we.__page__))a=void 0;else return h&&(we.__page__.$page.eventChannel=h),fn(we.__page__),we}let b=Kg(t,r);a?(a=l.webview.getWebviewById(a.id),a.nvue=b.meta.isNVue):a=Dg({path:t,routeOptions:b,query:n}),b.meta.id=parseInt(a.id),!!b.meta.isTabBar&&li.append(a),cT(a,t,n,b.meta);let O=t.slice(1);a.__uniapp_route=O;let D=Wo(r,e,n,b.meta,h),ge=parseInt(a.id);return a.nvue?u?MT(ge,u,D):LT(ge,a,D):IT(ge,O,n,D,BT(b)),a}function BT({meta:e}){let t=Hu(),{platform:n,pixelRatio:r,windowWidth:a}=No();return{css:!0,route:e.route,version:1,locale:"",platform:n,pixelRatio:r,windowWidth:a,disableScroll:e.disableScroll===!0,onPageScroll:!1,onPageReachBottom:!1,onReachBottomDistance:Y.hasOwn(e,"onReachBottomDistance")?e.onReachBottomDistance:te.ON_REACH_BOTTOM_DISTANCE,statusbarHeight:t,windowTop:e.navigationBar.type==="float"?t+te.NAVBAR_HEIGHT:0,windowBottom:li.indexOf(e.route)>=0&&li.cover?li.height:0}}function MT(e,t,n){Ge(t,n),fn(Wg(e,t,n)),e===1&&(T.splashscreen&&T.splashscreen.autoclose&&!T.splashscreen.alwaysShowBeforeRender&&l.navigator.closeSplashscreen(),T.onReady(function(){Ug()}))}function LT(e,t,n){let r={$:{},$getAppWebview(){return t},getOpenerEventChannel(){return n.eventChannel||(n.eventChannel=new te.EventChannel(e)),n.eventChannel},__setup(a,u){a.$getAppWebview=()=>t,a.getOpenerEventChannel=u.getOpenerEventChannel,Ge(a,n),t.__preload__&&(t.__page__=a);let h=qr(),b=h.findIndex(U=>U===u);b>-1&&h.splice(b,1,a)}};Ge(r,n),t.__preload__?t.__page__=r:fn(r)}let Jg=(e,{resolve:t,reject:n})=>{let{url:r,events:a,animationType:u,animationDuration:h}=e,{path:b,query:U}=te.parseUrl(r),[O,D]=VT(b,u,h);Wc(b,()=>{FT({url:r,path:b,query:U,events:a,aniType:O,aniDuration:D}).then(t).catch(n)},e.openType==="appLaunch")},DT=ye(Bu,Jg,QE,ay);function FT({url:e,path:t,query:n,events:r,aniType:a,aniDuration:u}){jn(te.ON_HIDE);let h=new te.EventChannel(Ig()+1,r);return new Promise(b=>{Yc(fc({url:e,path:t,query:n,openType:"navigateTo",eventChannel:h}),a,u,()=>{b({eventChannel:h})}),Za()})}function VT(e,t,n){let{globalStyle:r}=T,a=Ea(e);return[t||a.animationType||r.animationType||MO,n||a.animationDuration||r.animationDuration||zc]}let $T=ye(Mu,({url:e},{resolve:t,reject:n})=>{let{path:r,query:a}=te.parseUrl(e);Wc(r,()=>{UT({url:e,path:r,query:a}).then(t).catch(n)})},ty,sy);function UT({url:e,path:t,query:n}){let r=_r();return r&&uo(r),new Promise(a=>{Yc(fc({url:e,path:t,query:n,openType:"redirectTo"}),"none",0,()=>{if(r){let u=r.$getAppWebview();u.__preload__&&kT(u),u.close("none")}a(void 0)}),Za()})}let HT=({url:e},{resolve:t,reject:n})=>{let{path:r,query:a}=te.parseUrl(e);Wc(r,()=>{jT({url:e,path:r,query:a}).then(t).catch(n)})};function jT({url:e,path:t,query:n}){return new Promise(r=>{let a=qr().slice(0);ze.find(h=>h.path===t).meta.isTabBar&&li.switchTab(t.slice(1)),Yc(fc({url:e,path:t,query:n,openType:"reLaunch"}),"none",0,()=>{a.forEach(h=>$g(h,"none")),r(void 0)}),Za()})}let zT=ye(vh,HT,ny,ly),Zg=(e,{resolve:t,reject:n})=>{let{url:r}=e,{path:a,query:u}=te.parseUrl(r);Wc(a,()=>{GT({url:r,path:a,query:u}).then(t).catch(n)},e.openType==="appLaunch")},WT=ye(Nc,Zg,ry,cy);function GT({url:e,path:t,query:n}){li.switchTab(t.slice(1));let r=Vn(),a=r.length,u=!1,h=!1,b;a>=1&&(b=r[a-1],b&&!b.$.__isTabBar?(h=!0,r.reverse().forEach(O=>{!O.$.__isTabBar&&O!==b&&$g(O,"none")}),uo(b),k(()=>{b.$page.openType==="redirectTo"?Js(b.$getAppWebview(),Cg,zc):Js(b.$getAppWebview(),"auto")},100)):u=!0);let U;return qr().forEach(O=>{te.addLeadingSlash(O.route)===t?(O.$.__isActive||(h=!0),O.$.__isActive=!0,U=O):O.$.__isTabBar&&(O.$.__isActive=!1)}),b===U&&(u=!1),b&&u&&jn(b,te.ON_HIDE),new Promise(O=>{if(U){let D=U.$getAppWebview();D.show("none"),h&&!D.__preload__&&jn(U,te.ON_SHOW),Za(),O(void 0)}else Yc(fc({url:e,path:t,query:n,openType:"switchTab"}),"none",0,()=>{Za(),O(void 0)},70)})}let YT=Mt(mh,({url:e})=>{let t=RT({url:e});return t?{id:t.id,url:e,errMsg:"unPreloadPage:ok"}:{url:e,errMsg:"unPreloadPage:fail not found"}},oy),qT=ye(Lu,({url:e},{resolve:t,reject:n})=>{let r=e.split("?"),a=r[0],u=te.parseQuery(r[1]||""),h=xT({url:e,path:a,query:u});t({id:h.id,url:e,errMsg:"preloadPage:ok"})},iy);var KT={__proto__:null,sendHostEvent:Eg,navigateToMiniProgram:bO,onHostEventReceive:wg,onNativeEventReceive:EO,__log__:wO,navigateTo:DT,reLaunch:zT,switchTab:WT,upx2px:Em,addInterceptor:Om,removeInterceptor:Tm,interceptors:Pm,arrayBufferToBase64:Bn,base64ToArrayBuffer:Hn,createIntersectionObserver:E_,createMediaQueryObserver:w_,createSelectorQuery:P_,createVideoContext:Km,createMapContext:Zm,createAnimation:B_,onWindowResize:F_,offWindowResize:V_,onTabBarMidButtonTap:M_,createCanvasContext:d_,canvasGetImageData:h_,canvasPutImageData:g_,canvasToTempFilePath:p_,getSelectedTextRange:z_,getLocale:Ql,setLocale:H_,$on:Lm,$off:Fm,$once:Dm,$emit:Vm,onCreateVueApp:te.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:Ru,setStorageSync:Yw,setStorage:qw,getStorageSync:Kw,getStorage:Jw,removeStorageSync:Zw,removeStorage:Xw,clearStorageSync:Qw,clearStorage:eS,getStorageInfoSync:Ah,getStorageInfo:tS,getFileInfo:nS,saveFile:aS,getSavedFileList:cS,getSavedFileInfo:uS,removeSavedFile:fS,openDocument:dS,canIUse:hS,getDeviceInfo:kh,getAppBaseInfo:Rh,getSystemInfoSync:xh,getSystemInfo:yS,onCompassChange:wS,offCompassChange:SS,startCompass:Bh,stopCompass:Mh,vibrateShort:AS,vibrateLong:CS,onAccelerometerChange:OS,offAccelerometerChange:TS,startAccelerometer:Lh,stopAccelerometer:Dh,onBluetoothDeviceFound:PS,onBluetoothAdapterStateChange:IS,onBLEConnectionStateChange:NS,onBLECharacteristicValueChange:kS,openBluetoothAdapter:RS,closeBluetoothAdapter:xS,getBluetoothAdapterState:BS,startBluetoothDevicesDiscovery:MS,stopBluetoothDevicesDiscovery:LS,getBluetoothDevices:DS,getConnectedBluetoothDevices:FS,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:nA,getClipboardData:rA,setClipboardData:iA,onNetworkStatusChange:oA,offNetworkStatusChange:aA,getNetworkType:Uh,checkIsSupportSoterAuthentication:sA,checkIsSoterEnrolledInDevice:lA,startSoterAuthentication:cA,scanCode:uA,onThemeChange:fA,getScreenBrightness:dA,setScreenBrightness:hA,setKeepScreenOn:gA,getWindowInfo:Nh,getSystemSetting:pA,getAppAuthorizeSetting:Gh,openAppAuthorizeSetting:vA,getImageInfo:mA,getVideoInfo:_A,previewImage:bA,closePreviewImage:EA,getRecorderManager:SA,saveVideoToPhotosAlbum:AA,saveImageToPhotosAlbum:CA,compressImage:OA,compressVideo:TA,chooseImage:IA,chooseVideo:NA,showKeyboard:kA,hideKeyboard:RA,onKeyboardHeightChange:xA,offKeyboardHeightChange:BA,downloadFile:LA,request:$A,configMTLS:UA,connectSocket:WA,sendSocketMessage:GA,closeSocket:YA,onSocketOpen:qA,onSocketError:KA,onSocketMessage:JA,onSocketClose:ZA,uploadFile:QA,createInnerAudioContext:lC,getBackgroundAudioManager:bC,createLivePusherContext:wC,getLocation:CC,chooseLocation:OC,openLocation:TC,showModal:PC,showActionSheet:IC,showLoading:NC,showToast:kC,hideToast:RC,hideLoading:xC,startPullDownRefresh:BC,stopPullDownRefresh:MC,loadFontFace:LC,pageScrollTo:DC,setNavigationBarTitle:FC,showNavigationBarLoading:VC,hideNavigationBarLoading:$C,setNavigationBarColor:HC,setTabBarBadge:jC,setTabBarItem:zC,setTabBarStyle:WC,hideTabBar:GC,showTabBar:YC,showTabBarRedDot:qC,removeTabBarBadge:KC,hideTabBarRedDot:JC,getSubNVueById:nO,restoreGlobal:iO,requireGlobal:oO,getProvider:aO,login:hg,getUserInfo:sO,getUserProfile:lO,preLogin:pg,closeAuthView:mg,getCheckBoxState:_g,getUniverifyManager:fO,createPushMessage:dO,registerRuntime:hO,share:vO,shareWithSystem:mO,requestPayment:_O,requireNativePlugin:Ho,sendNativeEvent:Fh,createRewardedVideoAd:TO,createFullScreenVideoAd:IO,createInterstitialAd:kO,createInteractiveAd:BO,navigateBack:fT,redirectTo:$T,unPreloadPage:YT,preloadPage:qT};let JT=Y.extend(ce,{publishHandler:ZT});function ZT(e,t,n){t=JSON.stringify(t),Y.isArray(n)||(n=[n]);let r=`typeof UniViewJSBridge !== 'undefined' && UniViewJSBridge.subscribeHandler("${e}",${t},__PAGE_ID__)`;n.forEach(a=>{let u=String(a),h=l.webview.getWebviewById(u);h&&h.evalJS(r.replace("__PAGE_ID__",u))})}function XT(){let{tabBar:e}=T;if(!(e&&e.list&&e.list.length))return;let{entryPagePath:n}=T;e.selectedIndex=0;let r=e.list.findIndex(a=>a.pagePath===n);li.init(e,(a,u)=>{gt.switchTab({url:te.addLeadingSlash(a.pagePath),openType:"switchTab",from:"tabBar",success(){jn(te.ON_TAB_ITEM_TAP,{index:u,text:a.text,pagePath:a.pagePath})}})}),r!==-1&&(e.selectedIndex=r,r!==0&&li.switchTab(n))}function QT(){let e=l.globalEvent,t=g.requireModule("globalEvent"),n=st.emit;g.config.preload?l.key.addEventListener(Gi,Yi):e.addEventListener("splashclosed",()=>{l.key.addEventListener(Gi,Yi)}),e.addEventListener("pause",()=>{n(te.ON_APP_ENTER_BACKGROUND)}),e.addEventListener("resume",()=>{let a=Rt();a&&a.userAction&&Ve(a),n(te.ON_APP_ENTER_FOREGROUND,is())}),t.addEventListener("uistylechange",function(a){let u={theme:a.uistyle};n(te.ON_THEME_CHANGE,u)});let r=0;e.addEventListener("KeyboardHeightChange",function(a){r!==a.height&&(r=a.height,n(te.ON_KEYBOARD_HEIGHT_CHANGE,{height:r}))}),t.addEventListener(FO,function(a){a&&a.event&&yO(a.event,a.data)}),e.addEventListener("plusMessage",Xg),e.addEventListener("WebviewPostMessage",Xg)}function Xg({data:e}){e&&e.type&&st.subscribeHandler("plusMessage."+e.type,e.args)}function Qg(e,t,n=!1){st.subscribe("plusMessage."+e,t,n)}function eP(e){W_(e.$);let{entryPagePath:t,entryPageQuery:n,referrerInfo:r}=T,a=Tt({path:t,query:n,referrerInfo:r});jn(e,te.ON_LAUNCH,a),jn(e,te.ON_SHOW,a);let u=g.requireModule("plus").getAppState;(u&&Number(u()))===2&&jn(e,te.ON_HIDE,a)}function ep(e){return e=e.replace(/\/$/,""),e.indexOf("_")===0?l.io.convertLocalFileSystemURL(e):e}function tP(){let e=ep(ki),t=ep(ai),n=t.split("/");n.pop();let r=n.join("/");l.io.resolveLocalFileSystemURL(l.io.convertAbsoluteFileSystem(r),a=>{a.createReader().readEntries(function(h){let b=h;b&&b.length&&b.forEach(function(U){U.isDirectory&&U.fullPath.indexOf(e)===0&&U.fullPath.indexOf(t)!==0&&U.removeRecursively()})})})}let tp=0,Ll=0,Kc=null,Zs=null;function nP(e,t){if(Kc=null,Zs&&(S(Zs),Zs=null),e.type==="onFocus")if(Ll>0)e.detail.height=Ll;else{Zs=k(function(){e.detail.height=Ll,t(e)},tp),Kc=function(){Zs&&(S(Zs),Zs=null),e.detail.height=Ll,t(e)};return}t(e)}function rP(){tp=l.os.name.toLowerCase()==="android"?300:700,st.on(te.ON_KEYBOARD_HEIGHT_CHANGE,t=>{if(Ll=t.height,Ll>0){let n=Kc;Kc=null,n&&n()}})}function iP(e,t,n){let r=t.type;r==="onFocus"||r==="onBlur"?nP(t,a=>{n.fireEvent(e,a)}):n.fireEvent(e,t)}function oP(e,t){let n=co(parseInt(t));if(!n)return;let r=n.__page_container__;e.forEach(a=>{switch(a[0]){case te.ACTION_TYPE_EVENT:iP(a[1],a[2],r);break}})}let np={};function aP(e,t,n){let{adpid:r,width:a}=e,u=r+"-"+a,h=np[u];if(h&&h.length>0){t(h.splice(0,1)[0]);return}l.ad.getAds(e,b=>{let U=b.ads;t(U.splice(0,1)[0]),np[u]=h?h.concat(U):U},b=>{n({errCode:b.code,errMsg:b.message})})}function sP(){Z("getAdData",(e,t)=>{aP(e,n=>{t({code:0,data:n})},n=>{t({code:1,message:n})})})}let lP=["switchTab","reLaunch","redirectTo","navigateTo","navigateBack"];function cP(){lP.forEach(e=>{Z(e,t=>{gt[e](Y.extend(t,{fail(n){console.error(n.errMsg)}}))})})}let rp=!1;function uP(e,t){let n=t==="1";if(!(n&&rp)){if(n?(rp=!0,xg(l.webview.getLaunchWebview())):Bi||xg(l.webview.getWebviewById(t)),!Bi.loaded){if(Bi.id!==t)return console.error(`webviewReady[${Bi.id}][${t}] not match`);Bi.loaded=!0}st.emit(Ml+"."+t),n&&fP()}}function fP(){let{autoclose:e,alwaysShowBeforeRender:t}=T.splashscreen;e&&!t&&l.navigator.closeSplashscreen();let n=te.addLeadingSlash(T.entryPagePath),r=Ii(n);if(!r.meta.isNVue){let a={url:n+(T.entryPageQuery||""),openType:"appLaunch"},u={resolve(){},reject(){}};return r.meta.isTabBar?Zg(a,u):Jg(a,u)}}function dP(e,t){let n=co(parseInt(t));n&&(n.__uniapp_webview=!0)}function hP(e,t){let n=co(parseInt(t));n&&delete n.__uniapp_webview}let gP=({name:e,arg:t},n)=>{e==="postMessage"?pP(n[0],t):gt[e](Y.extend(t,{fail(r){console.error(r.errMsg)}}))};function pP(e,t){let n=vT("web-view",parseInt(e));n&&n.dispatchEvent(te.createUniEvent({type:"onMessage",target:Object.create(null),currentTarget:Object.create(null),detail:{data:[t]}}))}function vP({nodeId:e,ownerId:t,method:n,args:r},a){let u=Hg(e,parseInt(a));if(!u)return;let h=mP(t,u.__vueParentComponent);!h||!h[n]||h[n](r)}function mP(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 _P(){let{subscribe:e,subscribeHandler:t,publishHandler:n}=st;if(Qg("subscribeHandler",({type:r,data:a,pageId:u})=>{t(r,a,u)}),Qg(te.WEB_INVOKE_APPSERVICE,({data:r,webviewIds:a})=>{gP(r,a)}),T.renderer!=="native"){e(Ml,uP),e(lg,oP),j(),sP(),cP(),e(QC,dP),e(eO,hP),e(te.ON_WXS_INVOKE_CALL_METHOD,vP);let r=Ii(te.addLeadingSlash(T.entryPagePath));r&&!r.meta.isNVue&&n(Ml,{},1)}}let Dl,ef={globalData:{}};function bP({allowDefault:e=!1}={}){if(Dl)return Dl;if(e)return ef;console.error("[warn]: getApp() failed. Learn more: https://uniapp.dcloud.io/collocation/frame/window?id=getapp.")}function EP(e){if(gt.Vuex&&e.$store){let{useStore:t}=gt.Vuex;gt.Vuex.useStore=n=>n?t(n):e.$store}Lo(e),Dl=e,nt(Dl),Y.extend(Dl,ef),Vt(Dl,ef.globalData),Wt(),qg(),XT(),QT(),rP(),_P(),eP(e),k(tP,1e4),T.ready=!0}var yP={uni:KT,getApp:bP,getCurrentPages:ii,__definePage:PT,__registerApp:EP,__registerPage:fc,UniServiceJSBridge:JT};return yP}(xt,pn,A);B=B.default||B;let gt=B.uni,vn=B.getApp,Vn=B.getCurrentPages,st=B.UniServiceJSBridge;return B}var Vp=rI(aI);var yf,wf,Sf,es,Af,Cf,Of;function $p(){return es?{__definePage:yf,__registerApp:wf,__registerPage:Sf,uni:es,wx:es,getApp:Af,getCurrentPages:Cf,UniServiceJSBridge:Of}:{}}function Up(g){let{weex:l,plus:_,VueShared:A}=g;return es||({__definePage:yf,__registerApp:wf,__registerPage:Sf,uni:es,getApp:Af,getCurrentPages:Cf,UniServiceJSBridge:Of}=Fp(l,_,g),es.VueShared=A,sp(es)),{__definePage:yf,__registerApp:wf,__registerPage:Sf,plus:_,uni:es,wx:es,getApp:Af,getCurrentPages:Cf,UniServiceJSBridge:Of}}function Hp(g,l){let{__uniConfig:_}=l;if(!_)return;let A=l.weex;A.document.__$automator__=!!_.automator;let k=_.renderer!=="native"&&A.config.bundleUrl.indexOf("app-service.js")!==-1;if(Jr(l,$p()),k?Vp(l):(fp(g,l),kp(l.Vue.parseClassStyles)),Jr(l,Up(l)),A.config.plus_web_id==="1"){let T=A.requireModule("plus");T.setDefaultFontSize&&T.setDefaultFontSize(Math.round(l.plus.screen.resolutionWidth/20))}let{scale:S,deviceWidth:N,platform:f}=global.WXEnvironment;if(f.toLowerCase()==="ios"){let T=Math.ceil(N/S);A.requireModule("meta").setViewport({width:T,roundOffDeviation:!1})}}var rl=class extends nl{constructor(l){super();this.nodeType=8;this.type="comment";this.value="";this.value=l}toString(){return"<!-- "+this.value+" -->"}};function Co(g,l=[]){return{module:"dom",method:g,args:l}}var jl=class{constructor(l,_){this.id=l,this.batched=!1,this.updates=[],Fn(_)?Object.defineProperty(this,"handler",{configurable:!0,enumerable:!0,writable:!0,value:_}):console.error("[JS Runtime] invalid parameter, handler must be a function")}createFinish(l){return this.handler([Co("createFinish")],l)}updateFinish(l){return this.handler([Co("updateFinish")],l)}refreshFinish(l){return this.handler([Co("refreshFinish")],l)}createBody(l){let _=l.toJSON(),A=_.children;delete _.children;let k=[Co("createBody",[_])];return A&&k.push.apply(k,A.map(S=>Co("addElement",[_.ref,S,-1]))),this.addActions(k)}addElement(l,_,A){return A>=0||(A=-1),this.addActions(Co("addElement",[_,l.toJSON(),A]))}removeElement(l){if(yi(l)){let _=l.map(A=>Co("removeElement",[A]));return this.addActions(_)}return this.addActions(Co("removeElement",[l]))}moveElement(l,_,A){return this.addActions(Co("moveElement",[l,_,A]))}setAttr(l,_,A){return this.addActions(Co("updateAttrs",[l,{[_]:A}]))}setStyle(l,_,A){return this.addActions(Co("updateStyle",[l,{[_]:A}]))}setStyles(l,_){return this.addActions(Co("updateStyle",[l,_]))}addEvent(l,_){return this.addActions(Co("addEvent",[l,_]))}removeEvent(l,_){return this.addActions(Co("removeEvent",[l,_]))}handler(l,_){return _&&_()}addActions(l){let _=this.updates,A=this.handler;if(yi(l)||(l=[l]),this.batched)_.push.apply(_,l);else return A(l)}};var Tf={createBody:"callCreateBody",addElement:"callAddElement",removeElement:"callRemoveElement",moveElement:"callMoveElement",updateAttrs:"callUpdateAttrs",updateStyle:"callUpdateStyle",addEvent:"callAddEvent",removeEvent:"callRemoveEvent"};function jp(g,l){let _=l||global.callNative;return Fn(_)||console.error("[JS Runtime] no default handler"),function(k){yi(k)||(k=[k]);for(let S=0;S<k.length;S++){let N=lI(g,k[S],_);if(N===-1)return N}}}function sI(g,l){return g==="dom"&&Tf[l]&&Fn(global[Tf[l]])}function lI(g,l,_){let{module:A,method:k,args:S}=l;return sI(A,k)?global[Tf[k]](g,...S,"-1"):_(g,[l],"-1")}var du=class extends Ji{constructor(l){super();this.value=l,this.nodeType=3,this.type="text",this.value=""}toString(){return""+this.value}};var zp={slider:{change:function(g){return{index:g.index,source:g.source}},scroll:function(g){return{offsetXRatio:g.offsetXRatio,offsetYRatio:g.offsetYRatio,drag:g.drag}}},"scroll-view":{scrollend:function(g){return{contentOffset:g.contentOffset}}}};function Wp(g){let{attr:l,offsetLeft:_,offsetTop:A}=g,k={};return l&&Object.keys(l).forEach(S=>{S.indexOf("data-")===0&&(k[S.replace("data-","")]=l[S])}),{id:l&&l.id||"",dataset:k,offsetLeft:_||0,offsetTop:A||0}}var cI=["a","div","list","cell","loading","refresh","recycle-list","scroller","indicator","waterfall","web","richtext"],uI=["viewappear","viewdisappear"],fI={markertap:["markerId"],controltap:["controlId"],regionchange:["causedBy"],end:["causedBy"],appear:["direction"],disappear:["direction"]};function Gp(g,l){let _=g.type;if(uI.indexOf(_)!==-1)return g;let A=g.currentTarget,k=A.type.replace("u-","");if(cI.indexOf(k)!==-1)return g;let{timestamp:S,target:N}=g;if(!l){let ze=zp[k];ze?Fn(ze[_])?l=ze[_](g):l=g.detail||{}:l=g.detail||{}}let f={type:_,timeStamp:S,target:Wp(N),currentTarget:Wp(A),detail:l,touches:_==="touchend"||_==="panend"?[]:g.changedTouches,changedTouches:g.changedTouches};g.componentId&&(f.componentId=g.componentId);let T=fI[_];return T&&T.forEach(ze=>{Xs(g,ze)&&(f[ze]=g[ze])}),f}function dI(g,l){let _=l.attrs||{};for(let k in _)g.setAttr(k,_[k],!0);let A=l.style||{};for(let k in A)g.setStyle(k,A[k],!0)}var jo=class{constructor(l,_="",A){l=l?l.toString():"",this.id=l,this.URL=_,Sp(l,this),this.nodeMap={};let k=jo.Listener||jl;this.listener=new k(l,A||jp(l,jo.handler)),this.taskCenter=new Hl(l,A?(S,N)=>A(N):jo.handler),this.createDocumentElement()}getRef(l){return this.nodeMap[l]}open(){this.listener.batched=!1}close(){this.listener.batched=!0}createDocumentElement(){if(!this.documentElement){let l=new Ji("document");l.docId=this.id,l.ownerDocument=this,l.role="documentElement",l.ref="_documentElement",this.nodeMap._documentElement=l,this.documentElement=l,Object.defineProperty(l,"appendChild",{configurable:!0,enumerable:!0,writable:!0,value:_=>{sf(this,_)}}),Object.defineProperty(l,"insertBefore",{configurable:!0,enumerable:!0,writable:!0,value:(_,A)=>{sf(this,_,A)}}),Yn("debug")&&Mi(`Create document element (id: "${l.docId}", ref: "${l.ref}")`)}return this.documentElement}createBody(l,_){if(!this.body){let A=new Ji(l,_);lf(this,A),Yn("debug")&&Mi(`[createBody](${this.id},${A.type},${A.ref}) (${JSON.stringify(A.toJSON(!0))}).`)}return this.body}createElement(l,_){let A=new Ji(l,_);return Yn("debug")&&Mi(`[createElement](${this.id},${A.type},${A.ref}) (${JSON.stringify(A.toJSON(!0))}).`),A}createComment(l){return new rl(l)}createText(l){return new du(l)}fireEvent(l,_,A,k,S){if(!l)return;A=A||{},A.type=A.type||_,A.target=l,A.currentTarget=l,A.timestamp=Date.now(),k&&dI(l,k);let N,f=this.getRef("_root");if(f&&f.attr){let T=f.attr.bubble;N=T==="true"||T===!0}return A=Gp(A),l.fireEvent(_,A,N,S)}destroy(){Yn("debug")&&Mi(`[destroy](${this.id},document) Destroy document (id: "${this.id}", URL: "${this.URL}")`),this.taskCenter.destroyCallback(),delete this.listener,delete this.nodeMap,delete this.taskCenter,Ap(this.id)}};jo.handler=null;var Yp={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 qp(g,l,_){var A=[l];function k(N){var f=new RegExp;return f.compile(N.replace(/<([^>]+)>/g,function(T,ze){return g[ze]?(A.push(ze),g[ze]instanceof RegExp?"("+g[ze].source+")":"("+k(g[ze]).source+")"):""}),_),f}var S=k(g[l]);this.exec=function(N){var f=S.exec(N);if(f==null)return null;for(var T=new String(f[0]),ze=0;ze<A.length;ze++)f[ze]&&(T[A[ze]]=f[ze]);return T},Object.defineProperty(this,"lastIndex",{get:function(){return S.lastIndex},set:function(N){S.lastIndex=N}})}function hI(){var g=new qp(Yp,"InputElementDiv","g"),l=new qp(Yp,"InputElementRegExp","g"),_;Object.defineProperty(this,"source",{get:function(){return _},set:function(A){_=A,g.lastIndex=0,l.lastIndex=0}}),this.reset=function(){g.lastIndex=0,l.lastIndex=0},this.getNextToken=function(A){var k=g.lastIndex,S;A?S=g:S=l;var N=S.exec(_);if(N&&S.lastIndex-k>N.length)throw new SyntaxError("Unexpected token ILLEGAL");return g.lastIndex=S.lastIndex,l.lastIndex=S.lastIndex,N}}var Kp={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 mc(g,l){this.name=g,this.token=l,this.childNodes=[],this.toString=function(_){if(_||(_=""),this.childNodes.length==1)return this.childNodes[0].toString(_);for(var A=_+this.name+(this.token!=null&&this.name!=this.token?":"+this.token:"")+`
`,k=0;k<this.childNodes.length;k++)A+=this.childNodes[k].toString(_+"    ");return A}}function gI(){var g,l={Program:"$"},_={};function A(f){_[JSON.stringify(f)]=f;for(var T=Object.getOwnPropertyNames(f);T.length;){var ze=T.shift();!Kp[ze]||Kp[ze].forEach(function(pn){f[pn[0]]||T.push(pn[0]);var B=f,gt=null;pn.forEach(function(vn){B[vn]||(B[vn]={}),gt=B,B=B[vn]}),f[ze].$div&&(B.$div=!0),B.$reduce=ze,B.$count=pn.length})}for(var xt in f)typeof f[xt]!="object"||xt.charAt(0)=="$"||f[xt].$closure||(_[JSON.stringify(f[xt])]?f[xt]=_[JSON.stringify(f[xt])]:A(f[xt]));f.$closure=!0}A(l);var k=[],S=[l],N=l;this.insertSymbol=function(T,ze){for(;!N[T.name]&&N.$reduce;){for(var xt=N.$count,pn=new mc(N.$reduce);xt--;)pn.childNodes.push(k.pop()),S.pop();N=S[S.length-1],this.insertSymbol(pn)}if(N=N[T.name],k.push(T),S.push(N),!N)throw new Error;return N.$div},this.reset=function(){N=l,k=[],S=[l]},Object.defineProperty(this,"grammarTree",{get:function(){try{for(;N.$reduce;){for(var f=N.$count,T=new mc(N.$reduce);f--;)T.childNodes.push(k.pop()),S.pop();N=S[S.length-1],this.insertSymbol(T)}if(k.length>0&&N[";"])return this.insertSymbol(new mc(";",";")),this.grammarTree;if(k.length!=1||k[0].name!="Program")throw new Error}catch(ze){throw new SyntaxError("Unexpected end of input")}return k[0]}})}function pI(){this.lexicalParser=new hI,this.syntacticalParser=new gI;var g=["NullLiteral","BooleanLiteral","NumericLiteral","StringLiteral","RegularExpressionLiteral","Identifier","**","=>","{","}","(",")","[","]",".",";",",","<",">","<=",">=","==","!=","===","!==","+","-","*","%","++","--","<<",">>",">>>","&","|","^","!","~","&&","||","?",":","=","+=","-=","*=","%=","<<=",">>=",">>>=","&=","|=","^=","/","/=","instanceof","typeof","new","void","debugger","this","delete","in"],l={};g.forEach(function(_){Object.defineProperty(l,_,{})}),this.reset=function(){this.lexicalParser.reset(),this.syntacticalParser.reset()},this.parse=function(_,A){var k,S=!1;this.lexicalParser.source=_;for(var N=!1;k=this.lexicalParser.getNextToken(N);){A&&A(k);try{if(Object.getOwnPropertyNames(k).some(f=>l.hasOwnProperty(f)?(N=this.syntacticalParser.insertSymbol(new mc(f,k),S),S=!1,!0):!1))continue;(k.Keyword||k.Punctuator||k.DivPunctuator)&&l.hasOwnProperty(k.toString())&&(N=this.syntacticalParser.insertSymbol(new mc(k.toString(),k),S))}catch(f){throw new SyntaxError("Unexpected token "+k)}}return this.syntacticalParser.grammarTree}}var Jp=new pI;function vI(g){Jp.reset(),this.tree=Jp.parse(g),this.paths=[];var l=Object.create(null),_=this,A=Object.create(null);this.isSimple,this.isConst,S(this.tree),k(this.tree),this.paths.length===0&&(this.isConst=!0),this.setter=function(T){for(var ze=l,xt=0;xt<T.length-1;xt++)ze[T[xt]]||(ze[T[xt]]=Object.create(null)),ze=ze[T[xt]];return{isCompleted:function(){for(var pn in A)if(!A[pn])return!1;return!0},set:function(pn){if(A[T.join(".")]||(A[T.join(".")]=!0),ze[T[xt]]=pn,this.isCompleted())return _.exec()}}},this.valueOf=this.exec=function(){try{return function(){return(0,eval)(g)}.call(l)}catch(T){}};function k(T){for(var ze=T;ze.childNodes.length<=1&&ze.name!=="MemberExpression";)ze=ze.childNodes[0];ze.name==="MemberExpression"?_.isSimple=!0:_.isSimple=!1}function S(T){if(T.name==="CallExpression"&&T.childNodes[T.childNodes.length-1].name!=="CallExpression"){var ze=N(T.childNodes[1]);S(T.childNodes[0])}else if(T.name==="NewExpression"&&T.childNodes.length===1)var ze=N(T.childNodes[0]);else if(T.name==="MemberExpression"&&T.childNodes.length===1)var ze=N(T);else for(var xt=0;xt<T.childNodes.length;xt++)S(T.childNodes[xt])}function N(T){if(T.childNodes[0].name==="IdentifierName"){var ze=N(T.childNodes[2]);return ze&&(ze=ze.concat(T.childNodes[0].childNodes[0].token.toString())),f(ze),ze}else if(T.childNodes[0].name==="PrimaryExpression")if(T.childNodes[0].childNodes[0].name==="Identifier"){var ze=[T.childNodes[0].childNodes[0].token.toString()];return f(ze),ze}else return null;else{if(T.childNodes[0].name==="]")return N(T.childNodes[3]),S(T.childNodes[1]),null;if(T.childNodes[0].name==="Arguments")return S(T.childNodes[0]),S(T.childNodes[1]),null;for(var xt=0;xt<T.childNodes.length;xt++)S(T.childNodes[xt])}}function f(T){for(var ze=l,xt=0;xt<T.length-1;xt++)ze[T[xt]]||(ze[T[xt]]=Object.create(null)),ze=ze[T[xt]];_.paths.push(T),A[T.join(".")]=!1}}function il(g){var l=g.childNodes.slice().reverse(),_=l.filter(T=>!T.token||!T.token.Punctuator);if(g.name==="UnaryExpression"&&l.length===2&&l[0].name==="-"&&_.length===1){var A=il(_[0]);return A.value=-A.value,A}if(g.name==="Arguments"){for(var k=[],S=_[0];S;)S.childNodes.length===3&&(k.unshift(S.childNodes[0]),S=S.childNodes[2]),S.childNodes.length===1&&(k.unshift(S.childNodes[0]),S=null);return{type:"Arguments",children:k.map(T=>il(T))}}if(_&&_.length===1){var A=il(_[0]);return A}if(g.token&&["NullLiteral","BooleanLiteral","NumericLiteral","StringLiteral","Identifier"].some(T=>g.token[T])){var N=Object.keys(g.token).filter(T=>T.match(/Literal/)||T.match(/Identifier/))[0],f={NullLiteral:null,BooleanLiteral:Boolean(g.token),NumericLiteral:Number(g.token),StringLiteral:g.token,Identifier:g.token}[N];return{type:N,value:f}}return g.name==="CallExpression"?{type:"CallExpression",children:[il(l[0]),il(l[1])]}:{type:l.filter(T=>T.token&&T.token.Punctuator)[0].name,children:l.filter(T=>!T.token||!T.token.Punctuator).map(T=>il(T))}}function Zp(g){var l=new vI(g);return JSON.stringify(il(l.tree),null)}function mI(g,l){return l==="bind"&&(g==="bindingx"||g==="binding")}function Xp(g){if(!g)return;try{g=JSON.parse(g)}catch(_){}let l={};if(wi(g)?l.origin=g:g&&(l.origin=g.origin,l.transformed=g.transformed),!(!l.transformed&&!l.origin))return l.transformed=l.transformed||Zp(l.origin),l}function _I(g){return g&&(g.exitExpression=Xp(g.exitExpression),g.props&&g.props.forEach(l=>{l.expression=Xp(l.expression)}),g)}function bI(g){return function(l={}){if(Fn(g))return g({state:l.state==="end"?"exit":l.state,t:l.t!==void 0?l.t:l.deltaT})}}function Qp(g,l,_){return _&&(mI(g,l)?function(A,k=function(){}){if(!A)throw new Error("should pass options for binding");return _I(A),_(A,A&&A.eventType==="timing"?bI(k):k)}:_)}function EI(g,l){Object.defineProperty(g,"[[CurrentInstanceId]]",{value:l})}function ev(g){return g["[[CurrentInstanceId]]"]}function yI(g,l,_){let A=Nr(g);return!A||!Fn(A.send)?(console.error(`[JS Framework] Failed to find taskCenter (${g}).`),null):(...k)=>A.send("module",{module:l,method:_},k)}function wI(g,l,_,A){let k=Nr(g);return!k||!Fn(k.send)?(console.error(`[JS Framework] Failed to find taskCenter (${g}).`),null):Fn(A)?S=>k.send("module",{module:l,method:_},[S]):(console.error(`[JS Framework] ${l}.${_} must be assigned as a function.`),null)}var hu=class{constructor(l,_){EI(this,String(l)),this.config=_||{},this.document=new jo(l,this.config.bundleUrl),this.requireModule=this.requireModule.bind(this),this.importScript=this.importScript.bind(this),this.isRegisteredModule=cu,this.isRegisteredComponent=bf}requireModule(l){let _=ev(this);if(!(_&&this.document&&this.document.taskCenter)){console.error(`[JS Framework] Failed to requireModule("${l}"), instance (${_}) doesn't exist anymore.`);return}if(!cu(l)){console.warn(`[JS Framework] \u5F53\u524D\u8FD0\u884C\u7684\u57FA\u5EA7\u4E0D\u5305\u542B\u539F\u751F\u63D2\u4EF6[${l}]\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 A={},k=Lp(l);for(let S in k)Object.defineProperty(A,S,{enumerable:!0,configurable:!0,get:()=>Qp(l,S,yI(_,l,S)),set:N=>wI(_,l,S,N)});return A}supports(l){if(!wi(l))return null;let _=l.match(/^@(\w+)\/([\w-]+)(\.(\w+))?$/i);if(_){let A=_[1],k=_[2],S=_[4];switch(A){case"module":return cu(k,S);case"component":return bf(k)}}return null}importScript(l,_={}){let A=ev(this),k=Nr(A);return new Promise(function(S,N){if(!k||!Fn(k.send))return N(new Error(`[JS Framework] Failed to import script "${l}", no taskCenter (${A}) matched.`));try{k.send("module",{module:"script",method:"importScript"},[l,_],{callback:[f=>S(f),f=>N(f)]})}catch(f){N(f)}})}};function SI(g,l){let _=Object.create(null);return _.service=Object.create(null),Ss.forEach(({name:A,options:k})=>{let S=k.create;if(S)try{let N=S(g,l);Jr(_.service,N),Jr(_,N.instance)}catch(N){console.error(`[JS Runtime] Failed to create service ${A}.`)}}),delete _.service.instance,ma(_.service),_}var AI={uid:0},CI=bp(hc),OI=_p(hc);function tv(g,l,_){let A=new hu(g,l),k="Vue",S=SI(g,{weex:A,nvue:A,config:l,created:Date.now(),framework:k});ma(S);let N=Object.create(null);return Jr(N,xI(A)),Jr(N,S,{SharedObject:AI,weex:A,nvue:A,requireModule:f=>A.requireModule(f),__WEEX_CALL_JAVASCRIPT__:mf,services:S}),N.plus=new N.WeexPlus(A),N.VueShared=hc,N.UniShared=CI,N.VueReactivity=OI,Hp(g,N),ma(N),N}function TI(g,l,_={}){let A="Vue";_=of(_),_.env=of(global.WXEnvironment||{}),_.bundleType=A;let k=tv(g,_);PI(l,k)}function PI(g,l){let _=[],A=[];for(let S in l)_.push(S),A.push(l[S]);let k="(function (global) { "+g+" })(Object.create(this))";return new Function(..._,k)(...A)}function II(g){let l=Qa(g);try{if(l&&l.body)return l.body.toJSON()}catch(_){console.error("[JS Framework] Failed to get the virtual dom tree.");return}}function NI(g){cp(g),Ss.forEach(l=>{let _=l.options.destroy;_&&_(g)})}function kI(g){up(g),Ss.forEach(l=>{let _=l.options.refresh;_&&_(g)})}var RI={createInstance:TI,createInstanceContext:tv,getRoot:II,getDocument:Qa,registerService:uu,unregisterService:fu,callJS(g,l){return mf(g,l)},registerComponents:Dp,registerModules:Mp,destroyInstance:NI,refreshInstance:kI};function Pf(){return Bp(),RI}function xI(g){if(global.setTimeout&&global.setInterval)return{setTimeout:global.setTimeout,setInterval:global.setInterval,clearTimeout:global.clearTimeout,clearInterval:global.clearInterval};let l=g.requireModule("timer");return{setTimeout:(...A)=>{let k=function(){A[0](...A.slice(2))};return l.setTimeout(k,A[1]),g.document.taskCenter.callbackManager.lastCallbackId.toString()},setInterval:(...A)=>{let k=function(){A[0](...A.slice(2))};return l.setInterval(k,A[1]),g.document.taskCenter.callbackManager.lastCallbackId.toString()},clearTimeout:A=>{l.clearTimeout(A)},clearInterval:A=>{l.clearInterval(A)}}}var nv={Document:jo,Element:Ji,Comment:rl,Listener:jl,TaskCenter:Hl,sendTasks(...g){return Fn(callNative)?callNative(...g):(global.callNative||(()=>{}))(...g)}};jo.handler=nv.sendTasks;var ol=nv;function BI(){ma(ol.Comment),ma(ol.Listener),ma(ol.Document.prototype),ma(ol.Comment.prototype),ma(ol.Listener.prototype)}var gu={service:{register:uu,unregister:fu,has:Ef},freezePrototype:BI,init:Pf,config:ol};var If=class{constructor(l,_={}){this.type=l||"message",this.data=_.data||null,this.origin=_.origin||"",this.source=_.source||null,this.ports=_.ports||[],this.target=null,this.timeStamp=Date.now()}};var As={},_c={};function Nf(){}Nf.prototype.postMessage=function(g){if(this._closed)throw new Error(`BroadcastChannel "${this.name}" is closed.`);let l=As[this.name];if(l&&l.length)for(let _=0;_<l.length;++_){let A=l[_];A._closed||A===this||Fn(A.onmessage)&&A.onmessage(new If("message",{data:g}))}};Nf.prototype.close=function(){if(!this._closed&&(this._closed=!0,As[this.name])){let g=As[this.name].filter(l=>l!==this);g.length?As[this.name]=g:delete As[this.name]}};var rv={create:g=>{if(_c[g]=[],Fn(global.BroadcastChannel))return{};let l={BroadcastChannel:function(_){Object.defineProperty(this,"name",{configurable:!1,enumerable:!0,writable:!1,value:String(_)}),this._closed=!1,this.onmessage=null,As[this.name]||(As[this.name]=[]),As[this.name].push(this),_c[g].push(this)}};return l.BroadcastChannel.prototype=Nf.prototype,{instance:l}},destroy:g=>{_c[g]&&(_c[g].forEach(l=>l.close()),delete _c[g])}};function kf(){let{init:g}=gu;gu.service.register("BroadcastChannel",rv),gu.freezePrototype();let l=g();for(let _ in l)global[_]=(...A)=>{let k=l[_](...A);return k instanceof Error&&console.error(k.toString()),k}}var AR=global.console;function iv(){if(yp(),global.WXEnvironment&&global.WXEnvironment.platform!=="Web")global.console={debug:(...g)=>{Yn("debug")&&global.nativeLog(...bc(g),"__DEBUG")},log:(...g)=>{Yn("log")&&global.nativeLog(...bc(g),"__LOG")},info:(...g)=>{Yn("info")&&global.nativeLog(...bc(g),"__INFO")},warn:(...g)=>{Yn("warn")&&global.nativeLog(...bc(g),"__WARN")},error:(...g)=>{Yn("error")&&global.nativeLog(...bc(g),"__ERROR")}};else{let{debug:g,log:l,info:_,warn:A,error:k}=console;console.__ori__={debug:g,log:l,info:_,warn:A,error:k},console.debug=(...S)=>{Yn("debug")&&console.__ori__.debug.apply(console,S)},console.log=(...S)=>{Yn("log")&&console.__ori__.log.apply(console,S)},console.info=(...S)=>{Yn("info")&&console.__ori__.info.apply(console,S)},console.warn=(...S)=>{Yn("warn")&&console.__ori__.warn.apply(console,S)},console.error=(...S)=>{Yn("error")&&console.__ori__.error.apply(console,S)}}}function bc(g){return g.map(l=>{if(Xa(l).toLowerCase()==="[object object]")try{l=JSON.stringify(l)}catch(A){l="[object object]"}else l=String(l);return l})}iv();kf();})();

    3.