bnyer
/
scanCodePlugin
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
scanCode安卓原生插件
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
5 Commits
1 Branch
0 Tags
96 MiB
 
 
 
 
Branch: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
scanCodePlugin/app/build/intermediates/merged_assets/debug/out/uni-jsframework-vue3.js

2 lines
663 KiB
Raw Permalink Blame History

//{"version":"3.8.7","encode":"base64"}
var __UniServiceStartTime__ = Date.now();var global=this; var process={env:{}}; var setTimeout=global.setTimeout;
(()=>{var sI=Object.defineProperty;var lI=(g,s)=>{for(var p in s)sI(g,p,{get:s[p],enumerable:!0})};var Ta=Object.freeze;function dc({getCurrentPages:g,uni:s,UniShared:p,Vue:w,VueShared:k}){var S=function(d,E,B,We){"use strict";function Lt(){let Ve=g(),ot=Ve.length;if(ot)return Ve[ot-1]}function en(){let Ve=Lt();if(Ve)return Ve.$vm}function xt(Ve,ot,bt){if(B.isString(Ve))bt=ot,ot=Ve,Ve=en();else if(typeof Ve=="number"){let Sn=g().find(Jt=>Jt.$page.id===Ve);Sn?Ve=Sn.$vm:Ve=en()}if(!Ve)return;if(Ve.__call_hook)return Ve.__call_hook(ot,bt);let tn=Ve.$[ot];return tn&&E.invokeArrayFns(tn,bt)}function I(Ve,ot,bt,tn){B.isFunction(ot)&&We.injectHook(Ve,ot.bind(bt),tn)}function St(Ve,ot,bt){var tn;let Sn=Ve.mpType||bt.$mpType;if(!(!Sn||Sn==="component")&&(Object.keys(Ve).forEach(Jt=>{if(E.isUniLifecycleHook(Jt,Ve[Jt],!1)){let rr=Ve[Jt];B.isArray(rr)?rr.forEach(Ar=>I(Jt,Ar,bt,ot)):I(Jt,rr,bt,ot)}}),Sn==="page")){ot.__isVisible=!0;try{xt(bt,E.ON_LOAD,ot.attrs.__pageQuery),delete ot.attrs.__pageQuery,((tn=bt.$page)===null||tn===void 0?void 0:tn.openType)!=="preloadPage"&&xt(bt,E.ON_SHOW)}catch(Jt){console.error(Jt.message+E.LINEFEED+Jt.stack)}}}function Pn(Ve,ot){st(ot,Ve.$renderjs,Ve["$"+E.RENDERJS_MODULES])}function st(Ve,ot,bt={}){if(!B.isArray(ot))return;let tn=Ve.uid,Sn=Ve.$wxsModules||(Ve.$wxsModules=[]),Jt=Ve.ctx;ot.forEach(rr=>{bt[rr]&&(Jt[rr]=W(tn,bt[rr],rr),Sn.push(rr))})}function W(Ve,ot,bt){let tn={};return new Proxy(tn,{get(Sn,Jt){return tn[Jt]||(tn[Jt]=Z(Ve,ot,bt,Jt))}})}function Z(Ve,ot,bt,tn){let Sn=()=>{},Jt=()=>E.WXS_PROTOCOL+JSON.stringify([Ve,ot,bt+"."+tn]);return new Proxy(Sn,{get(rr,Ar){return Ar==="toJSON"?Jt:Sn[Ar]||(Sn[Ar]=Z(Ve,ot,bt+"."+tn,Ar))},apply(rr,Ar,Or){return E.WXS_PROTOCOL+JSON.stringify([Ve,ot,bt+"."+tn,[...Or]])}})}function fn(Ve,ot){st(ot,Ve.$wxs,Ve["$"+E.WXS_MODULES])}function sn(Ve,ot,bt){fn(Ve,ot),Pn(Ve,ot),St(Ve,ot,bt)}function _n(Ve,ot,bt){return Ve[ot]=bt}function Wn(Ve){return function(bt,tn,Sn){if(!tn)throw bt;let Jt=Ve._instance;if(!Jt||!Jt.proxy)throw bt;xt(Jt.proxy,E.ON_ERROR,bt)}}function pi(Ve,ot){return Ve?[...new Set([].concat(Ve,ot))]:ot}function vi(Ve){E.UniLifecycleHooks.forEach(ot=>{Ve[ot]=pi})}let ar,Sr="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",Cn=/^(?:[A-Za-z\d+/]{4})*?(?:[A-Za-z\d+/]{2}(?:==)?|[A-Za-z\d+/]{3}=?)?$/;typeof atob!="function"?ar=function(Ve){if(Ve=String(Ve).replace(/[\t\n\f\r ]+/g,""),!Cn.test(Ve))throw new Error("Failed to execute 'atob' on 'Window': The string to be decoded is not correctly encoded.");Ve+="==".slice(2-(Ve.length&3));for(var ot,bt="",tn,Sn,Jt=0;Jt<Ve.length;)ot=Sr.indexOf(Ve.charAt(Jt++))<<18|Sr.indexOf(Ve.charAt(Jt++))<<12|(tn=Sr.indexOf(Ve.charAt(Jt++)))<<6|(Sn=Sr.indexOf(Ve.charAt(Jt++))),bt+=tn===64?String.fromCharCode(ot>>16&255):Sn===64?String.fromCharCode(ot>>16&255,ot>>8&255):String.fromCharCode(ot>>16&255,ot>>8&255,ot&255);return bt}:ar=atob;function wr(Ve){return decodeURIComponent(ar(Ve).split("").map(function(ot){return"%"+("00"+ot.charCodeAt(0).toString(16)).slice(-2)}).join(""))}function Cr(){let Ve=s.getStorageSync("uni_id_token")||"",ot=Ve.split(".");if(!Ve||ot.length!==3)return{uid:null,role:[],permission:[],tokenExpired:0};let bt;try{bt=JSON.parse(wr(ot[1]))}catch(tn){throw new Error("\u83B7\u53D6\u5F53\u524D\u7528\u6237\u4FE1\u606F\u51FA\u9519\uFF0C\u8BE6\u7EC6\u9519\u8BEF\u4FE1\u606F\u4E3A\uFF1A"+tn.message)}return bt.tokenExpired=bt.exp*1e3,delete bt.exp,delete bt.iat,bt}function mi(Ve){Ve.uniIDHasRole=function(ot){let{role:bt}=Cr();return bt.indexOf(ot)>-1},Ve.uniIDHasPermission=function(ot){let{permission:bt}=Cr();return this.uniIDHasRole("admin")||bt.indexOf(ot)>-1},Ve.uniIDTokenValid=function(){let{tokenExpired:ot}=Cr();return ot>Date.now()}}function ri(Ve){let ot=Ve._context.config;ot.errorHandler=E.invokeCreateErrorHandler(Ve,Wn),vi(ot.optionMergeStrategies);let bt=ot.globalProperties;mi(bt),bt.$set=_n,bt.$applyOptions=sn,E.invokeCreateVueAppHook(Ve)}return d.initApp=ri,Object.defineProperty(d,"__esModule",{value:!0}),d}({},p,k,w);return S}function tu(g,{nvue:s,UniShared:p,VueShared:w,VueReactivity:k}){let S={platform:s.config.env.platform,UniShared:p,VueShared:w,VueReactivity:k};return g(S,s.document)}function cI({setTimeout:g,clearTimeout:s,uni:p,getCurrentPages:w,Vue:k,weex:S,plus:d,BroadcastChannel:E,UniViewJSBridge:B,VueShared:We,UniShared:Lt,__uniConfig:en}){var xt=function(I,St,Pn){"use strict";let st=["navigate","redirect","switchTab","reLaunch","navigateBack"],W=["slide-in-right","slide-in-left","slide-in-top","slide-in-bottom","fade-in","zoom-out","zoom-fade-out","pop-in","none"],Z=["slide-out-right","slide-out-left","slide-out-top","slide-out-bottom","fade-out","zoom-in","zoom-fade-in","pop-out","none"],fn={hoverClass:{type:String,default:"navigator-hover"},url:{type:String,default:""},openType:{type:String,default:"navigate",validator(m){return Boolean(~st.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||W.concat(Z).includes(m)}},animationDuration:{type:[String,Number],default:300}};function sn(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":p.navigateTo({url:m.url,animationType:m.animationType||"pop-in",animationDuration:R});break;case"redirect":p.redirectTo({url:m.url,exists:m.exists});break;case"switchTab":p.switchTab({url:m.url});break;case"reLaunch":p.reLaunch({url:m.url});break;case"navigateBack":p.navigateBack({delta:m.delta,animationType:m.animationType||"pop-out",animationDuration:R});break}}}function _n(m){if(m.hoverClass&&m.hoverClass!=="none"){let R={hoverClass:m.hoverClass};return St.hasOwn(m,"hoverStartTime")&&(R.hoverStartTime=m.hoverStartTime),St.hasOwn(m,"hoverStayTime")&&(R.hoverStayTime=m.hoverStayTime),St.hasOwn(m,"hoverStopPropagation")&&(R.hoverStopPropagation=m.hoverStopPropagation),R}return{}}function Wn(m,R){return I.createElementVNode("u-text",St.extend({appendAsTree:!0},R),m)}let pi=[{"navigator-hover":{"":{backgroundColor:"rgba(0,0,0,0.1)",opacity:.7}}}],vi=I.defineComponent({name:"Navigator",props:fn,styles:pi,setup(m,{slots:R}){let U=sn(m);return()=>I.createVNode("view",I.mergeProps(_n(m),{onClick:U}),[R.default&&R.default()])}});function ar(m){return Symbol(m)}function Sr(){let m;try{m=I.getCurrentInstance().root.proxy.$page.id}catch(R){let U=d.webview.currentWebview().id;m=isNaN(Number(U))?U:Number(U)}return m}let Cn,wr,Cr;function mi(){return typeof window=="object"&&typeof navigator=="object"&&typeof document=="object"?"webview":"v8"}function ri(){return Cn.webview.currentWebview().id}let Ve,ot,bt={};function tn(m){let R=m.data&&m.data.__message;if(!R||!R.__page)return;let U=R.__page,$=bt[U];$&&$(R),R.keep||delete bt[U]}function Sn(m,R){mi()==="v8"?Cr?(Ve&&Ve.close(),Ve=new Cr(ri()),Ve.onmessage=tn):ot||(ot=wr.requireModule("globalEvent"),ot.addEventListener("plusMessage",tn)):window.__plusMessage=tn,bt[m]=R}class Jt{constructor(R){this.webview=R}sendMessage(R){let U=JSON.parse(JSON.stringify({__message:{data:R}})),$=this.webview.id;Cr?new Cr($).postMessage(U):Cn.webview.postMessageToUniNView&&Cn.webview.postMessageToUniNView(U,$)}close(){this.webview.close()}}function rr({context:m={},url:R,data:U={},style:$={},onMessage:X,onClose:J}){let te=en.darkmode;Cn=m.plus||d,wr=m.weex||(typeof S=="object"?S:null),Cr=m.BroadcastChannel||(typeof E=="object"?E:null);let ce={autoBackButton:!0,titleSize:"17px"},pe=`page${Date.now()}`;$=St.extend({},$),$.titleNView!==!1&&$.titleNView!=="none"&&($.titleNView=St.extend(ce,$.titleNView));let Pe={top:0,bottom:0,usingComponents:{},popGesture:"close",scrollIndicator:"none",animationType:"pop-in",animationDuration:200,uniNView:{path:`/${R}.js`,defaultFontSize:16,viewport:Cn.screen.resolutionWidth}};$=St.extend(Pe,$);let fe=Cn.webview.create("",pe,$,{extras:{from:ri(),runtime:mi(),data:St.extend({},U,{darkmode:te}),useGlobalEvent:!Cr}});return fe.addEventListener("close",J),Sn(pe,we=>{St.isFunction(X)&&X(we.data),we.keep||fe.close("auto")}),fe.show($.animationType,$.animationDuration),new Jt(fe)}let Ar={for:{type:String,default:""}},Or=ar("ul");function On(){let m=[];return I.provide(Or,{addHandler(R){m.push(R)},removeHandler(R){m.splice(m.indexOf(R),1)}}),m}let dn=I.defineComponent({name:"Label",props:Ar,styles:[],setup(m,{slots:R}){let U=Sr(),$=On(),X=J=>{m.for?B.emit(`uni-label-click-${U}-${m.for}`,J,!0):$.length&&$[0](J,!0)};return()=>I.createVNode("view",{onClick:X},[R.default&&R.default()])}});function Tr(m,R){_i(m.id,R),I.watch(()=>m.id,(U,$)=>{Co($,R,!0),_i(U,R,!0)}),I.onUnmounted(()=>{Co(m.id,R)})}function _i(m,R,U){let $=Sr();U&&!m||!St.isPlainObject(R)||Object.keys(R).forEach(X=>{U?X.indexOf("@")!==0&&X.indexOf("uni-")!==0&&B.on(`uni-${X}-${$}-${m}`,R[X]):X.indexOf("uni-")===0?B.on(X,R[X]):m&&B.on(`uni-${X}-${$}-${m}`,R[X])})}function Co(m,R,U){let $=Sr();U&&!m||!St.isPlainObject(R)||Object.keys(R).forEach(X=>{U?X.indexOf("@")!==0&&X.indexOf("uni-")!==0&&B.off(`uni-${X}-${$}-${m}`,R[X]):X.indexOf("uni-")===0?B.off(X,R[X]):m&&B.off(`uni-${X}-${$}-${m}`,R[X])})}function ca(m){return Object.keys(m).map(R=>[R,m[R]])}let Fi=["class","style"],Yo=/^on[A-Z]+/,Ao=(m={})=>{let{excludeListeners:R=!1,excludeKeys:U=[]}=m,$=I.getCurrentInstance(),X=I.shallowRef({}),J=I.shallowRef({}),te=I.shallowRef({}),ce=U.concat(Fi);return $.attrs=I.reactive($.attrs),I.watchEffect(()=>{let pe=ca($.attrs).reduce((Pe,[fe,we])=>(ce.includes(fe)?Pe.exclude[fe]=we:Yo.test(fe)?(R||(Pe.attrs[fe]=we),Pe.listeners[fe]=we):Pe.attrs[fe]=we,Pe),{exclude:{},attrs:{},listeners:{}});X.value=pe.attrs,J.value=pe.listeners,te.value=pe.exclude}),{$attrs:X,$listeners:J,$excludeAttrs:te}},Ji={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}},Mr=ar("uf"),ua=[{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)"}}}],Oo={default:"d",primary:"p",warn:"w"},To=I.defineComponent({inheritAttrs:!1,name:"Button",props:St.extend(Ji,{type:{type:String,default:"default"},size:{type:String,default:"default"}}),styles:ua,setup(m,{slots:R,attrs:U}){let{$attrs:$,$excludeAttrs:X,$listeners:J}=Ao({excludeListeners:!0}),te=m.type,ce=I.ref(null),pe=I.inject(Mr,!1),Pe=(Et,je)=>{let Bt=J.value.onClick||(()=>{});if(m.disabled)return;Bt(Et);let cn=m.formType;if(cn){if(!pe)return;cn==="submit"?pe.submit(Et):cn==="reset"&&pe.reset(Et)}},fe=Et=>{let je="ub-"+Oo[te]+Et;return m.disabled&&(je+="-d"),m.plain&&(je+="-plain"),m.size==="mini"&&Et==="-t"&&(je+=" ub-mini"),je},we=Et=>{if(m.disabled)return"";let je="ub-"+Oo[te]+Et+"-hover";return m.plain&&(je+="-plain"),je},ct=I.inject(Or,!1);ct&&(ct.addHandler(Pe),I.onBeforeUnmount(()=>{ct.removeHandler(Pe)})),Tr(m,{"label-click":Pe});let gt=I.computed(()=>{let Et={};for(let je in J.value){let Bt=J.value[je];je!=="onClick"&&(Et[je]=Bt)}return Et}),$t=()=>{if(!R.default)return[];let Et=R.default();return Et.length===1&&Et[0].type===I.Text?[Wn(Et[0].children,{class:"ub-t "+fe("-t")})]:Et};return()=>{let Et=St.extend({},_n(m),{hoverClass:we("")},$.value,X.value,gt.value);return I.createVNode("view",I.mergeProps({ref:ce,class:["ub",fe("")],onClick:Pe},Et),[m.loading?I.createVNode("loading-indicator",I.mergeProps({class:["ub-loading",`ub-${Oo[te]}-loading`]},{arrow:"false",animating:"true"}),null):null,...$t()])}}}),Zi={scaleArea:{type:Boolean,default:!1}};function ii(m){let R=[];return St.isArray(m)&&m.forEach(U=>{I.isVNode(U)?U.type===I.Fragment?R.push(...ii(U.children)):R.push(U):St.isArray(U)&&R.push(...ii(U))}),R}function qo(m){let R=Object.create(null);return function($){return R[$]||(R[$]=m($))}}let uo=qo(function(m){let R={},U=/;(?![^(]*\))/g,$=/:(.+)/;return m.split(U).forEach(function(X){if(X){let J=X.split($);J.length>1&&(R[J[0].trim()]=J[1].trim())}}),R}),Nn=m=>new Promise((R,U)=>{if(!m)return R({width:0,height:0,top:0,left:0});S.requireModule("dom").getComponentRect(m,({size:X})=>{R(X)})}),hr=I.defineComponent({name:"MovableArea",props:Zi,styles:[{"uni-movable-area":{"":{overflow:"hidden",width:"10px",height:"10px"}}}],setup(m,{slots:R}){let U=I.ref(0),$=I.ref(0),X=I.ref(0),J=I.ref(0),te=I.ref(!1),ce=I.ref(null),pe=[],Pe=null,fe=je=>{Pe=je},we=()=>Nn(ce.value).then(({width:je,height:Bt,top:cn,left:Wt})=>{U.value=je,$.value=Bt,X.value=cn,J.value=Wt}),ct=()=>{we().then(()=>{pe.forEach(function(je){je.setParent()})})};I.onMounted(()=>{g(()=>{te.value=!0,ct()},200)});let gt={onPanstart(je){Pe&&Pe.touchstart(je)},onPanmove(je){je.stopPropagation(),Pe&&Pe.touchmove(je)},onPanend(je){Pe&&Pe.touchend(je),Pe=null}},$t=je=>{pe.push(je)},Et=je=>{let Bt=pe.indexOf(je);Bt>=0&&pe.splice(Bt,1)};return I.provide("_isMounted",te),I.provide("parentSize",{width:U,height:$,top:X,left:J}),I.provide("addMovableViewContext",$t),I.provide("removeMovableViewContext",Et),I.provide("setTouchMovableViewContext",fe),()=>{let je=R.default&&R.default(),Bt=ii(je);return I.createVNode("view",I.mergeProps({ref:ce,class:"uni-movable-area"},gt),[Bt])}}});function fo(m){let R={};function U(fe,we){R[fe]&&R[fe](we)}function $(fe,we){R[fe]=function(ct){St.isFunction(we)&&(ct.touches=ct.changedTouches,we(ct)===!1&&ct.stopPropagation())}}let X=0,J=0,te=0,ce=0,pe=function(fe,we,ct,gt){if(m({target:fe.target,currentTarget:fe.currentTarget,stopPropagation:fe.stopPropagation.bind(fe),touches:fe.touches,changedTouches:fe.changedTouches,detail:{state:we,x:ct,y:gt,dx:ct-X,dy:gt-J,ddx:ct-te,ddy:gt-ce,timeStamp:fe.timeStamp||Date.now()}})===!1)return!1},Pe=null;return $("touchstart",function(fe){if(!Pe)return Pe=fe,X=te=fe.touches[0].pageX,J=ce=fe.touches[0].pageY,pe(fe,"start",X,J)}),$("touchmove",function(fe){if(Pe){let we=pe(fe,"move",fe.touches[0].pageX,fe.touches[0].pageY);return te=fe.touches[0].pageX,ce=fe.touches[0].pageY,we}}),$("touchend",function(fe){if(Pe)return Pe=null,pe(fe,"end",fe.changedTouches[0].pageX,fe.changedTouches[0].pageY)}),{touchstart:function(fe){U("touchstart",fe)},touchmove:function(fe){U("touchmove",fe)},touchend:function(fe){U("touchend",fe)}}}function Gn(m,R){return(U,$)=>{m.value&&R(U,Xi(U,m.value,$||{}))}}function Xi(m,R,U={}){return R=Qi(R),{type:m,timeStamp:Date.now(),target:R,currentTarget:R,detail:U}}let Po=Pn.cacheStringFunction(m=>m.charAt(0).toLowerCase()+m.slice(1));function Qi(m){let{offsetLeft:R,offsetTop:U}=m,$=m.attr,X={};return Object.keys($||{}).forEach(J=>{J.indexOf("data")===0&&(X[Po(J.replace("data",""))]=$[J])}),{id:$&&$.id||"",dataset:X,offsetLeft:R||0,offsetTop:U||0}}function bi(m,R,U){return m>R-U&&m<R+U}function Jn(m,R){return bi(m,0,R)}function Dr(){}Dr.prototype.x=function(m){return Math.sqrt(m)};function In(m,R){this._m=m,this._f=1e3*R,this._startTime=0,this._v=0}In.prototype.setV=function(m,R){let U=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/U,this._y_a=-this._f*this._y_v/U,this._t=Math.abs(m/this._x_a)||Math.abs(R/this._y_a),this._lastDt=null,this._startTime=new Date().getTime()},In.prototype.setS=function(m,R){this._x_s=m,this._y_s=R},In.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,U=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&&U<this._endPositionY||this._y_a<0&&U>this._endPositionY)&&(U=this._endPositionY),{x:R,y:U}},In.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}},In.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}},In.prototype.dt=function(){return-this._x_v/this._x_a},In.prototype.done=function(){let m=bi(this.s().x,this._endPositionX)||bi(this.s().y,this._endPositionY)||this._lastDt===this._t;return this._lastDt=null,m},In.prototype.setEnd=function(m,R){this._endPositionX=m,this._endPositionY=R},In.prototype.reconfigure=function(m,R){this._m=m,this._f=1e3*R};function Un(m,R,U){this._m=m,this._k=R,this._c=U,this._solution=null,this._endPosition=0,this._startTime=0}Un.prototype._solve=function(m,R){let U=this._c,$=this._m,X=this._k,J=U*U-4*$*X;if(J===0){let fe=-U/(2*$),we=m,ct=R/(fe*m);return{x:function(gt){return(we+ct*gt)*Math.pow(Math.E,fe*gt)},dx:function(gt){let $t=Math.pow(Math.E,fe*gt);return fe*(we+ct*gt)*$t+ct*$t}}}if(J>0){let fe=(-U-Math.sqrt(J))/(2*$),we=(-U+Math.sqrt(J))/(2*$),ct=(R-fe*m)/(we-fe),gt=m-ct;return{x:function($t){let Et,je;return $t===this._t&&(Et=this._powER1T,je=this._powER2T),this._t=$t,Et||(Et=this._powER1T=Math.pow(Math.E,fe*$t)),je||(je=this._powER2T=Math.pow(Math.E,we*$t)),gt*Et+ct*je},dx:function($t){let Et,je;return $t===this._t&&(Et=this._powER1T,je=this._powER2T),this._t=$t,Et||(Et=this._powER1T=Math.pow(Math.E,fe*$t)),je||(je=this._powER2T=Math.pow(Math.E,we*$t)),gt*fe*Et+ct*we*je}}}let te=Math.sqrt(4*$*X-U*U)/(2*$),ce=-U/2*$,pe=m,Pe=(R-ce*m)/te;return{x:function(fe){return Math.pow(Math.E,ce*fe)*(pe*Math.cos(te*fe)+Pe*Math.sin(te*fe))},dx:function(fe){let we=Math.pow(Math.E,ce*fe),ct=Math.cos(te*fe),gt=Math.sin(te*fe);return we*(Pe*te*ct-pe*te*gt)+ce*we*(Pe*gt+pe*ct)}}},Un.prototype.x=function(m){return m===void 0&&(m=(new Date().getTime()-this._startTime)/1e3),this._solution?this._endPosition+this._solution.x(m):0},Un.prototype.dx=function(m){return m===void 0&&(m=(new Date().getTime()-this._startTime)/1e3),this._solution?this._solution.dx(m):0},Un.prototype.setEnd=function(m,R,U){if(U||(U=new Date().getTime()),m!==this._endPosition||!Jn(R,.1)){R=R||0;let $=this._endPosition;this._solution&&(Jn(R,.1)&&(R=this._solution.dx((U-this._startTime)/1e3)),$=this._solution.x((U-this._startTime)/1e3),Jn(R,.1)&&(R=0),Jn($,.1)&&($=0),$+=this._endPosition),this._solution&&Jn($-m,.1)&&Jn(R,.1)||(this._endPosition=m,this._solution=this._solve($-this._endPosition,R),this._startTime=U)}},Un.prototype.snap=function(m){this._startTime=new Date().getTime(),this._endPosition=m,this._solution={x:function(){return 0},dx:function(){return 0}}},Un.prototype.done=function(m){return m||(m=new Date().getTime()),bi(this.x(),this._endPosition,.1)&&Jn(this.dx(),.1)},Un.prototype.reconfigure=function(m,R,U){this._m=m,this._k=R,this._c=U,this.done()||(this._solution=this._solve(this.x()-this._endPosition,this.dx()),this._startTime=new Date().getTime())},Un.prototype.springConstant=function(){return this._k},Un.prototype.damping=function(){return this._c},Un.prototype.configuration=function(){function m(U,$){U.reconfigure(1,$,U.damping())}function R(U,$){U.reconfigure(1,U.springConstant(),$)}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 qr(m,R,U){this._springX=new Un(m,R,U),this._springY=new Un(m,R,U),this._springScale=new Un(m,R,U),this._startTime=0}qr.prototype.setEnd=function(m,R,U,$){let X=new Date().getTime();this._springX.setEnd(m,$,X),this._springY.setEnd(R,$,X),this._springScale.setEnd(U,$,X),this._startTime=X},qr.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)}},qr.prototype.done=function(){let m=new Date().getTime();return this._springX.done(m)&&this._springY.done(m)&&this._springScale.done(m)},qr.prototype.reconfigure=function(m,R,U){this._springX.reconfigure(m,R,U),this._springY.reconfigure(m,R,U),this._springScale.reconfigure(m,R,U)};let Io={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 oi(m,R){return+((1e3*m-1e3*R)/1e3).toFixed(1)}function Kr(m,R,U){let $={id:0,cancelled:!1},X=function(te){te&&te.id&&Fr(te.id),te&&(te.cancelled=!0)};function J(te,ce,pe,Pe){if(!te||!te.cancelled){pe(ce);let fe=ce.done();fe||te.cancelled||(te.id=eo(J.bind(null,te,ce,pe,Pe))),fe&&Pe&&Pe(ce)}}return J($,m,R,U),{cancel:X.bind(null,$),model:m}}let sr=!1;function Vi(m){sr||(sr=!0,eo(function(){m(),sr=!1}))}function eo(m){return g(m,16)}function Fr(m){s(m)}let Ei=S.requireModule("animation"),gr=I.defineComponent({name:"MovableView",props:Io,emits:["change","scale"],styles:[{"uni-movable-view":{"":{position:"absolute",top:"0px",left:"0px",width:"10px",height:"10px"}}}],setup(m,{emit:R,slots:U}){let $=I.ref(null),X=Gn($,R),J=I.inject("setTouchMovableViewContext",()=>{}),te=gn(m,X,$,J);return()=>{let ce={preventGesture:!0};return I.createVNode("view",I.mergeProps({ref:$,onTouchstart:te,class:"uni-movable-view",style:"transform-origin: center;"},ce),[U.default&&U.default()])}}});function gn(m,R,U,$){let X=I.inject("_isMounted",I.ref(!1)),J=I.inject("parentSize",{width:I.ref(0),height:I.ref(0),top:I.ref(0),left:I.ref(0)}),te=I.inject("addMovableViewContext",()=>{}),ce=I.inject("removeMovableViewContext",()=>{}),pe={touchstart:()=>{},touchmove:()=>{},touchend:()=>{}};function Pe(Be){return Number(Be)||0}function fe(Be){return Be=Number(Be),isNaN(Be)?1:Be}let we=I.ref(Pe(m.x)),ct=I.ref(Pe(m.y)),gt=I.ref(fe(Number(m.scaleValue))),$t=I.ref(0),Et=I.ref(0),je=I.ref(0),Bt=I.ref(0),cn=I.ref(0),Wt=I.ref(0),ht=null,Zt=null,Rn={x:0,y:0},Gt={x:0,y:0},Ut=1,Ft=0,qt=0,Xo=!1,ci,ei,Gi=null,Ga=null,Mn={top:0,left:0,width:0,height:0},Dn=new Dr,Ir=new Dr,Fn={historyX:[0,0],historyY:[0,0],historyT:[0,0]},br=I.computed(()=>{let Be=Number(m.damping);return isNaN(Be)?20:Be}),zr=I.computed(()=>{let Be=Number(m.friction);return isNaN(Be)||Be<=0?2:Be}),Qo=I.computed(()=>{let Be=Number(m.scaleMin);return isNaN(Be)?.5:Be}),cs=I.computed(()=>{let Be=Number(m.scaleMax);return isNaN(Be)?10:Be}),nn=I.computed(()=>m.direction==="all"||m.direction==="horizontal"),pn=I.computed(()=>m.direction==="all"||m.direction==="vertical"),Vn=new qr(1,9*Math.pow(br.value,2)/40,br.value),zn=new In(1,zr.value);I.watch(()=>m.x,Be=>{we.value=Pe(Be)}),I.watch(()=>m.y,Be=>{ct.value=Pe(Be)}),I.watch(()=>m.scaleValue,Be=>{gt.value=fe(Number(Be))}),I.watch(we,us),I.watch(ct,Ya),I.watch(gt,ea),I.watch(Qo,Na),I.watch(cs,Na);function Ci(){Zt&&Zt.cancel(),ht&&ht.cancel()}function us(Be){if(nn.value){if(Be+Gt.x===Ft)return Ft;ht&&ht.cancel(),bo(Be+Gt.x,ct.value+Gt.y,Ut)}return Be}function Ya(Be){if(pn.value){if(Be+Gt.y===qt)return qt;ht&&ht.cancel(),bo(we.value+Gt.x,Be+Gt.y,Ut)}return Be}function Na(){if(!m.scale)return!1;Li(Ut,!0)}function ea(Be){return m.scale?(Be=_o(Be),Li(Be,!0),Be):!1}function so(){m.disabled||(Ci(),Fn.historyX=[0,0],Fn.historyY=[0,0],Fn.historyT=[0,0],nn.value&&(ci=Ft),pn.value&&(ei=qt),Gi=null,Ga=null,Xo=!0)}function qa(Be){if(!m.disabled&&Xo){let Pt=Ft,Ot=qt;if(Ga===null&&(Ga=Math.abs(Be.detail.dx/Be.detail.dy)>1?"htouchmove":"vtouchmove"),nn.value&&(Pt=Be.detail.dx+ci,Fn.historyX.shift(),Fn.historyX.push(Pt),!pn.value&&Gi===null&&(Gi=Math.abs(Be.detail.dx/Be.detail.dy)<1)),pn.value&&(Ot=Be.detail.dy+ei,Fn.historyY.shift(),Fn.historyY.push(Ot),!nn.value&&Gi===null&&(Gi=Math.abs(Be.detail.dy/Be.detail.dx)<1)),Fn.historyT.shift(),Fn.historyT.push(Be.detail.timeStamp),!Gi){let yn="touch";Pt<je.value?m.outOfBounds?(yn="touch-out-of-bounds",Pt=je.value-Dn.x(je.value-Pt)):Pt=je.value:Pt>cn.value&&(m.outOfBounds?(yn="touch-out-of-bounds",Pt=cn.value+Dn.x(Pt-cn.value)):Pt=cn.value),Ot<Bt.value?m.outOfBounds?(yn="touch-out-of-bounds",Ot=Bt.value-Ir.x(Bt.value-Ot)):Ot=Bt.value:Ot>Wt.value&&(m.outOfBounds?(yn="touch-out-of-bounds",Ot=Wt.value+Ir.x(Ot-Wt.value)):Ot=Wt.value),Vi(function(){Fo(Pt,Ot,Ut,yn)})}}}function fs(){if(!m.disabled&&Xo&&(Xo=!1,!Gi&&!ds("out-of-bounds")&&m.inertia)){let Be=1e3*(Fn.historyX[1]-Fn.historyX[0])/(Fn.historyT[1]-Fn.historyT[0]),Pt=1e3*(Fn.historyY[1]-Fn.historyY[0])/(Fn.historyT[1]-Fn.historyT[0]);zn.setV(Be,Pt),zn.setS(Ft,qt);let Ot=zn.delta().x,yn=zn.delta().y,Er=Ot+Ft,Ai=yn+qt;Er<je.value?(Er=je.value,Ai=qt+(je.value-Ft)*yn/Ot):Er>cn.value&&(Er=cn.value,Ai=qt+(cn.value-Ft)*yn/Ot),Ai<Bt.value?(Ai=Bt.value,Er=Ft+(Bt.value-qt)*Ot/yn):Ai>Wt.value&&(Ai=Wt.value,Er=Ft+(Wt.value-qt)*Ot/yn),zn.setEnd(Er,Ai),Zt=Kr(zn,function(){let Yi=zn.s(),Eo=Yi.x,ka=Yi.y;Fo(Eo,ka,Ut,"friction")},function(){Zt.cancel()})}}function Wr(Be,Pt){let Ot=!1;return Be>cn.value?(Be=cn.value,Ot=!0):Be<je.value&&(Be=je.value,Ot=!0),Pt>Wt.value?(Pt=Wt.value,Ot=!0):Pt<Bt.value&&(Pt=Bt.value,Ot=!0),{x:Be,y:Pt,outOfBounds:Ot}}function Ka(){Rn.x=Mn.left-J.left.value,Rn.y=Mn.top-J.top.value}function Ja(Be){Be=Be||Ut,Be=_o(Be),Et.value=Mn.height/Ut,$t.value=Mn.width/Ut;let Pt=Et.value*Be,Ot=$t.value*Be;Gt.x=(Ot-$t.value)/2,Gt.y=(Pt-Et.value)/2}function Do(){let Be=0-Rn.x+Gt.x,Pt=J.width.value-$t.value-Rn.x-Gt.x;je.value=Math.min(Be,Pt),cn.value=Math.max(Be,Pt);let Ot=0-Rn.y+Gt.y,yn=J.height.value-Et.value-Rn.y-Gt.y;Bt.value=Math.min(Ot,yn),Wt.value=Math.max(Ot,yn)}function Li(Be,Pt){if(m.scale){Be=_o(Be),Ja(Be),Do();let Ot=Wr(Ft,qt),yn=Ot.x,Er=Ot.y;Pt?bo(yn,Er,Be,"",!0,!0):Vi(function(){Fo(yn,Er,Be,"",!0,!0)})}}function _o(Be){return Be=Math.max(.5,Qo.value,Be),Be=Math.min(10,cs.value,Be),Be}function bo(Be,Pt,Ot,yn,Er,Ai){Ci(),nn.value||(Be=Ft),pn.value||(Pt=qt),m.scale||(Ot=Ut);let Yi=Wr(Be,Pt);if(Be=Yi.x,Pt=Yi.y,!m.animation){Fo(Be,Pt,Ot,yn,Er,Ai);return}Vn._springX._solution=null,Vn._springY._solution=null,Vn._springScale._solution=null,Vn._springX._endPosition=Ft,Vn._springY._endPosition=qt,Vn._springScale._endPosition=Ut,Vn.setEnd(Be,Pt,Ot,1),ht=Kr(Vn,function(){let Eo=Vn.x(),ka=Eo.x,ta=Eo.y,gs=Eo.scale;Fo(ka,ta,gs,yn,Er,Ai)},function(){ht.cancel()})}function ds(Be){let Pt=Wr(Ft,qt),Ot=Pt.x,yn=Pt.y,Er=Pt.outOfBounds;return Er&&bo(Ot,yn,Ut,Be),Er}function Fo(Be,Pt,Ot,yn="",Er,Ai){Be!==null&&Be.toString()!=="NaN"&&typeof Be=="number"||(Be=Ft||0),Pt!==null&&Pt.toString()!=="NaN"&&typeof Pt=="number"||(Pt=qt||0),Be=Number(Be.toFixed(1)),Pt=Number(Pt.toFixed(1)),Ot=Number(Ot.toFixed(1)),Ft===Be&&qt===Pt||Er||R("change",{x:oi(Be,Gt.x),y:oi(Pt,Gt.y),source:yn}),m.scale||(Ot=Ut),Ot=_o(Ot),Ot=+Ot.toFixed(3),Ai&&Ot!==Ut&&R("scale",{x:Be,y:Pt,scale:Ot});let Yi=`translate(${Be}px, ${Pt}px) scale(${Ot})`;Ei.transition(U.value,{styles:{transform:Yi},duration:0,delay:0}),Ft=Be,qt=Pt,Ut=Ot}function Bs(){return Nn(U.value).then(Be=>{Mn=Be})}function hs(){if(!X.value)return;Ci();let Be=m.scale?gt.value:1;Ka(),Ja(Be),Do(),Ft=we.value+Gt.x,qt=ct.value+Gt.y;let Pt=Wr(Ft,qt),Ot=Pt.x,yn=Pt.y;Fo(Ot,yn,Be,"",!0)}return I.onMounted(()=>{pe=fo(Pt=>{switch(Pt.detail.state){case"start":so();break;case"move":qa(Pt);break;case"end":fs()}}),g(()=>{Bs().then(()=>{hs()})},100),zn.reconfigure(1,zr.value),Vn.reconfigure(1,9*Math.pow(br.value,2)/40,br.value);let Be={setParent:hs};te(Be),I.onUnmounted(()=>{ce(Be)})}),I.onUnmounted(()=>{Ci()}),()=>{$(pe)}}let Jr=16,kr={activeColor:Pn.PRIMARY_COLOR,backgroundColor:"#EBEBEB",activeMode:"backwards"},Mt={percent:{type:[Number,String],default:0,validator(m){return!isNaN(parseFloat(m))}},fontSize:{type:[String,Number],default:Jr},showInfo:{type:[Boolean,String],default:!1},strokeWidth:{type:[Number,String],default:6,validator(m){return!isNaN(parseFloat(m))}},color:{type:String,default:kr.activeColor},activeColor:{type:String,default:kr.activeColor},backgroundColor:{type:String,default:kr.backgroundColor},active:{type:[Boolean,String],default:!1},activeMode:{type:String,default:kr.activeMode},duration:{type:[Number,String],default:30,validator(m){return!isNaN(parseFloat(m))}},borderRadius:{type:[Number,String],default:0}},Oe=[{"uni-progress":{"":{flex:1,flexDirection:"row",alignItems:"center"}},"uni-progress-bar":{"":{flex:1}},"uni-progress-inner-bar":{"":{position:"absolute"}},"uni-progress-info":{"":{marginLeft:"15px"}}}],Zr=I.defineComponent({name:"Progress",props:Mt,styles:Oe,emits:["activeend"],setup(m,{emit:R}){let U=I.ref(null),$=I.ref(null),X=Gn(U,R),J=Ii(m);return I.watch(()=>J.realPercent,(te,ce)=>{J.lastPercent=ce||0,ai(J,m,X)}),I.onMounted(()=>{g(()=>{Nn($.value).then(({width:te})=>{J.progressWidth=te||0,ai(J,m,X)})},50)}),()=>{let{showInfo:te,fontSize:ce}=m,{outerBarStyle:pe,innerBarStyle:Pe,currentPercent:fe}=J;return I.createVNode("div",{ref:U,class:"uni-progress"},[I.createVNode("div",{ref:$,style:pe,class:"uni-progress-bar"},[I.createVNode("div",{style:Pe,class:"uni-progress-inner-bar"},null)]),te?Wn(fe+"%",{class:"uni-progress-info",style:{fontSize:ce}}):null])}}});function Ii(m){let R=I.ref(0),U=I.ref(0),$=I.computed(()=>({backgroundColor:m.backgroundColor,borderRadius:m.borderRadius,height:m.strokeWidth})),X=I.computed(()=>{let ce=m.color!==kr.activeColor&&m.activeColor===kr.activeColor?m.color:m.activeColor;return{width:R.value*U.value/100,height:m.strokeWidth,backgroundColor:ce,borderRadius:m.borderRadius}}),J=I.computed(()=>{let ce=parseFloat(m.percent);return ce<0&&(ce=0),ce>100&&(ce=100),ce});return I.reactive({outerBarStyle:$,innerBarStyle:X,realPercent:J,currentPercent:R,strokeTimer:0,lastPercent:0,progressWidth:U})}function ai(m,R,U){m.strokeTimer&&clearInterval(m.strokeTimer),R.active?(m.currentPercent=R.activeMode===kr.activeMode?0:m.lastPercent,m.strokeTimer=setInterval(()=>{m.currentPercent+1>m.realPercent?(m.currentPercent=m.realPercent,m.strokeTimer&&clearInterval(m.strokeTimer),U("activeend",{})):m.currentPercent+=1},parseFloat(R.duration))):m.currentPercent=m.realPercent}let Vr={value:{type:Array,default(){return[]},validator:function(m){return St.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:""}},Ni=St.extend({},Vr,{height:{type:[Number,String],default:0},maskTopStyle:{type:String,default:""},maskBottomStyle:{type:String,default:""}}),pr=I.defineComponent({name:"PickerView",props:Ni,emits:["change","update:value"],setup(m,{slots:R,emit:U}){let $=I.ref(null),X=$r(m),J=Gn($,U),te=[],ce=Pe=>Array.prototype.indexOf.call(te.filter(fe=>fe.type!==I.Comment),Pe),pe=Pe=>I.computed({get(){let fe=ce(Pe.vnode);return X.value[fe]||0},set(fe){if(!Pe.data._isMounted)return;let we=ce(Pe.vnode);if(we<0)return;if(X.value[we]!==fe){X.value[we]=fe;let gt=X.value.map($t=>$t);U("update:value",gt),J("change",{value:gt})}}});return I.provide("getPickerViewColumn",pe),I.provide("pickerViewProps",m),()=>{let Pe=R.default&&R.default();te=ii(Pe);let fe=m.height?{height:`${parseFloat(m.height)}px`}:{};return I.createVNode("view",I.mergeProps({ref:$,class:"uni-picker-view",style:fe},{preventGesture:!0}),[I.createVNode("view",{class:"uni-picker-view-wrapper"},[te])])}},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 $r(m){let R=I.reactive([...m.value]),U=I.reactive({value:R});return I.watch(()=>m.value,$=>{U.value.length=$.length,I.nextTick(()=>{$.forEach((X,J)=>{X!==U.value[J]&&U.value.splice(J,1,X)})})}),U}let Xr=S.requireModule("dom"),Pr=S.config.env.platform.toLowerCase()==="android";function ki(m){return St.extend({},St.isString(m)?uo(m):m)}let ln={length:{type:[Number,String],default:0}},$i=I.defineComponent({name:"PickerViewColumn",props:ln,data:()=>({_isMounted:!1}),setup(m,{slots:R}){let U=I.getCurrentInstance(),$=I.ref(null),X=I.ref(null),J=I.ref(null),te=I.ref(null),ce=I.inject("pickerViewProps"),Pe=I.inject("getPickerViewColumn")(U),fe=I.computed(()=>ki(ce.indicatorStyle)),we=I.computed(()=>ki(ce.maskTopStyle)),ct=I.computed(()=>ki(ce.maskBottomStyle)),gt=I.ref(0);gt.value=Ur(fe.value);let $t=I.ref(0);$t.value=parseFloat(ce.height);let{setCurrent:Et,onScrollend:je}=to(m,Pe,X,gt),Bt=()=>{let Wt,ht;g(()=>{Promise.all([Nn($.value).then(({height:Zt})=>{Wt=$t.value=Zt}),Pr&&m.length?Nn(J.value).then(({height:Zt})=>{ht=gt.value=Zt/parseFloat(m.length)}):Nn(te.value).then(({height:Zt})=>{ht=gt.value=Zt})]).then(()=>{Wt&&ht?g(()=>{U.data._isMounted=!0,Et(Pe.value,!1,!0)},50):Bt()})},50)};I.onMounted(Bt);let cn=Wt=>Wt?Pr?I.createVNode("div",{ref:J,style:"flex-direction:column;"},[Wt]):Wt:null;return()=>{let Wt=R.default&&R.default(),ht=($t.value-gt.value)/2,Zt=`${$t.value-ht}px`,Rn={showScrollbar:!1,scrollToBegin:!1,decelerationRate:.3,scrollY:!0};return Pr||(Rn.scrollTop=Pe.value*gt.value),I.createVNode("view",{ref:$,class:"uni-picker-view-column"},[I.createVNode("scroll-view",I.mergeProps({class:"uni-picker-view-group",style:"flex-direction:column;",onScrollend:je},Rn),[I.createVNode("view",{ref:X,class:"uni-picker-view-content",style:{paddingTop:`${ht}px`,paddingBottom:`${ht}px`}},[cn(Wt)])]),I.createVNode("u-scalable",{class:"uni-picker-view-mask"},[I.createVNode("u-scalable",{class:"uni-picker-view-mask uni-picker-view-mask-top",style:St.extend({},we.value,{bottom:Zt})},null),I.createVNode("u-scalable",{class:"uni-picker-view-mask uni-picker-view-mask-bottom",style:St.extend({},ct.value,{top:Zt})},null)]),I.createVNode("u-scalable",{ref:te,class:"uni-picker-view-indicator",style:St.extend({},fe.value,{top:`${ht}px`})},null)])}},styles:[{"uni-picker-view-column":{"":{flex:1,position:"relative",alignItems:"stretch",overflow:"hidden"}},"uni-picker-view-mask":{"":{position:"absolute",top:0,left:0,right:0,bottom:0,pointerEvents:"none"}},"uni-picker-view-mask-top":{"":{bottom:0,backgroundImage:"linear-gradient(to bottom,rgba(255, 255, 255, 0.95),rgba(255, 255, 255, 0.6))"}},"uni-picker-view-mask-bottom":{"":{top:0,backgroundImage:"linear-gradient(to top,rgba(255, 255, 255, 0.95),rgba(255, 255, 255, 0.6))"}},"uni-picker-view-group":{"":{position:"absolute",top:0,left:0,right:0,bottom:0}},"uni-picker-view-content":{"":{flexDirection:"column",paddingTop:0,paddingRight:0,paddingBottom:0,paddingLeft:0}},"uni-picker-view-indicator":{"":{position:"absolute",left:0,right:0,top:0,height:"34px",pointerEvents:"none",borderColor:"#e5e5e5",borderTopWidth:"1px",borderBottomWidth:"1px"}}}]});function Ur(m){let U=(m.height||m.lineHeight||"").match(/(-?[\d\.]+)px/),$=0;return U&&($=parseFloat(U[1])),$}function to(m,R,U,$){let X;function J(pe,Pe=!0){Xr.scrollToElement(U.value,{offset:pe*$.value,animated:Pe}),Pe&&(X=Date.now())}I.watch(()=>m.length,()=>{g(()=>{te(R.value,!0,!0)},150)}),I.watch(R,pe=>J(pe));let te=(pe,Pe=!0,fe)=>{R.value===pe&&!fe||(R.value=pe,Pr&&J(pe,Pe))};return{setCurrent:te,onScrollend:pe=>{if(Date.now()-X<340)return;let Pe=pe.detail.contentOffset.y,fe=Math.round(Pe/$.value);Pe%$.value?te(fe,!0,!0):R.value=fe}}}let bn={SELECTOR:"selector",MULTISELECTOR:"multiSelector",TIME:"time",DATE:"date"},Hr={YEAR:"year",MONTH:"month",DAY:"day"};function ir(m){return m>9?m:`0${m}`}function yi(m,R){m=String(m||"");let U=new Date;if(R===bn.TIME){let $=m.split(":");$.length===2&&U.setHours(parseInt($[0]),parseInt($[1]))}else{let $=m.split("-");$.length===3&&U.setFullYear(parseInt($[0]),parseInt(String(parseFloat($[1])-1)),parseInt($[2]))}return U}function Ri(m){if(m.mode===bn.TIME)return"00:00";if(m.mode===bn.DATE){let R=new Date().getFullYear()-100;switch(m.fields){case Hr.YEAR:return R;case Hr.MONTH:return R+"-01";default:return R+"-01-01"}}return""}function vr(m){if(m.mode===bn.TIME)return"23:59";if(m.mode===bn.DATE){let R=new Date().getFullYear()+100;switch(m.fields){case Hr.YEAR:return R;case Hr.MONTH:return R+"-12";default:return R+"-12-31"}}return""}let Qr={name:{type:String,default:""},range:{type:Array,default(){return[]}},rangeKey:{type:String,default:""},value:{type:[Number,String,Array],default:0},mode:{type:String,default:bn.SELECTOR,validator(m){return Object.values(bn).indexOf(m)>=0}},fields:{type:String,default:""},start:{type:String,default:Ri},end:{type:String,default:vr},disabled:{type:[Boolean,String],default:!1}},Zn=I.defineComponent({name:"Picker",props:Qr,emits:["change","cancel","columnchange"],setup(m,{slots:R,emit:U}){let $=I.ref(null),X=Gn($,U),J=I.ref(null),te=I.ref(null),ce=()=>{let Et=m.value;switch(m.mode){case bn.MULTISELECTOR:{St.isArray(Et)||(Et=[]),St.isArray(J.value)||(J.value=[]);let je=J.value.length=Math.max(Et.length,m.range.length);for(let Bt=0;Bt<je;Bt++){let cn=Number(Et[Bt]),Wt=Number(J.value[Bt]),ht=isNaN(cn)?isNaN(Wt)?0:Wt:cn;J.value.splice(Bt,1,ht<0?0:ht)}}break;case bn.TIME:case bn.DATE:J.value=String(Et);break;default:{let je=Number(Et);J.value=je<0?0:je;break}}},pe=Et=>{te.value&&te.value.sendMessage(Et)},Pe=Et=>{let je={event:"cancel"};te.value=rr({url:"__uniapppicker",data:Et,style:{titleNView:!1,animationType:"none",animationDuration:0,background:"rgba(0,0,0,0)",popGesture:"none"},onMessage:Bt=>{let cn=Bt.event;if(cn==="created"){pe(Et);return}if(cn==="columnchange"){delete Bt.event,X(cn,Bt);return}je=Bt},onClose:()=>{te.value=null;let Bt=je.event;delete je.event,Bt&&X(Bt,je)}})},fe=Et=>{d.nativeUI[m.mode===bn.TIME?"pickTime":"pickDate"](je=>{let Bt=je.date;X("change",{value:m.mode===bn.TIME?`${ir(Bt.getHours())}:${ir(Bt.getMinutes())}`:`${Bt.getFullYear()}-${ir(Bt.getMonth()+1)}-${ir(Bt.getDate())}`})},()=>{X("cancel",{})},m.mode===bn.TIME?{time:yi(m.value,bn.TIME)}:{date:yi(m.value,bn.DATE),minDate:yi(m.start,bn.DATE),maxDate:yi(m.end,bn.DATE)})},we=Et=>{(Et.mode===bn.TIME||Et.mode===bn.DATE)&&!Et.fields?fe():(Et.fields=Object.values(Hr).includes(Et.fields)?Et.fields:Hr.DAY,Pe(Et))},ct=Et=>{m.disabled||we(St.extend({},m,{value:J.value,locale:p.getLocale()}))},gt=I.inject(Mr,!1),$t={submit:()=>[m.name,J.value],reset:()=>{switch(m.mode){case bn.SELECTOR:J.value=0;break;case bn.MULTISELECTOR:St.isArray(m.value)&&(J.value=m.value.map(Et=>0));break;case bn.DATE:case bn.TIME:J.value="";break}}};return gt&&(gt.addField($t),I.onBeforeUnmount(()=>gt.removeField($t))),Object.keys(m).forEach(Et=>{I.watch(()=>m[Et],je=>{let Bt={};Bt[Et]=je,pe(Bt)},{deep:!0})}),I.watch(()=>m.value,ce,{deep:!0}),ce(),()=>I.createVNode("view",{ref:$,onClick:ct},[R.default&&R.default()])}}),Xn={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}},Hn=[{"uni-slider":{"":{flex:1,flexDirection:"column"}},"uni-slider-wrapper":{"":{flexDirection:"row",justifyContent:"center",alignItems:"center"}},"uni-slider-tap-area":{"":{position:"relative",flex:1,flexDirection:"row",alignItems:"center",paddingTop:"14",paddingBottom:"14"}},"uni-slider-handle-wrapper":{"":{position:"relative",flex:1,backgroundColor:"#e9e9e9",height:"2",borderRadius:"5",marginRight:"14",marginLeft:"14"}},"uni-slider-track":{"":{height:"2",borderRadius:"6",backgroundColor:"#007aff"}},"uni-slider-thumb":{"":{position:"absolute",top:"1",width:"28",height:"28",borderRadius:50,boxShadow:"0 0 4px #ebebeb"}},"uni-slider-value":{"":{color:"#888888",fontSize:"16",width:"30"}}}],Qn=I.defineComponent({name:"USlider",props:Xn,styles:Hn,setup(m,{emit:R}){let U=I.ref(null),$=I.ref(null),X=Gn(U,R),J=lr(m),te=ho(m,J,X);return go(m,J),I.watch(()=>m.value,ce=>{J.sliderValue=Number(ce)}),I.onMounted(()=>{g(()=>{Nn($.value).then(({width:ce,left:pe})=>{J.sliderLeft=pe,J.sliderWidth=ce||0,J.sliderValue=Number(m.value)})},100)}),()=>{let{showValue:ce}=m,{trackTapStyle:pe,trackStyle:Pe,trackActiveStyle:fe,thumbStyle:we,sliderValue:ct}=J;return I.createVNode("div",{class:"uni-slider",ref:U},[I.createVNode("div",{class:"uni-slider-wrapper"},[I.createVNode("div",I.mergeProps({class:"uni-slider-tap-area",style:pe},te),[I.createVNode("div",{class:"uni-slider-handle-wrapper",style:Pe,ref:$},[I.createVNode("div",{class:"uni-slider-track",style:fe},null)]),I.createVNode("div",{class:"uni-slider-thumb",style:we},null)]),ce?Wn(ct+"",{class:"uni-slider-value"}):null])])}}});function lr(m){let R=I.ref(0),U=I.ref(0),$=I.ref(0),X=()=>m.backgroundColor!=="#e9e9e9"?m.backgroundColor:m.color!=="#007aff"?m.color:"#007aff",J=()=>m.activeColor!=="#007aff"?m.activeColor:m.selectedColor!=="#e9e9e9"?m.selectedColor:"#e9e9e9",te=()=>{let Pe=Number(m.max),fe=Number(m.min);return($.value-fe)/(Pe-fe)*U.value},ce=Number(m.blockSize)/2;return I.reactive({sliderLeft:R,sliderWidth:U,sliderValue:$,sliderThumbOffset:ce,trackTapStyle:I.computed(()=>({paddingTop:ce,paddingBottom:ce})),trackStyle:I.computed(()=>({backgroundColor:X(),marginLeft:ce,marginRight:ce})),trackActiveStyle:I.computed(()=>({backgroundColor:J(),width:te()})),thumbStyle:I.computed(()=>({width:m.blockSize,height:m.blockSize,backgroundColor:m.blockColor,left:te()}))})}function ho(m,R,U){let $=null;function X(ce,pe){m.disabled||(ce==="move"?(J(pe),U("changing",{value:R.sliderValue})):ce==="end"&&(J(pe),U("change",{value:R.sliderValue})))}function J(ce){ce-=R.sliderThumbOffset,ce<0&&(ce=0),ce>R.sliderWidth&&(ce=R.sliderWidth);let pe=Number(m.max),Pe=Number(m.min),fe=Number(m.step),we=ce/R.sliderWidth*(pe-Pe);fe>0&&we>fe&&we%fe/fe!==0?we-=we%fe:we=parseInt(we+""),R.sliderValue=we+Pe}return{onTouchstart(ce){ce.changedTouches.length===1&&!$&&($=ce,X("start",ce.changedTouches[0].pageX))},onTouchmove(ce){ce.changedTouches.length===1&&$&&X("move",ce.changedTouches[0].pageX)},onTouchend(ce){ce.changedTouches.length===1&&$&&($=null,X("end",ce.changedTouches[0].pageX))}}}function go(m,R){let U=I.inject(Mr,!1),$={submit:()=>{let X=["",null];return m.name&&(X[0]=m.name,X[1]=R.sliderValue),X},reset:()=>{R.sliderValue=Number(m.value)}};U&&(U.addField($),I.onUnmounted(()=>{U.removeField($)}))}let No={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"}},no={switch:"switch",checkbox:"checkbox"},ko={width:52,height:32},jr=I.defineComponent({name:"Switch",props:No,emits:["change"],setup(m,{emit:R}){let U=I.ref(null),$=I.ref(m.checked),X=Rr(m,$),J=Gn(U,R);I.watch(()=>m.checked,ce=>{$.value=ce});let te=(ce,pe)=>{m.disabled||($.value=ce.detail?ce.detail.value:!$.value,J("change",{value:$.value}))};return X&&(X.addHandler(te),I.onBeforeUnmount(()=>{X.removeHandler(te)})),Tr(m,{"label-click":te}),()=>{let{color:ce,type:pe,disabled:Pe}=m;return I.createVNode("div",{ref:U},[pe===no.switch?I.createVNode("dc-switch",I.mergeProps({dataUncType:"uni-switch"},{onChange:te},{checked:$.value,color:ce,disabled:Pe},{style:ko}),null):null,pe===no.checkbox?I.createVNode(I.resolveComponent("checkbox"),I.mergeProps({style:{color:ce}},{checked:$.value,disabled:Pe},{onClick:te}),null):null])}}});function Rr(m,R){let U=I.inject(Mr,!1),$=I.inject(Or,!1),X={submit:()=>{let J=["",null];return m.name&&(J[0]=m.name,J[1]=R.value),J},reset:()=>{R.value=!1}};return U&&(U.addField(X),I.onUnmounted(()=>{U.removeField(X)})),$}let ro={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:""}},Ko=ar("ucg"),xi={name:{type:String,default:""}},Ui=[{"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"}}}],Ro=I.defineComponent({name:"Checkbox",props:ro,styles:Ui,setup(m,{slots:R}){let U=I.ref(null),$=I.ref(m.checked),X=I.ref(m.value),J=I.computed(()=>m.disabled?"#adadad":m.color),te=()=>{$.value=!1},ce=(we,ct)=>{m.disabled||($.value=!$.value,pe&&pe.checkboxChange(we))},{uniCheckGroup:pe,uniLabel:Pe}=Bi($,X,te);Pe&&(Pe.addHandler(ce),I.onBeforeUnmount(()=>{Pe.removeHandler(ce)})),Tr(m,{"label-click":ce}),I.watch([()=>m.checked,()=>m.value],([we,ct])=>{$.value=we,X.value=ct});let fe=()=>{if(!R.default)return[];let we=R.default();return we.length===1&&we[0].type===Text?[Wn(we[0].children,{class:"uni-checkbox-slot"})]:we};return()=>I.createVNode("div",I.mergeProps({ref:U},{dataUncType:"uni-checkbox"},{onClick:ce,class:"uni-checkbox"}),[I.createVNode("div",{class:["uni-checkbox-input",{"uni-checkbox-input-disabled":m.disabled}]},[$.value?Wn("\uEA08",{class:"uni-icon",style:{color:J.value}}):null]),...fe()])}});function Bi(m,R,U){let $=I.computed(()=>({checkboxChecked:Boolean(m.value),value:R.value})),X={reset:U},J=I.inject(Ko,!1);J&&J.addField($);let te=I.inject(Mr,!1);te&&te.addField(X);let ce=I.inject(Or,!1);return I.onBeforeUnmount(()=>{J&&J.removeField($),te&&te.removeField(X)}),{uniCheckGroup:J,uniForm:te,uniLabel:ce}}let Hi=I.defineComponent({name:"CheckboxGroup",props:xi,emits:["change"],setup(m,{slots:R,emit:U}){let $=I.ref(null),X=Gn($,U);return xo(m,X),()=>I.createVNode("div",{ref:$,class:"uni-checkbox-group"},[R.default&&R.default()])}});function xo(m,R){let U=[],$=()=>U.reduce((J,te)=>(te.value.checkboxChecked&&J.push(te.value.value),J),new Array);I.provide(Ko,{addField(J){U.push(J)},removeField(J){U.splice(U.indexOf(J),1)},checkboxChange(J){R("change",{value:$()})}});let X=I.inject(Mr,!1);return X&&X.addField({submit:()=>{let J=["",null];return m.name!==""&&(J[0]=m.name,J[1]=$()),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:""}},Q=ar("ucg"),he={name:{type:String,default:""}},se=[{"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"}}}],de=I.defineComponent({name:"Radio",props:x,styles:se,emits:["change"],setup(m,{slots:R}){let U=I.ref(null),$=I.ref(m.checked),X=I.ref(m.value),J=I.computed(()=>{let ct=m.disabled?"#adadad":m.color;return $.value?{backgroundColor:ct,borderColor:ct}:{borderColor:"#d1d1d1"}}),te=()=>{$.value=!1},{uniCheckGroup:ce,uniLabel:pe,field:Pe}=mt($,X,te),fe=(ct,gt)=>{m.disabled||$.value||($.value=!$.value,ce&&ce.radioChange(ct,Pe))};pe&&(pe.addHandler(fe),I.onBeforeUnmount(()=>{pe.removeHandler(fe)})),Tr(m,{"label-click":fe}),I.watch([()=>m.checked,()=>m.value],([ct,gt])=>{$.value=ct,X.value=gt});let we=()=>{if(!R.default)return[];let ct=R.default();return ct.length===1&&ct[0].type===Text?[Wn(ct[0].children,{class:"uni-radio-slot"})]:ct};return()=>{let{disabled:ct}=m;return I.createVNode("div",I.mergeProps({ref:U},{dataUncType:"uni-radio"},{onClick:fe,class:"uni-radio"}),[I.createVNode("div",{style:J.value,class:["uni-radio-input",{"uni-radio-input-disabled":ct}]},[$.value?Wn("\uEA08",{class:"uni-radio-input-icon"}):null]),...we()])}}});function mt(m,R,U){let $=I.computed({get:()=>({radioChecked:Boolean(m.value),value:R.value}),set:({radioChecked:pe})=>{m.value=pe}}),X={reset:U},J=I.inject(Q,!1);J&&J.addField($);let te=I.inject(Mr,!1);te&&te.addField(X);let ce=I.inject(Or,!1);return I.onBeforeUnmount(()=>{J&&J.removeField($),te&&te.removeField(X)}),{uniCheckGroup:J,uniForm:te,uniLabel:ce,field:$}}let K=I.defineComponent({name:"RadioGroup",props:he,emits:["change"],setup(m,{slots:R,emit:U}){let $=I.ref(null),X=Gn($,U);return z(m,X),()=>I.createVNode("div",{ref:$},[R.default&&R.default()])}});function z(m,R){let U=[];I.onMounted(()=>{ce(U.length-1)});let $=()=>{var pe;return(pe=U.find(Pe=>Pe.value.radioChecked))==null?void 0:pe.value.value};I.provide(Q,{addField(pe){U.push(pe)},removeField(pe){U.splice(U.indexOf(pe),1)},radioChange(pe,Pe){let fe=U.indexOf(Pe);ce(fe,!0),R("change",{value:$()})}});let X=I.inject(Mr,!1),J={submit:()=>{let pe=["",null];return m.name!==""&&(pe[0]=m.name,pe[1]=$()),pe}};X&&(X.addField(J),I.onBeforeUnmount(()=>{X.removeField(J)}));function te(pe,Pe){pe.value={radioChecked:Pe,value:pe.value.value}}function ce(pe,Pe){U.forEach((fe,we)=>{we!==pe&&Pe&&te(U[we],!1)})}return U}let ie=["u-input","u-textarea"],xe=I.defineComponent({name:"Form",emits:["submit","reset"],setup({},{slots:m,emit:R}){let U=I.ref(null),$=Gn(U,R),X=[],J;return I.provide(Mr,{addField(te){X.push(te)},removeField(te){X.splice(X.indexOf(te),1)},submit(te){let ce={};J&&J(ce);let pe=X.reduce((Pe,fe)=>{if(fe.submit){let[we,ct]=fe.submit();we&&(Pe[we]=ct)}return Pe},Object.create(null));Object.assign(ce,pe),$("submit",{value:ce})},reset(te){J&&J(),X.forEach(ce=>ce.reset&&ce.reset()),$("reset",te)}}),()=>{let te=m.default&&m.default();return J=nt(te),I.createVNode("view",{ref:U},[te])}}});function nt(m){let R=S.requireModule("plus"),U=($,X)=>{(X||m||[]).forEach(function(J){ie.indexOf(String(J.type))>=0&&J.el&&J.el.attr&&J.el.attr.name&&($?$[J.el.attr.name]=R.getValue(J.el.nodeId):J.el.setValue("")),St.isArray(J.children)&&J.children&&J.children.length&&U($,J.children)})};return U}let Yt={type:{type:String,default:""},size:{type:[String,Number],default:23},color:{type:String,default:""}},Tn={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"},jn={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"},xr=[{"uni-icon":{"":{fontFamily:"unincomponents"}}}],mr=I.defineComponent({name:"Icon",props:Yt,styles:xr,setup(m,{}){return()=>Wn(jn[m.type],{class:"uni-icon",style:{color:m.color||Tn[m.type],fontSize:m.size}})}}),po={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}},vo=S.config.env.platform.toLowerCase()==="android",Jo=[{"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"}}}],mo=I.defineComponent({name:"Swiper",props:po,styles:Jo,emits:["change","transition","animationfinish"],setup(m,{slots:R,emit:U}){let $=I.ref(null),X=[],J=Gn($,U),te=Yn(m),ce=Bn(te,m,X,J);return I.watch([()=>m.current,()=>m.currentItemId],([pe,Pe])=>{er(te,m,X)}),I.onMounted(()=>{g(()=>{Nn($.value).then(({width:pe,height:Pe})=>{te.swiperWidth=pe,te.swiperHeight=Pe})},50)}),()=>{let pe=R.default&&R.default(),{indicatorStyle:Pe,currentSync:fe}=te;return X=ii(pe),I.createVNode("div",{ref:$,class:"uni-swiper"},[I.createVNode("slider",I.mergeProps({class:"uni-swiper-slider"},{autoPlay:m.autoplay,interval:m.interval,index:fe,keepIndex:!0,showIndicators:m.indicatorDots,infinite:m.circular,vertical:m.vertical,scrollable:!m.disableTouch},ce),[X,I.createVNode("indicator",{class:"uni-swiper-dots",style:Pe},null)])])}}});function Yn(m){let R=I.ref(0),U=I.ref(0),$=I.ref(m.current),X=I.ref("autoplay"),J=I.computed(()=>({itemColor:m.indicatorColor,itemSelectedColor:m.indicatorActiveColor,itemSize:8,opacity:m.indicatorDots?1:0}));return I.reactive({swiperWidth:R,swiperHeight:U,indicatorStyle:J,currentSync:$,currentChangeSource:X})}function Bn(m,R,U,$){let X=0,J=fe=>{let we=fe.detail,ct=R.vertical,gt=(ct?we.offsetYRatio:we.offsetXRatio)||0;if((fe.drag||fe.drag)&&(m.currentChangeSource="touch"),gt===0){let $t=Math.abs(X);if($t===1)return;$t>.5&&(gt=1)}X=gt,$("transition",{dx:ct?0:-m.swiperWidth*gt,dy:ct?-m.swiperHeight*gt:0})},te=fe=>{let we=()=>{$("animationfinish",pe()),m.currentChangeSource="autoplay"};vo?we():g(we,50)},ce=fe=>{St.isString(fe.detail.source)&&(m.currentChangeSource=fe.detail.source),m.currentSync=fe.detail.index,X=0};function pe(){let fe=Number(m.currentSync),we=U[fe]||{},ct=we.componentInstance&&we.componentInstance.itemId||"";return{current:fe,currentItemId:ct,source:m.currentChangeSource}}return I.watch(()=>m.currentSync,fe=>{$("change",pe())}),{onScroll:J,onScrollend:te,onChange:ce}}function er(m,R,U){let $=-1;if(R.currentItemId)for(let X=0,J=U;X<J.length;X++){let te=J[X].componentInstance;if(te&&te.itemId===R.currentItemId){$=X;break}}$<0&&($=Math.round(Number(R.current))||0),$=$<0?0:$,m.currentSync!==$&&(m.currentChangeSource="",m.currentSync=$)}let Si={itemId:{type:String,default:""}},is=I.defineComponent({name:"SwiperItem",props:Si,setup(m,{slots:R}){return()=>I.createVNode("div",{class:"uni-swiper-item",style:{position:"absolute",left:0,top:0,right:0,bottom:0,overflow:"hidden"}},[R.default&&R.default()])}});var fa=/^<([-A-Za-z0-9_]+)((?:\s+[a-zA-Z_:][-a-zA-Z0-9_:.]*(?:\s*=\s*(?:(?:"[^"]*")|(?:'[^']*')|[^>\s]+))?)*)\s*(\/?)>/,_r=/^<\/([-A-Za-z0-9_]+)[^>]*>/,Pa=/([a-zA-Z_:][-a-zA-Z0-9_:.]*)(?:\s*=\s*(?:(?:"((?:\\.|[^"])*)")|(?:'((?:\\.|[^'])*)')|([^>\s]+)))?/g,$a=Bo("area,base,basefont,br,col,frame,hr,img,input,link,meta,param,embed,command,keygen,source,track,wbr"),Ua=Bo("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"),Ha=Bo("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"),ja=Bo("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr"),da=Bo("checked,compact,declare,defer,disabled,ismap,multiple,nohref,noresize,noshade,nowrap,readonly,selected"),Ia=Bo("script,style");function Ln(m,R){var U,$,X,J=[],te=m;for(J.last=function(){return this[this.length-1]};m;){if($=!0,!J.last()||!Ia[J.last()]){if(m.indexOf("<!--")==0?(U=m.indexOf("-->"),U>=0&&(R.comment&&R.comment(m.substring(4,U)),m=m.substring(U+3),$=!1)):m.indexOf("</")==0?(X=m.match(_r),X&&(m=m.substring(X[0].length),X[0].replace(_r,Pe),$=!1)):m.indexOf("<")==0&&(X=m.match(fa),X&&(m=m.substring(X[0].length),X[0].replace(fa,pe),$=!1)),$){U=m.indexOf("<");var ce=U<0?m:m.substring(0,U);m=U<0?"":m.substring(U),R.chars&&R.chars(ce)}}else m=m.replace(new RegExp("([\\s\\S]*?)</"+J.last()+"[^>]*>"),function(fe,we){return we=we.replace(/<!--([\s\S]*?)-->|<!\[CDATA\[([\s\S]*?)]]>/g,"$1$2"),R.chars&&R.chars(we),""}),Pe("",J.last());if(m==te)throw"Parse Error: "+m;te=m}Pe();function pe(fe,we,ct,gt){if(we=we.toLowerCase(),Ua[we])for(;J.last()&&Ha[J.last()];)Pe("",J.last());if(ja[we]&&J.last()==we&&Pe("",we),gt=$a[we]||!!gt,gt||J.push(we),R.start){var $t=[];ct.replace(Pa,function(Et,je){var Bt=arguments[2]?arguments[2]:arguments[3]?arguments[3]:arguments[4]?arguments[4]:da[je]?je:"";$t.push({name:je,value:Bt,escaped:Bt.replace(/(^|[^\\])"/g,'$1\\"')})}),R.start&&R.start(we,$t,gt)}}function Pe(fe,we){if(we)for(var ct=J.length-1;ct>=0&&J[ct]!=we;ct--);else var ct=0;if(ct>=0){for(var gt=J.length-1;gt>=ct;gt--)R.end&&R.end(J[gt]);J.length=ct}}}function Bo(m){for(var R={},U=m.split(","),$=0;$<U.length;$++)R[U[$]]=!0;return R}function Zo(m){return m.replace(/<\?xml.*\?>\n/,"").replace(/<!doctype.*>\n/,"").replace(/<!DOCTYPE.*>\n/,"")}function ji(m){return m.reduce(function(R,U){let $=U.value,X=U.name;return $.match(/ /)&&["style","src"].indexOf(X)===-1&&($=$.split(" ")),R[X]?Array.isArray(R[X])?R[X].push($):R[X]=[R[X],$]:R[X]=$,R},{})}function os(m){m=Zo(m);let R=[],U={node:"root",children:[]};return Ln(m,{start:function($,X,J){let te={name:$};if(X.length!==0&&(te.attrs=ji(X)),J){let ce=R[0]||U;ce.children||(ce.children=[]),ce.children.push(te)}else R.unshift(te)},end:function($){let X=R.shift();if(X.name!==$&&console.error("invalid state: mismatch end tag"),R.length===0)U.children.push(X);else{let J=R[0];J.children||(J.children=[]),J.children.push(X)}},chars:function($){let X={type:"text",text:$};if(R.length===0)U.children.push(X);else{let J=R[0];J.children||(J.children=[]),J.children.push(X)}},comment:function($){let X={node:"comment",text:$},J=R[0];J.children||(J.children=[]),J.children.push(X)}}),U.children}let as={nodes:{type:[Array,String],default:function(){return[]}}},Lo=16,ss=I.defineComponent({name:"RichText",props:as,setup(m){let R=I.getCurrentInstance();return()=>{let U=m.nodes;return St.isString(U)&&(U=os(U)),I.createVNode("u-rich-text",{value:io(U||[],R.root,{defaultFontSize:Lo})},null)}}});function io(m,R,U){let $=["span","a","image","img"],X={blockquote:we,br:Et,div:we,dl:we,h1:gt(2),h2:gt(1.5),h3:gt(1.17),h4:gt(1),h5:gt(.83),h6:gt(.67),hr:we,ol:we,p:we,strong:$t,table:we,tbody:we,tfoot:we,thead:we,ul:we},J=/&(amp|gt|lt|nbsp|quot|apos);/g,te={amp:"&",gt:">",lt:"<",nbsp:" ",quot:'"',apos:"'"},ce={type:"span",__type:"break",attr:{value:`
`}},pe={__block:!0,__break:!0,children:[]},Pe=null;function fe(ht){let Zt=Object.create(null);if(ht.attrs){let Rn=(ht.attrs.class||"").split(" ");Object.assign(Zt,I.parseClassList(Rn,R),uo(ht.attrs.style||""))}if(ht.name==="img"||ht.name==="image"){let Rn=ht.attrs;Zt.width=Zt.width||Rn.width,Zt.height=Zt.height||Rn.height}return Zt}function we(ht){return ht.__block=!0,ht}function ct(ht,Zt){return ht.style&&!ht.style.fontSize&&(ht.style.fontSize=U.defaultFontSize*Zt),we($t(ht))}function gt(ht){return function(Zt){return ct(Zt,ht)}}function $t(ht){return ht.style&&!ht.style.fontWeight&&(ht.style.fontWeight="bold"),ht}function Et(ht){return ht.__value=" ",we(ht)}function je(ht){return ht.replace(J,function(Zt,Rn){return te[Rn]})}function Bt(ht){let Zt=(ht.name||"").toLowerCase(),Rn=Zt,Gt=X[Zt];$.indexOf(Zt)===-1&&(Zt="span"),Zt==="img"&&(Zt="image");let Ut={type:Zt,__type:Rn,attr:Object.create(null)};return(ht.type==="text"||ht.text)&&(Ut.__value=Ut.attr.value=je((ht.text||"").trim())),ht.attrs&&Object.keys(ht.attrs).forEach(Ft=>{Ft!=="class"&&Ft!=="style"&&(Ut.attr[Ft]=ht.attrs[Ft])}),Ut.style=fe(ht),Gt&&Gt(Ut),(pe.__block||Ut.__block)&&(Pe||(pe.children.push(ce),Pe=[pe,ce])),pe=Ut,(pe.__value||pe.type==="image"&&pe.attr.src)&&(Pe=null),Ut.children=cn(ht.children),pe=Ut,pe.__block&&pe.style.height&&!/^0(px)?$/.test(pe.style.height)&&(Pe=null),Ut}function cn(ht){return St.isArray(ht)?ht.map(Zt=>Bt(Zt)):[]}let Wt=cn(m);if(Pe){let[ht,Zt]=Pe,Rn=ht.children,Gt=Rn.indexOf(Zt);Rn.splice(Gt,1)}return Wt}let si={};function wi(m,R,U){let{adpid:$,width:X}=m,J=$+"-"+X,te=si[J];if(te&&te.length>0){R(te.splice(0,1)[0]);return}d.ad.getAds(m,ce=>{let pe=ce.ads;R(pe.splice(0,1)[0]),si[J]=te?te.concat(pe):pe},ce=>{U({errCode:ce.code,errMsg:ce.message})})}let zi={adpid:{type:[Number,String],default:""},data:{type:String,default:""},width:{type:String,default:""},channel:{type:String,default:""}},li={load:"load",close:"close",error:"error",downloadchange:"downloadchange"},cr=I.defineComponent({name:"Ad",props:zi,emits:[li.load,li.close,li.error,li.downloadchange],setup(m,{emit:R}){let U=I.ref(null),$=Gn(U,R),X=or();I.watch(()=>m.adpid,te=>{za(X,m,$)}),I.watch(()=>m.data,te=>{X.data=te}),I.onMounted(()=>{g(()=>{Nn(U.value).then(({width:te})=>{X.width=te===0?-1:te,za(X,m,$)})},50)});let J={onDownloadchange(te){$(li.downloadchange,te)},onDislike(te){$(li.close,te)}};return()=>I.createVNode("u-ad",I.mergeProps({ref:U},{data:X.data,rendering:!0},J),null)}});function or(m){let R=I.ref("");return I.reactive({width:0,data:R})}function za(m,R,U){wi({adpid:R.adpid,width:m.width},$=>{m.data=$,U(li.load,{})},$=>{U(li.error,$)})}let Wa={};function Wi(m,R,U,$,X){let J=m+"-"+R,te=Wa[J];if(te&&te.length>0){$(te.splice(0,1)[0]);return}d.ad.getDrawAds({adpid:String(m),count:3,width:R},ce=>{let pe=ce.ads;$(pe.splice(0,1)[0]),Wa[J]=te?te.concat(pe):pe},ce=>{X({errCode:ce.code,errMsg:ce.message})})}let oo={adpid:{type:[Number,String],default:""},data:{type:String,default:""},width:{type:String,default:""}},ao={load:"load",close:"close",error:"error"},ls=I.defineComponent({name:"AdDraw",props:oo,emits:[ao.load,ao.close,ao.error],setup(m,{emit:R}){let U=I.ref(null),$=Gn(U,R),X=ha();I.watch(()=>m.adpid,te=>{Mo(X,m,$)}),I.watch(()=>m.data,te=>{X.data=te});let J={onDislike(te){$(ao.close,te)}};return I.onMounted(()=>{g(()=>{Nn(U.value).then(({width:te,height:ce})=>{X.width=te===0?-1:te,X.height=ce===0?-1:ce,Mo(X,m,$)})},50)}),()=>{let{data:te}=X;return I.createVNode("u-ad-draw",I.mergeProps({ref:U},{data:te,rendering:!0},J),null)}}});function ha(m){let R=I.ref("");return I.reactive({width:0,height:0,data:R})}function Mo(m,R,U){Wi(R.adpid,m.width,m.height,$=>{m.data=$,U(ao.load,{})},$=>{U(ao.error,$)})}return{Navigator:vi,Label:dn,Button:To,MovableArea:hr,MovableView:gr,Progress:Zr,PickerView:pr,PickerViewColumn:$i,Picker:Zn,USlider:Qn,Switch:jr,Checkbox:Ro,CheckboxGroup:Hi,Radio:de,RadioGroup:K,Form:xe,Icon:mr,Swiper:mo,SwiperItem:is,RichText:ss,Ad:cr,AdDraw:ls}}(k,We,Lt);return xt}function uI(g,s){let{UniShared:p,Vue:w}=s;function k(d,E,B){let We=d.$[E];return We&&p.invokeArrayFns(We,B)}let S=g.setup;return g.inheritAttrs=!1,g.setup=(d,E)=>{let{attrs:{__pageId:B,__pagePath:We,__pageQuery:Lt}}=E,en=s.__uniRoutes.find(St=>St.meta.route===We),xt=w.getCurrentInstance(),I=xt.proxy;if(en&&(en.meta.isSubNVue||fI(I,s,{__pageId:B,__pagePath:We})),w.onMounted(()=>{w.nextTick(()=>{k(I,p.ON_READY)}),xt.onPageScroll&&I.$el.addEvent("scroll",St=>{St.scrollTop=St.detail.scrollTop,k(I,p.ON_PAGE_SCROLL,St)}),xt.onReachBottom&&I.$el.addEvent("scrolltolower",St=>{k(I,p.ON_REACH_BOTTOM,St)})}),w.onBeforeUnmount(()=>{k(I,p.ON_UNLOAD)}),S)return S(Lt,E)},g}function fI(g,s,{__pageId:p,__pagePath:w}){let k=s.getCurrentPages(),S=k[k.length-1];if(S&&S.__setup)S.__setup(g,S);else{let d="/"+w;return s.__registerPage({url:d,path:d,query:{},openType:"launch",webview:{id:p+""},nvuePageVm:g})}}var Bl={},Pp;function Ip(g){Pp=g}var nu;function dI(g){if(nu)return nu;let s=new g.Emitter;return nu={on(p,w){return s.on(p,w)},once(p,w){return s.once(p,w)},off(p,w){return s.off(p,w)},emit(p,...w){return s.emit(p,...w)}},nu}function hI(g){return(s,p,w)=>{let{nvue:k}=p,S=tu(g,p);p.Vue=S,Bl[s]={instanceId:s,config:k.config,document:k.document,data:w};let{createApp:d}=S;S.createVueApp=S.createApp=(E,B)=>(p.__uniConfig.styles=E.styles||[],d(E,B).use(gI,s,p)),S.createPageApp=(E,B)=>{uI(E,p);let We=B.$store;delete B.$store;let Lt=d(E,B);return We&&Lt.use(We),Lt.use(vI,S,s,p)}}}var gI={install(g,s,p){dc(p).initApp(g),pI(g,s,p)}};function pI(g,s,p){let{mount:w}=g,k=Bl[s];return g.mount=S=>{let d=S==="#app",E=k.app=w(Np(k.document,{isRoot:d}));return d&&p.__registerApp(E),E},g}var vI={install(g,s,p,w){let{weex:k,plus:S,BroadcastChannel:d,VueShared:E,UniShared:B,getCurrentPages:We,setTimeout:Lt,clearTimeout:en,__uniConfig:xt}=w;g.config.globalProperties.$requireNativePlugin=k.requireModule;let I=cI({uni:Pp,Vue:s,weex:k,plus:S,BroadcastChannel:d,UniViewJSBridge:dI(B),VueShared:E,UniShared:B,getCurrentPages:We,setTimeout:Lt,clearTimeout:en,__uniConfig:xt});Object.keys(I).forEach(St=>{g.component(s.hyphenate(St),I[St])}),dc(w).initApp(g),mI(g,p,w)}};function mI(g,s,{nvue:p}){let{config:{compilerOptions:w},mount:k}=g;w.isCustomElement=d=>!!p.supports(`@component/${d}`);let S=Bl[s];return g.mount=d=>{let E=d==="#root",B=S.app=k(Np(S.document,{isRoot:E}));if(E)try{p.document.taskCenter.send("dom",{action:"createFinish"},[])}catch(We){}return B},g}function Np(g,{isRoot:s}){if(s)return g.documentElement;let p=g.createComment("root");return g.documentElement.appendChild(p),p}function kp(g){let s=Bl[g];if(s&&s.app&&s.document){try{s.app.$.appContext.app.unmount(),s.document.destroy()}catch(p){}delete s.document,delete s.app}delete Bl[g]}function Rp(g){let s=Bl[g];if(!s||!s.app)return new Error(`refreshInstance: instance ${g} not found!`);s.document.taskCenter.send("dom",{action:"refreshFinish"},[])}function _I(g,s){let{UniShared:p,VueShared:w,VueReactivity:k}=g;var S=function(d,E,B,We){"use strict";function Lt(a){}function en(a,u){}function xt(a,u,v,y){var P;try{P=y?a(...y):a()}catch(O){St(O,u,v)}return P}function I(a,u,v,y){if(E.isFunction(a)){var P=xt(a,u,v,y);return P&&E.isPromise(P)&&P.catch(G=>{St(G,u,v)}),P}for(var O=[],F=0;F<a.length;F++)O.push(I(a[F],u,v,y));return O}function St(a,u,v){if(u&&u.vnode,u){for(var y=u.parent,P=u.proxy,O=v;y;){var F=y.ec;if(F){for(var G=0;G<F.length;G++)if(F[G](a,P,O)===!1)return}y=y.parent}var Y=u.appContext.config.errorHandler;if(Y){xt(Y,null,10,[a,P,O]);return}}Pn(a)}function Pn(a,u,v){console.error(a)}var st=!1,W=!1,Z=[],fn=0,sn=[],_n=null,Wn=0,pi=Promise.resolve(),vi=null;function ar(a){var u=vi||pi;return a?u.then(this?a.bind(this):a):u}function Sr(a){for(var u=fn+1,v=Z.length;u<v;){var y=u+v>>>1,P=ot(Z[y]);P<a?u=y+1:v=y}return u}function Cn(a){(!Z.length||!Z.includes(a,st&&a.allowRecurse?fn+1:fn))&&(a.id==null?Z.push(a):Z.splice(Sr(a.id),0,a),wr())}function wr(){!st&&!W&&(W=!0,vi=pi.then(tn))}function Cr(a){var u=Z.indexOf(a);u>fn&&Z.splice(u,1)}function mi(a){E.isArray(a)?sn.push(...a):(!_n||!_n.includes(a,a.allowRecurse?Wn+1:Wn))&&sn.push(a),wr()}function ri(a){for(var u=arguments.length>1&&arguments[1]!==void 0?arguments[1]:st?fn+1:0;u<Z.length;u++){var v=Z[u];v&&v.pre&&(Z.splice(u,1),u--,v())}}function Ve(a){if(sn.length){var u=[...new Set(sn)];if(sn.length=0,_n){_n.push(...u);return}for(_n=u,_n.sort((v,y)=>ot(v)-ot(y)),Wn=0;Wn<_n.length;Wn++)_n[Wn]();_n=null,Wn=0}}var ot=a=>a.id==null?1/0:a.id,bt=(a,u)=>{var v=ot(a)-ot(u);if(v===0){if(a.pre&&!u.pre)return-1;if(u.pre&&!a.pre)return 1}return v};function tn(a){W=!1,st=!0,Z.sort(bt);var u=E.NOOP;try{for(fn=0;fn<Z.length;fn++){var v=Z[fn];v&&v.active!==!1&&xt(v,null,14)}}finally{fn=0,Z.length=0,Ve(),st=!1,vi=null,(Z.length||sn.length)&&tn()}}d.devtools=void 0;var Sn=[];function Jt(a,u){var v,y;if(d.devtools=a,d.devtools)d.devtools.enabled=!0,Sn.forEach(O=>{var{event:F,args:G}=O;return d.devtools.emit(F,...G)}),Sn=[];else if(typeof window!="undefined"&&window.HTMLElement&&!((y=(v=window.navigator)===null||v===void 0?void 0:v.userAgent)===null||y===void 0?void 0:y.includes("jsdom"))){var P=u.__VUE_DEVTOOLS_HOOK_REPLAY__=u.__VUE_DEVTOOLS_HOOK_REPLAY__||[];P.push(O=>{Jt(O,u)}),setTimeout(()=>{d.devtools||(u.__VUE_DEVTOOLS_HOOK_REPLAY__=null,Sn=[])},3e3)}else Sn=[]}function rr(a,u){if(!a.isUnmounted){for(var v=a.vnode.props||E.EMPTY_OBJ,y=arguments.length,P=new Array(y>2?y-2:0),O=2;O<y;O++)P[O-2]=arguments[O];var F=P,G=u.startsWith("update:"),Y=G&&u.slice(7);if(Y&&Y in v){var le="".concat(Y==="modelValue"?"model":Y,"Modifiers"),{number:ze,trim:at}=v[le]||E.EMPTY_OBJ;at&&(F=P.map(wt=>E.isString(wt)?wt.trim():wt)),ze&&(F=P.map(E.looseToNumber))}var ge,Ge=v[ge=E.toHandlerKey(u)]||v[ge=E.toHandlerKey(E.camelize(u))];!Ge&&G&&(Ge=v[ge=E.toHandlerKey(E.hyphenate(u))]),Ge&&I(Ge,a,6,F);var Xe=v[ge+"Once"];if(Xe){if(!a.emitted)a.emitted={};else if(a.emitted[ge])return;a.emitted[ge]=!0,I(Xe,a,6,F)}}}function Ar(a,u){var v=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!1,y=u.emitsCache,P=y.get(a);if(P!==void 0)return P;var O=a.emits,F={},G=!1;if(!E.isFunction(a)){var Y=le=>{var ze=Ar(le,u,!0);ze&&(G=!0,E.extend(F,ze))};!v&&u.mixins.length&&u.mixins.forEach(Y),a.extends&&Y(a.extends),a.mixins&&a.mixins.forEach(Y)}return!O&&!G?(E.isObject(a)&&y.set(a,null),null):(E.isArray(O)?O.forEach(le=>F[le]=null):E.extend(F,O),E.isObject(a)&&y.set(a,F),F)}function Or(a,u){return!a||!E.isOn(u)?!1:(u=u.slice(2).replace(/Once$/,""),E.hasOwn(a,u[0].toLowerCase()+u.slice(1))||E.hasOwn(a,E.hyphenate(u))||E.hasOwn(a,u))}var On=null,dn=null;function Tr(a){var u=On;return On=a,dn=a&&a.type.__scopeId||null,u}function _i(a){dn=a}function Co(){dn=null}var ca=a=>Fi;function Fi(a){var u=arguments.length>1&&arguments[1]!==void 0?arguments[1]:On;if(!u||a._n)return a;var v=function(){v._d&&$t(-1);var y=Tr(u),P;try{P=a(...arguments)}finally{Tr(y),v._d&&$t(1)}return P};return v._n=!0,v._c=!0,v._d=!0,v}function Yo(){}function Ao(a){var{type:u,vnode:v,proxy:y,withProxy:P,props:O,propsOptions:[F],slots:G,attrs:Y,emit:le,render:ze,renderCache:at,data:ge,setupState:Ge,ctx:Xe,inheritAttrs:wt}=a,it,Ce,Ee=Tr(a);try{if(v.shapeFlag&4){var Te=P||y;it=Mn(ze.call(Te,Te,at,O,Ge,ge,Xe)),Ce=Y}else{var lt=u;it=Mn(lt.length>1?lt(O,{attrs:Y,slots:G,emit:le}):lt(O,null)),Ce=u.props?Y:Mr(Y)}}catch(l){Pe.length=0,St(l,a,1),it=Ft(ce)}var Ne=it;if(Ce&&wt!==!1){var Ct=Object.keys(Ce),{shapeFlag:i}=Ne;Ct.length&&i&(1|6)&&(F&&Ct.some(E.isModelListener)&&(Ce=ua(Ce,F)),Ne=ci(Ne,Ce))}return v.dirs&&(Ne=ci(Ne),Ne.dirs=Ne.dirs?Ne.dirs.concat(v.dirs):v.dirs),v.transition&&(Ne.transition=v.transition),it=Ne,Tr(Ee),it}function Ji(a){for(var u,v=0;v<a.length;v++){var y=a[v];if(cn(y)){if(y.type!==ce||y.children==="v-if"){if(u)return;u=y}}else return}return u}var Mr=a=>{var u;for(var v in a)(v==="class"||v==="style"||E.isOn(v))&&((u||(u={}))[v]=a[v]);return u},ua=(a,u)=>{var v={};for(var y in a)(!E.isModelListener(y)||!(y.slice(9)in u))&&(v[y]=a[y]);return v};function Oo(a,u,v){var{props:y,children:P,component:O}=a,{props:F,children:G,patchFlag:Y}=u,le=O.emitsOptions;if(u.dirs||u.transition)return!0;if(v&&Y>=0){if(Y&1024)return!0;if(Y&16)return y?To(y,F,le):!!F;if(Y&8)for(var ze=u.dynamicProps,at=0;at<ze.length;at++){var ge=ze[at];if(F[ge]!==y[ge]&&!Or(le,ge))return!0}}else return(P||G)&&(!G||!G.$stable)?!0:y===F?!1:y?F?To(y,F,le):!0:!!F;return!1}function To(a,u,v){var y=Object.keys(u);if(y.length!==Object.keys(a).length)return!0;for(var P=0;P<y.length;P++){var O=y[P];if(u[O]!==a[O]&&!Or(v,O))return!0}return!1}function Zi(a,u){for(var{vnode:v,parent:y}=a;y&&y.subTree===v;)(v=y.vnode).el=u,y=y.parent}var ii=a=>a.__isSuspense,qo={name:"Suspense",__isSuspense:!0,process(a,u,v,y,P,O,F,G,Y,le){a==null?hr(u,v,y,P,O,F,G,Y,le):fo(a,u,v,y,P,F,G,Y,le)},hydrate:Xi,create:Gn,normalize:Po},uo=qo;function Nn(a,u){var v=a.props&&a.props[u];E.isFunction(v)&&v()}function hr(a,u,v,y,P,O,F,G,Y){var{p:le,o:{createElement:ze}}=Y,at=ze("div"),ge=a.suspense=Gn(a,P,y,u,at,v,O,F,G,Y);le(null,ge.pendingBranch=a.ssContent,at,null,y,ge,O,F),ge.deps>0?(Nn(a,"onPending"),Nn(a,"onFallback"),le(null,a.ssFallback,u,v,y,null,O,F),Jn(ge,a.ssFallback)):ge.resolve()}function fo(a,u,v,y,P,O,F,G,Y){var{p:le,um:ze,o:{createElement:at}}=Y,ge=u.suspense=a.suspense;ge.vnode=u,u.el=a.el;var Ge=u.ssContent,Xe=u.ssFallback,{activeBranch:wt,pendingBranch:it,isInFallback:Ce,isHydrating:Ee}=ge;if(it)ge.pendingBranch=Ge,Wt(Ge,it)?(le(it,Ge,ge.hiddenContainer,null,P,ge,O,F,G),ge.deps<=0?ge.resolve():Ce&&(le(wt,Xe,v,y,P,null,O,F,G),Jn(ge,Xe))):(ge.pendingId++,Ee?(ge.isHydrating=!1,ge.activeBranch=it):ze(it,P,ge),ge.deps=0,ge.effects.length=0,ge.hiddenContainer=at("div"),Ce?(le(null,Ge,ge.hiddenContainer,null,P,ge,O,F,G),ge.deps<=0?ge.resolve():(le(wt,Xe,v,y,P,null,O,F,G),Jn(ge,Xe))):wt&&Wt(Ge,wt)?(le(wt,Ge,v,y,P,ge,O,F,G),ge.resolve(!0)):(le(null,Ge,ge.hiddenContainer,null,P,ge,O,F,G),ge.deps<=0&&ge.resolve()));else if(wt&&Wt(Ge,wt))le(wt,Ge,v,y,P,ge,O,F,G),Jn(ge,Ge);else if(Nn(u,"onPending"),ge.pendingBranch=Ge,ge.pendingId++,le(null,Ge,ge.hiddenContainer,null,P,ge,O,F,G),ge.deps<=0)ge.resolve();else{var{timeout:Te,pendingId:lt}=ge;Te>0?setTimeout(()=>{ge.pendingId===lt&&ge.fallback(Xe)},Te):Te===0&&ge.fallback(Xe)}}function Gn(a,u,v,y,P,O,F,G,Y,le){var ze=arguments.length>10&&arguments[10]!==void 0?arguments[10]:!1,{p:at,m:ge,um:Ge,n:Xe,o:{parentNode:wt,remove:it}}=le,Ce=a.props?E.toNumber(a.props.timeout):void 0,Ee={vnode:a,parent:u,parentComponent:v,isSVG:F,container:y,hiddenContainer:P,anchor:O,deps:0,pendingId:0,timeout:typeof Ce=="number"?Ce:-1,activeBranch:null,pendingBranch:null,isInFallback:!0,isHydrating:ze,isUnmounted:!1,effects:[],resolve(){var Te=arguments.length>0&&arguments[0]!==void 0?arguments[0]:!1,{vnode:lt,activeBranch:Ne,pendingBranch:Ct,pendingId:i,effects:l,parentComponent:f,container:_}=Ee;if(Ee.isHydrating)Ee.isHydrating=!1;else if(!Te){var A=Ne&&Ct.transition&&Ct.transition.mode==="out-in";A&&(Ne.transition.afterLeave=()=>{i===Ee.pendingId&&ge(Ct,_,C,0)});var{anchor:C}=Ee;Ne&&(C=Xe(Ne),Ge(Ne,f,Ee,!0)),A||ge(Ct,_,C,0)}Jn(Ee,Ct),Ee.pendingBranch=null,Ee.isInFallback=!1;for(var N=Ee.parent,M=!1;N;){if(N.pendingBranch){N.effects.push(...l),M=!0;break}N=N.parent}M||mi(l),Ee.effects=[],Nn(lt,"onResolve")},fallback(Te){if(!!Ee.pendingBranch){var{vnode:lt,activeBranch:Ne,parentComponent:Ct,container:i,isSVG:l}=Ee;Nn(lt,"onFallback");var f=Xe(Ne),_=()=>{!Ee.isInFallback||(at(null,Te,i,f,Ct,null,l,G,Y),Jn(Ee,Te))},A=Te.transition&&Te.transition.mode==="out-in";A&&(Ne.transition.afterLeave=_),Ee.isInFallback=!0,Ge(Ne,Ct,null,!0),A||_()}},move(Te,lt,Ne){Ee.activeBranch&&ge(Ee.activeBranch,Te,lt,Ne),Ee.container=Te},next(){return Ee.activeBranch&&Xe(Ee.activeBranch)},registerDep(Te,lt){var Ne=!!Ee.pendingBranch;Ne&&Ee.deps++;var Ct=Te.vnode.el;Te.asyncDep.catch(i=>{St(i,Te,0)}).then(i=>{if(!(Te.isUnmounted||Ee.isUnmounted||Ee.pendingId!==Te.suspenseId)){Te.asyncResolved=!0;var{vnode:l}=Te;Na(Te,i,!1),Ct&&(l.el=Ct);var f=!Ct&&Te.subTree.el;lt(Te,l,wt(Ct||Te.subTree.el),Ct?null:Xe(Te.subTree),Ee,F,Y),f&&it(f),Zi(Te,l.el),Ne&&--Ee.deps===0&&Ee.resolve()}})},unmount(Te,lt){Ee.isUnmounted=!0,Ee.activeBranch&&Ge(Ee.activeBranch,v,Te,lt),Ee.pendingBranch&&Ge(Ee.pendingBranch,v,Te,lt)}};return Ee}function Xi(a,u,v,y,P,O,F,G,Y){var le=u.suspense=Gn(u,y,v,a.parentNode,s.createElement("div"),null,P,O,F,G,!0),ze=Y(a,le.pendingBranch=u.ssContent,v,le,O,F);return le.deps===0&&le.resolve(),ze}function Po(a){var{shapeFlag:u,children:v}=a,y=u&32;a.ssContent=Qi(y?v.default:v),a.ssFallback=y?Qi(v.fallback):Ft(ce)}function Qi(a){var u;if(E.isFunction(a)){var v=gt&&a._c;v&&(a._d=!1,we()),a=a(),v&&(a._d=!0,u=fe,ct())}if(E.isArray(a)){var y=Ji(a);a=y}return a=Mn(a),u&&!a.dynamicChildren&&(a.dynamicChildren=u.filter(P=>P!==a)),a}function bi(a,u){u&&u.pendingBranch?E.isArray(a)?u.effects.push(...a):u.effects.push(a):mi(a)}function Jn(a,u){a.activeBranch=u;var{vnode:v,parentComponent:y}=a,P=v.el=u.el;y&&y.subTree===v&&(y.vnode.el=P,Zi(y,P))}function Dr(a,u){if(nn){var v=nn.provides,y=nn.parent&&nn.parent.provides;y===v&&(v=nn.provides=Object.create(y)),v[a]=u,nn.type.mpType==="app"&&nn.appContext.app.provide(a,u)}}function In(a,u){var v=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!1,y=nn||On;if(y){var P=y.parent==null?y.vnode.appContext&&y.vnode.appContext.provides:y.parent.provides;if(P&&a in P)return P[a];if(arguments.length>1)return v&&E.isFunction(u)?u.call(y.proxy):u}}function Un(a,u){return sr(a,null,u)}function qr(a,u){return sr(a,null,{flush:"post"})}function Io(a,u){return sr(a,null,{flush:"sync"})}var oi={};function Kr(a,u,v){return sr(a,u,v)}function sr(a,u){var{immediate:v,deep:y,flush:P,onTrack:O,onTrigger:F}=arguments.length>2&&arguments[2]!==void 0?arguments[2]:E.EMPTY_OBJ,G=B.getCurrentScope()===(nn==null?void 0:nn.scope)?nn:null,Y,le=!1,ze=!1;if(B.isRef(a)?(Y=()=>a.value,le=B.isShallow(a)):B.isReactive(a)?(Y=()=>a,y=!0):E.isArray(a)?(ze=!0,le=a.some(Ne=>B.isReactive(Ne)||B.isShallow(Ne)),Y=()=>a.map(Ne=>{if(B.isRef(Ne))return Ne.value;if(B.isReactive(Ne))return Fr(Ne);if(E.isFunction(Ne))return xt(Ne,G,2)})):E.isFunction(a)?u?Y=()=>xt(a,G,2):Y=()=>{if(!(G&&G.isUnmounted))return ge&&ge(),I(a,G,3,[Ge])}:Y=E.NOOP,u&&y){var at=Y;Y=()=>Fr(at())}var ge,Ge=Ne=>{ge=Te.onStop=()=>{xt(Ne,G,4)}},Xe;if(d.isInSSRComponentSetup)if(Ge=E.NOOP,u?v&&I(u,G,3,[Y(),ze?[]:void 0,Ge]):Y(),P==="sync"){var wt=Eo();Xe=wt.__watcherHandles||(wt.__watcherHandles=[])}else return E.NOOP;var it=ze?new Array(a.length).fill(oi):oi,Ce=()=>{if(!!Te.active)if(u){var Ne=Te.run();(y||le||(ze?Ne.some((Ct,i)=>E.hasChanged(Ct,it[i])):E.hasChanged(Ne,it)))&&(ge&&ge(),I(u,G,3,[Ne,it===oi?void 0:ze&&it[0]===oi?[]:it,Ge]),it=Ne)}else Te.run()};Ce.allowRecurse=!!u;var Ee;P==="sync"?Ee=Ce:P==="post"?Ee=()=>cr(Ce,G&&G.suspense):(Ce.pre=!0,G&&(Ce.id=G.uid),Ee=()=>Cn(Ce));var Te=new B.ReactiveEffect(Y,Ee);u?v?Ce():it=Te.run():P==="post"?cr(Te.run.bind(Te),G&&G.suspense):Te.run();var lt=()=>{Te.stop(),G&&G.scope&&E.remove(G.scope.effects,Te)};return Xe&&Xe.push(lt),lt}function Vi(a,u,v){var y=this.proxy,P=E.isString(a)?a.includes(".")?eo(y,a):()=>y[a]:a.bind(y,y),O;E.isFunction(u)?O=u:(O=u.handler,v=u);var F=nn;Vn(this);var G=sr(P,O.bind(y),v);return F?Vn(F):zn(),G}function eo(a,u){var v=u.split(".");return()=>{for(var y=a,P=0;P<v.length&&y;P++)y=y[v[P]];return y}}function Fr(a,u){if(!E.isObject(a)||a.__v_skip||(u=u||new Set,u.has(a)))return a;if(u.add(a),B.isRef(a))Fr(a.value,u);else if(E.isArray(a))for(var v=0;v<a.length;v++)Fr(a[v],u);else if(E.isSet(a)||E.isMap(a))a.forEach(P=>{Fr(P,u)});else if(E.isPlainObject(a))for(var y in a)Fr(a[y],u);return a}function Ei(){var a={isMounted:!1,isLeaving:!1,isUnmounting:!1,leavingVNodes:new Map};return Zn(()=>{a.isMounted=!0}),Qn(()=>{a.isUnmounting=!0}),a}var gr=[Function,Array],gn={mode:String,appear:Boolean,persisted:Boolean,onBeforeEnter:gr,onEnter:gr,onAfterEnter:gr,onEnterCancelled:gr,onBeforeLeave:gr,onLeave:gr,onAfterLeave:gr,onLeaveCancelled:gr,onBeforeAppear:gr,onAppear:gr,onAfterAppear:gr,onAppearCancelled:gr},Jr={name:"BaseTransition",props:gn,setup(a,u){var{slots:v}=u,y=pn(),P=Ei(),O;return()=>{var F=v.default&&Vr(v.default(),!0);if(!(!F||!F.length)){var G=F[0];if(F.length>1){for(var Y of F)if(Y.type!==ce){G=Y;break}}var le=B.toRaw(a),{mode:ze}=le;if(P.isLeaving)return Zr(G);var at=Ii(G);if(!at)return Zr(G);var ge=Oe(at,le,P,y);ai(at,ge);var Ge=y.subTree,Xe=Ge&&Ii(Ge),wt=!1,{getTransitionKey:it}=at.type;if(it){var Ce=it();O===void 0?O=Ce:Ce!==O&&(O=Ce,wt=!0)}if(Xe&&Xe.type!==ce&&(!Wt(at,Xe)||wt)){var Ee=Oe(Xe,le,P,y);if(ai(Xe,Ee),ze==="out-in")return P.isLeaving=!0,Ee.afterLeave=()=>{P.isLeaving=!1,y.update.active!==!1&&y.update()},Zr(G);ze==="in-out"&&at.type!==ce&&(Ee.delayLeave=(Te,lt,Ne)=>{var Ct=Mt(P,Xe);Ct[String(Xe.key)]=Xe,Te._leaveCb=()=>{lt(),Te._leaveCb=void 0,delete ge.delayedLeave},ge.delayedLeave=Ne})}return G}}}},kr=Jr;function Mt(a,u){var{leavingVNodes:v}=a,y=v.get(u.type);return y||(y=Object.create(null),v.set(u.type,y)),y}function Oe(a,u,v,y){var{appear:P,mode:O,persisted:F=!1,onBeforeEnter:G,onEnter:Y,onAfterEnter:le,onEnterCancelled:ze,onBeforeLeave:at,onLeave:ge,onAfterLeave:Ge,onLeaveCancelled:Xe,onBeforeAppear:wt,onAppear:it,onAfterAppear:Ce,onAppearCancelled:Ee}=u,Te=String(a.key),lt=Mt(v,a),Ne=(l,f)=>{l&&I(l,y,9,f)},Ct=(l,f)=>{var _=f[1];Ne(l,f),E.isArray(l)?l.every(A=>A.length<=1)&&_():l.length<=1&&_()},i={mode:O,persisted:F,beforeEnter(l){var f=G;if(!v.isMounted)if(P)f=wt||G;else return;l._leaveCb&&l._leaveCb(!0);var _=lt[Te];_&&Wt(a,_)&&_.el._leaveCb&&_.el._leaveCb(),Ne(f,[l])},enter(l){var f=Y,_=le,A=ze;if(!v.isMounted)if(P)f=it||Y,_=Ce||le,A=Ee||ze;else return;var C=!1,N=l._enterCb=M=>{C||(C=!0,M?Ne(A,[l]):Ne(_,[l]),i.delayedLeave&&i.delayedLeave(),l._enterCb=void 0)};f?Ct(f,[l,N]):N()},leave(l,f){var _=String(a.key);if(l._enterCb&&l._enterCb(!0),v.isUnmounting)return f();Ne(at,[l]);var A=!1,C=l._leaveCb=N=>{A||(A=!0,f(),N?Ne(Xe,[l]):Ne(Ge,[l]),l._leaveCb=void 0,lt[_]===a&&delete lt[_])};lt[_]=a,ge?Ct(ge,[l,C]):C()},clone(l){return Oe(l,u,v,y)}};return i}function Zr(a){if(Pr(a))return a=ci(a),a.children=null,a}function Ii(a){return Pr(a)?a.children?a.children[0]:void 0:a}function ai(a,u){a.shapeFlag&6&&a.component?ai(a.component.subTree,u):a.shapeFlag&128?(a.ssContent.transition=u.clone(a.ssContent),a.ssFallback.transition=u.clone(a.ssFallback)):a.transition=u}function Vr(a){for(var u=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!1,v=arguments.length>2?arguments[2]:void 0,y=[],P=0,O=0;O<a.length;O++){var F=a[O],G=v==null?F.key:String(v)+String(F.key!=null?F.key:O);F.type===J?(F.patchFlag&128&&P++,y=y.concat(Vr(F.children,u,G))):(u||F.type!==ce)&&y.push(G!=null?ci(F,{key:G}):F)}if(P>1)for(var Y=0;Y<y.length;Y++)y[Y].patchFlag=-2;return y}function Ni(a){return E.isFunction(a)?{setup:a,name:a.name}:a}var pr=a=>!!a.type.__asyncLoader;function $r(a){E.isFunction(a)&&(a={loader:a});var{loader:u,loadingComponent:v,errorComponent:y,delay:P=200,timeout:O,suspensible:F=!0,onError:G}=a,Y=null,le,ze=0,at=()=>(ze++,Y=null,ge()),ge=()=>{var Ge;return Y||(Ge=Y=u().catch(Xe=>{if(Xe=Xe instanceof Error?Xe:new Error(String(Xe)),G)return new Promise((wt,it)=>{var Ce=()=>wt(at()),Ee=()=>it(Xe);G(Xe,Ce,Ee,ze+1)});throw Xe}).then(Xe=>Ge!==Y&&Y?Y:(Xe&&(Xe.__esModule||Xe[Symbol.toStringTag]==="Module")&&(Xe=Xe.default),le=Xe,Xe)))};return Ni({name:"AsyncComponentWrapper",__asyncLoader:ge,get __asyncResolved(){return le},setup(){var Ge=nn;if(le)return()=>Xr(le,Ge);var Xe=Ee=>{Y=null,St(Ee,Ge,13)};if(F&&Ge.suspense||d.isInSSRComponentSetup)return ge().then(Ee=>()=>Xr(Ee,Ge)).catch(Ee=>(Xe(Ee),()=>y?Ft(y,{error:Ee}):null));var wt=B.ref(!1),it=B.ref(),Ce=B.ref(!!P);return P&&setTimeout(()=>{Ce.value=!1},P),O!=null&&setTimeout(()=>{if(!wt.value&&!it.value){var Ee=new Error("Async component timed out after ".concat(O,"ms."));Xe(Ee),it.value=Ee}},O),ge().then(()=>{wt.value=!0,Ge.parent&&Pr(Ge.parent.vnode)&&Cn(Ge.parent.update)}).catch(Ee=>{Xe(Ee),it.value=Ee}),()=>{if(wt.value&&le)return Xr(le,Ge);if(it.value&&y)return Ft(y,{error:it.value});if(v&&!Ce.value)return Ft(v)}}})}function Xr(a,u){var{ref:v,props:y,children:P,ce:O}=u.vnode,F=Ft(a,y,P);return F.ref=v,F.ce=O,delete u.vnode.ce,F}var Pr=a=>a.type.__isKeepAlive,ki={name:"KeepAlive",__isKeepAlive:!0,props:{include:[String,RegExp,Array],exclude:[String,RegExp,Array],max:[String,Number]},setup(a,u){var{slots:v}=u,y=pn(),P=y.ctx;if(!P.renderer)return()=>{var Te=v.default&&v.default();return Te&&Te.length===1?Te[0]:Te};var O=new Map,F=new Set,G=null,Y=y.suspense,{renderer:{p:le,m:ze,um:at,o:{createElement:ge}}}=P,Ge=ge("div");P.activate=(Te,lt,Ne,Ct,i)=>{var l=Te.component;ze(Te,lt,Ne,0,Y),le(l.vnode,Te,lt,Ne,l,Y,Ct,Te.slotScopeIds,i),cr(()=>{l.isDeactivated=!1,l.a&&E.invokeArrayFns(l.a);var f=Te.props&&Te.props.onVnodeMounted;f&&br(f,l.parent,Te)},Y)},P.deactivate=Te=>{var lt=Te.component;ze(Te,Ge,null,1,Y),cr(()=>{lt.da&&E.invokeArrayFns(lt.da);var Ne=Te.props&&Te.props.onVnodeUnmounted;Ne&&br(Ne,lt.parent,Te),lt.isDeactivated=!0},Y)};function Xe(Te){ir(Te),at(Te,y,Y,!0)}function wt(Te){O.forEach((lt,Ne)=>{var Ct=Li(lt.type);Ct&&(!Te||!Te(Ct))&&it(Ne)})}function it(Te){var lt=O.get(Te);!G||!Wt(lt,G)?Xe(lt):G&&ir(G),O.delete(Te),F.delete(Te)}Kr(()=>[a.include,a.exclude],Te=>{var[lt,Ne]=Te;lt&&wt(Ct=>$i(lt,Ct)),Ne&&wt(Ct=>!$i(Ne,Ct))},{flush:"post",deep:!0});var Ce=null,Ee=()=>{Ce!=null&&O.set(Ce,yi(y.subTree))};return Zn(Ee),Hn(Ee),Qn(()=>{O.forEach(Te=>{var{subTree:lt,suspense:Ne}=y,Ct=yi(lt);if(Te.type===Ct.type&&Te.key===Ct.key){ir(Ct);var i=Ct.component.da;i&&cr(i,Ne);return}Xe(Te)})}),()=>{if(Ce=null,!v.default)return null;var Te=v.default(),lt=Te[0];if(Te.length>1)return G=null,Te;if(!cn(lt)||!(lt.shapeFlag&4)&&!(lt.shapeFlag&128))return G=null,lt;var Ne=yi(lt),Ct=Ne.type,i=Li(pr(Ne)?Ne.type.__asyncResolved||{}:Ct),{include:l,exclude:f,max:_}=a;if(l&&(!i||!$i(l,i))||f&&i&&$i(f,i))return G=Ne,lt;var A=Ne.key==null?Ct:Ne.key,C=O.get(A);return Ne.el&&(Ne=ci(Ne),lt.shapeFlag&128&&(lt.ssContent=Ne)),Ce=A,C?(Ne.el=C.el,Ne.component=C.component,Ne.transition&&ai(Ne,Ne.transition),Ne.shapeFlag|=512,F.delete(A),F.add(A)):(F.add(A),_&&F.size>parseInt(_,10)&&it(F.values().next().value)),Ne.shapeFlag|=256,G=Ne,ii(lt.type)?lt:Ne}}},ln=ki;function $i(a,u){return E.isArray(a)?a.some(v=>$i(v,u)):E.isString(a)?a.split(",").includes(u):E.isRegExp(a)?a.test(u):!1}function Ur(a,u){bn(a,"a",u)}function to(a,u){bn(a,"da",u)}function bn(a,u){var v=arguments.length>2&&arguments[2]!==void 0?arguments[2]:nn,y=a.__wdc||(a.__wdc=()=>{for(var O=v;O;){if(O.isDeactivated)return;O=O.parent}return a()});if(Ri(u,y,v),v)for(var P=v.parent;P&&P.parent;)Pr(P.parent.vnode)&&Hr(y,u,v,P),P=P.parent}function Hr(a,u,v,y){var P=Ri(u,a,y,!0);lr(()=>{E.remove(y[u],P)},v)}function ir(a){a.shapeFlag&=~256,a.shapeFlag&=~512}function yi(a){return a.shapeFlag&128?a.ssContent:a}function Ri(a,u){var v=arguments.length>2&&arguments[2]!==void 0?arguments[2]:nn,y=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1;if(v){if(We.isRootHook(a)&&v!==v.root&&(v=v.root,We.isRootImmediateHook(a))){var P=v.proxy;I(u.bind(P),v,a,We.ON_LOAD===a?[P.$page.options]:[])}var O=v[a]||(v[a]=[]),F=u.__weh||(u.__weh=function(){if(!v.isUnmounted){B.pauseTracking(),Vn(v);for(var G=arguments.length,Y=new Array(G),le=0;le<G;le++)Y[le]=arguments[le];var ze=I(u,v,a,Y);return zn(),B.resetTracking(),ze}});return y?O.unshift(F):O.push(F),F}}var vr=a=>function(u){var v=arguments.length>1&&arguments[1]!==void 0?arguments[1]:nn;return(!d.isInSSRComponentSetup||a==="sp")&&Ri(a,function(){return u(...arguments)},v)},Qr=vr("bm"),Zn=vr("m"),Xn=vr("bu"),Hn=vr("u"),Qn=vr("bum"),lr=vr("um"),ho=vr("sp"),go=vr("rtg"),No=vr("rtc");function no(a){var u=arguments.length>1&&arguments[1]!==void 0?arguments[1]:nn;Ri("ec",a,u)}function ko(a,u){var v=On;if(v===null)return a;for(var y=Do(v)||v.proxy,P=a.dirs||(a.dirs=[]),O=0;O<u.length;O++){var[F,G,Y,le=E.EMPTY_OBJ]=u[O];F&&(E.isFunction(F)&&(F={mounted:F,updated:F}),F.deep&&Fr(G),P.push({dir:F,instance:y,value:G,oldValue:void 0,arg:Y,modifiers:le}))}return a}function jr(a,u,v,y){for(var P=a.dirs,O=u&&u.dirs,F=0;F<P.length;F++){var G=P[F];O&&(G.oldValue=O[F].value);var Y=G.dir[y];Y&&(B.pauseTracking(),I(Y,v,8,[a.el,G,a,u]),B.resetTracking())}}var Rr="components",ro="directives";function Ko(a,u){return Bi(Rr,a,!0,u)||a}var xi=Symbol();function Ui(a){return E.isString(a)?Bi(Rr,a,!1)||a:a||xi}function Ro(a){return Bi(ro,a)}function Bi(a,u){var v=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1,y=On||nn;if(y){var P=y.type;if(a===Rr){var O=Li(P,!1);if(O&&(O===u||O===E.camelize(u)||O===E.capitalize(E.camelize(u))))return P}var F=Hi(y[a]||P[a],u)||Hi(y.appContext[a],u);return!F&&v?P:F}}function Hi(a,u){return a&&(a[u]||a[E.camelize(u)]||a[E.capitalize(E.camelize(u))])}function xo(a,u,v,y){var P,O=v&&v[y];if(E.isArray(a)||E.isString(a)){P=new Array(a.length);for(var F=0,G=a.length;F<G;F++)P[F]=u(a[F],F,void 0,O&&O[F])}else if(typeof a=="number"){P=new Array(a);for(var Y=0;Y<a;Y++)P[Y]=u(Y+1,Y,void 0,O&&O[Y])}else if(E.isObject(a))if(a[Symbol.iterator])P=Array.from(a,(Ge,Xe)=>u(Ge,Xe,void 0,O&&O[Xe]));else{var le=Object.keys(a);P=new Array(le.length);for(var ze=0,at=le.length;ze<at;ze++){var ge=le[ze];P[ze]=u(a[ge],ge,ze,O&&O[ze])}}else P=[];return v&&(v[y]=P),P}function x(a,u){for(var v=function(P){var O=u[P];if(E.isArray(O))for(var F=0;F<O.length;F++)a[O[F].name]=O[F].fn;else O&&(a[O.name]=O.key?function(){var G=O.fn(...arguments);return G&&(G.key=O.key),G}:O.fn)},y=0;y<u.length;y++)v(y);return a}function Q(a,u){var v=arguments.length>2&&arguments[2]!==void 0?arguments[2]:{},y=arguments.length>3?arguments[3]:void 0,P=arguments.length>4?arguments[4]:void 0;if(On.isCE||On.parent&&pr(On.parent)&&On.parent.isCE)return u!=="default"&&(v.name=u),Ft("slot",v,y&&y());var O=a[u];O&&O._c&&(O._d=!1),we();var F=O&&he(O(v)),G=Bt(J,{key:v.key||F&&F.key||"_".concat(u)},F||(y?y():[]),F&&a._===1?64:-2);return!P&&G.scopeId&&(G.slotScopeIds=[G.scopeId+"-s"]),O&&O._c&&(O._d=!0),G}function he(a){return a.some(u=>cn(u)?!(u.type===ce||u.type===J&&!he(u.children)):!0)?a:null}function se(a,u){var v={};for(var y in a)v[u&&/[A-Z]/.test(y)?"on:".concat(y):E.toHandlerKey(y)]=a[y];return v}var de=a=>a?Ci(a)?Do(a)||a.proxy:de(a.parent):null,mt=E.extend(Object.create(null),{$:a=>a,$el:a=>a.vnode.el,$data:a=>a.data,$props:a=>a.props,$attrs:a=>a.attrs,$slots:a=>a.slots,$refs:a=>a.refs,$parent:a=>de(a.parent),$root:a=>de(a.root),$emit:a=>a.emit,$options:a=>xr(a),$forceUpdate:a=>a.f||(a.f=()=>Cn(a.update)),$nextTick:a=>a.n||(a.n=ar.bind(a.proxy)),$watch:a=>Vi.bind(a)}),K=(a,u)=>a!==E.EMPTY_OBJ&&!a.__isScriptSetup&&E.hasOwn(a,u),z={get(a,u){var{_:v}=a,{ctx:y,setupState:P,data:O,props:F,accessCache:G,type:Y,appContext:le}=v,ze;if(u[0]!=="$"){var at=G[u];if(at!==void 0)switch(at){case 1:return P[u];case 2:return O[u];case 4:return y[u];case 3:return F[u]}else{if(K(P,u))return G[u]=1,P[u];if(O!==E.EMPTY_OBJ&&E.hasOwn(O,u))return G[u]=2,O[u];if((ze=v.propsOptions[0])&&E.hasOwn(ze,u))return G[u]=3,F[u];if(y!==E.EMPTY_OBJ&&E.hasOwn(y,u))return G[u]=4,y[u];xe&&(G[u]=0)}}var ge=mt[u],Ge,Xe;if(ge)return u==="$attrs"&&B.track(v,"get",u),ge(v);if((Ge=Y.__cssModules)&&(Ge=Ge[u]))return Ge;if(y!==E.EMPTY_OBJ&&E.hasOwn(y,u))return G[u]=4,y[u];if(Xe=le.config.globalProperties,E.hasOwn(Xe,u))return Xe[u]},set(a,u,v){var{_:y}=a,{data:P,setupState:O,ctx:F}=y;return K(O,u)?(O[u]=v,!0):P!==E.EMPTY_OBJ&&E.hasOwn(P,u)?(P[u]=v,!0):E.hasOwn(y.props,u)||u[0]==="$"&&u.slice(1)in y?!1:(F[u]=v,!0)},has(a,u){var{_:{data:v,setupState:y,accessCache:P,ctx:O,appContext:F,propsOptions:G}}=a,Y;return!!P[u]||v!==E.EMPTY_OBJ&&E.hasOwn(v,u)||K(y,u)||(Y=G[0])&&E.hasOwn(Y,u)||E.hasOwn(O,u)||E.hasOwn(mt,u)||E.hasOwn(F.config.globalProperties,u)},defineProperty(a,u,v){return v.get!=null?a._.accessCache[u]=0:E.hasOwn(v,"value")&&this.set(a,u,v.value,null),Reflect.defineProperty(a,u,v)}},ie=E.extend({},z,{get(a,u){if(u!==Symbol.unscopables)return z.get(a,u,a)},has(a,u){var v=u[0]!=="_"&&!E.isGloballyWhitelisted(u);return v}}),xe=!0;function nt(a){var u=xr(a),v=a.proxy,y=a.ctx;xe=!1,u.beforeCreate&&Tn(u.beforeCreate,a,"bc");var{data:P,computed:O,methods:F,watch:G,provide:Y,inject:le,created:ze,beforeMount:at,mounted:ge,beforeUpdate:Ge,updated:Xe,activated:wt,deactivated:it,beforeDestroy:Ce,beforeUnmount:Ee,destroyed:Te,unmounted:lt,render:Ne,renderTracked:Ct,renderTriggered:i,errorCaptured:l,serverPrefetch:f,expose:_,inheritAttrs:A,components:C,directives:N,filters:M}=u,H=null;if(le&&Yt(le,y,H,a.appContext.config.unwrapInjectedRef),F)for(var ne in F){var ve=F[ne];E.isFunction(ve)&&(y[ne]=ve.bind(v))}if(P){var Le=P.call(v,v);E.isObject(Le)&&(a.data=B.reactive(Le))}if(xe=!0,O){var ue=function(ye){var Fe=O[ye],Ae=E.isFunction(Fe)?Fe.bind(v,v):E.isFunction(Fe.get)?Fe.get.bind(v,v):E.NOOP,_t=!E.isFunction(Fe)&&E.isFunction(Fe.set)?Fe.set.bind(v):E.NOOP,At=bo({get:Ae,set:_t});Object.defineProperty(y,ye,{enumerable:!0,configurable:!0,get:()=>At.value,set:Ke=>At.value=Ke})};for(var ke in O)ue(ke)}if(G)for(var Ye in G)jn(G[Ye],y,v,Ye);if(Y){var ft=E.isFunction(Y)?Y.call(v):Y;Reflect.ownKeys(ft).forEach(ye=>{Dr(ye,ft[ye])})}ze&&Tn(ze,a,"c");function Qe(ye,Fe){E.isArray(Fe)?Fe.forEach(Ae=>ye(Ae.bind(v))):Fe&&ye(Fe.bind(v))}if(Qe(Qr,at),Qe(Zn,ge),Qe(Xn,Ge),Qe(Hn,Xe),Qe(Ur,wt),Qe(to,it),Qe(no,l),Qe(No,Ct),Qe(go,i),Qe(Qn,Ee),Qe(lr,lt),Qe(ho,f),E.isArray(_))if(_.length){var Re=a.exposed||(a.exposed={});_.forEach(ye=>{Object.defineProperty(Re,ye,{get:()=>v[ye],set:Fe=>v[ye]=Fe})})}else a.exposed||(a.exposed={});Ne&&a.render===E.NOOP&&(a.render=Ne),A!=null&&(a.inheritAttrs=A),C&&(a.components=C),N&&(a.directives=N);var me=a.appContext.config.globalProperties.$applyOptions;me&&me(u,a,v)}function Yt(a,u){var v=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1;E.isArray(a)&&(a=mo(a));var y=function(O){var F=a[O],G=void 0;E.isObject(F)?"default"in F?G=In(F.from||O,F.default,!0):G=In(F.from||O):G=In(F),B.isRef(G)&&v?Object.defineProperty(u,O,{enumerable:!0,configurable:!0,get:()=>G.value,set:Y=>G.value=Y}):u[O]=G};for(var P in a)y(P)}function Tn(a,u,v){I(E.isArray(a)?a.map(y=>y.bind(u.proxy)):a.bind(u.proxy),u,v)}function jn(a,u,v,y){var P=y.includes(".")?eo(v,y):()=>v[y];if(E.isString(a)){var O=u[a];E.isFunction(O)&&Kr(P,O)}else if(E.isFunction(a))Kr(P,a.bind(v));else if(E.isObject(a))if(E.isArray(a))a.forEach(G=>jn(G,u,v,y));else{var F=E.isFunction(a.handler)?a.handler.bind(v):u[a.handler];E.isFunction(F)&&Kr(P,F,a)}}function xr(a){var u=a.type,{mixins:v,extends:y}=u,{mixins:P,optionsCache:O,config:{optionMergeStrategies:F}}=a.appContext,G=O.get(u),Y;return G?Y=G:!P.length&&!v&&!y?Y=u:(Y={},P.length&&P.forEach(le=>mr(Y,le,F,!0)),mr(Y,u,F)),E.isObject(u)&&O.set(u,Y),Y}function mr(a,u,v){var y=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1,{mixins:P,extends:O}=u;O&&mr(a,O,v,!0),P&&P.forEach(Y=>mr(a,Y,v,!0));for(var F in u)if(!(y&&F==="expose")){var G=po[F]||v&&v[F];a[F]=G?G(a[F],u[F]):u[F]}return a}var po={data:vo,props:Bn,emits:Bn,methods:Bn,computed:Bn,beforeCreate:Yn,created:Yn,beforeMount:Yn,mounted:Yn,beforeUpdate:Yn,updated:Yn,beforeDestroy:Yn,beforeUnmount:Yn,destroyed:Yn,unmounted:Yn,activated:Yn,deactivated:Yn,errorCaptured:Yn,serverPrefetch:Yn,components:Bn,directives:Bn,watch:er,provide:vo,inject:Jo};function vo(a,u){return u?a?function(){return E.extend(E.isFunction(a)?a.call(this,this):a,E.isFunction(u)?u.call(this,this):u)}:u:a}function Jo(a,u){return Bn(mo(a),mo(u))}function mo(a){if(E.isArray(a)){for(var u={},v=0;v<a.length;v++)u[a[v]]=a[v];return u}return a}function Yn(a,u){return a?[...new Set([].concat(a,u))]:u}function Bn(a,u){return a?E.extend(E.extend(Object.create(null),a),u):u}function er(a,u){if(!a)return u;if(!u)return a;var v=E.extend(Object.create(null),a);for(var y in u)v[y]=Yn(a[y],u[y]);return v}function Si(a,u,v){var y=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1,P={},O={};E.def(O,Zt,1),a.propsDefaults=Object.create(null),fa(a,u,P,O);for(var F in a.propsOptions[0])F in P||(P[F]=void 0);v?a.props=y?P:B.shallowReactive(P):a.type.props?a.props=P:a.props=O,a.attrs=O}function is(a,u,v,y){var{props:P,attrs:O,vnode:{patchFlag:F}}=a,G=B.toRaw(P),[Y]=a.propsOptions,le=!1;if((y||F>0)&&!(F&16)){if(F&8)for(var ze=a.vnode.dynamicProps,at=0;at<ze.length;at++){var ge=ze[at];if(!Or(a.emitsOptions,ge)){var Ge=u[ge];if(Y)if(E.hasOwn(O,ge))Ge!==O[ge]&&(O[ge]=Ge,le=!0);else{var Xe=E.camelize(ge);P[Xe]=_r(Y,G,Xe,Ge,a,!1)}else Ge!==O[ge]&&(O[ge]=Ge,le=!0)}}}else{fa(a,u,P,O)&&(le=!0);var wt;for(var it in G)(!u||!E.hasOwn(u,it)&&((wt=E.hyphenate(it))===it||!E.hasOwn(u,wt)))&&(Y?v&&(v[it]!==void 0||v[wt]!==void 0)&&(P[it]=_r(Y,G,it,void 0,a,!0)):delete P[it]);if(O!==G)for(var Ce in O)(!u||!E.hasOwn(u,Ce)&&!0)&&(delete O[Ce],le=!0)}le&&B.trigger(a,"set","$attrs")}function fa(a,u,v,y){var[P,O]=a.propsOptions,F=!1,G;if(u){for(var Y in u)if(!E.isReservedProp(Y)){var le=u[Y],ze=void 0;P&&E.hasOwn(P,ze=E.camelize(Y))?!O||!O.includes(ze)?v[ze]=le:(G||(G={}))[ze]=le:Or(a.emitsOptions,Y)||(!(Y in y)||le!==y[Y])&&(y[Y]=le,F=!0)}}if(O)for(var at=B.toRaw(v),ge=G||E.EMPTY_OBJ,Ge=0;Ge<O.length;Ge++){var Xe=O[Ge];v[Xe]=_r(P,at,Xe,ge[Xe],a,!E.hasOwn(ge,Xe))}return F}function _r(a,u,v,y,P,O){var F=a[v];if(F!=null){var G=E.hasOwn(F,"default");if(G&&y===void 0){var Y=F.default;if(F.type!==Function&&E.isFunction(Y)){var{propsDefaults:le}=P;v in le?y=le[v]:(Vn(P),y=le[v]=Y.call(null,u),zn())}else y=Y}F[0]&&(O&&!G?y=!1:F[1]&&(y===""||y===E.hyphenate(v))&&(y=!0))}return y}function Pa(a,u){var v=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!1,y=u.propsCache,P=y.get(a);if(P)return P;var O=a.props,F={},G=[],Y=!1;if(!E.isFunction(a)){var le=Te=>{Y=!0;var[lt,Ne]=Pa(Te,u,!0);E.extend(F,lt),Ne&&G.push(...Ne)};!v&&u.mixins.length&&u.mixins.forEach(le),a.extends&&le(a.extends),a.mixins&&a.mixins.forEach(le)}if(!O&&!Y)return E.isObject(a)&&y.set(a,E.EMPTY_ARR),E.EMPTY_ARR;if(E.isArray(O))for(var ze=0;ze<O.length;ze++){var at=E.camelize(O[ze]);$a(at)&&(F[at]=E.EMPTY_OBJ)}else if(O)for(var ge in O){var Ge=E.camelize(ge);if($a(Ge)){var Xe=O[ge],wt=F[Ge]=E.isArray(Xe)||E.isFunction(Xe)?{type:Xe}:Object.assign({},Xe);if(wt){var it=ja(Boolean,wt.type),Ce=ja(String,wt.type);wt[0]=it>-1,wt[1]=Ce<0||it<Ce,(it>-1||E.hasOwn(wt,"default"))&&G.push(Ge)}}}var Ee=[F,G];return E.isObject(a)&&y.set(a,Ee),Ee}function $a(a){return a[0]!=="$"}function Ua(a){var u=a&&a.toString().match(/^\s*(function|class) (\w+)/);return u?u[2]:a===null?"null":""}function Ha(a,u){return Ua(a)===Ua(u)}function ja(a,u){return E.isArray(u)?u.findIndex(v=>Ha(v,a)):E.isFunction(u)&&Ha(u,a)?0:-1}var da=a=>a[0]==="_"||a==="$stable",Ia=a=>E.isArray(a)?a.map(Mn):[Mn(a)],Ln=(a,u,v)=>{if(u._n)return u;var y=Fi(function(){return Ia(u(...arguments))},v);return y._c=!1,y},Bo=(a,u,v)=>{var y=a._ctx;for(var P in a)if(!da(P)){var O=a[P];E.isFunction(O)?u[P]=Ln(P,O,y):O!=null&&function(){var F=Ia(O);u[P]=()=>F}()}},Zo=(a,u)=>{var v=Ia(u);a.slots.default=()=>v},ji=(a,u)=>{if(a.vnode.shapeFlag&32){var v=u._;v?(a.slots=B.toRaw(u),E.def(u,"_",v)):Bo(u,a.slots={})}else a.slots={},u&&Zo(a,u);E.def(a.slots,Zt,1)},os=(a,u,v)=>{var{vnode:y,slots:P}=a,O=!0,F=E.EMPTY_OBJ;if(y.shapeFlag&32){var G=u._;G?v&&G===1?O=!1:(E.extend(P,u),!v&&G===1&&delete P._):(O=!u.$stable,Bo(u,P)),F=u}else u&&(Zo(a,u),F={default:1});if(O)for(var Y in P)!da(Y)&&!(Y in F)&&delete P[Y]};function as(){return{app:null,config:{isNativeTag:E.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 Lo=0;function ss(a,u){return function(y){var P=arguments.length>1&&arguments[1]!==void 0?arguments[1]:null;E.isFunction(y)||(y=Object.assign({},y)),P!=null&&!E.isObject(P)&&(P=null);var O=as(),F=new Set,G=!1,Y=O.app={_uid:Lo++,_component:y,_props:P,_container:null,_context:O,_instance:null,version:ps,get config(){return O.config},set config(le){},use(le){for(var ze=arguments.length,at=new Array(ze>1?ze-1:0),ge=1;ge<ze;ge++)at[ge-1]=arguments[ge];return F.has(le)||(le&&E.isFunction(le.install)?(F.add(le),le.install(Y,...at)):E.isFunction(le)&&(F.add(le),le(Y,...at))),Y},mixin(le){return O.mixins.includes(le)||O.mixins.push(le),Y},component(le,ze){return ze?(O.components[le]=ze,Y):O.components[le]},directive(le,ze){return ze?(O.directives[le]=ze,Y):O.directives[le]},mount(le,ze,at){if(!G){var ge=Ft(y,P);return ge.appContext=O,ze&&u?u(ge,le):a(ge,le,at),G=!0,Y._container=le,le.__vue_app__=Y,Y._instance=ge.component,Do(ge.component)||ge.component.proxy}},unmount(){G&&(a(null,Y._container),delete Y._container.__vue_app__)},provide(le,ze){return O.provides[le]=ze,Y}};return Y}}function io(a,u,v,y){var P=arguments.length>4&&arguments[4]!==void 0?arguments[4]:!1;if(E.isArray(a)){a.forEach((wt,it)=>io(wt,u&&(E.isArray(u)?u[it]:u),v,y,P));return}if(!(pr(y)&&!P)){var O=y.shapeFlag&4?Do(y.component)||y.component.proxy:y.el,F=P?null:O,{i:G,r:Y}=a,le=u&&u.r,ze=G.refs===E.EMPTY_OBJ?G.refs={}:G.refs,at=G.setupState;if(le!=null&&le!==Y&&(E.isString(le)?(ze[le]=null,E.hasOwn(at,le)&&(at[le]=null)):B.isRef(le)&&(le.value=null)),E.isFunction(Y))xt(Y,G,12,[F,ze]);else{var ge=E.isString(Y),Ge=B.isRef(Y);if(ge||Ge){var Xe=()=>{if(a.f){var wt=ge?E.hasOwn(at,Y)?at[Y]:ze[Y]:Y.value;P?E.isArray(wt)&&E.remove(wt,O):E.isArray(wt)?wt.includes(O)||wt.push(O):ge?(ze[Y]=[O],E.hasOwn(at,Y)&&(at[Y]=ze[Y])):(Y.value=[O],a.k&&(ze[a.k]=Y.value))}else ge?(ze[Y]=F,E.hasOwn(at,Y)&&(at[Y]=F)):Ge&&(Y.value=F,a.k&&(ze[a.k]=F))};F?(Xe.id=-1,cr(Xe,v)):Xe()}}}}var si=!1,wi=a=>/svg/.test(a.namespaceURI)&&a.tagName!=="foreignObject",zi=a=>a.nodeType===8;function li(a){var{mt:u,p:v,o:{patchProp:y,createText:P,nextSibling:O,parentNode:F,remove:G,insert:Y,createComment:le}}=a,ze=(Ce,Ee)=>{if(!Ee.hasChildNodes()){v(null,Ce,Ee),Ve(),Ee._vnode=Ce;return}si=!1,at(Ee.firstChild,Ce,null,null,null),Ve(),Ee._vnode=Ce,si&&console.error("Hydration completed but contains mismatches.")},at=function(Ce,Ee,Te,lt,Ne){var Ct=arguments.length>5&&arguments[5]!==void 0?arguments[5]:!1,i=zi(Ce)&&Ce.data==="[",l=()=>wt(Ce,Ee,Te,lt,Ne,i),{type:f,ref:_,shapeFlag:A,patchFlag:C}=Ee,N=Ce.nodeType;Ee.el=Ce,C===-2&&(Ct=!1,Ee.dynamicChildren=null);var M=null;switch(f){case te:N!==3?Ee.children===""?(Y(Ee.el=P(""),F(Ce),Ce),M=Ce):M=l():(Ce.data!==Ee.children&&(si=!0,Ce.data=Ee.children),M=O(Ce));break;case ce:N!==8||i?M=l():M=O(Ce);break;case pe:if(i&&(Ce=O(Ce),N=Ce.nodeType),N===1||N===3){M=Ce;for(var H=!Ee.children.length,ne=0;ne<Ee.staticCount;ne++)H&&(Ee.children+=M.nodeType===1?M.outerHTML:M.data),ne===Ee.staticCount-1&&(Ee.anchor=M),M=O(M);return i?O(M):M}else l();break;case J:i?M=Xe(Ce,Ee,Te,lt,Ne,Ct):M=l();break;default:if(A&1)N!==1||Ee.type.toLowerCase()!==Ce.tagName.toLowerCase()?M=l():M=ge(Ce,Ee,Te,lt,Ne,Ct);else if(A&6){Ee.slotScopeIds=Ne;var ve=F(Ce);if(u(Ee,ve,null,Te,lt,wi(ve),Ct),M=i?it(Ce):O(Ce),M&&zi(M)&&M.data==="teleport end"&&(M=O(M)),pr(Ee)){var Le;i?(Le=Ft(J),Le.anchor=M?M.previousSibling:ve.lastChild):Le=Ce.nodeType===3?ei(""):Ft("div"),Le.el=Ce,Ee.component.subTree=Le}}else A&64?N!==8?M=l():M=Ee.type.hydrate(Ce,Ee,Te,lt,Ne,Ct,a,Ge):A&128&&(M=Ee.type.hydrate(Ce,Ee,Te,lt,wi(F(Ce)),Ne,Ct,a,at))}return _!=null&&io(_,null,lt,Ee),M},ge=(Ce,Ee,Te,lt,Ne,Ct)=>{Ct=Ct||!!Ee.dynamicChildren;var{type:i,props:l,patchFlag:f,shapeFlag:_,dirs:A}=Ee,C=i==="input"&&A||i==="option";if(C||f!==-1){if(A&&jr(Ee,null,Te,"created"),l)if(C||!Ct||f&(16|32))for(var N in l)(C&&N.endsWith("value")||E.isOn(N)&&!E.isReservedProp(N))&&y(Ce,N,null,l[N],!1,void 0,Te);else l.onClick&&y(Ce,"onClick",null,l.onClick,!1,void 0,Te);var M;if((M=l&&l.onVnodeBeforeMount)&&br(M,Te,Ee),A&&jr(Ee,null,Te,"beforeMount"),((M=l&&l.onVnodeMounted)||A)&&bi(()=>{M&&br(M,Te,Ee),A&&jr(Ee,null,Te,"mounted")},lt),_&16&&!(l&&(l.innerHTML||l.textContent)))for(var H=Ge(Ce.firstChild,Ee,Ce,Te,lt,Ne,Ct);H;){si=!0;var ne=H;H=H.nextSibling,G(ne)}else _&8&&Ce.textContent!==Ee.children&&(si=!0,Ce.textContent=Ee.children)}return Ce.nextSibling},Ge=(Ce,Ee,Te,lt,Ne,Ct,i)=>{i=i||!!Ee.dynamicChildren;for(var l=Ee.children,f=l.length,_=0;_<f;_++){var A=i?l[_]:l[_]=Mn(l[_]);if(Ce)Ce=at(Ce,A,lt,Ne,Ct,i);else{if(A.type===te&&!A.children)continue;si=!0,v(null,A,Te,null,lt,Ne,wi(Te),Ct)}}return Ce},Xe=(Ce,Ee,Te,lt,Ne,Ct)=>{var{slotScopeIds:i}=Ee;i&&(Ne=Ne?Ne.concat(i):i);var l=F(Ce),f=Ge(O(Ce),Ee,l,Te,lt,Ne,Ct);return f&&zi(f)&&f.data==="]"?O(Ee.anchor=f):(si=!0,Y(Ee.anchor=le("]"),l,f),f)},wt=(Ce,Ee,Te,lt,Ne,Ct)=>{if(si=!0,Ee.el=null,Ct)for(var i=it(Ce);;){var l=O(Ce);if(l&&l!==i)G(l);else break}var f=O(Ce),_=F(Ce);return G(Ce),v(null,Ee,_,f,Te,lt,wi(_),Ne),f},it=Ce=>{for(var Ee=0;Ce;)if(Ce=O(Ce),Ce&&zi(Ce)&&(Ce.data==="["&&Ee++,Ce.data==="]")){if(Ee===0)return O(Ce);Ee--}return Ce};return[ze,at]}var cr=bi;function or(a){return Wa(a)}function za(a){return Wa(a,li)}function Wa(a,u){var v=E.getGlobalThis();v.__VUE__=!0;var{insert:y,remove:P,patchProp:O,forcePatchProp:F,createElement:G,createText:Y,createComment:le,setText:ze,setElementText:at,parentNode:ge,nextSibling:Ge,setScopeId:Xe=E.NOOP,insertStaticContent:wt}=a,it=function(L,j,ae){var re=arguments.length>3&&arguments[3]!==void 0?arguments[3]:null,oe=arguments.length>4&&arguments[4]!==void 0?arguments[4]:null,$e=arguments.length>5&&arguments[5]!==void 0?arguments[5]:null,rt=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]:!!j.dynamicChildren;if(L!==j){L&&!Wt(L,j)&&(re=Ae(L),Qe(L,oe,$e,!0),L=null),j.patchFlag===-2&&(Je=!1,j.dynamicChildren=null);var{type:Ue,ref:Vt,shapeFlag:pt}=j;switch(Ue){case te:Ce(L,j,ae,re);break;case ce:Ee(L,j,ae,re);break;case pe:L==null&&Te(j,ae,re,rt);break;case J:N(L,j,ae,re,oe,$e,rt,qe,Je);break;default:pt&1?Ct(L,j,ae,re,oe,$e,rt,qe,Je):pt&6?M(L,j,ae,re,oe,$e,rt,qe,Je):(pt&64||pt&128)&&Ue.process(L,j,ae,re,oe,$e,rt,qe,Je,At)}Vt!=null&&oe&&io(Vt,L&&L.ref,$e,j||L,!j)}},Ce=(L,j,ae,re)=>{if(L==null)y(j.el=Y(j.children),ae,re);else{var oe=j.el=L.el;j.children!==L.children&&ze(oe,j.children)}},Ee=(L,j,ae,re)=>{L==null?y(j.el=le(j.children||""),ae,re):j.el=L.el},Te=(L,j,ae,re)=>{[L.el,L.anchor]=wt(L.children,j,ae,re,L.el,L.anchor)},lt=(L,j,ae)=>{for(var{el:re,anchor:oe}=L,$e;re&&re!==oe;)$e=Ge(re),y(re,j,ae),re=$e;y(oe,j,ae)},Ne=L=>{for(var{el:j,anchor:ae}=L,re;j&&j!==ae;)re=Ge(j),P(j),j=re;P(ae)},Ct=(L,j,ae,re,oe,$e,rt,qe,Je)=>{rt=rt||j.type==="svg",L==null?i(j,ae,re,oe,$e,rt,qe,Je):_(L,j,oe,$e,rt,qe,Je)},i=(L,j,ae,re,oe,$e,rt,qe)=>{var Je,Ue,{type:Vt,props:pt,shapeFlag:kt,transition:Rt,dirs:xn}=L;if(Je=L.el=G(L.type,$e,pt&&pt.is,pt),kt&8?at(Je,L.children):kt&16&&f(L.children,Je,null,re,oe,$e&&Vt!=="foreignObject",rt,qe),xn&&jr(L,null,re,"created"),l(Je,L,L.scopeId,rt,re),pt){for(var kn in pt)kn!=="value"&&!E.isReservedProp(kn)&&O(Je,kn,null,pt[kn],$e,L.children,re,oe,Fe,L.hostInstance);"value"in pt&&O(Je,"value",null,pt.value,!1,[],re,null,void 0,L.hostInstance),(Ue=pt.onVnodeBeforeMount)&&br(Ue,re,L)}xn&&jr(L,null,re,"beforeMount");var hn=(!oe||oe&&!oe.pendingBranch)&&Rt&&!Rt.persisted;hn&&Rt.beforeEnter(Je),y(Je,j,ae),((Ue=pt&&pt.onVnodeMounted)||hn||xn)&&cr(()=>{Ue&&br(Ue,re,L),hn&&Rt.enter(Je),xn&&jr(L,null,re,"mounted")},oe)},l=(L,j,ae,re,oe)=>{if(ae&&Xe(L,ae),re)for(var $e=0;$e<re.length;$e++)Xe(L,re[$e]);if(oe){var rt=oe.subTree;if(j===rt){var qe=oe.vnode;l(L,qe,qe.scopeId,qe.slotScopeIds,oe.parent)}}},f=function(L,j,ae,re,oe,$e,rt,qe){for(var Je=arguments.length>8&&arguments[8]!==void 0?arguments[8]:0,Ue=Je;Ue<L.length;Ue++){var Vt=L[Ue]=qe?Dn(L[Ue]):Mn(L[Ue]);it(null,Vt,j,ae,re,oe,$e,rt,qe)}},_=(L,j,ae,re,oe,$e,rt)=>{var qe=j.el=L.el,{patchFlag:Je,dynamicChildren:Ue,dirs:Vt}=j;Je|=L.patchFlag&16;var pt=L.props||E.EMPTY_OBJ,kt=j.props||E.EMPTY_OBJ,Rt;ae&&Wi(ae,!1),(Rt=kt.onVnodeBeforeUpdate)&&br(Rt,ae,j,L),Vt&&jr(j,L,ae,"beforeUpdate"),ae&&Wi(ae,!0);var xn=oe&&j.type!=="foreignObject";if(Ue?A(L.dynamicChildren,Ue,qe,ae,re,xn,$e):rt||ue(L,j,qe,null,ae,re,xn,$e,!1),Je>0){if(Je&16)C(qe,j,pt,kt,ae,re,oe);else if(Je&2&&pt.class!==kt.class&&O(qe,"class",null,kt.class,oe,[],ae,null,void 0,j.hostInstance),Je&4&&O(qe,"style",pt.style,kt.style,oe,[],ae,null,void 0,j.hostInstance),Je&8)for(var kn=j.dynamicProps,hn=0;hn<kn.length;hn++){var mn=kn[hn],ur=pt[mn],ni=kt[mn];(ni!==ur||mn==="value"||F&&F(qe,mn))&&O(qe,mn,ur,ni,oe,L.children,ae,re,Fe,j.hostInstance)}Je&1&&L.children!==j.children&&at(qe,j.children)}else!rt&&Ue==null&&C(qe,j,pt,kt,ae,re,oe);((Rt=kt.onVnodeUpdated)||Vt)&&cr(()=>{Rt&&br(Rt,ae,j,L),Vt&&jr(j,L,ae,"updated")},re)},A=(L,j,ae,re,oe,$e,rt)=>{for(var qe=0;qe<j.length;qe++){var Je=L[qe],Ue=j[qe],Vt=Je.el&&(Je.type===J||!Wt(Je,Ue)||Je.shapeFlag&(6|64))?ge(Je.el):ae;it(Je,Ue,Vt,null,re,oe,$e,rt,!0)}},C=(L,j,ae,re,oe,$e,rt)=>{if(ae!==re){if(ae!==E.EMPTY_OBJ)for(var qe in ae)!E.isReservedProp(qe)&&!(qe in re)&&O(L,qe,ae[qe],null,rt,j.children,oe,$e,Fe,j.hostInstance);for(var Je in re)if(!E.isReservedProp(Je)){var Ue=re[Je],Vt=ae[Je];(Ue!==Vt&&Je!=="value"||F&&F(L,Je))&&O(L,Je,Vt,Ue,rt,j.children,oe,$e,Fe,j.hostInstance)}"value"in re&&O(L,"value",ae.value,re.value,!1,[],oe,null,void 0,j.hostInstance)}},N=(L,j,ae,re,oe,$e,rt,qe,Je)=>{var Ue=j.el=L?L.el:Y(""),Vt=j.anchor=L?L.anchor:Y(""),{patchFlag:pt,dynamicChildren:kt,slotScopeIds:Rt}=j;Rt&&(qe=qe?qe.concat(Rt):Rt),L==null?(y(Ue,ae,re),y(Vt,ae,re),f(j.children,ae,Vt,oe,$e,rt,qe,Je)):pt>0&&pt&64&&kt&&L.dynamicChildren?(A(L.dynamicChildren,kt,ae,oe,$e,rt,qe),(j.key!=null||oe&&j===oe.subTree)&&oo(L,j,!0)):ue(L,j,ae,Vt,oe,$e,rt,qe,Je)},M=(L,j,ae,re,oe,$e,rt,qe,Je)=>{j.slotScopeIds=qe,L==null?j.shapeFlag&512?oe.ctx.activate(j,ae,re,rt,Je):H(j,ae,re,oe,$e,rt,Je):ne(L,j,Je)},H=(L,j,ae,re,oe,$e,rt)=>{var qe=L.component=cs(L,re,oe);if(Pr(L)&&(qe.ctx.renderer=At),us(qe),qe.asyncDep){if(oe&&oe.registerDep(qe,ve),!L.el){var Je=qe.subTree=Ft(ce);Ee(null,Je,j,ae)}return}ve(qe,L,j,ae,oe,$e,rt)},ne=(L,j,ae)=>{var re=j.component=L.component;if(Oo(L,j,ae))if(re.asyncDep&&!re.asyncResolved){Le(re,j,ae);return}else re.next=j,Cr(re.update),re.update();else j.el=L.el,re.vnode=j},ve=(L,j,ae,re,oe,$e,rt)=>{var qe=()=>{if(L.isMounted){var{next:Kt,bu:rn,u:lo,parent:q,vnode:ee}=L,be=Kt,Me;Wi(L,!1),Kt?(Kt.el=ee.el,Le(L,Kt,rt)):Kt=ee,rn&&E.invokeArrayFns(rn),(Me=Kt.props&&Kt.props.onVnodeBeforeUpdate)&&br(Me,q,Kt,ee),Wi(L,!0);var De=Ao(L),Ze=L.subTree;L.subTree=De,it(Ze,De,ge(Ze.el),Ae(Ze),L,oe,$e),Kt.el=De.el,be===null&&Zi(L,De.el),lo&&cr(lo,oe),(Me=Kt.props&&Kt.props.onVnodeUpdated)&&cr(()=>br(Me,q,Kt,ee),oe)}else{var Vt,{el:pt,props:kt}=j,{bm:Rt,m:xn,parent:kn}=L,hn=pr(j);if(Wi(L,!1),Rt&&E.invokeArrayFns(Rt),!hn&&(Vt=kt&&kt.onVnodeBeforeMount)&&br(Vt,kn,j),Wi(L,!0),pt&&Nt){var mn=()=>{L.subTree=Ao(L),Nt(pt,L.subTree,L,oe,null)};hn?j.type.__asyncLoader().then(()=>!L.isUnmounted&&mn()):mn()}else{var ur=L.subTree=Ao(L);it(null,ur,ae,re,L,oe,$e),j.el=ur.el}if(xn&&cr(xn,oe),!hn&&(Vt=kt&&kt.onVnodeMounted)){var ni=j;cr(()=>br(Vt,kn,ni),oe)}(j.shapeFlag&256||kn&&pr(kn.vnode)&&kn.vnode.shapeFlag&256)&&L.a&&cr(L.a,oe),L.isMounted=!0,j=ae=re=null}},Je=L.effect=new B.ReactiveEffect(qe,()=>Cn(Ue),L.scope),Ue=L.update=()=>Je.run();Ue.id=L.uid,Wi(L,!0),Ue()},Le=(L,j,ae)=>{j.component=L;var re=L.vnode.props;L.vnode=j,L.next=null,is(L,j.props,re,ae),os(L,j.children,ae),B.pauseTracking(),ri(),B.resetTracking()},ue=function(L,j,ae,re,oe,$e,rt,qe){var Je=arguments.length>8&&arguments[8]!==void 0?arguments[8]:!1,Ue=L&&L.children,Vt=L?L.shapeFlag:0,pt=j.children,{patchFlag:kt,shapeFlag:Rt}=j;if(kt>0){if(kt&128){Ye(Ue,pt,ae,re,oe,$e,rt,qe,Je);return}else if(kt&256){ke(Ue,pt,ae,re,oe,$e,rt,qe,Je);return}}Rt&8?(Vt&16&&Fe(Ue,oe,$e),pt!==Ue&&at(ae,pt)):Vt&16?Rt&16?Ye(Ue,pt,ae,re,oe,$e,rt,qe,Je):Fe(Ue,oe,$e,!0):(Vt&8&&at(ae,""),Rt&16&&f(pt,ae,re,oe,$e,rt,qe,Je))},ke=(L,j,ae,re,oe,$e,rt,qe,Je)=>{L=L||E.EMPTY_ARR,j=j||E.EMPTY_ARR;var Ue=L.length,Vt=j.length,pt=Math.min(Ue,Vt),kt;for(kt=0;kt<pt;kt++){var Rt=j[kt]=Je?Dn(j[kt]):Mn(j[kt]);it(L[kt],Rt,ae,null,oe,$e,rt,qe,Je)}Ue>Vt?Fe(L,oe,$e,!0,!1,pt):f(j,ae,re,oe,$e,rt,qe,Je,pt)},Ye=(L,j,ae,re,oe,$e,rt,qe,Je)=>{for(var Ue=0,Vt=j.length,pt=L.length-1,kt=Vt-1;Ue<=pt&&Ue<=kt;){var Rt=L[Ue],xn=j[Ue]=Je?Dn(j[Ue]):Mn(j[Ue]);if(Wt(Rt,xn))it(Rt,xn,ae,null,oe,$e,rt,qe,Je);else break;Ue++}for(;Ue<=pt&&Ue<=kt;){var kn=L[pt],hn=j[kt]=Je?Dn(j[kt]):Mn(j[kt]);if(Wt(kn,hn))it(kn,hn,ae,null,oe,$e,rt,qe,Je);else break;pt--,kt--}if(Ue>pt){if(Ue<=kt)for(var mn=kt+1,ur=mn<Vt?j[mn].el:re;Ue<=kt;)it(null,j[Ue]=Je?Dn(j[Ue]):Mn(j[Ue]),ae,ur,oe,$e,rt,qe,Je),Ue++}else if(Ue>kt)for(;Ue<=pt;)Qe(L[Ue],oe,$e,!0),Ue++;else{var ni=Ue,Kt=Ue,rn=new Map;for(Ue=Kt;Ue<=kt;Ue++){var lo=j[Ue]=Je?Dn(j[Ue]):Mn(j[Ue]);lo.key!=null&&rn.set(lo.key,Ue)}var q,ee=0,be=kt-Kt+1,Me=!1,De=0,Ze=new Array(be);for(Ue=0;Ue<be;Ue++)Ze[Ue]=0;for(Ue=ni;Ue<=pt;Ue++){var vt=L[Ue];if(ee>=be){Qe(vt,oe,$e,!0);continue}var et=void 0;if(vt.key!=null)et=rn.get(vt.key);else for(q=Kt;q<=kt;q++)if(Ze[q-Kt]===0&&Wt(vt,j[q])){et=q;break}et===void 0?Qe(vt,oe,$e,!0):(Ze[et-Kt]=Ue+1,et>=De?De=et:Me=!0,it(vt,j[et],ae,null,oe,$e,rt,qe,Je),ee++)}var tt=Me?ao(Ze):E.EMPTY_ARR;for(q=tt.length-1,Ue=be-1;Ue>=0;Ue--){var He=Kt+Ue,Ht=j[He],Dt=He+1<Vt?j[He+1].el:re;Ze[Ue]===0?it(null,Ht,ae,Dt,oe,$e,rt,qe,Je):Me&&(q<0||Ue!==tt[q]?ft(Ht,ae,Dt,2):q--)}}},ft=function(L,j,ae,re){var oe=arguments.length>4&&arguments[4]!==void 0?arguments[4]:null,{el:$e,type:rt,transition:qe,children:Je,shapeFlag:Ue}=L;if(Ue&6){ft(L.component.subTree,j,ae,re);return}if(Ue&128){L.suspense.move(j,ae,re);return}if(Ue&64){rt.move(L,j,ae,At);return}if(rt===J){y($e,j,ae);for(var Vt=0;Vt<Je.length;Vt++)ft(Je[Vt],j,ae,re);y(L.anchor,j,ae);return}if(rt===pe){lt(L,j,ae);return}var pt=re!==2&&Ue&1&&qe;if(pt)if(re===0)qe.beforeEnter($e),y($e,j,ae),cr(()=>qe.enter($e),oe);else{var{leave:kt,delayLeave:Rt,afterLeave:xn}=qe,kn=()=>y($e,j,ae),hn=()=>{kt($e,()=>{kn(),xn&&xn()})};Rt?Rt($e,kn,hn):hn()}else y($e,j,ae)},Qe=function(L,j,ae){var re=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1,oe=arguments.length>4&&arguments[4]!==void 0?arguments[4]:!1,{type:$e,props:rt,ref:qe,children:Je,dynamicChildren:Ue,shapeFlag:Vt,patchFlag:pt,dirs:kt}=L;if(qe!=null&&io(qe,null,ae,L,!0),Vt&256){j.ctx.deactivate(L);return}var Rt=Vt&1&&kt,xn=!pr(L),kn;if(xn&&(kn=rt&&rt.onVnodeBeforeUnmount)&&br(kn,j,L),Vt&6)ye(L.component,ae,re);else{if(Vt&128){L.suspense.unmount(ae,re);return}Rt&&jr(L,null,j,"beforeUnmount"),Vt&64?L.type.remove(L,j,ae,oe,At,re):Ue&&($e!==J||pt>0&&pt&64)?Fe(Ue,j,ae,!1,!0):($e===J&&pt&(128|256)||!oe&&Vt&16)&&Fe(Je,j,ae),re&&Re(L)}(xn&&(kn=rt&&rt.onVnodeUnmounted)||Rt)&&cr(()=>{kn&&br(kn,j,L),Rt&&jr(L,null,j,"unmounted")},ae)},Re=L=>{var{type:j,el:ae,anchor:re,transition:oe}=L;if(j===J){me(ae,re);return}if(j===pe){Ne(L);return}var $e=()=>{P(ae),oe&&!oe.persisted&&oe.afterLeave&&oe.afterLeave()};if(L.shapeFlag&1&&oe&&!oe.persisted){var{leave:rt,delayLeave:qe}=oe,Je=()=>rt(ae,$e);qe?qe(L.el,$e,Je):Je()}else $e()},me=(L,j)=>{for(var ae;L!==j;)ae=Ge(L),P(L),L=ae;P(j)},ye=(L,j,ae)=>{var{bum:re,scope:oe,update:$e,subTree:rt,um:qe}=L;re&&E.invokeArrayFns(re),oe.stop(),$e&&($e.active=!1,Qe(rt,L,j,ae)),qe&&cr(qe,j),cr(()=>{L.isUnmounted=!0},j),j&&j.pendingBranch&&!j.isUnmounted&&L.asyncDep&&!L.asyncResolved&&L.suspenseId===j.pendingId&&(j.deps--,j.deps===0&&j.resolve())},Fe=function(L,j,ae){for(var re=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1,oe=arguments.length>4&&arguments[4]!==void 0?arguments[4]:!1,$e=arguments.length>5&&arguments[5]!==void 0?arguments[5]:0,rt=$e;rt<L.length;rt++)Qe(L[rt],j,ae,re,oe)},Ae=L=>L.shapeFlag&6?Ae(L.component.subTree):L.shapeFlag&128?L.suspense.next():Ge(L.anchor||L.el),_t=(L,j,ae)=>{L==null?j._vnode&&Qe(j._vnode,null,null,!0):it(j._vnode||null,L,j,null,null,null,ae),ri(),Ve(),j._vnode=L},At={p:it,um:Qe,m:ft,r:Re,mt:H,mc:f,pc:ue,pbc:A,n:Ae,o:a},Ke,Nt;return u&&([Ke,Nt]=u(At)),{render:_t,hydrate:Ke,createApp:ss(_t,Ke)}}function Wi(a,u){var{effect:v,update:y}=a;v.allowRecurse=y.allowRecurse=u}function oo(a,u){var v=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!1,y=a.children,P=u.children;if(E.isArray(y)&&E.isArray(P))for(var O=0;O<y.length;O++){var F=y[O],G=P[O];G.shapeFlag&1&&!G.dynamicChildren&&((G.patchFlag<=0||G.patchFlag===32)&&(G=P[O]=Dn(P[O]),G.el=F.el),v||oo(F,G)),G.type===te&&(G.el=F.el)}}function ao(a){var u=a.slice(),v=[0],y,P,O,F,G,Y=a.length;for(y=0;y<Y;y++){var le=a[y];if(le!==0){if(P=v[v.length-1],a[P]<le){u[y]=P,v.push(y);continue}for(O=0,F=v.length-1;O<F;)G=O+F>>1,a[v[G]]<le?O=G+1:F=G;le<a[v[O]]&&(O>0&&(u[y]=v[O-1]),v[O]=y)}}for(O=v.length,F=v[O-1];O-- >0;)v[O]=F,F=u[F];return v}var ls=a=>a.__isTeleport,ha=a=>a&&(a.disabled||a.disabled===""),Mo=a=>typeof SVGElement!="undefined"&&a instanceof SVGElement,ga=(a,u)=>{var v=a&&a.to;if(E.isString(v))if(u){var y=u(v);return y}else return null;else return v},m={__isTeleport:!0,process(a,u,v,y,P,O,F,G,Y,le){var{mc:ze,pc:at,pbc:ge,o:{insert:Ge,querySelector:Xe,createText:wt,createComment:it}}=le,Ce=ha(u.props),{shapeFlag:Ee,children:Te,dynamicChildren:lt}=u;if(a==null){var Ne=u.el=wt(""),Ct=u.anchor=wt("");Ge(Ne,v,y),Ge(Ct,v,y);var i=u.target=ga(u.props,Xe),l=u.targetAnchor=wt("");i&&(Ge(l,i),F=F||Mo(i));var f=(ve,Le)=>{Ee&16&&ze(Te,ve,Le,P,O,F,G,Y)};Ce?f(v,Ct):i&&f(i,l)}else{u.el=a.el;var _=u.anchor=a.anchor,A=u.target=a.target,C=u.targetAnchor=a.targetAnchor,N=ha(a.props),M=N?v:A,H=N?_:C;if(F=F||Mo(A),lt?(ge(a.dynamicChildren,lt,M,P,O,F,G),oo(a,u,!0)):Y||at(a,u,M,H,P,O,F,G,!1),Ce)N||R(u,v,_,le,1);else if((u.props&&u.props.to)!==(a.props&&a.props.to)){var ne=u.target=ga(u.props,Xe);ne&&R(u,ne,null,le,0)}else N&&R(u,A,C,le,1)}X(u)},remove(a,u,v,y,P,O){var{um:F,o:{remove:G}}=P,{shapeFlag:Y,children:le,anchor:ze,targetAnchor:at,target:ge,props:Ge}=a;if(ge&&G(at),(O||!ha(Ge))&&(G(ze),Y&16))for(var Xe=0;Xe<le.length;Xe++){var wt=le[Xe];F(wt,u,v,!0,!!wt.dynamicChildren)}},move:R,hydrate:U};function R(a,u,v,y){var{o:{insert:P},m:O}=y,F=arguments.length>4&&arguments[4]!==void 0?arguments[4]:2;F===0&&P(a.targetAnchor,u,v);var{el:G,anchor:Y,shapeFlag:le,children:ze,props:at}=a,ge=F===2;if(ge&&P(G,u,v),(!ge||ha(at))&&le&16)for(var Ge=0;Ge<ze.length;Ge++)O(ze[Ge],u,v,2);ge&&P(Y,u,v)}function U(a,u,v,y,P,O,F,G){var{o:{nextSibling:Y,parentNode:le,querySelector:ze}}=F,at=u.target=ga(u.props,ze);if(at){var ge=at._lpa||at.firstChild;if(u.shapeFlag&16)if(ha(u.props))u.anchor=G(Y(a),u,le(a),v,y,P,O),u.targetAnchor=ge;else{u.anchor=Y(a);for(var Ge=ge;Ge;)if(Ge=Y(Ge),Ge&&Ge.nodeType===8&&Ge.data==="teleport anchor"){u.targetAnchor=Ge,at._lpa=u.targetAnchor&&Y(u.targetAnchor);break}G(ge,u,at,v,y,P,O)}X(u)}return u.anchor&&Y(u.anchor)}var $=m;function X(a){var u=a.ctx;if(u&&u.ut){for(var v=a.children[0].el;v!==a.targetAnchor;)v.nodeType===1&&v.setAttribute("data-v-owner",u.uid),v=v.nextSibling;u.ut()}}var J=Symbol(void 0),te=Symbol(void 0),ce=Symbol(void 0),pe=Symbol(void 0),Pe=[],fe=null;function we(){var a=arguments.length>0&&arguments[0]!==void 0?arguments[0]:!1;Pe.push(fe=a?null:[])}function ct(){Pe.pop(),fe=Pe[Pe.length-1]||null}var gt=1;function $t(a){gt+=a}function Et(a){return a.dynamicChildren=gt>0?fe||E.EMPTY_ARR:null,ct(),gt>0&&fe&&fe.push(a),a}function je(a,u,v,y,P,O){return Et(Ut(a,u,v,y,P,O,!0))}function Bt(a,u,v,y,P){return Et(Ft(a,u,v,y,P,!0))}function cn(a){return a?a.__v_isVNode===!0:!1}function Wt(a,u){return a.type===u.type&&a.key===u.key}function ht(a){}var Zt="__vInternal",Rn=a=>{var{key:u}=a;return u!=null?u:null},Gt=a=>{var{ref:u,ref_key:v,ref_for:y}=a;return u!=null?E.isString(u)||B.isRef(u)||E.isFunction(u)?{i:On,r:u,k:v,f:!!y}:u:null};function Ut(a){var u=arguments.length>1&&arguments[1]!==void 0?arguments[1]:null,v=arguments.length>2&&arguments[2]!==void 0?arguments[2]:null,y=arguments.length>3&&arguments[3]!==void 0?arguments[3]:0,P=arguments.length>4&&arguments[4]!==void 0?arguments[4]:null,O=arguments.length>5&&arguments[5]!==void 0?arguments[5]:a===J?0:1,F=arguments.length>6&&arguments[6]!==void 0?arguments[6]:!1,G=arguments.length>7&&arguments[7]!==void 0?arguments[7]:!1,Y={__v_isVNode:!0,__v_skip:!0,type:a,props:u,key:u&&Rn(u),ref:u&&Gt(u),scopeId:dn,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:O,patchFlag:y,dynamicProps:P,dynamicChildren:null,appContext:null,hostInstance:On,ctx:On};return G?(Ir(Y,v),O&128&&a.normalize(Y)):v&&(Y.shapeFlag|=E.isString(v)?8:16),gt>0&&!F&&fe&&(Y.patchFlag>0||O&6)&&Y.patchFlag!==32&&fe.push(Y),Y}var Ft=qt;function qt(a){var u=arguments.length>1&&arguments[1]!==void 0?arguments[1]:null,v=arguments.length>2&&arguments[2]!==void 0?arguments[2]:null,y=arguments.length>3&&arguments[3]!==void 0?arguments[3]:0,P=arguments.length>4&&arguments[4]!==void 0?arguments[4]:null,O=arguments.length>5&&arguments[5]!==void 0?arguments[5]:!1;if((!a||a===xi)&&(a=ce),cn(a)){var F=ci(a,u,!0);return v&&Ir(F,v),gt>0&&!O&&fe&&(F.shapeFlag&6?fe[fe.indexOf(a)]=F:fe.push(F)),F.patchFlag|=-2,F}if(_o(a)&&(a=a.__vccOpts),u){u=Xo(u);var{class:G,style:Y}=u;G&&!E.isString(G)&&(u.class=E.normalizeClass(G)),E.isObject(Y)&&(B.isProxy(Y)&&!E.isArray(Y)&&(Y=E.extend({},Y)),u.style=E.normalizeStyle(Y))}var le=E.isString(a)?1:ii(a)?128:ls(a)?64:E.isObject(a)?4:E.isFunction(a)?2:0;return Ut(a,u,v,y,P,le,O,!0)}function Xo(a){return a?B.isProxy(a)||Zt in a?E.extend({},a):a:null}function ci(a,u){var v=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!1,{props:y,ref:P,patchFlag:O,children:F}=a,G=u?Fn(y||{},u):y,Y={__v_isVNode:!0,__v_skip:!0,type:a.type,props:G,key:G&&Rn(G),ref:u&&u.ref?v&&P?E.isArray(P)?P.concat(Gt(u)):[P,Gt(u)]:Gt(u):P,scopeId:a.scopeId,slotScopeIds:a.slotScopeIds,children:F,target:a.target,targetAnchor:a.targetAnchor,staticCount:a.staticCount,shapeFlag:a.shapeFlag,patchFlag:u&&a.type!==J?O===-1?16:O|16:O,dynamicProps:a.dynamicProps,dynamicChildren:a.dynamicChildren,appContext:a.appContext,hostInstance:a.hostInstance,dirs:a.dirs,transition:a.transition,component:a.component,suspense:a.suspense,ssContent:a.ssContent&&ci(a.ssContent),ssFallback:a.ssFallback&&ci(a.ssFallback),el:a.el,anchor:a.anchor,ctx:a.ctx,ce:a.ce};return Y}function ei(){var a=arguments.length>0&&arguments[0]!==void 0?arguments[0]:" ",u=arguments.length>1&&arguments[1]!==void 0?arguments[1]:0;return Ft(te,null,a,u)}function Gi(a,u){var v=Ft(pe,null,a);return v.staticCount=u,v}function Ga(){var a=arguments.length>0&&arguments[0]!==void 0?arguments[0]:"",u=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!1;return u?(we(),Bt(ce,null,a)):Ft(ce,null,a)}function Mn(a){return a==null||typeof a=="boolean"?Ft(ce):E.isArray(a)?Ft(J,null,a.slice()):typeof a=="object"?Dn(a):Ft(te,null,String(a))}function Dn(a){return a.el===null&&a.patchFlag!==-1||a.memo?a:ci(a)}function Ir(a,u){var v=0,{shapeFlag:y}=a;if(u==null)u=null;else if(E.isArray(u))v=16;else if(typeof u=="object")if(y&(1|64)){var P=u.default;P&&(P._c&&(P._d=!1),Ir(a,P()),P._c&&(P._d=!0));return}else{v=32;var O=u._;!O&&!(Zt in u)?u._ctx=On:O===3&&On&&(On.slots._===1?u._=1:(u._=2,a.patchFlag|=1024))}else E.isFunction(u)?(u={default:u,_ctx:On},v=32):(u=String(u),y&64?(v=16,u=[ei(u)]):v=8);a.children=u,a.shapeFlag|=v}function Fn(){for(var a={},u=0;u<arguments.length;u++){var v=u<0||arguments.length<=u?void 0:arguments[u];for(var y in v)if(y==="class")a.class!==v.class&&(a.class=E.normalizeClass([a.class,v.class]));else if(y==="style")a.style=E.normalizeStyle([a.style,v.style]);else if(E.isOn(y)){var P=a[y],O=v[y];O&&P!==O&&!(E.isArray(P)&&P.includes(O))&&(a[y]=P?[].concat(P,O):O)}else y!==""&&(a[y]=v[y])}return a}function br(a,u,v){var y=arguments.length>3&&arguments[3]!==void 0?arguments[3]:null;I(a,u,7,[v,y])}var zr=as(),Qo=0;function cs(a,u,v){var y=a.type,P=(u?u.appContext:a.appContext)||zr,O={uid:Qo++,vnode:a,type:y,parent:u,appContext:P,root:null,next:null,subTree:null,effect:null,update:null,scope:new B.EffectScope(!0),render:null,proxy:null,exposed:null,exposeProxy:null,withProxy:null,provides:u?u.provides:Object.create(P.provides),accessCache:null,renderCache:[],components:null,directives:null,propsOptions:Pa(y,P),emitsOptions:Ar(y,P),emit:null,emitted:null,propsDefaults:E.EMPTY_OBJ,inheritAttrs:y.inheritAttrs,ctx:E.EMPTY_OBJ,data:E.EMPTY_OBJ,props:E.EMPTY_OBJ,attrs:E.EMPTY_OBJ,slots:E.EMPTY_OBJ,refs:E.EMPTY_OBJ,setupState:E.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 O.ctx={_:O},O.root=u?u.root:O,O.emit=rr.bind(null,O),a.ce&&a.ce(O),O}var nn=null,pn=()=>nn||On,Vn=a=>{nn=a,a.scope.on()},zn=()=>{nn&&nn.scope.off(),nn=null};function Ci(a){return a.vnode.shapeFlag&4}d.isInSSRComponentSetup=!1;function us(a){var u=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!1;d.isInSSRComponentSetup=u;var{props:v,children:y}=a.vnode,P=Ci(a);Si(a,v,P,u),ji(a,y);var O=P?Ya(a,u):void 0;return d.isInSSRComponentSetup=!1,O}function Ya(a,u){var v=a.type;a.accessCache=Object.create(null),a.proxy=B.markRaw(new Proxy(a.ctx,z));var{setup:y}=v;if(y){var P=a.setupContext=y.length>1?Ja(a):null;Vn(a),B.pauseTracking();var O=xt(y,a,0,[a.props,P]);if(B.resetTracking(),zn(),E.isPromise(O)){if(O.then(zn,zn),u)return O.then(F=>{Na(a,F,u)}).catch(F=>{St(F,a,0)});a.asyncDep=O}else Na(a,O,u)}else Wr(a,u)}function Na(a,u,v){E.isFunction(u)?a.type.__ssrInlineRender?a.ssrRender=u:a.render=u:E.isObject(u)&&(a.setupState=B.proxyRefs(u)),Wr(a,v)}var ea,so;function qa(a){ea=a,so=u=>{u.render._rc&&(u.withProxy=new Proxy(u.ctx,ie))}}var fs=()=>!ea;function Wr(a,u,v){var y=a.type;if(!a.render){if(!u&&ea&&!y.render){var P=y.template||xr(a).template;if(P){var{isCustomElement:O,compilerOptions:F}=a.appContext.config,{delimiters:G,compilerOptions:Y}=y,le=E.extend(E.extend({isCustomElement:O,delimiters:G},F),Y);y.render=ea(P,le)}}a.render=y.render||E.NOOP,so&&so(a)}Vn(a),B.pauseTracking(),nt(a),B.resetTracking(),zn()}function Ka(a){return new Proxy(a.attrs,{get(u,v){return B.track(a,"get","$attrs"),u[v]}})}function Ja(a){var u=y=>{a.exposed=y||{}},v;return{get attrs(){return v||(v=Ka(a))},slots:a.slots,emit:a.emit,expose:u}}function Do(a){if(a.exposed)return a.exposeProxy||(a.exposeProxy=new Proxy(B.proxyRefs(B.markRaw(a.exposed)),{get(u,v){if(v in u)return u[v];if(v in mt)return mt[v](a)},has(u,v){return v in u||v in mt}}))}function Li(a){var u=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!0;return E.isFunction(a)?a.displayName||a.name:a.name||u&&a.__name}function _o(a){return E.isFunction(a)&&"__vccOpts"in a}var bo=(a,u)=>B.computed(a,u,d.isInSSRComponentSetup);function ds(){return null}function Fo(){return null}function Bs(a){}function hs(a,u){return null}function Ls(){return Pt().slots}function Be(){return Pt().attrs}function Pt(){var a=pn();return a.setupContext||(a.setupContext=Ja(a))}function Ot(a,u){var v=E.isArray(a)?a.reduce((O,F)=>(O[F]={},O),{}):a;for(var y in u){var P=v[y];P?E.isArray(P)||E.isFunction(P)?v[y]={type:P,default:u[y]}:P.default=u[y]:P===null&&(v[y]={default:u[y]})}return v}function yn(a,u){var v={},y=function(O){u.includes(O)||Object.defineProperty(v,O,{enumerable:!0,get:()=>a[O]})};for(var P in a)y(P);return v}function Er(a){var u=pn(),v=a();return zn(),E.isPromise(v)&&(v=v.catch(y=>{throw Vn(u),y})),[v,()=>Vn(u)]}function Ai(a,u,v){var y=arguments.length;return y===2?E.isObject(u)&&!E.isArray(u)?cn(u)?Ft(a,null,[u]):Ft(a,u):Ft(a,null,u):(y>3?v=Array.prototype.slice.call(arguments,2):y===3&&cn(v)&&(v=[v]),Ft(a,u,v))}var Yi=Symbol(""),Eo=()=>{{var a=In(Yi);return a}};function ka(){}function ta(a,u,v,y){var P=v[y];if(P&&gs(P,a))return P;var O=u();return O.memo=a.slice(),v[y]=O}function gs(a,u){var v=a.memo;if(v.length!=u.length)return!1;for(var y=0;y<v.length;y++)if(E.hasChanged(v[y],u[y]))return!1;return gt>0&&fe&&fe.push(a),!0}var ps="3.2.47",dl=null,$l=null,Ul={insert:(a,u,v)=>v?u.insertBefore(a,v):u.appendChild(a),remove:a=>{var u=a.parentNode;u&&u.removeChild(a)},createElement:a=>s.createElement(a),createText:a=>s.createText(a),createComment:a=>s.createComment(a),setText:(a,u)=>{a.setAttr("value",u)},setElementText:(a,u)=>{a.setAttr("value",u)},parentNode:a=>a.parentNode,nextSibling:a=>a.nextSibling};function pa(a){return Object.keys(a)}function va(a){var u={};return E.isArray(a)&&a.forEach(v=>{pa(v).forEach(y=>{var P=v[y],O=u[y]||(u[y]={});pa(P).forEach(F=>{var G=P[F],Y=O[F]||(O[F]={});pa(G).forEach(le=>{le[0]==="!"?(Y[le]=G[le],delete Y[le.slice(1)]):E.hasOwn(Y,"!"+le)||(Y[le]=G[le])})})})}),u}function na(a,u){var v=u&&u.classList;return v&&v.includes(a)}var ma=/[+~> ]$/,Ra="parentNode",vs="previousSibling";function ra(a,u){for(var v=a.split("."),y=v.length-1;y>0;y--){var P=v[y],O=P[P.length-1],F=P.replace(ma,"");if(O==="~"||O===" "){for(var G=O==="~"?vs:Ra;u&&(u=u[G],!na(F,u)););if(!u)return!1}else if(O===">"?u=u&&u[Ra]:O==="+"&&(u=u&&u[vs]),!na(F,u))return!1}return!0}var Ms=1e3;function Hl(a,u,v){var{styles:y,weights:P}=a;pa(u).forEach(O=>{if(!(O&&v&&!ra(O,v))){var F=O.split(".").length,G=u[O];pa(G).forEach(Y=>{var le=G[Y],ze=Y[0]==="!";ze&&(Y=Y.slice(1));var at=P[Y]||0,ge=F+(ze?Ms:0);ge>=at&&(P[Y]=ge,y[Y]=le)})}})}function ms(a,u){var v=arguments.length>2&&arguments[2]!==void 0?arguments[2]:null,y={styles:{},weights:{}};return a.forEach(P=>{var O=u[P];O&&Hl(y,O,v)}),y.styles}function Ds(a){return ms(a.classList,a.styleSheet,a)}function Fs(a,u){var v=arguments.length>2&&arguments[2]!==void 0?arguments[2]:null;return ms(a,Vs(u),v)}function Vs(a){var{type:u,appContext:v}=a,y=u;if(!y.__styles)if(v&&E.isArray(v.provides.__globalStyles)&&(v.provides.__globalStyles=va(v.provides.__globalStyles)),y.mpType==="page"&&v)y.__styles=v.provides.__globalStyles;else{var P=[];v&&P.push(v.provides.__globalStyles),E.isArray(y.styles)&&y.styles.forEach(O=>P.push(O)),y.__styles=va(P)}return y.__styles}function _s(a,u,v){var y=arguments.length>3&&arguments[3]!==void 0?arguments[3]:null;y&&([u,v]=yo(a,u,v,y)),a.setAttr(u,v)}var xa="hoverClass",hl="placeholderClass",$s="placeholderStyle",jl="indicatorClass",Vo="indicatorStyle",Za="maskClass",_a="maskStyle",Ba={view:{class:[xa],style:[]},button:{class:[xa],style:[]},navigator:{class:[xa],style:[]},"u-input":{class:[hl],style:[$s]},"u-textarea":{class:[hl],style:[$s]},"picker-view":{class:[jl,Za],style:[Vo,_a]}};function yo(a,u,v,y){if(!v)return[u,v];var P=Ba[a.type];if(P){var O=E.camelize(u);if(P.class.indexOf(O)>-1)return[O,Fs([v],y,a)];if(P.style.indexOf(u)>-1)return E.isString(v)?[O,E.parseStringStyle(v)]:[O,E.normalizeStyle(v)]}return[u,v]}function ia(a,u,v){var y=arguments.length>3&&arguments[3]!==void 0?arguments[3]:null;if(!!y){var P=v?v.split(" "):[];a.setClassList(P),a.setStyleSheet(Vs(y))}}function Xa(a,u,v,y){a.addEvent(u,v)}function Us(a,u){a.removeEvent(u)}function gl(a,u,v,y){var P=arguments.length>4&&arguments[4]!==void 0?arguments[4]:null,O=a._vei||(a._vei={}),F=O[u];if(y&&F)F.value=y;else{var[G,Y]=Hs(u);if(y){var le=O[u]=Qa(y,P);Xa(a,G,le)}else F&&(Us(a,G),O[u]=void 0)}}var $o=/(?:Once|Passive|Capture)$/;function bs(a){return a==="on-post-message"?"onPostMessage":a}function Hs(a){var u;if($o.test(a)){u={};for(var v;v=a.match($o);)a=a.slice(0,a.length-v[0].length),u[v[0].toLowerCase()]=!0}var y=a[2]===":"?a.slice(3):a.slice(2);return[bs(E.hyphenate(y)),u]}function Qa(a,u){var v=P=>{I(v.value,u,5,[P])};v.value=a;var y=new Set;return E.isArray(v.value)?v.value.forEach(P=>{P.modifiers&&P.modifiers.forEach(O=>{y.add(O)})}):(v.value.modifiers&&v.value.modifiers.forEach(P=>{y.add(P)}),ti(v,u)),v.modifiers=[...y],v}function ti(a,u){if(!!u){var{$wxsModules:v}=u;if(!!v){var y=a.value.toString();!v.find(P=>y.indexOf("."+P+".")>-1)||(a.wxsEvent=a.value())}}}function Br(a,u,v){if(!!v){E.isString(v)&&(v=E.parseStringStyle(v));var y={},P=u&&!E.isString(u);if(P){for(var O in u)v[O]==null&&(y[E.camelize(O)]="");for(var F in v){var G=v[F];G!==u[F]&&(y[E.camelize(F)]=G)}}else for(var Y in v)y[E.camelize(Y)]=v[Y];a.setStyles(y)}}var oa=["u-input","u-textarea"],pl=function(a,u,v,y){var P=arguments.length>6?arguments[6]:void 0,O=arguments.length>9?arguments[9]:void 0;u==="class"?ia(a,v,y,O||P):u==="style"?Br(a,v,y):E.isOn(u)?E.isModelListener(u)||gl(a,u,v,y,P):u==="modelValue"&&oa.includes(a.type)?a.setAttrs({modelValue:y,value:y}):_s(a,u,y,P)};function zl(){var a=arguments.length>0&&arguments[0]!==void 0?arguments[0]:"$style";{var u=pn();if(!u)return E.EMPTY_OBJ;var v=u.type.__cssModules;if(!v)return E.EMPTY_OBJ;var y=v[a];return y||E.EMPTY_OBJ}}function js(a){var u=pn();if(!!u){var v=()=>Es(u.subTree,a(u.proxy));Zn(()=>Un(v,{flush:"post"})),Hn(v)}}function Es(a,u){if(a.shapeFlag&128){var v=a.suspense;a=v.activeBranch,v.pendingBranch&&!v.isHydrating&&v.effects.push(()=>{Es(v.activeBranch,u)})}for(;a.component;)a=a.component.subTree;if(a.shapeFlag&1&&a.el){var y=a.el.style;for(var P in u)y.setProperty("--".concat(P),u[P])}else a.type===J&&a.children.forEach(O=>Es(O,u))}var zs=["ctrl","shift","alt","meta"],Ws={stop:a=>a.stopPropagation(),prevent:a=>a.preventDefault(),self:a=>a.target!==a.currentTarget,ctrl:a=>!a.ctrlKey,shift:a=>!a.shiftKey,alt:a=>!a.altKey,meta:a=>!a.metaKey,left:a=>"button"in a&&a.button!==0,middle:a=>"button"in a&&a.button!==1,right:a=>"button"in a&&a.button!==2,exact:(a,u)=>zs.some(v=>a["".concat(v,"Key")]&&!u.includes(v))},vl=(a,u)=>function(v){for(var y=0;y<u.length;y++){var P=Ws[u[y]];if(P&&P(v,u))return}for(var O=arguments.length,F=new Array(O>1?O-1:0),G=1;G<O;G++)F[G-1]=arguments[G];return a(v,...F)},Gs=(a,u)=>v=>{if("key"in v){var y=E.hyphenate(v.key);if(u.some(P=>P===y))return a(v)}},ys=E.extend({patchProp:pl},Ul),Ss;function ws(){return Ss||(Ss=or(ys))}var ml=function(){ws().render(...arguments)},_l=function(){var a=ws().createApp(...arguments),{mount:u}=a;return a.mount=v=>u(v),a};return Object.defineProperty(d,"camelize",{enumerable:!0,get:function(){return E.camelize}}),Object.defineProperty(d,"capitalize",{enumerable:!0,get:function(){return E.capitalize}}),Object.defineProperty(d,"hyphenate",{enumerable:!0,get:function(){return E.hyphenate}}),Object.defineProperty(d,"normalizeClass",{enumerable:!0,get:function(){return E.normalizeClass}}),Object.defineProperty(d,"normalizeProps",{enumerable:!0,get:function(){return E.normalizeProps}}),Object.defineProperty(d,"normalizeStyle",{enumerable:!0,get:function(){return E.normalizeStyle}}),Object.defineProperty(d,"toDisplayString",{enumerable:!0,get:function(){return E.toDisplayString}}),Object.defineProperty(d,"toHandlerKey",{enumerable:!0,get:function(){return E.toHandlerKey}}),Object.defineProperty(d,"EffectScope",{enumerable:!0,get:function(){return B.EffectScope}}),Object.defineProperty(d,"ReactiveEffect",{enumerable:!0,get:function(){return B.ReactiveEffect}}),Object.defineProperty(d,"customRef",{enumerable:!0,get:function(){return B.customRef}}),Object.defineProperty(d,"effect",{enumerable:!0,get:function(){return B.effect}}),Object.defineProperty(d,"effectScope",{enumerable:!0,get:function(){return B.effectScope}}),Object.defineProperty(d,"getCurrentScope",{enumerable:!0,get:function(){return B.getCurrentScope}}),Object.defineProperty(d,"isProxy",{enumerable:!0,get:function(){return B.isProxy}}),Object.defineProperty(d,"isReactive",{enumerable:!0,get:function(){return B.isReactive}}),Object.defineProperty(d,"isReadonly",{enumerable:!0,get:function(){return B.isReadonly}}),Object.defineProperty(d,"isRef",{enumerable:!0,get:function(){return B.isRef}}),Object.defineProperty(d,"isShallow",{enumerable:!0,get:function(){return B.isShallow}}),Object.defineProperty(d,"markRaw",{enumerable:!0,get:function(){return B.markRaw}}),Object.defineProperty(d,"onScopeDispose",{enumerable:!0,get:function(){return B.onScopeDispose}}),Object.defineProperty(d,"proxyRefs",{enumerable:!0,get:function(){return B.proxyRefs}}),Object.defineProperty(d,"reactive",{enumerable:!0,get:function(){return B.reactive}}),Object.defineProperty(d,"readonly",{enumerable:!0,get:function(){return B.readonly}}),Object.defineProperty(d,"ref",{enumerable:!0,get:function(){return B.ref}}),Object.defineProperty(d,"shallowReactive",{enumerable:!0,get:function(){return B.shallowReactive}}),Object.defineProperty(d,"shallowReadonly",{enumerable:!0,get:function(){return B.shallowReadonly}}),Object.defineProperty(d,"shallowRef",{enumerable:!0,get:function(){return B.shallowRef}}),Object.defineProperty(d,"stop",{enumerable:!0,get:function(){return B.stop}}),Object.defineProperty(d,"toRaw",{enumerable:!0,get:function(){return B.toRaw}}),Object.defineProperty(d,"toRef",{enumerable:!0,get:function(){return B.toRef}}),Object.defineProperty(d,"toRefs",{enumerable:!0,get:function(){return B.toRefs}}),Object.defineProperty(d,"triggerRef",{enumerable:!0,get:function(){return B.triggerRef}}),Object.defineProperty(d,"unref",{enumerable:!0,get:function(){return B.unref}}),d.BaseTransition=kr,d.BaseTransitionPropsValidators=gn,d.Comment=ce,d.Fragment=J,d.KeepAlive=ln,d.Static=pe,d.Suspense=uo,d.Teleport=$,d.Text=te,d.assertNumber=en,d.callWithAsyncErrorHandling=I,d.callWithErrorHandling=xt,d.cloneVNode=ci,d.compatUtils=$l,d.computed=bo,d.createApp=_l,d.createBlock=Bt,d.createCommentVNode=Ga,d.createElementBlock=je,d.createElementVNode=Ut,d.createHydrationRenderer=za,d.createPropsRestProxy=yn,d.createRenderer=or,d.createSlots=x,d.createStaticVNode=Gi,d.createTextVNode=ei,d.createVNode=Ft,d.defineAsyncComponent=$r,d.defineComponent=Ni,d.defineEmits=Fo,d.defineExpose=Bs,d.defineProps=ds,d.getCurrentInstance=pn,d.getTransitionRawChildren=Vr,d.guardReactiveProps=Xo,d.h=Ai,d.handleError=St,d.initCustomFormatter=ka,d.inject=In,d.injectHook=Ri,d.isMemoSame=gs,d.isRuntimeOnly=fs,d.isVNode=cn,d.mergeDefaults=Ot,d.mergeProps=Fn,d.nextTick=ar,d.onActivated=Ur,d.onBeforeMount=Qr,d.onBeforeUnmount=Qn,d.onBeforeUpdate=Xn,d.onDeactivated=to,d.onErrorCaptured=no,d.onMounted=Zn,d.onRenderTracked=No,d.onRenderTriggered=go,d.onServerPrefetch=ho,d.onUnmounted=lr,d.onUpdated=Hn,d.openBlock=we,d.parseClassList=Fs,d.parseClassStyles=Ds,d.popScopeId=Co,d.provide=Dr,d.pushScopeId=_i,d.queuePostFlushCb=mi,d.registerRuntimeCompiler=qa,d.render=ml,d.renderList=xo,d.renderSlot=Q,d.resolveComponent=Ko,d.resolveDirective=Ro,d.resolveDynamicComponent=Ui,d.resolveFilter=dl,d.resolveTransitionHooks=Oe,d.setBlockTracking=$t,d.setDevtoolsHook=Jt,d.setTransitionHooks=ai,d.ssrContextKey=Yi,d.toHandlers=se,d.transformVNodeArgs=ht,d.useAttrs=Be,d.useCssModule=zl,d.useCssStyles=va,d.useCssVars=js,d.useSSRContext=Eo,d.useSlots=Ls,d.useTransitionState=Ei,d.version=ps,d.warn=Lt,d.watch=Kr,d.watchEffect=Un,d.watchPostEffect=qr,d.watchSyncEffect=Io,d.withAsyncContext=Er,d.withCtx=Fi,d.withDefaults=hs,d.withDirectives=ko,d.withKeys=Gs,d.withMemo=ta,d.withModifiers=vl,d.withScopeId=ca,Object.defineProperty(d,"__esModule",{value:!0}),d}({},w,k,p);return S.__TYPE__="nvue",S}var xp=hI(_I);var hc={};lI(hc,{EMPTY_ARR:()=>RI,EMPTY_OBJ:()=>kI,NO:()=>BI,NOOP:()=>xI,camelize:()=>qI,capitalize:()=>iu,def:()=>QI,extend:()=>hi,getGlobalThis:()=>nN,hasChanged:()=>ZI,hasOwn:()=>il,hyphenate:()=>df,invokeArrayFns:()=>XI,isArray:()=>Pi,isBuiltInDirective:()=>GI,isFunction:()=>$n,isGloballyWhitelisted:()=>yI,isHTMLTag:()=>PI,isIntegerKey:()=>zI,isMap:()=>Mp,isModelListener:()=>DI,isObject:()=>Ml,isOn:()=>MI,isPlainObject:()=>Dl,isPromise:()=>HI,isRegExp:()=>$I,isReservedProp:()=>WI,isSVGTag:()=>II,isSet:()=>Dp,isString:()=>gi,isSymbol:()=>UI,looseToNumber:()=>eN,makeMap:()=>Ll,normalizeClass:()=>ff,normalizeProps:()=>AI,normalizeStyle:()=>uf,parseStringStyle:()=>Bp,remove:()=>FI,toDisplayString:()=>NI,toHandlerKey:()=>JI,toNumber:()=>tN,toRawType:()=>jI,toTypeString:()=>Fa});function Ll(g,s){let p=Object.create(null),w=g.split(",");for(let k=0;k<w.length;k++)p[w[k]]=!0;return s?k=>!!p[k.toLowerCase()]:k=>!!p[k]}var EI="Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt",yI=Ll(EI);function uf(g){if(Pi(g)){let s={};for(let p=0;p<g.length;p++){let w=g[p],k=gi(w)?Bp(w):uf(w);if(k)for(let S in k)s[S]=k[S]}return s}else{if(gi(g))return g;if(Ml(g))return g}}var SI=/;(?![^(]*\))/g,wI=/:([^]+)/,CI=/\/\*.*?\*\//gs;function Bp(g){let s={};return g.replace(CI,"").split(SI).forEach(p=>{if(p){let w=p.split(wI);w.length>1&&(s[w[0].trim()]=w[1].trim())}}),s}function ff(g){let s="";if(gi(g))s=g;else if(Pi(g))for(let p=0;p<g.length;p++){let w=ff(g[p]);w&&(s+=w+" ")}else if(Ml(g))for(let p in g)g[p]&&(s+=p+" ");return s.trim()}function AI(g){if(!g)return null;let{class:s,style:p}=g;return s&&!gi(s)&&(g.class=ff(s)),p&&(g.style=uf(p)),g}var OI="html,body,base,head,link,meta,style,title,address,article,aside,footer,header,hgroup,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",TI="svg,animate,animateMotion,animateTransform,circle,clipPath,color-profile,defs,desc,discard,ellipse,feBlend,feColorMatrix,feComponentTransfer,feComposite,feConvolveMatrix,feDiffuseLighting,feDisplacementMap,feDistantLight,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",PI=Ll(OI),II=Ll(TI),NI=g=>gi(g)?g:g==null?"":Pi(g)||Ml(g)&&(g.toString===Fp||!$n(g.toString))?JSON.stringify(g,Lp,2):String(g),Lp=(g,s)=>s&&s.__v_isRef?Lp(g,s.value):Mp(s)?{[`Map(${s.size})`]:[...s.entries()].reduce((p,[w,k])=>(p[`${w} =>`]=k,p),{})}:Dp(s)?{[`Set(${s.size})`]:[...s.values()]}:Ml(s)&&!Pi(s)&&!Dl(s)?String(s):s,kI={},RI=[],xI=()=>{},BI=()=>!1,LI=/^on[^a-z]/,MI=g=>LI.test(g),DI=g=>g.startsWith("onUpdate:"),hi=Object.assign,FI=(g,s)=>{let p=g.indexOf(s);p>-1&&g.splice(p,1)},VI=Object.prototype.hasOwnProperty,il=(g,s)=>VI.call(g,s),Pi=Array.isArray,Mp=g=>Fa(g)==="[object Map]",Dp=g=>Fa(g)==="[object Set]",$I=g=>Fa(g)==="[object RegExp]",$n=g=>typeof g=="function",gi=g=>typeof g=="string",UI=g=>typeof g=="symbol",Ml=g=>g!==null&&typeof g=="object",HI=g=>Ml(g)&&$n(g.then)&&$n(g.catch),Fp=Object.prototype.toString,Fa=g=>Fp.call(g),jI=g=>Fa(g).slice(8,-1),Dl=g=>Fa(g)==="[object Object]",zI=g=>gi(g)&&g!=="NaN"&&g[0]!=="-"&&""+parseInt(g,10)===g,WI=Ll(",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted"),GI=Ll("bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text,memo"),ru=g=>{let s=Object.create(null);return p=>s[p]||(s[p]=g(p))},YI=/-(\w)/g,qI=ru(g=>g.replace(YI,(s,p)=>p?p.toUpperCase():"")),KI=/\B([A-Z])/g,df=ru(g=>g.replace(KI,"-$1").toLowerCase()),iu=ru(g=>g.charAt(0).toUpperCase()+g.slice(1)),JI=ru(g=>g?`on${iu(g)}`:""),ZI=(g,s)=>!Object.is(g,s),XI=(g,s)=>{for(let p=0;p<g.length;p++)g[p](s)},QI=(g,s,p)=>{Object.defineProperty(g,s,{configurable:!0,enumerable:!1,value:p})},eN=g=>{let s=parseFloat(g);return isNaN(s)?g:s},tN=g=>{let s=gi(g)?Number(g):NaN;return isNaN(s)?g:s},Vp,nN=()=>Vp||(Vp=typeof globalThis!="undefined"?globalThis:typeof self!="undefined"?self:typeof window!="undefined"?window:typeof global!="undefined"?global:{});function $p(g){var s=function(p,w){"use strict";function k(x,...Q){console.warn(`[Vue warn] ${x}`,...Q)}let S;class d{constructor(Q=!1){this.detached=Q,this._active=!0,this.effects=[],this.cleanups=[],this.parent=S,!Q&&S&&(this.index=(S.scopes||(S.scopes=[])).push(this)-1)}get active(){return this._active}run(Q){if(this._active){let he=S;try{return S=this,Q()}finally{S=he}}}on(){S=this}off(){S=this.parent}stop(Q){if(this._active){let he,se;for(he=0,se=this.effects.length;he<se;he++)this.effects[he].stop();for(he=0,se=this.cleanups.length;he<se;he++)this.cleanups[he]();if(this.scopes)for(he=0,se=this.scopes.length;he<se;he++)this.scopes[he].stop(!0);if(!this.detached&&this.parent&&!Q){let de=this.parent.scopes.pop();de&&de!==this&&(this.parent.scopes[this.index]=de,de.index=this.index)}this.parent=void 0,this._active=!1}}}function E(x){return new d(x)}function B(x,Q=S){Q&&Q.active&&Q.effects.push(x)}function We(){return S}function Lt(x){S&&S.cleanups.push(x)}let en=x=>{let Q=new Set(x);return Q.w=0,Q.n=0,Q},xt=x=>(x.w&Z)>0,I=x=>(x.n&Z)>0,St=({deps:x})=>{if(x.length)for(let Q=0;Q<x.length;Q++)x[Q].w|=Z},Pn=x=>{let{deps:Q}=x;if(Q.length){let he=0;for(let se=0;se<Q.length;se++){let de=Q[se];xt(de)&&!I(de)?de.delete(x):Q[he++]=de,de.w&=~Z,de.n&=~Z}Q.length=he}},st=new WeakMap,W=0,Z=1,fn=30,sn,_n=Symbol(""),Wn=Symbol("");class pi{constructor(Q,he=null,se){this.fn=Q,this.scheduler=he,this.active=!0,this.deps=[],this.parent=void 0,B(this,se)}run(){if(!this.active)return this.fn();let Q=sn,he=Cn;for(;Q;){if(Q===this)return;Q=Q.parent}try{return this.parent=sn,sn=this,Cn=!0,Z=1<<++W,W<=fn?St(this):vi(this),this.fn()}finally{W<=fn&&Pn(this),Z=1<<--W,sn=this.parent,Cn=he,this.parent=void 0,this.deferStop&&this.stop()}}stop(){sn===this?this.deferStop=!0:this.active&&(vi(this),this.onStop&&this.onStop(),this.active=!1)}}function vi(x){let{deps:Q}=x;if(Q.length){for(let he=0;he<Q.length;he++)Q[he].delete(x);Q.length=0}}function ar(x,Q){x.effect&&(x=x.effect.fn);let he=new pi(x);Q&&(w.extend(he,Q),Q.scope&&B(he,Q.scope)),(!Q||!Q.lazy)&&he.run();let se=he.run.bind(he);return se.effect=he,se}function Sr(x){x.effect.stop()}let Cn=!0,wr=[];function Cr(){wr.push(Cn),Cn=!1}function mi(){wr.push(Cn),Cn=!0}function ri(){let x=wr.pop();Cn=x===void 0?!0:x}function Ve(x,Q,he){if(Cn&&sn){let se=st.get(x);se||st.set(x,se=new Map);let de=se.get(he);de||se.set(he,de=en()),ot(de,void 0)}}function ot(x,Q){let he=!1;W<=fn?I(x)||(x.n|=Z,he=!xt(x)):he=!x.has(sn),he&&(x.add(sn),sn.deps.push(x))}function bt(x,Q,he,se,de,mt){let K=st.get(x);if(!K)return;let z=[];if(Q==="clear")z=[...K.values()];else if(he==="length"&&w.isArray(x)){let xe=Number(se);K.forEach((nt,Yt)=>{(Yt==="length"||Yt>=xe)&&z.push(nt)})}else switch(he!==void 0&&z.push(K.get(he)),Q){case"add":w.isArray(x)?w.isIntegerKey(he)&&z.push(K.get("length")):(z.push(K.get(_n)),w.isMap(x)&&z.push(K.get(Wn)));break;case"delete":w.isArray(x)||(z.push(K.get(_n)),w.isMap(x)&&z.push(K.get(Wn)));break;case"set":w.isMap(x)&&z.push(K.get(_n));break}let ie=void 0;if(z.length===1)z[0]&&tn(z[0]);else{let xe=[];for(let nt of z)nt&&xe.push(...nt);tn(en(xe))}}function tn(x,Q){let he=w.isArray(x)?x:[...x];for(let se of he)se.computed&&Sn(se,Q);for(let se of he)se.computed||Sn(se,Q)}function Sn(x,Q){(x!==sn||x.allowRecurse)&&(x.scheduler?x.scheduler():x.run())}function Jt(x,Q){var he;return(he=st.get(x))===null||he===void 0?void 0:he.get(Q)}let rr=w.makeMap("__proto__,__v_isRef,__isVue"),Ar=new Set(Object.getOwnPropertyNames(Symbol).filter(x=>x!=="arguments"&&x!=="caller").map(x=>Symbol[x]).filter(w.isSymbol)),Or=Fi(),On=Fi(!1,!0),dn=Fi(!0),Tr=Fi(!0,!0),_i=Co();function Co(){let x={};return["includes","indexOf","lastIndexOf"].forEach(Q=>{x[Q]=function(...he){let se=ln(this);for(let mt=0,K=this.length;mt<K;mt++)Ve(se,"get",mt+"");let de=se[Q](...he);return de===-1||de===!1?se[Q](...he.map(ln)):de}}),["push","pop","shift","unshift","splice"].forEach(Q=>{x[Q]=function(...he){Cr();let se=ln(this)[Q].apply(this,he);return ri(),se}}),x}function ca(x){let Q=ln(this);return Ve(Q,"has",x),Q.hasOwnProperty(x)}function Fi(x=!1,Q=!1){return function(se,de,mt){if(de==="__v_isReactive")return!x;if(de==="__v_isReadonly")return x;if(de==="__v_isShallow")return Q;if(de==="__v_raw"&&mt===(x?Q?Mt:kr:Q?Jr:gn).get(se))return se;let K=w.isArray(se);if(!x){if(K&&w.hasOwn(_i,de))return Reflect.get(_i,de,mt);if(de==="hasOwnProperty")return ca}let z=Reflect.get(se,de,mt);return(w.isSymbol(de)?Ar.has(de):rr(de))||(x||Ve(se,"get",de),Q)?z:ir(z)?K&&w.isIntegerKey(de)?z:z.value:w.isObject(z)?x?Vr(z):Ii(z):z}}let Yo=Ji(),Ao=Ji(!0);function Ji(x=!1){return function(he,se,de,mt){let K=he[se];if(Xr(K)&&ir(K)&&!ir(de))return!1;if(!x&&(!Pr(de)&&!Xr(de)&&(K=ln(K),de=ln(de)),!w.isArray(he)&&ir(K)&&!ir(de)))return K.value=de,!0;let z=w.isArray(he)&&w.isIntegerKey(se)?Number(se)<he.length:w.hasOwn(he,se),ie=Reflect.set(he,se,de,mt);return he===ln(mt)&&(z?w.hasChanged(de,K)&&bt(he,"set",se,de,K):bt(he,"add",se,de)),ie}}function Mr(x,Q){let he=w.hasOwn(x,Q),se=x[Q],de=Reflect.deleteProperty(x,Q);return de&&he&&bt(x,"delete",Q,void 0,se),de}function ua(x,Q){let he=Reflect.has(x,Q);return(!w.isSymbol(Q)||!Ar.has(Q))&&Ve(x,"has",Q),he}function Oo(x){return Ve(x,"iterate",w.isArray(x)?"length":_n),Reflect.ownKeys(x)}let To={get:Or,set:Yo,deleteProperty:Mr,has:ua,ownKeys:Oo},Zi={get:dn,set(x,Q){return!0},deleteProperty(x,Q){return!0}},ii=w.extend({},To,{get:On,set:Ao}),qo=w.extend({},Zi,{get:Tr}),uo=x=>x,Nn=x=>Reflect.getPrototypeOf(x);function hr(x,Q,he=!1,se=!1){x=x.__v_raw;let de=ln(x),mt=ln(Q);he||(Q!==mt&&Ve(de,"get",Q),Ve(de,"get",mt));let{has:K}=Nn(de),z=se?uo:he?to:Ur;if(K.call(de,Q))return z(x.get(Q));if(K.call(de,mt))return z(x.get(mt));x!==de&&x.get(Q)}function fo(x,Q=!1){let he=this.__v_raw,se=ln(he),de=ln(x);return Q||(x!==de&&Ve(se,"has",x),Ve(se,"has",de)),x===de?he.has(x):he.has(x)||he.has(de)}function Gn(x,Q=!1){return x=x.__v_raw,!Q&&Ve(ln(x),"iterate",_n),Reflect.get(x,"size",x)}function Xi(x){x=ln(x);let Q=ln(this);return Nn(Q).has.call(Q,x)||(Q.add(x),bt(Q,"add",x,x)),this}function Po(x,Q){Q=ln(Q);let he=ln(this),{has:se,get:de}=Nn(he),mt=se.call(he,x);mt||(x=ln(x),mt=se.call(he,x));let K=de.call(he,x);return he.set(x,Q),mt?w.hasChanged(Q,K)&&bt(he,"set",x,Q,K):bt(he,"add",x,Q),this}function Qi(x){let Q=ln(this),{has:he,get:se}=Nn(Q),de=he.call(Q,x);de||(x=ln(x),de=he.call(Q,x));let mt=se?se.call(Q,x):void 0,K=Q.delete(x);return de&&bt(Q,"delete",x,void 0,mt),K}function bi(){let x=ln(this),Q=x.size!==0,he=void 0,se=x.clear();return Q&&bt(x,"clear",void 0,void 0,he),se}function Jn(x,Q){return function(se,de){let mt=this,K=mt.__v_raw,z=ln(K),ie=Q?uo:x?to:Ur;return!x&&Ve(z,"iterate",_n),K.forEach((xe,nt)=>se.call(de,ie(xe),ie(nt),mt))}}function Dr(x,Q,he){return function(...se){let de=this.__v_raw,mt=ln(de),K=w.isMap(mt),z=x==="entries"||x===Symbol.iterator&&K,ie=x==="keys"&&K,xe=de[x](...se),nt=he?uo:Q?to:Ur;return!Q&&Ve(mt,"iterate",ie?Wn:_n),{next(){let{value:Yt,done:Tn}=xe.next();return Tn?{value:Yt,done:Tn}:{value:z?[nt(Yt[0]),nt(Yt[1])]:nt(Yt),done:Tn}},[Symbol.iterator](){return this}}}}function In(x){return function(...Q){return x==="delete"?!1:this}}function Un(){let x={get(mt){return hr(this,mt)},get size(){return Gn(this)},has:fo,add:Xi,set:Po,delete:Qi,clear:bi,forEach:Jn(!1,!1)},Q={get(mt){return hr(this,mt,!1,!0)},get size(){return Gn(this)},has:fo,add:Xi,set:Po,delete:Qi,clear:bi,forEach:Jn(!1,!0)},he={get(mt){return hr(this,mt,!0)},get size(){return Gn(this,!0)},has(mt){return fo.call(this,mt,!0)},add:In("add"),set:In("set"),delete:In("delete"),clear:In("clear"),forEach:Jn(!0,!1)},se={get(mt){return hr(this,mt,!0,!0)},get size(){return Gn(this,!0)},has(mt){return fo.call(this,mt,!0)},add:In("add"),set:In("set"),delete:In("delete"),clear:In("clear"),forEach:Jn(!0,!0)};return["keys","values","entries",Symbol.iterator].forEach(mt=>{x[mt]=Dr(mt,!1,!1),he[mt]=Dr(mt,!0,!1),Q[mt]=Dr(mt,!1,!0),se[mt]=Dr(mt,!0,!0)}),[x,he,Q,se]}let[qr,Io,oi,Kr]=Un();function sr(x,Q){let he=Q?x?Kr:oi:x?Io:qr;return(se,de,mt)=>de==="__v_isReactive"?!x:de==="__v_isReadonly"?x:de==="__v_raw"?se:Reflect.get(w.hasOwn(he,de)&&de in se?he:se,de,mt)}let Vi={get:sr(!1,!1)},eo={get:sr(!1,!0)},Fr={get:sr(!0,!1)},Ei={get:sr(!0,!0)};function gr(x,Q,he){let se=ln(he);if(se!==he&&Q.call(x,se)){let de=w.toRawType(x);console.warn(`Reactive ${de} contains both the raw and reactive versions of the same object${de==="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 gn=new WeakMap,Jr=new WeakMap,kr=new WeakMap,Mt=new WeakMap;function Oe(x){switch(x){case"Object":case"Array":return 1;case"Map":case"Set":case"WeakMap":case"WeakSet":return 2;default:return 0}}function Zr(x){return x.__v_skip||!Object.isExtensible(x)?0:Oe(w.toRawType(x))}function Ii(x){return Xr(x)?x:pr(x,!1,To,Vi,gn)}function ai(x){return pr(x,!1,ii,eo,Jr)}function Vr(x){return pr(x,!0,Zi,Fr,kr)}function Ni(x){return pr(x,!0,qo,Ei,Mt)}function pr(x,Q,he,se,de){if(!w.isObject(x)||x.__v_raw&&!(Q&&x.__v_isReactive))return x;let mt=de.get(x);if(mt)return mt;let K=Zr(x);if(K===0)return x;let z=new Proxy(x,K===2?se:he);return de.set(x,z),z}function $r(x){return Xr(x)?$r(x.__v_raw):!!(x&&x.__v_isReactive)}function Xr(x){return!!(x&&x.__v_isReadonly)}function Pr(x){return!!(x&&x.__v_isShallow)}function ki(x){return $r(x)||Xr(x)}function ln(x){let Q=x&&x.__v_raw;return Q?ln(Q):x}function $i(x){return w.def(x,"__v_skip",!0),x}let Ur=x=>w.isObject(x)?Ii(x):x,to=x=>w.isObject(x)?Vr(x):x;function bn(x){Cn&&sn&&(x=ln(x),ot(x.dep||(x.dep=en())))}function Hr(x,Q){x=ln(x);let he=x.dep;he&&tn(he)}function ir(x){return!!(x&&x.__v_isRef===!0)}function yi(x){return vr(x,!1)}function Ri(x){return vr(x,!0)}function vr(x,Q){return ir(x)?x:new Qr(x,Q)}class Qr{constructor(Q,he){this.__v_isShallow=he,this.dep=void 0,this.__v_isRef=!0,this._rawValue=he?Q:ln(Q),this._value=he?Q:Ur(Q)}get value(){return bn(this),this._value}set value(Q){let he=this.__v_isShallow||Pr(Q)||Xr(Q);Q=he?Q:ln(Q),w.hasChanged(Q,this._rawValue)&&(this._rawValue=Q,this._value=he?Q:Ur(Q),Hr(this,Q))}}function Zn(x){Hr(x,void 0)}function Xn(x){return ir(x)?x.value:x}let Hn={get:(x,Q,he)=>Xn(Reflect.get(x,Q,he)),set:(x,Q,he,se)=>{let de=x[Q];return ir(de)&&!ir(he)?(de.value=he,!0):Reflect.set(x,Q,he,se)}};function Qn(x){return $r(x)?x:new Proxy(x,Hn)}class lr{constructor(Q){this.dep=void 0,this.__v_isRef=!0;let{get:he,set:se}=Q(()=>bn(this),()=>Hr(this));this._get=he,this._set=se}get value(){return this._get()}set value(Q){this._set(Q)}}function ho(x){return new lr(x)}function go(x){let Q=w.isArray(x)?new Array(x.length):{};for(let he in x)Q[he]=no(x,he);return Q}class No{constructor(Q,he,se){this._object=Q,this._key=he,this._defaultValue=se,this.__v_isRef=!0}get value(){let Q=this._object[this._key];return Q===void 0?this._defaultValue:Q}set value(Q){this._object[this._key]=Q}get dep(){return Jt(ln(this._object),this._key)}}function no(x,Q,he){let se=x[Q];return ir(se)?se:new No(x,Q,he)}var ko;class jr{constructor(Q,he,se,de){this._setter=he,this.dep=void 0,this.__v_isRef=!0,this[ko]=!1,this._dirty=!0,this.effect=new pi(Q,()=>{this._dirty||(this._dirty=!0,Hr(this))}),this.effect.computed=this,this.effect.active=this._cacheable=!de,this.__v_isReadonly=se}get value(){let Q=ln(this);return bn(Q),(Q._dirty||!Q._cacheable)&&(Q._dirty=!1,Q._value=Q.effect.run()),Q._value}set value(Q){this._setter(Q)}}ko="__v_isReadonly";function Rr(x,Q,he=!1){let se,de,mt=w.isFunction(x);return mt?(se=x,de=w.NOOP):(se=x.get,de=x.set),new jr(se,de,mt||!de,he)}var ro;let Ko=Promise.resolve(),xi=[],Ui=!1,Ro=x=>{xi.push(x),Ui||(Ui=!0,Ko.then(Bi))},Bi=()=>{for(let x=0;x<xi.length;x++)xi[x]();xi.length=0,Ui=!1};class Hi{constructor(Q){this.dep=void 0,this._dirty=!0,this.__v_isRef=!0,this[ro]=!0;let he,se=!1,de=!1;this.effect=new pi(Q,mt=>{if(this.dep){if(mt)he=this._value,se=!0;else if(!de){let K=se?he:this._value;de=!0,se=!1,Ro(()=>{this.effect.active&&this._get()!==K&&Hr(this),de=!1})}for(let K of this.dep)K.computed instanceof Hi&&K.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 bn(this),ln(this)._get()}}ro="__v_isReadonly";function xo(x){return new Hi(x)}return p.EffectScope=d,p.ITERATE_KEY=_n,p.ReactiveEffect=pi,p.computed=Rr,p.customRef=ho,p.deferredComputed=xo,p.effect=ar,p.effectScope=E,p.enableTracking=mi,p.getCurrentScope=We,p.isProxy=ki,p.isReactive=$r,p.isReadonly=Xr,p.isRef=ir,p.isShallow=Pr,p.markRaw=$i,p.onScopeDispose=Lt,p.pauseTracking=Cr,p.proxyRefs=Qn,p.reactive=Ii,p.readonly=Vr,p.ref=yi,p.resetTracking=ri,p.shallowReactive=ai,p.shallowReadonly=Ni,p.shallowRef=Ri,p.stop=Sr,p.toRaw=ln,p.toRef=no,p.toRefs=go,p.track=Ve,p.trigger=bt,p.triggerRef=Zn,p.unref=Xn,Object.defineProperty(p,"__esModule",{value:!0}),p}({},g);return s}function Up(g){var s=function(p){"use strict";let w=`
`,k=44,S=50,d=50,E=["%","%"],B="#007aff",We=/^([a-z-]+:)?\/\//i,Lt=/^data:.*,.*/,en="WEB_INVOKE_APPSERVICE",xt="wxs://",I="json://",St="wxsModules",Pn="renderjsModules",st="onShow",W="onHide",Z="onLaunch",fn="onError",sn="onThemeChange",_n="offThemeChange",Wn="onKeyboardHeightChange",pi="onPageNotFound",vi="onUnhandledRejection",ar="onLoad",Sr="onReady",Cn="onUnload",wr="onInit",Cr="onSaveExitState",mi="onResize",ri="onBackPress",Ve="onPageScroll",ot="onTabItemTap",bt="onReachBottom",tn="onPullDownRefresh",Sn="onShareTimeline",Jt="onAddToFavorites",rr="onShareAppMessage",Ar="onNavigationBarButtonTap",Or="onNavigationBarSearchInputClicked",On="onNavigationBarSearchInputChanged",dn="onNavigationBarSearchInputConfirmed",Tr="onNavigationBarSearchInputFocusChanged",_i="onAppEnterForeground",Co="onAppEnterBackground",ca="onWxsInvokeCallMethod";function Fi(K){return!!K.appContext}function Yo(K){return K&&(Fi(K)?K.proxy:K)}function Ao(K){return K.nodeType===1}function Ji(K,z=!1){let{vnode:ie}=K;if(Ao(ie.el))return z?ie.el?[ie.el]:[]:ie.el;let{subTree:xe}=K;if(xe.shapeFlag&16){let nt=xe.children.filter(Yt=>Yt.el&&Ao(Yt.el));if(nt.length>0)return z?nt.map(Yt=>Yt.el):nt[0].el}return z?ie.el?[ie.el]:[]:ie.el}let Mr=0;function ua(K,...z){let ie=Date.now(),xe=Mr?ie-Mr:0;return Mr=ie,`[${ie}][${xe}ms][${K}]\uFF1A${z.map(nt=>JSON.stringify(nt)).join(" ")}`}function Oo(K){let z=Object.create(null);return ie=>z[ie]||(z[ie]=K(ie))}function To(K){return Oo(K)}function Zi(K=""){return(""+K).replace(/[^\x00-\xff]/g,"**").length}function ii(K){return K.indexOf("/")===0}function qo(K){return ii(K)?K:"/"+K}function uo(K){return ii(K)?K.slice(1):K}let Nn=(K,z)=>{let ie;for(let xe=0;xe<K.length;xe++)ie=K[xe](z);return ie};function hr(K,z=null){let ie;return(...xe)=>(K&&(ie=K.apply(z,xe),K=null),ie)}function fo(K,z){K=K||{},p.isString(z)&&(z={errMsg:z}),/:ok$/.test(z.errMsg)?p.isFunction(K.success)&&K.success(z):p.isFunction(K.fail)&&K.fail(z),p.isFunction(K.complete)&&K.complete(z)}function Gn(K){let z={};return p.isPlainObject(K)&&Object.keys(K).sort().forEach(ie=>{let xe=ie;z[xe]=K[xe]}),Object.keys(z)?z:K}let Xi=encodeURIComponent;function Po(K,z=Xi){let ie=K?Object.keys(K).map(xe=>{let nt=K[xe];return typeof nt===void 0||nt===null?nt="":p.isPlainObject(nt)&&(nt=JSON.stringify(nt)),z(xe)+"="+z(nt)}).filter(xe=>xe.length>0).join("&"):null;return ie?`?${ie}`:""}function Qi(K){try{return decodeURIComponent(""+K)}catch(z){}return""+K}let bi=/\+/g;function Jn(K){let z={};if(K===""||K==="?")return z;let xe=(K[0]==="?"?K.slice(1):K).split("&");for(let nt=0;nt<xe.length;++nt){let Yt=xe[nt].replace(bi," "),Tn=Yt.indexOf("="),jn=Qi(Tn<0?Yt:Yt.slice(0,Tn)),xr=Tn<0?null:Qi(Yt.slice(Tn+1));if(jn in z){let mr=z[jn];p.isArray(mr)||(mr=z[jn]=[mr]),mr.push(xr)}else z[jn]=xr}return z}function Dr(K){let[z,ie]=K.split("?",2);return{path:z,query:Jn(ie||"")}}function In(K){let z={};return K&&Object.keys(K).forEach(ie=>{ie.indexOf("data-")===0&&(z[ie.replace("data-","")]=K[ie])}),z}class Un extends Error{constructor(z){super(z);this.name="DOMException"}}function qr(K,z){return z&&(z.capture&&(K+="Capture"),z.once&&(K+="Once"),z.passive&&(K+="Passive")),`on${p.capitalize(p.camelize(K))}`}class Io{constructor(z,ie){this.defaultPrevented=!1,this.timeStamp=Date.now(),this._stop=!1,this._end=!1,this.type=z,this.bubbles=!!ie.bubbles,this.cancelable=!!ie.cancelable}preventDefault(){this.defaultPrevented=!0}stopImmediatePropagation(){this._end=this._stop=!0}stopPropagation(){this._stop=!0}}function oi(K){if(K instanceof Io)return K;let[z]=Vi(K.type),ie=new Io(z,{bubbles:!1,cancelable:!1});return p.extend(ie,K),ie}class Kr{constructor(){this.listeners=Object.create(null)}dispatchEvent(z){let ie=this.listeners[z.type];if(!ie)return!1;let xe=oi(z),nt=ie.length;for(let Yt=0;Yt<nt&&(ie[Yt].call(this,xe),!xe._end);Yt++);return xe.cancelable&&xe.defaultPrevented}addEventListener(z,ie,xe){z=qr(z,xe),(this.listeners[z]||(this.listeners[z]=[])).push(ie)}removeEventListener(z,ie,xe){z=qr(z,xe);let nt=this.listeners[z];if(!nt)return;let Yt=nt.indexOf(ie);Yt>-1&&nt.splice(Yt,1)}}let sr=/(?:Once|Passive|Capture)$/;function Vi(K){let z;if(sr.test(K)){z={};let ie;for(;ie=K.match(sr);)K=K.slice(0,K.length-ie[0].length),z[ie[0].toLowerCase()]=!0}return[p.hyphenate(K.slice(2)),z]}let eo=(()=>({stop:1,prevent:1<<1,self:1<<2}))();function Fr(K){let z=0;return K.includes("stop")&&(z|=eo.stop),K.includes("prevent")&&(z|=eo.prevent),K.includes("self")&&(z|=eo.self),z}let Ei=0,gr=1,gn=3,Jr=8;function kr(K,z){let{parentNode:ie}=K;if(!ie)return null;let{childNodes:xe}=ie;return xe[xe.indexOf(K)+(z==="n"?1:-1)]||null}function Mt(K){let{parentNode:z}=K;if(z){let{childNodes:ie}=z,xe=ie.indexOf(K);xe>-1&&(K.parentNode=null,ie.splice(xe,1))}}function Oe(K){!K.nodeId&&K.pageNode&&(K.nodeId=K.pageNode.genId())}class Zr extends Kr{constructor(z,ie,xe){super();if(this.pageNode=null,this.parentNode=null,this._text=null,xe){let{pageNode:nt}=xe;nt&&(this.pageNode=nt,this.nodeId=nt.genId(),!nt.isUnmounted&&nt.onCreate(this,ie))}this.nodeType=z,this.nodeName=ie,this.childNodes=[]}get firstChild(){return this.childNodes[0]||null}get lastChild(){let{childNodes:z}=this,ie=z.length;return ie?z[ie-1]:null}get nextSibling(){return kr(this,"n")}get nodeValue(){return null}set nodeValue(z){}get textContent(){return this._text||""}set textContent(z){this._text=z,this.pageNode&&!this.pageNode.isUnmounted&&this.pageNode.onTextContent(this,z)}get parentElement(){let{parentNode:z}=this;return z&&z.nodeType===gr?z:null}get previousSibling(){return kr(this,"p")}appendChild(z){return this.insertBefore(z,null)}cloneNode(z){let ie=p.extend(Object.create(Object.getPrototypeOf(this)),this),{attributes:xe}=ie;return xe&&(ie.attributes=p.extend({},xe)),z&&(ie.childNodes=ie.childNodes.map(nt=>nt.cloneNode(!0))),ie}insertBefore(z,ie){Mt(z),z.pageNode=this.pageNode,z.parentNode=this,Oe(z);let{childNodes:xe}=this;if(ie){let nt=xe.indexOf(ie);if(nt===-1)throw new Un("Failed to execute 'insertBefore' on 'Node': The node before which the new node is to be inserted is not a child of this node.");xe.splice(nt,0,z)}else xe.push(z);return this.pageNode&&!this.pageNode.isUnmounted?this.pageNode.onInsertBefore(this,z,ie):z}removeChild(z){let{childNodes:ie}=this,xe=ie.indexOf(z);if(xe===-1)throw new Un("Failed to execute 'removeChild' on 'Node': The node to be removed is not a child of this node.");return z.parentNode=null,ie.splice(xe,1),this.pageNode&&!this.pageNode.isUnmounted?this.pageNode.onRemoveChild(z):z}}let Ii="class",ai="style",Vr=".vOwnerId",Ni=".vRenderjs";class pr extends Zr{constructor(z,ie,xe){super(z,ie,xe);this.attributes=Object.create(null),this.style=null,this.vShow=null,this._html=null}get className(){return this.attributes[Ii]||""}set className(z){this.setAttribute(Ii,z)}get innerHTML(){return""}set innerHTML(z){this._html=z}addEventListener(z,ie,xe){super.addEventListener(z,ie,xe),this.pageNode&&!this.pageNode.isUnmounted&&(ie.wxsEvent?this.pageNode.onAddWxsEvent(this,qr(z,xe),ie.wxsEvent,Fr(ie.modifiers||[])):this.pageNode.onAddEvent(this,qr(z,xe),Fr(ie.modifiers||[])))}removeEventListener(z,ie,xe){super.removeEventListener(z,ie,xe),this.pageNode&&!this.pageNode.isUnmounted&&this.pageNode.onRemoveEvent(this,qr(z,xe))}getAttribute(z){return z===ai?this.style:this.attributes[z]}removeAttribute(z){z==ai?this.style=null:delete this.attributes[z],this.pageNode&&!this.pageNode.isUnmounted&&this.pageNode.onRemoveAttribute(this,z)}setAttribute(z,ie){z===ai?this.style=ie:this.attributes[z]=ie,this.pageNode&&!this.pageNode.isUnmounted&&this.pageNode.onSetAttribute(this,z,ie)}toJSON({attr:z,normalize:ie}={}){let{attributes:xe,style:nt,listeners:Yt,_text:Tn}=this,jn={};Object.keys(xe).length&&(jn.a=ie?ie(xe):xe);let xr=Object.keys(Yt);if(xr.length){let mr,po={};xr.forEach(vo=>{let Jo=Yt[vo];if(Jo.length){let{wxsEvent:mo,modifiers:Yn}=Jo[0],Bn=Fr(Yn||[]);mo?(mr||(mr={}),mr[vo]=[ie?ie(mo):mo,Bn]):po[vo]=Bn}}),jn.e=ie?ie(po,!1):po,mr&&(jn.w=ie?ie(mr,!1):mr)}return nt!==null&&(jn.s=ie?ie(nt):nt),z||(jn.i=this.nodeId,jn.n=this.nodeName),Tn!==null&&(jn.t=ie?ie(Tn):Tn),jn}}class $r extends Zr{constructor(z,ie){super(Jr,"#comment",ie);this._text=""}toJSON(z={}){return z.attr?{}:{i:this.nodeId}}}class Xr extends pr{constructor(z,ie){super(gr,z.toUpperCase(),ie);this.tagName=this.nodeName}}class Pr extends Xr{get value(){return this.getAttribute("value")}set value(z){this.setAttribute("value",z)}}class ki extends Pr{}class ln extends pr{constructor(z,ie){super(gn,"#text",ie);this._text=z}get nodeValue(){return this._text||""}set nodeValue(z){this._text=z,this.pageNode&&!this.pageNode.isUnmounted&&this.pageNode.onNodeValue(this,z)}}let $i={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"]},Ur=["animation"],to=(K,z)=>{if(Ur.indexOf(z)>-1)return!0;let ie=$i[K.nodeName];return!!(ie&&ie.indexOf(z)>-1)},bn=1,Hr=2,ir=3,yi=4,Ri=5,vr=6,Qr=7,Zn=8,Xn=9,Hn=10,Qn=12,lr=15,ho=20;function go(K,z,{clearTimeout:ie,setTimeout:xe}){let nt,Yt=function(){ie(nt),nt=xe(()=>K.apply(this,arguments),z)};return Yt.cancel=function(){ie(nt)},Yt}class No{constructor(z,ie){this.id=z,this.listener={},this.emitCache=[],ie&&Object.keys(ie).forEach(xe=>{this.on(xe,ie[xe])})}emit(z,...ie){let xe=this.listener[z];if(!xe)return this.emitCache.push({eventName:z,args:ie});xe.forEach(nt=>{nt.fn.apply(nt.fn,ie)}),this.listener[z]=xe.filter(nt=>nt.type!=="once")}on(z,ie){this._addListener(z,"on",ie),this._clearCache(z)}once(z,ie){this._addListener(z,"once",ie),this._clearCache(z)}off(z,ie){let xe=this.listener[z];if(!!xe)if(ie)for(let nt=0;nt<xe.length;)xe[nt].fn===ie&&(xe.splice(nt,1),nt--),nt++;else delete this.listener[z]}_clearCache(z){for(let ie=0;ie<this.emitCache.length;ie++){let xe=this.emitCache[ie],nt=z?xe.eventName===z?z:null:xe.eventName;if(!nt)continue;if(typeof this.emit.apply(this,[nt,...xe.args])=="number"){this.emitCache.pop();continue}this.emitCache.splice(ie,1),ie--}}_addListener(z,ie,xe){(this.listener[z]||(this.listener[z]=[])).push({fn:xe,type:ie})}}let no=[wr,ar,st,W,Cn,ri,Ve,ot,bt,tn,Sn,rr,Jt,Cr,Ar,Or,On,dn,Tr],ko=[ar,st];function jr(K){return ko.indexOf(K)>-1}function Rr(K){return no.indexOf(K)>-1}let ro=[st,W,Z,fn,sn,pi,vi,wr,ar,Sr,Cn,mi,ri,Ve,ot,bt,tn,Sn,Jt,rr,Cr,Ar,Or,On,dn,Tr];function Ko(K,z,ie=!0){return ie&&!p.isFunction(z)?!1:ro.indexOf(K)>-1?!0:K.indexOf("on")===0}let xi,Ui=[];function Ro(K){if(xi)return K(xi);Ui.push(K)}function Bi(K){xi=K,Ui.forEach(z=>z(K))}let Hi=hr((K,z)=>{if(p.isFunction(K._component.onError))return z(K)}),xo=function(){};xo.prototype={on:function(K,z,ie){var xe=this.e||(this.e={});return(xe[K]||(xe[K]=[])).push({fn:z,ctx:ie}),this},once:function(K,z,ie){var xe=this;function nt(){xe.off(K,nt),z.apply(ie,arguments)}return nt._=z,this.on(K,nt,ie)},emit:function(K){var z=[].slice.call(arguments,1),ie=((this.e||(this.e={}))[K]||[]).slice(),xe=0,nt=ie.length;for(xe;xe<nt;xe++)ie[xe].fn.apply(ie[xe].ctx,z);return this},off:function(K,z){var ie=this.e||(this.e={}),xe=ie[K],nt=[];if(xe&&z)for(var Yt=0,Tn=xe.length;Yt<Tn;Yt++)xe[Yt].fn!==z&&xe[Yt].fn._!==z&&nt.push(xe[Yt]);return nt.length?ie[K]=nt:delete ie[K],this}};var x=xo;let Q={black:"rgba(0,0,0,0.4)",white:"rgba(255,255,255,0.4)"};function he(K){return K&&K in Q?Q[K]:K}function se(K){return K==="black"?"#000000":"#ffffff"}function de(K,z={},ie="light"){let xe=z[ie],nt={};return xe?(Object.keys(K).forEach(Yt=>{let Tn=K[Yt];nt[Yt]=(()=>{if(p.isPlainObject(Tn))return de(Tn,z,ie);if(p.isArray(Tn))return Tn.map(jn=>p.isPlainObject(jn)?de(jn,z,ie):jn);if(p.isString(Tn)&&Tn.startsWith("@")){let jn=Tn.replace("@",""),xr=xe[jn]||Tn;switch(Yt){case"titleColor":xr=se(xr);break;case"borderStyle":xr=he(xr);break}return xr}return Tn})()}),nt):K}var mt={invokeArrayFns:Nn,isUniLifecycleHook:Ko,ON_LOAD:ar,ON_SHOW:st,LINEFEED:w,RENDERJS_MODULES:Pn,formatLog:ua,WXS_PROTOCOL:xt,WXS_MODULES:St,UniLifecycleHooks:ro,ON_ERROR:fn,invokeCreateErrorHandler:Hi,invokeCreateVueAppHook:Bi,parseNVueDataset:In,once:hr,I18N_JSON_DELIMITERS:E,Emitter:x,normalizeStyles:de,addLeadingSlash:qo,resolveComponentInstance:Yo,removeLeadingSlash:uo,ON_RESIZE:mi,ON_APP_ENTER_FOREGROUND:_i,ON_APP_ENTER_BACKGROUND:Co,ON_HIDE:W,ON_PAGE_SCROLL:Ve,ON_REACH_BOTTOM:bt,SCHEME_RE:We,DATA_RE:Lt,cacheStringFunction:To,parseQuery:Jn,callOptions:fo,ON_UNHANDLE_REJECTION:vi,ON_PAGE_NOT_FOUND:pi,PRIMARY_COLOR:B,getLen:Zi,ON_THEME_CHANGE:sn,TABBAR_HEIGHT:S,NAVBAR_HEIGHT:k,sortObject:Gn,OFF_THEME_CHANGE:_n,ON_KEYBOARD_HEIGHT_CHANGE:Wn,normalizeTabBarStyles:he,ON_NAVIGATION_BAR_BUTTON_TAP:Ar,stringifyQuery:Po,debounce:go,ON_PULL_DOWN_REFRESH:tn,ON_NAVIGATION_BAR_SEARCH_INPUT_CHANGED:On,ON_NAVIGATION_BAR_SEARCH_INPUT_CONFIRMED:dn,ON_NAVIGATION_BAR_SEARCH_INPUT_CLICKED:Or,ON_NAVIGATION_BAR_SEARCH_INPUT_FOCUS_CHANGED:Tr,ON_BACK_PRESS:ri,UniNode:Zr,NODE_TYPE_PAGE:Ei,ACTION_TYPE_PAGE_CREATE:bn,ACTION_TYPE_PAGE_CREATED:Hr,ACTION_TYPE_PAGE_SCROLL:lr,ACTION_TYPE_INSERT:yi,ACTION_TYPE_CREATE:ir,ACTION_TYPE_REMOVE:Ri,ACTION_TYPE_ADD_EVENT:Zn,ACTION_TYPE_ADD_WXS_EVENT:Qn,ACTION_TYPE_REMOVE_EVENT:Xn,ACTION_TYPE_SET_ATTRIBUTE:vr,ACTION_TYPE_REMOVE_ATTRIBUTE:Qr,ACTION_TYPE_SET_TEXT:Hn,ON_READY:Sr,ON_UNLOAD:Cn,EventChannel:No,ON_REACH_BOTTOM_DISTANCE:d,parseUrl:Dr,onCreateVueApp:Ro,ON_TAB_ITEM_TAP:ot,ON_LAUNCH:Z,ACTION_TYPE_EVENT:ho,createUniEvent:oi,ON_WXS_INVOKE_CALL_METHOD:ca,WEB_INVOKE_APPSERVICE:en,isRootHook:Rr,isRootImmediateHook:jr,UniInputElement:Pr,UniTextAreaElement:ki,UniElement:Xr,UniTextNode:ln,UniCommentNode:$r,forcePatchProp:to,JSON_PROTOCOL:I,resolveOwnerEl:Ji,ATTR_V_OWNER_ID:Vr,ATTR_V_RENDERJS:Ni};return mt}(g);return s}var rN=1;function Hp(){return(rN++).toString()}var hf=g=>g&&JSON.parse(JSON.stringify(g))||g;function gc(g){let s=Fa(g);return s.substring(8,s.length-1)}function gf(g){if(!$n(btoa))return"";let s=Array.prototype.map.call(new Uint8Array(g),p=>String.fromCharCode(p)).join("");return btoa(s)}function pc(g){if(!g||typeof g!="object")return!0;for(let s in g)if(il(g,s))return!1;return!0}var ou=["off","error","warn","info","log","debug"],au={};function jp(){ou.forEach(g=>{let s=ou.indexOf(g);au[g]={},ou.forEach(p=>{ou.indexOf(p)<=s&&(au[g][p]=!0)})})}function Kn(g){let s=global.WXEnvironment&&global.WXEnvironment.logLevel||"log";return au[s]&&au[s][g]}function Di(g){global.nativeLog("wxInteractionAnalyzer: [jsfm]"+g,"__DEBUG")}function zp(g,s,p){return`${s}@${p}#${g}`}var su=class{constructor(s){this.instanceId=String(s),this.lastCallbackId=0,this.callbacks={},this.hooks={}}add(s){return this.lastCallbackId++,this.callbacks[this.lastCallbackId]=s,this.lastCallbackId}remove(s){let p=this.callbacks[s];return delete this.callbacks[s],p}registerHook(s,p,w,k){let S=zp(s,p,w);this.hooks[S]&&console.warn(`[JS Framework] Override an existing component hook "${S}".`),this.hooks[S]=k}triggerHook(s,p,w,k){let S=zp(s,p,w),d=this.hooks[S];if(!$n(d))return console.error(`[JS Framework] Invalid hook function type (${typeof d}) on "${S}".`),null;let E=null;try{E=d.apply(null,k||[])}catch(B){throw console.error(`[JS Framework] Failed to execute the hook function on "${S}".`),B}return E}consume(s,p,w){let k=this.callbacks[s];if((typeof w=="undefined"||w===!1)&&delete this.callbacks[s],$n(k))try{return k.call(null,p,w)}catch(S){throw console.error(`[JS Framework] Failed to execute the callback function:
 ${S.toString()}`),S}return new Error(`invalid callback id "${s}"`)}close(){this.callbacks={},this.hooks={}}};var lu={};function Wp(g,s){g&&(lu[g]=s)}function rs(g){return lu[g]}function Gp(g){delete lu[g]}function Lr(g){if(g){let s=lu[g];if(s&&s.taskCenter)return s.taskCenter}return null}function iN(g){g.calcClassList&&g.calcClassList()}function pf(g,s,p){let{documentElement:w}=g;if(w.pureChildren.length>0||s.parentNode)return;let k=w.children,S=p?k.indexOf(p):-1;S<0?k.push(s):k.splice(S,0,s),s.nodeType===1?(s.role==="body"?(s.docId=g.id,s.ownerDocument=g,s.parentNode=w,ol(s,w)):(s.children.forEach(d=>{d.parentNode=s}),vf(g,s),ol(s,w),delete g.nodeMap[s.nodeId]),w.pureChildren.push(s),oN(g,s)):(s.parentNode=w,g.nodeMap[s.ref]=s)}function oN(g,s){let p=s.toJSON();g&&g.taskCenter&&$n(g.taskCenter.send)&&g.taskCenter.send("dom",{action:"createBody"},[p])}function vf(g,s){s.role="body",s.depth=1,delete g.nodeMap[s.nodeId],s.ref="_root",g.nodeMap._root=s,g.body=s}function ol(g,s){g.parentNode=s,iN(g),s.docId&&(g.docId=s.docId,g.ownerDocument=s.ownerDocument,g.ownerDocument.nodeMap[g.nodeId]=g,g.depth=s.depth+1),g.children.forEach(p=>{ol(p,g)})}function mf(g){for(;g;){if(g.nodeType===1)return g;g=g.nextSibling}}function _f(g){for(;g;){if(g.nodeType===1)return g;g=g.previousSibling}}function al(g,s,p,w=!1){p<0&&(p=0);let k=s[p-1],S=s[p];return s.splice(p,0,g),w&&(k&&(k.nextSibling=g),g.previousSibling=k,g.nextSibling=S,S&&(S.previousSibling=g)),p}function sl(g,s,p,w=!1){let k=s.indexOf(g);if(k<0)return-1;if(w){let B=s[k-1],We=s[k+1];B&&(B.nextSibling=We),We&&(We.previousSibling=B)}s.splice(k,1);let S=p;k<=p&&(S=p-1);let d=s[S-1],E=s[S];return s.splice(S,0,g),w&&(d&&(d.nextSibling=g),g.previousSibling=d,g.nextSibling=E,E&&(E.previousSibling=g)),k===S?-1:p}function bf(g,s,p=!1){let w=s.indexOf(g);if(!(w<0)){if(p){let k=s[w-1],S=s[w+1];k&&(k.nextSibling=S),S&&(S.previousSibling=k)}s.splice(w,1)}}var ll=class{constructor(){this.depth=0;this.nodeId=Hp(),this.ref=this.nodeId,this.children=[],this.pureChildren=[],this.parentNode=null,this.nextSibling=null,this.previousSibling=null}destroy(){let s=rs(this.docId);s&&(delete this.docId,delete s.nodeMap[this.nodeId]),this.children.forEach(p=>{p.destroy()})}};var Yp={};function Ef(g,s){if(!Pi(s)||!s.length)return;class p extends Ki{}s.forEach(w=>{p.prototype[w]=function(...k){let S=Lr(this.docId);if(S)return S.send("component",{ref:this.ref,component:g,method:w},k)}}),Yp[g]=p}function qp(g){return Yp[g]}function Nr(g,s,p,w,k){let S={type:"decl",prop:g,value:s.toString(),raws:w,source:k};return p&&(S.important=!0),S}var aN="backgroundColor",sN="backgroundImage",lN=g=>{let{value:s,important:p,raws:w,source:k}=g;return/^#?\S+$/.test(s)||/^rgba?(.+)$/.test(s)?[Nr(aN,s,p,w,k)]:/^linear-gradient(.+)$/.test(s)?[Nr(sN,s,p,w,k)]:[g]},cN="Width",uN="Style",fN="Color",vc=g=>{let{prop:s,value:p,important:w,raws:k,source:S}=g,d=p.replace(/\s*,\s*/g,",").split(/\s+/),E=[/^[\d\.]+\S*$/,/^(solid|dashed|dotted)$/,/\S+/].map(B=>{let We=d.findIndex(Lt=>B.test(Lt));return We<0?null:d.splice(We,1)[0]});return d.length?[g]:[Nr(s+cN,(E[0]||"0").trim(),w,k,S),Nr(s+uN,(E[1]||"solid").trim(),w,k,S),Nr(s+fN,(E[2]||"#000000").trim(),w,k,S)]},dN="borderTop",hN="borderRight",gN="borderBottom",pN="borderLeft",yf=g=>{let{prop:s,value:p,important:w,raws:k,source:S}=g,d=df(s).split("-")[1];d=iu(d);let E=p.replace(/\s*,\s*/g,",").split(/\s+/);switch(E.length){case 1:return[g];case 2:E.push(E[0],E[1]);break;case 3:E.push(E[1]);break}return[Nr(dN+d,E[0],w,k,S),Nr(hN+d,E[1],w,k,S),Nr(gN+d,E[2],w,k,S),Nr(pN+d,E[3],w,k,S)]},vN="borderTopLeftRadius",mN="borderTopRightRadius",_N="borderBottomRightRadius",bN="borderBottomLeftRadius",EN=g=>{let{value:s,important:p,raws:w,source:k}=g,S=s.split(/\s+/);if(s.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[Nr(vN,S[0],p,w,k),Nr(mN,S[1],p,w,k),Nr(_N,S[2],p,w,k),Nr(bN,S[3],p,w,k)]},yN=yf,SN=yf,wN="flexDirection",CN="flexWrap",AN=g=>{let{value:s,important:p,raws:w,source:k}=g,S=s.split(/\s+/),d=[/^(column|column-reverse|row|row-reverse)$/,/^(nowrap|wrap|wrap-reverse)$/].map(E=>{let B=S.findIndex(We=>E.test(We));return B<0?null:S.splice(B,1)[0]});return S.length?[g]:[Nr(wN,d[0]||"column",p,w,k),Nr(CN,d[1]||"nowrap",p,w,k)]},ON="Top",TN="Right",PN="Bottom",IN="Left",Kp=g=>s=>{let{value:p,important:w,raws:k,source:S}=s,d=p.split(/\s+/);switch(d.length){case 1:d.push(d[0],d[0],d[0]);break;case 2:d.push(d[0],d[1]);break;case 3:d.push(d[1]);break}return[Nr(g+ON,d[0],w,k,S),Nr(g+TN,d[1],w,k,S),Nr(g+PN,d[2],w,k,S),Nr(g+IN,d[3],w,k,S)]},NN=Kp("margin"),kN=Kp("padding"),RN="transitionProperty",xN="transitionDuration",BN="transitionTimingFunction",LN="transitionDelay",MN=g=>{let s=/^(\S*)?\s*(\d*\.?\d+(?:ms|s)?)?\s*(\S*)?\s*(\d*\.?\d+(?:ms|s)?)?$/,{value:p,important:w,raws:k,source:S}=g,d=[],E=p.match(s);return E&&(E[1]&&d.push(Nr(RN,E[1],w,k,S)),E[2]&&d.push(Nr(xN,E[2],w,k,S)),E[3]&&d.push(Nr(BN,E[3],w,k,S)),E[4]&&d.push(Nr(LN,E[4],w,k,S))),d},Jp={transition:MN,margin:NN,padding:kN,border:vc,background:lN};hi(Jp,{borderTop:vc,borderRight:vc,borderBottom:vc,borderLeft:vc,borderStyle:yN,borderWidth:SN,borderColor:yf,borderRadius:EN,flexFlow:AN});var Zp=Symbol("expanded"),Xp={postcssPlugin:"nvue:expand",Declaration(g){if(g[Zp])return;let s=Jp[g.prop];if(s){let p=s(g);p.length===1&&p[0]===g||g.replaceWith(p)}g[Zp]=!0}};var DN=Xp.Declaration;function Sf(g,s){let p=hi({replaceWith(k){w=k}},FN(g,s)),w=[p];return DN(p),w}function FN(g,s){let p=s+"";return p.includes("!important")?{prop:g,value:p.replace(/\s*!important/,""),important:!0}:{prop:g,value:p,important:!1}}var VN="view",$N=["click","longpress","touchstart","touchmove","touchend","panstart","panmove","panend","horizontalpan","verticalpan","swipe"];function wf(g,s){let p=rs(g);p.nodeMap[s.nodeId]=s}var Cf;function Qp(g){Cf||(Cf=g)}var Ki=class extends ll{constructor(s=VN,p={},w){super();let k=qp(s);if(k&&!w)return new k(s,p,!0);this.nodeType=1,this.type=s,this.attr=p.attr||{},this.style=p.style||{},this.classStyle=p.classStyle||{},this.classList=p.classList||[],this.styleSheet=p.styleSheet||{},this.event={}}appendChild(s){if(!(s.parentNode&&s.parentNode!==this)){if(s.parentNode){if(Kn("debug")&&Di(`[appendChild](${this.docId},${s.type},${s.ref}) Move <${s.type}> to ${this.children.length} of <${this.type}> (${this.ref}).`),sl(s,this.children,this.children.length,!0),s.nodeType===1){let p=sl(s,this.pureChildren,this.pureChildren.length),w=Lr(this.docId);if(w&&p>=0)return w.send("dom",{action:"moveElement"},[s.ref,this.ref,p])}}else if(Kn("debug")&&Di(`[appendChild](${this.docId},${s.type},${s.ref}) Append <${s.type}> to <${this.type}> (${this.ref}).`),ol(s,this),al(s,this.children,this.children.length,!0),this.docId&&wf(this.docId,s),s.nodeType===1){al(s,this.pureChildren,this.pureChildren.length);let p=Lr(this.docId);if(p)return p.send("dom",{action:"addElement"},[this.ref,s.toJSON(),-1])}}}insertBefore(s,p){if(!(s.parentNode&&s.parentNode!==this)&&!(s===p||s.nextSibling&&s.nextSibling===p)){if(s.parentNode){if(sl(s,this.children,this.children.indexOf(p),!0),s.nodeType===1){let w=mf(p),k=sl(s,this.pureChildren,w?this.pureChildren.indexOf(w):this.pureChildren.length),S=Lr(this.docId);if(S&&k>=0)return S.send("dom",{action:"moveElement"},[s.ref,this.ref,k])}}else if(Kn("debug")&&Di(`[insertBefore](${this.docId},${s.type},${s.ref}) Insert <${s.type}> to <${this.type}> (${this.ref}), before (${p.ref}).`),ol(s,this),al(s,this.children,this.children.indexOf(p),!0),this.docId&&wf(this.docId,s),s.nodeType===1){let w=mf(p),k=al(s,this.pureChildren,w?this.pureChildren.indexOf(w):this.pureChildren.length),S=Lr(this.docId);if(S)return S.send("dom",{action:"addElement"},[this.ref,s.toJSON(),k])}}}insertAfter(s,p){if(!(s.parentNode&&s.parentNode!==this)&&!(s===p||s.previousSibling&&s.previousSibling===p)){if(s.parentNode){if(sl(s,this.children,this.children.indexOf(p)+1,!0),s.nodeType===1){let w=sl(s,this.pureChildren,this.pureChildren.indexOf(_f(p))+1),k=Lr(this.docId);if(k&&w>=0)return k.send("dom",{action:"moveElement"},[s.ref,this.ref,w])}}else if(Kn("debug")&&Di(`[insertAfter](${this.docId},${s.type},${s.ref}) Insert <${s.type}> to <${this.type}> (${this.ref}), after (${p.ref}).`),ol(s,this),al(s,this.children,this.children.indexOf(p)+1,!0),this.docId&&wf(this.docId,s),s.nodeType===1){let w=al(s,this.pureChildren,this.pureChildren.indexOf(_f(p))+1),k=Lr(this.docId);if(k)return k.send("dom",{action:"addElement"},[this.ref,s.toJSON(),w])}}}removeChild(s,p){if(s.parentNode&&(bf(s,this.children,!0),s.nodeType===1)){Kn("debug")&&Di(`[removeChild](${this.docId},${s.type},${s.ref}) Remove <${s.type}> from <${this.type}> (${this.ref}).`),bf(s,this.pureChildren);let w=Lr(this.docId);w&&w.send("dom",{action:"removeElement"},[s.ref])}p||s.destroy()}clear(){let s=Lr(this.docId);s&&this.pureChildren.forEach(p=>{s.send("dom",{action:"removeElement"},[p.ref])}),this.children.forEach(p=>{p.destroy()}),this.children.length=0,this.pureChildren.length=0}setAttr(s,p,w){if(this.attr[s]===p&&w!==!1)return;this.attr[s]=p;let k=Lr(this.docId);!w&&k&&k.send("dom",{action:"updateAttrs"},[this.ref,{[s]:p}])}setAttrs(s,p){if(pc(s))return;let w={};for(let k in s)this.attr[k]!==s[k]&&(this.attr[k]=s[k],w[k]=s[k]);if(!pc(w)){let k=Lr(this.docId);!p&&k&&k.send("dom",{action:"updateAttrs"},[this.ref,w])}}setStyle(s,p,w){Sf(s,p).forEach(({prop:k,value:S})=>{if(this.style[k]===S&&w!==!1)return;this.style[k]=S;let d=Lr(this.docId);!w&&d&&d.send("dom",{action:"updateStyle"},[this.ref,{[k]:S===""&&k in this.classStyle?this.classStyle[k]:S}])})}setStyles(s,p){if(pc(s))return;let w={};for(let k in s)Sf(k,s[k]).forEach(({prop:S,value:d})=>{this.style[S]!==d&&(this.style[S]=d,w[S]=d===""&&S in this.classStyle?this.classStyle[S]:d)});if(!pc(w)){let k=Lr(this.docId);!p&&k&&k.send("dom",{action:"updateStyle"},[this.ref,w])}}setClassStyle(s){for(let w in this.classStyle)this.classStyle[w]="";hi(this.classStyle,s);let p=Lr(this.docId);p&&p.send("dom",{action:"updateStyle"},[this.ref,this.toStyle()])}setClassList(s){s.length===this.classList.length&&s.filter(p=>!this.classList.includes(p)).length===0||(this.classList=s,this.parentNode&&this.calcClassList())}calcClassList(){this.setClassStyle(Cf(this))}setStyleSheet(s){this.styleSheet=s}addEvent(s,p,w){if(this.event||(this.event={}),!this.event[s]){Kn("debug")&&Di(`[addEvent](${this.docId},${this.type},${this.ref}) Add "${s}" event on <${this.type}> (${this.ref}).`),this.event[s]={handler:p,params:w};let k=Lr(this.docId);k&&k.send("dom",{action:"addEvent"},[this.ref,s])}}removeEvent(s){if(this.event&&this.event[s]){Kn("debug")&&Di(`[removeEvent](${this.docId},${this.type},${this.ref}) Remove "${s}" event on <${this.type}> (${this.ref}).`),delete this.event[s];let p=Lr(this.docId);p&&p.send("dom",{action:"removeEvent"},[this.ref,s])}}fireEvent(s,p,w,k){let S=null,d=!1,E=this.event[s];if(E&&p){Kn("debug")&&Di(`[fireEvent](${this.docId},${this.type},${this.ref}) Fire "${s}" event on <${this.type}> (${this.ref}).`);let B=E.handler;p.stopPropagation=()=>{d=!0},p.preventDefault=()=>{};try{k&&k.params?S=B.call(this,...k.params,p):S=B.call(this,p)}catch(We){throw console.error(`[JS Framework] Failed to invoke the event handler of "${s}" on ${this.type} (${this.ref}):
 ${We.toString()}`),We}}return!d&&w&&$N.indexOf(s)!==-1&&this.parentNode&&this.parentNode.fireEvent&&(p.currentTarget=this.parentNode,this.parentNode.fireEvent(s,p,w)),S}toStyle(){let s=Object.assign({},this.classStyle),p=this.style;for(let w in p){let k=p[w];s[w]=k===""&&w in this.classStyle?this.classStyle[w]:k}return s}toJSON(s=!1){let p={ref:this.ref.toString(),type:this.type,attr:this.attr,style:this.toStyle()},w=[];for(let k in this.event){let{params:S}=this.event[k];S?w.push({type:k,params:S}):w.push(k)}return w.length&&(p.event=w),!s&&this.pureChildren.length&&(p.children=this.pureChildren.map(k=>k.toJSON())),p}toString(){return"<"+this.type+" attr="+JSON.stringify(this.attr)+" style="+JSON.stringify(this.toStyle())+">"+this.pureChildren.map(s=>s.toString()).join("")+"</"+this.type+">"}};function ev(g){let s=g&&g.__v_raw;return s?ev(s):g}function tv(g){let s=gc(g);switch(s){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 ev(g);case"ArrayBuffer":return{"@type":"binary",dataType:s,base64:gf(g)};case"Int8Array":case"Uint8Array":case"Uint8ClampedArray":case"Int16Array":case"Uint16Array":case"Int32Array":case"Uint32Array":case"Float32Array":case"Float64Array":return{"@type":"binary",dataType:s,base64:gf(g.buffer)};default:return JSON.stringify(g)}}var cu=function(){},Fl=class{constructor(s,p){Object.defineProperty(this,"instanceId",{enumerable:!0,value:String(s)}),Object.defineProperty(this,"callbackManager",{enumerable:!0,value:new su(s)}),cu=p||function(){}}callback(s,p,w){return this.callbackManager.consume(s,p,w)}registerHook(s,p,w,k){return this.callbackManager.registerHook(s,p,w,k)}triggerHook(s,p,w,k){return this.callbackManager.triggerHook(s,p,w,k)}updateData(s,p,w){this.send("module",{module:"dom",method:"updateComponentData"},[s,p,w])}destroyCallback(){return this.callbackManager.close()}normalize(s,p=!1){let w=gc(s);if(s&&s instanceof Ki)return s.ref;if(s&&s.$el instanceof Ki)return s.$el.ref;if(w==="Function")return this.callbackManager.add(s).toString();if(p){if(w==="Object"){let k={};for(let S in s)k[S]=this.normalize(s[S],!0);return k}if(w==="Array")return s.map(k=>this.normalize(k,!0))}return s&&s.ref&&s["[[VirtualElement]]"]?s.ref:tv(s)}send(s,p,w,k){let{action:S,component:d,ref:E,module:B,method:We}=p;switch(w=w.map(Lt=>this.normalize(Lt,s!=="module")),gc(k)==="Object"&&(k=this.normalize(k,!0)),s){case"dom":return Kn("debug")&&Di(`[task](${this.instanceId},${s},${S}) ${JSON.stringify(w)}`),this[S](this.instanceId,w);case"component":return this.componentHandler(this.instanceId,E,We,w,hi({component:d},k));default:return Kn("debug")&&Di(`[task](${this.instanceId},${B},${We}) ${JSON.stringify(w)}`),this.moduleHandler(this.instanceId,B,We,w,k)}}callDOM(s,p){return this[s](this.instanceId,p)}callComponent(s,p,w,k){return this.componentHandler(this.instanceId,s,p,w,k)}callModule(s,p,w,k){return this.moduleHandler(this.instanceId,s,p,w,k)}};function nv(){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},s=Fl.prototype;for(let p in g){let w=g[p];s[p]=w?(k,S)=>w(k,...S):(k,S)=>cu(k,[{module:"dom",method:p,args:S}],"-1")}s.componentHandler=global.callNativeComponent||((p,w,k,S,d)=>cu(p,[{component:d.component,ref:w,method:k,args:S}])),s.moduleHandler=global.callNativeModule||((p,w,k,S)=>cu(p,[{module:w,method:k,args:S}]))}function UN(g,s,p,w,k,S){let d=g.getRef(s);if(d)return g.fireEvent(d,p,w,k,S);if(w)return w._nodeId=s,g.fireEvent(g.getRef("_documentElement"),p,w,k,S)}function HN(g,s,p,w){return g.taskCenter.callback(s,p,w)}function jN(g,s,p,w,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(s,p,w,k)}catch(d){throw console.error(`[JS Framework] Failed to trigger the "${p}@${w}" hook on ${s}.`),d}return S}function Af(g,s){let p=rs(g);if(!p)return new Error(`[JS Framework] Failed to receiveTasks, instance (${g}) is not available.`);if(Pi(s))return s.map(w=>{switch(w.method){case"callback":return HN(p,...w.args);case"fireEventSync":case"fireEvent":return UN(p,...w.args);case"componentHook":return jN(p,...w.args)}})}var ks={};function rv(g={}){for(let s in g)il(ks,s)||(ks[s]={}),!!Pi(g[s])&&g[s].forEach(p=>{gi(p)?ks[s][p]=!0:Dl(p)&&gi(p.name)&&(ks[s][p.name]=p.args||[])})}function uu(g,s){return gi(s)?!!(ks[g]&&ks[g][s]):!!ks[g]}function iv(g){return ks[g]}var Of={};function ov(g){!Pi(g)||g.forEach(s=>{!s||(gi(s)?Of[s]=!0:Dl(s)&&gi(s.type)&&(Of[s.type]=s,Ef(s.type,s.methods)))})}function Tf(g){return!!Of[g]}var Rs=[];function fu(g,s){Pf(g)?console.warn(`Service "${g}" has been registered already!`):(s=hi({},s),Rs.push({name:g,options:s}))}function du(g){Rs.some((s,p)=>{if(s.name===g)return Rs.splice(p,1),!0})}function Pf(g){return zN(g)>=0}function zN(g){return Rs.map(s=>s.name).indexOf(g)}function WN(g){return s=>{let p=tu(g,s),{createApp:w}=p;p.createVueApp=p.createApp=(k,S)=>w(k,S).use(GN,s),s.Vue=p}}var GN={install(g,s){YN(g,s),dc(s).initApp(g)}};function YN(g,s){let{mount:p}=g;g.mount=w=>{let k=p(w);return w==="#app"&&s.__registerApp(k),k}}function qN(g){let{UniShared:s,VueShared:p,VueReactivity:w}=g;var k=function(S,d,E,B){"use strict";function We(i){}function Lt(i,l){}function en(i,l,f,_){var A;try{A=_?i(..._):i()}catch(C){I(C,l,f)}return A}function xt(i,l,f,_){if(d.isFunction(i)){var A=en(i,l,f,_);return A&&d.isPromise(A)&&A.catch(M=>{I(M,l,f)}),A}for(var C=[],N=0;N<i.length;N++)C.push(xt(i[N],l,f,_));return C}function I(i,l,f){if(l&&l.vnode,l){for(var _=l.parent,A=l.proxy,C=f;_;){var N=_.ec;if(N){for(var M=0;M<N.length;M++)if(N[M](i,A,C)===!1)return}_=_.parent}var H=l.appContext.config.errorHandler;if(H){en(H,null,10,[i,A,C]);return}}St(i)}function St(i,l,f){console.error(i)}var Pn=!1,st=!1,W=[],Z=0,fn=[],sn=null,_n=0,Wn={then(i){setTimeout(()=>i(),0)}},pi=S.platform==="iOS",vi=pi?Wn:Promise.resolve(),ar=null;function Sr(i){var l=ar||vi;return i?l.then(this?i.bind(this):i):l}function Cn(i){for(var l=Z+1,f=W.length;l<f;){var _=l+f>>>1,A=bt(W[_]);A<i?l=_+1:f=_}return l}function wr(i){(!W.length||!W.includes(i,Pn&&i.allowRecurse?Z+1:Z))&&(i.id==null?W.push(i):W.splice(Cn(i.id),0,i),Cr())}function Cr(){!Pn&&!st&&(st=!0,ar=vi.then(Sn))}function mi(i){var l=W.indexOf(i);l>Z&&W.splice(l,1)}function ri(i){d.isArray(i)?fn.push(...i):(!sn||!sn.includes(i,i.allowRecurse?_n+1:_n))&&fn.push(i),Cr()}function Ve(i){for(var l=arguments.length>1&&arguments[1]!==void 0?arguments[1]:Pn?Z+1:0;l<W.length;l++){var f=W[l];f&&f.pre&&(W.splice(l,1),l--,f())}}function ot(i){if(fn.length){var l=[...new Set(fn)];if(fn.length=0,sn){sn.push(...l);return}for(sn=l,sn.sort((f,_)=>bt(f)-bt(_)),_n=0;_n<sn.length;_n++)sn[_n]();sn=null,_n=0}}var bt=i=>i.id==null?1/0:i.id,tn=(i,l)=>{var f=bt(i)-bt(l);if(f===0){if(i.pre&&!l.pre)return-1;if(l.pre&&!i.pre)return 1}return f};function Sn(i){st=!1,Pn=!0,W.sort(tn);var l=d.NOOP;try{for(Z=0;Z<W.length;Z++){var f=W[Z];f&&f.active!==!1&&en(f,null,14)}}finally{Z=0,W.length=0,ot(),Pn=!1,ar=null,(W.length||fn.length)&&Sn()}}S.devtools=void 0;var Jt=[];function rr(i,l){var f,_;if(S.devtools=i,S.devtools)S.devtools.enabled=!0,Jt.forEach(C=>{var{event:N,args:M}=C;return S.devtools.emit(N,...M)}),Jt=[];else if(typeof window!="undefined"&&window.HTMLElement&&!((_=(f=window.navigator)===null||f===void 0?void 0:f.userAgent)===null||_===void 0?void 0:_.includes("jsdom"))){var A=l.__VUE_DEVTOOLS_HOOK_REPLAY__=l.__VUE_DEVTOOLS_HOOK_REPLAY__||[];A.push(C=>{rr(C,l)}),setTimeout(()=>{S.devtools||(l.__VUE_DEVTOOLS_HOOK_REPLAY__=null,Jt=[])},3e3)}else Jt=[]}function Ar(i,l){if(!i.isUnmounted){for(var f=i.vnode.props||d.EMPTY_OBJ,_=arguments.length,A=new Array(_>2?_-2:0),C=2;C<_;C++)A[C-2]=arguments[C];var N=A,M=l.startsWith("update:"),H=M&&l.slice(7);if(H&&H in f){var ne="".concat(H==="modelValue"?"model":H,"Modifiers"),{number:ve,trim:Le}=f[ne]||d.EMPTY_OBJ;Le&&(N=A.map(ft=>d.isString(ft)?ft.trim():ft)),ve&&(N=A.map(d.looseToNumber))}var ue,ke=f[ue=d.toHandlerKey(l)]||f[ue=d.toHandlerKey(d.camelize(l))];!ke&&M&&(ke=f[ue=d.toHandlerKey(d.hyphenate(l))]),ke&&xt(ke,i,6,N);var Ye=f[ue+"Once"];if(Ye){if(!i.emitted)i.emitted={};else if(i.emitted[ue])return;i.emitted[ue]=!0,xt(Ye,i,6,N)}}}function Or(i,l){var f=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!1,_=l.emitsCache,A=_.get(i);if(A!==void 0)return A;var C=i.emits,N={},M=!1;if(!d.isFunction(i)){var H=ne=>{var ve=Or(ne,l,!0);ve&&(M=!0,d.extend(N,ve))};!f&&l.mixins.length&&l.mixins.forEach(H),i.extends&&H(i.extends),i.mixins&&i.mixins.forEach(H)}return!C&&!M?(d.isObject(i)&&_.set(i,null),null):(d.isArray(C)?C.forEach(ne=>N[ne]=null):d.extend(N,C),d.isObject(i)&&_.set(i,N),N)}function On(i,l){return!i||!d.isOn(l)?!1:(l=l.slice(2).replace(/Once$/,""),d.hasOwn(i,l[0].toLowerCase()+l.slice(1))||d.hasOwn(i,d.hyphenate(l))||d.hasOwn(i,l))}var dn=null,Tr=null;function _i(i){var l=dn;return dn=i,Tr=i&&i.type.__scopeId||null,l}function Co(i){Tr=i}function ca(){Tr=null}var Fi=i=>Yo;function Yo(i){var l=arguments.length>1&&arguments[1]!==void 0?arguments[1]:dn;if(!l||i._n)return i;var f=function(){f._d&&Et(-1);var _=_i(l),A;try{A=i(...arguments)}finally{_i(_),f._d&&Et(1)}return A};return f._n=!0,f._c=!0,f._d=!0,f}function Ao(){}function Ji(i){var{type:l,vnode:f,proxy:_,withProxy:A,props:C,propsOptions:[N],slots:M,attrs:H,emit:ne,render:ve,renderCache:Le,data:ue,setupState:ke,ctx:Ye,inheritAttrs:ft}=i,Qe,Re,me=_i(i);try{if(f.shapeFlag&4){var ye=A||_;Qe=Dn(ve.call(ye,ye,Le,C,ke,ue,Ye)),Re=H}else{var Fe=l;Qe=Dn(Fe.length>1?Fe(C,{attrs:H,slots:M,emit:ne}):Fe(C,null)),Re=l.props?H:ua(H)}}catch(Ke){fe.length=0,I(Ke,i,1),Qe=qt(pe)}var Ae=Qe;if(Re&&ft!==!1){var _t=Object.keys(Re),{shapeFlag:At}=Ae;_t.length&&At&(1|6)&&(N&&_t.some(d.isModelListener)&&(Re=Oo(Re,N)),Ae=ei(Ae,Re))}return f.dirs&&(Ae=ei(Ae),Ae.dirs=Ae.dirs?Ae.dirs.concat(f.dirs):f.dirs),f.transition&&(Ae.transition=f.transition),Qe=Ae,_i(me),Qe}function Mr(i){for(var l,f=0;f<i.length;f++){var _=i[f];if(Wt(_)){if(_.type!==pe||_.children==="v-if"){if(l)return;l=_}}else return}return l}var ua=i=>{var l;for(var f in i)(f==="class"||f==="style"||d.isOn(f))&&((l||(l={}))[f]=i[f]);return l},Oo=(i,l)=>{var f={};for(var _ in i)(!d.isModelListener(_)||!(_.slice(9)in l))&&(f[_]=i[_]);return f};function To(i,l,f){var{props:_,children:A,component:C}=i,{props:N,children:M,patchFlag:H}=l,ne=C.emitsOptions;if(l.dirs||l.transition)return!0;if(f&&H>=0){if(H&1024)return!0;if(H&16)return _?Zi(_,N,ne):!!N;if(H&8)for(var ve=l.dynamicProps,Le=0;Le<ve.length;Le++){var ue=ve[Le];if(N[ue]!==_[ue]&&!On(ne,ue))return!0}}else return(A||M)&&(!M||!M.$stable)?!0:_===N?!1:_?N?Zi(_,N,ne):!0:!!N;return!1}function Zi(i,l,f){var _=Object.keys(l);if(_.length!==Object.keys(i).length)return!0;for(var A=0;A<_.length;A++){var C=_[A];if(l[C]!==i[C]&&!On(f,C))return!0}return!1}function ii(i,l){for(var{vnode:f,parent:_}=i;_&&_.subTree===f;)(f=_.vnode).el=l,_=_.parent}var qo=i=>i.__isSuspense,uo={name:"Suspense",__isSuspense:!0,process(i,l,f,_,A,C,N,M,H,ne){i==null?fo(l,f,_,A,C,N,M,H,ne):Gn(i,l,f,_,A,N,M,H,ne)},hydrate:Po,create:Xi,normalize:Qi},Nn=uo;function hr(i,l){var f=i.props&&i.props[l];d.isFunction(f)&&f()}function fo(i,l,f,_,A,C,N,M,H){var{p:ne,o:{createElement:ve}}=H,Le=ve("div",l),ue=i.suspense=Xi(i,A,_,l,Le,f,C,N,M,H);ne(null,ue.pendingBranch=i.ssContent,Le,null,_,ue,C,N),ue.deps>0?(hr(i,"onPending"),hr(i,"onFallback"),ne(null,i.ssFallback,l,f,_,null,C,N),Dr(ue,i.ssFallback)):ue.resolve()}function Gn(i,l,f,_,A,C,N,M,H){var{p:ne,um:ve,o:{createElement:Le}}=H,ue=l.suspense=i.suspense;ue.vnode=l,l.el=i.el;var ke=l.ssContent,Ye=l.ssFallback,{activeBranch:ft,pendingBranch:Qe,isInFallback:Re,isHydrating:me}=ue;if(Qe)ue.pendingBranch=ke,ht(ke,Qe)?(ne(Qe,ke,ue.hiddenContainer,null,A,ue,C,N,M),ue.deps<=0?ue.resolve():Re&&(ne(ft,Ye,f,_,A,null,C,N,M),Dr(ue,Ye))):(ue.pendingId++,me?(ue.isHydrating=!1,ue.activeBranch=Qe):ve(Qe,A,ue),ue.deps=0,ue.effects.length=0,ue.hiddenContainer=Le("div",f),Re?(ne(null,ke,ue.hiddenContainer,null,A,ue,C,N,M),ue.deps<=0?ue.resolve():(ne(ft,Ye,f,_,A,null,C,N,M),Dr(ue,Ye))):ft&&ht(ke,ft)?(ne(ft,ke,f,_,A,ue,C,N,M),ue.resolve(!0)):(ne(null,ke,ue.hiddenContainer,null,A,ue,C,N,M),ue.deps<=0&&ue.resolve()));else if(ft&&ht(ke,ft))ne(ft,ke,f,_,A,ue,C,N,M),Dr(ue,ke);else if(hr(l,"onPending"),ue.pendingBranch=ke,ue.pendingId++,ne(null,ke,ue.hiddenContainer,null,A,ue,C,N,M),ue.deps<=0)ue.resolve();else{var{timeout:ye,pendingId:Fe}=ue;ye>0?setTimeout(()=>{ue.pendingId===Fe&&ue.fallback(Ye)},ye):ye===0&&ue.fallback(Ye)}}function Xi(i,l,f,_,A,C,N,M,H,ne){var ve=arguments.length>10&&arguments[10]!==void 0?arguments[10]:!1,{p:Le,m:ue,um:ke,n:Ye,o:{parentNode:ft,remove:Qe}}=ne,Re=i.props?d.toNumber(i.props.timeout):void 0,me={vnode:i,parent:l,parentComponent:f,isSVG:N,container:_,hiddenContainer:A,anchor:C,deps:0,pendingId:0,timeout:typeof Re=="number"?Re:-1,activeBranch:null,pendingBranch:null,isInFallback:!0,isHydrating:ve,isUnmounted:!1,effects:[],resolve(){var ye=arguments.length>0&&arguments[0]!==void 0?arguments[0]:!1,{vnode:Fe,activeBranch:Ae,pendingBranch:_t,pendingId:At,effects:Ke,parentComponent:Nt,container:L}=me;if(me.isHydrating)me.isHydrating=!1;else if(!ye){var j=Ae&&_t.transition&&_t.transition.mode==="out-in";j&&(Ae.transition.afterLeave=()=>{At===me.pendingId&&ue(_t,L,ae,0)});var{anchor:ae}=me;Ae&&(ae=Ye(Ae),ke(Ae,Nt,me,!0)),j||ue(_t,L,ae,0)}Dr(me,_t),me.pendingBranch=null,me.isInFallback=!1;for(var re=me.parent,oe=!1;re;){if(re.pendingBranch){re.effects.push(...Ke),oe=!0;break}re=re.parent}oe||ri(Ke),me.effects=[],hr(Fe,"onResolve")},fallback(ye){if(!!me.pendingBranch){var{vnode:Fe,activeBranch:Ae,parentComponent:_t,container:At,isSVG:Ke}=me;hr(Fe,"onFallback");var Nt=Ye(Ae),L=()=>{!me.isInFallback||(Le(null,ye,At,Nt,_t,null,Ke,M,H),Dr(me,ye))},j=ye.transition&&ye.transition.mode==="out-in";j&&(Ae.transition.afterLeave=L),me.isInFallback=!0,ke(Ae,_t,null,!0),j||L()}},move(ye,Fe,Ae){me.activeBranch&&ue(me.activeBranch,ye,Fe,Ae),me.container=ye},next(){return me.activeBranch&&Ye(me.activeBranch)},registerDep(ye,Fe){var Ae=!!me.pendingBranch;Ae&&me.deps++;var _t=ye.vnode.el;ye.asyncDep.catch(At=>{I(At,ye,0)}).then(At=>{if(!(ye.isUnmounted||me.isUnmounted||me.pendingId!==ye.suspenseId)){ye.asyncResolved=!0;var{vnode:Ke}=ye;ea(ye,At,!1),_t&&(Ke.el=_t);var Nt=!_t&&ye.subTree.el;Fe(ye,Ke,ft(_t||ye.subTree.el),_t?null:Ye(ye.subTree),me,N,H),Nt&&Qe(Nt),ii(ye,Ke.el),Ae&&--me.deps===0&&me.resolve()}})},unmount(ye,Fe){me.isUnmounted=!0,me.activeBranch&&ke(me.activeBranch,f,ye,Fe),me.pendingBranch&&ke(me.pendingBranch,f,ye,Fe)}};return me}function Po(i,l,f,_,A,C,N,M,H){var ne=l.suspense=Xi(l,_,f,i.parentNode,document.createElement("div"),null,A,C,N,M,!0),ve=H(i,ne.pendingBranch=l.ssContent,f,ne,C,N);return ne.deps===0&&ne.resolve(),ve}function Qi(i){var{shapeFlag:l,children:f}=i,_=l&32;i.ssContent=bi(_?f.default:f),i.ssFallback=_?bi(f.fallback):qt(pe)}function bi(i){var l;if(d.isFunction(i)){var f=$t&&i._c;f&&(i._d=!1,ct()),i=i(),f&&(i._d=!0,l=we,gt())}if(d.isArray(i)){var _=Mr(i);i=_}return i=Dn(i),l&&!i.dynamicChildren&&(i.dynamicChildren=l.filter(A=>A!==i)),i}function Jn(i,l){l&&l.pendingBranch?d.isArray(i)?l.effects.push(...i):l.effects.push(i):ri(i)}function Dr(i,l){i.activeBranch=l;var{vnode:f,parentComponent:_}=i,A=f.el=l.el;_&&_.subTree===f&&(_.vnode.el=A,ii(_,A))}function In(i,l){if(pn){var f=pn.provides,_=pn.parent&&pn.parent.provides;_===f&&(f=pn.provides=Object.create(_)),f[i]=l,pn.type.mpType==="app"&&pn.appContext.app.provide(i,l)}}function Un(i,l){var f=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!1,_=pn||dn;if(_){var A=_.parent==null?_.vnode.appContext&&_.vnode.appContext.provides:_.parent.provides;if(A&&i in A)return A[i];if(arguments.length>1)return f&&d.isFunction(l)?l.call(_.proxy):l}}function qr(i,l){return Vi(i,null,l)}function Io(i,l){return Vi(i,null,{flush:"post"})}function oi(i,l){return Vi(i,null,{flush:"sync"})}var Kr={};function sr(i,l,f){return Vi(i,l,f)}function Vi(i,l){var{immediate:f,deep:_,flush:A,onTrack:C,onTrigger:N}=arguments.length>2&&arguments[2]!==void 0?arguments[2]:d.EMPTY_OBJ,M=E.getCurrentScope()===(pn==null?void 0:pn.scope)?pn:null,H,ne=!1,ve=!1;if(E.isRef(i)?(H=()=>i.value,ne=E.isShallow(i)):E.isReactive(i)?(H=()=>i,_=!0):d.isArray(i)?(ve=!0,ne=i.some(Ae=>E.isReactive(Ae)||E.isShallow(Ae)),H=()=>i.map(Ae=>{if(E.isRef(Ae))return Ae.value;if(E.isReactive(Ae))return Ei(Ae);if(d.isFunction(Ae))return en(Ae,M,2)})):d.isFunction(i)?l?H=()=>en(i,M,2):H=()=>{if(!(M&&M.isUnmounted))return ue&&ue(),xt(i,M,3,[ke])}:H=d.NOOP,l&&_){var Le=H;H=()=>Ei(Le())}var ue,ke=Ae=>{ue=ye.onStop=()=>{en(Ae,M,4)}},Ye;if(S.isInSSRComponentSetup)if(ke=d.NOOP,l?f&&xt(l,M,3,[H(),ve?[]:void 0,ke]):H(),A==="sync"){var ft=ka();Ye=ft.__watcherHandles||(ft.__watcherHandles=[])}else return d.NOOP;var Qe=ve?new Array(i.length).fill(Kr):Kr,Re=()=>{if(!!ye.active)if(l){var Ae=ye.run();(_||ne||(ve?Ae.some((_t,At)=>d.hasChanged(_t,Qe[At])):d.hasChanged(Ae,Qe)))&&(ue&&ue(),xt(l,M,3,[Ae,Qe===Kr?void 0:ve&&Qe[0]===Kr?[]:Qe,ke]),Qe=Ae)}else ye.run()};Re.allowRecurse=!!l;var me;A==="sync"?me=Re:A==="post"?me=()=>or(Re,M&&M.suspense):(Re.pre=!0,M&&(Re.id=M.uid),me=()=>wr(Re));var ye=new E.ReactiveEffect(H,me);l?f?Re():Qe=ye.run():A==="post"?or(ye.run.bind(ye),M&&M.suspense):ye.run();var Fe=()=>{ye.stop(),M&&M.scope&&d.remove(M.scope.effects,ye)};return Ye&&Ye.push(Fe),Fe}function eo(i,l,f){var _=this.proxy,A=d.isString(i)?i.includes(".")?Fr(_,i):()=>_[i]:i.bind(_,_),C;d.isFunction(l)?C=l:(C=l.handler,f=l);var N=pn;zn(this);var M=Vi(A,C.bind(_),f);return N?zn(N):Ci(),M}function Fr(i,l){var f=l.split(".");return()=>{for(var _=i,A=0;A<f.length&&_;A++)_=_[f[A]];return _}}function Ei(i,l){if(!d.isObject(i)||i.__v_skip||(l=l||new Set,l.has(i)))return i;if(l.add(i),E.isRef(i))Ei(i.value,l);else if(d.isArray(i))for(var f=0;f<i.length;f++)Ei(i[f],l);else if(d.isSet(i)||d.isMap(i))i.forEach(A=>{Ei(A,l)});else if(d.isPlainObject(i))for(var _ in i)Ei(i[_],l);return i}function gr(){var i={isMounted:!1,isLeaving:!1,isUnmounting:!1,leavingVNodes:new Map};return Xn(()=>{i.isMounted=!0}),lr(()=>{i.isUnmounting=!0}),i}var gn=[Function,Array],Jr={mode:String,appear:Boolean,persisted:Boolean,onBeforeEnter:gn,onEnter:gn,onAfterEnter:gn,onEnterCancelled:gn,onBeforeLeave:gn,onLeave:gn,onAfterLeave:gn,onLeaveCancelled:gn,onBeforeAppear:gn,onAppear:gn,onAfterAppear:gn,onAppearCancelled:gn},kr={name:"BaseTransition",props:Jr,setup(i,l){var{slots:f}=l,_=Vn(),A=gr(),C;return()=>{var N=f.default&&Ni(f.default(),!0);if(!(!N||!N.length)){var M=N[0];if(N.length>1){for(var H of N)if(H.type!==pe){M=H;break}}var ne=E.toRaw(i),{mode:ve}=ne;if(A.isLeaving)return Ii(M);var Le=ai(M);if(!Le)return Ii(M);var ue=Zr(Le,ne,A,_);Vr(Le,ue);var ke=_.subTree,Ye=ke&&ai(ke),ft=!1,{getTransitionKey:Qe}=Le.type;if(Qe){var Re=Qe();C===void 0?C=Re:Re!==C&&(C=Re,ft=!0)}if(Ye&&Ye.type!==pe&&(!ht(Le,Ye)||ft)){var me=Zr(Ye,ne,A,_);if(Vr(Ye,me),ve==="out-in")return A.isLeaving=!0,me.afterLeave=()=>{A.isLeaving=!1,_.update.active!==!1&&_.update()},Ii(M);ve==="in-out"&&Le.type!==pe&&(me.delayLeave=(ye,Fe,Ae)=>{var _t=Oe(A,Ye);_t[String(Ye.key)]=Ye,ye._leaveCb=()=>{Fe(),ye._leaveCb=void 0,delete ue.delayedLeave},ue.delayedLeave=Ae})}return M}}}},Mt=kr;function Oe(i,l){var{leavingVNodes:f}=i,_=f.get(l.type);return _||(_=Object.create(null),f.set(l.type,_)),_}function Zr(i,l,f,_){var{appear:A,mode:C,persisted:N=!1,onBeforeEnter:M,onEnter:H,onAfterEnter:ne,onEnterCancelled:ve,onBeforeLeave:Le,onLeave:ue,onAfterLeave:ke,onLeaveCancelled:Ye,onBeforeAppear:ft,onAppear:Qe,onAfterAppear:Re,onAppearCancelled:me}=l,ye=String(i.key),Fe=Oe(f,i),Ae=(Ke,Nt)=>{Ke&&xt(Ke,_,9,Nt)},_t=(Ke,Nt)=>{var L=Nt[1];Ae(Ke,Nt),d.isArray(Ke)?Ke.every(j=>j.length<=1)&&L():Ke.length<=1&&L()},At={mode:C,persisted:N,beforeEnter(Ke){var Nt=M;if(!f.isMounted)if(A)Nt=ft||M;else return;Ke._leaveCb&&Ke._leaveCb(!0);var L=Fe[ye];L&&ht(i,L)&&L.el._leaveCb&&L.el._leaveCb(),Ae(Nt,[Ke])},enter(Ke){var Nt=H,L=ne,j=ve;if(!f.isMounted)if(A)Nt=Qe||H,L=Re||ne,j=me||ve;else return;var ae=!1,re=Ke._enterCb=oe=>{ae||(ae=!0,oe?Ae(j,[Ke]):Ae(L,[Ke]),At.delayedLeave&&At.delayedLeave(),Ke._enterCb=void 0)};Nt?_t(Nt,[Ke,re]):re()},leave(Ke,Nt){var L=String(i.key);if(Ke._enterCb&&Ke._enterCb(!0),f.isUnmounting)return Nt();Ae(Le,[Ke]);var j=!1,ae=Ke._leaveCb=re=>{j||(j=!0,Nt(),re?Ae(Ye,[Ke]):Ae(ke,[Ke]),Ke._leaveCb=void 0,Fe[L]===i&&delete Fe[L])};Fe[L]=i,ue?_t(ue,[Ke,ae]):ae()},clone(Ke){return Zr(Ke,l,f,_)}};return At}function Ii(i){if(ki(i))return i=ei(i),i.children=null,i}function ai(i){return ki(i)?i.children?i.children[0]:void 0:i}function Vr(i,l){i.shapeFlag&6&&i.component?Vr(i.component.subTree,l):i.shapeFlag&128?(i.ssContent.transition=l.clone(i.ssContent),i.ssFallback.transition=l.clone(i.ssFallback)):i.transition=l}function Ni(i){for(var l=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!1,f=arguments.length>2?arguments[2]:void 0,_=[],A=0,C=0;C<i.length;C++){var N=i[C],M=f==null?N.key:String(f)+String(N.key!=null?N.key:C);N.type===te?(N.patchFlag&128&&A++,_=_.concat(Ni(N.children,l,M))):(l||N.type!==pe)&&_.push(M!=null?ei(N,{key:M}):N)}if(A>1)for(var H=0;H<_.length;H++)_[H].patchFlag=-2;return _}function pr(i){return d.isFunction(i)?{setup:i,name:i.name}:i}var $r=i=>!!i.type.__asyncLoader;function Xr(i){d.isFunction(i)&&(i={loader:i});var{loader:l,loadingComponent:f,errorComponent:_,delay:A=200,timeout:C,suspensible:N=!0,onError:M}=i,H=null,ne,ve=0,Le=()=>(ve++,H=null,ue()),ue=()=>{var ke;return H||(ke=H=l().catch(Ye=>{if(Ye=Ye instanceof Error?Ye:new Error(String(Ye)),M)return new Promise((ft,Qe)=>{var Re=()=>ft(Le()),me=()=>Qe(Ye);M(Ye,Re,me,ve+1)});throw Ye}).then(Ye=>ke!==H&&H?H:(Ye&&(Ye.__esModule||Ye[Symbol.toStringTag]==="Module")&&(Ye=Ye.default),ne=Ye,Ye)))};return pr({name:"AsyncComponentWrapper",__asyncLoader:ue,get __asyncResolved(){return ne},setup(){var ke=pn;if(ne)return()=>Pr(ne,ke);var Ye=me=>{H=null,I(me,ke,13)};if(N&&ke.suspense||S.isInSSRComponentSetup)return ue().then(me=>()=>Pr(me,ke)).catch(me=>(Ye(me),()=>_?qt(_,{error:me}):null));var ft=E.ref(!1),Qe=E.ref(),Re=E.ref(!!A);return A&&setTimeout(()=>{Re.value=!1},A),C!=null&&setTimeout(()=>{if(!ft.value&&!Qe.value){var me=new Error("Async component timed out after ".concat(C,"ms."));Ye(me),Qe.value=me}},C),ue().then(()=>{ft.value=!0,ke.parent&&ki(ke.parent.vnode)&&wr(ke.parent.update)}).catch(me=>{Ye(me),Qe.value=me}),()=>{if(ft.value&&ne)return Pr(ne,ke);if(Qe.value&&_)return qt(_,{error:Qe.value});if(f&&!Re.value)return qt(f)}}})}function Pr(i,l){var{ref:f,props:_,children:A,ce:C}=l.vnode,N=qt(i,_,A);return N.ref=f,N.ce=C,delete l.vnode.ce,N}var ki=i=>i.type.__isKeepAlive,ln={name:"KeepAlive",__isKeepAlive:!0,props:{include:[String,RegExp,Array],exclude:[String,RegExp,Array],max:[String,Number]},setup(i,l){var{slots:f}=l,_=Vn(),A=_.ctx;if(!A.renderer)return()=>{var ye=f.default&&f.default();return ye&&ye.length===1?ye[0]:ye};var C=new Map,N=new Set,M=null,H=_.suspense,{renderer:{p:ne,m:ve,um:Le,o:{createElement:ue}}}=A,ke=ue("div",null);A.activate=(ye,Fe,Ae,_t,At)=>{var Ke=ye.component;ve(ye,Fe,Ae,0,H),ne(Ke.vnode,ye,Fe,Ae,Ke,H,_t,ye.slotScopeIds,At),or(()=>{Ke.isDeactivated=!1,Ke.a&&d.invokeArrayFns(Ke.a);var Nt=ye.props&&ye.props.onVnodeMounted;Nt&&zr(Nt,Ke.parent,ye)},H)},A.deactivate=ye=>{var Fe=ye.component;ve(ye,ke,null,1,H),or(()=>{Fe.da&&d.invokeArrayFns(Fe.da);var Ae=ye.props&&ye.props.onVnodeUnmounted;Ae&&zr(Ae,Fe.parent,ye),Fe.isDeactivated=!0},H)};function Ye(ye){yi(ye),Le(ye,_,H,!0)}function ft(ye){C.forEach((Fe,Ae)=>{var _t=_o(Fe.type);_t&&(!ye||!ye(_t))&&Qe(Ae)})}function Qe(ye){var Fe=C.get(ye);!M||!ht(Fe,M)?Ye(Fe):M&&yi(M),C.delete(ye),N.delete(ye)}sr(()=>[i.include,i.exclude],ye=>{var[Fe,Ae]=ye;Fe&&ft(_t=>Ur(Fe,_t)),Ae&&ft(_t=>!Ur(Ae,_t))},{flush:"post",deep:!0});var Re=null,me=()=>{Re!=null&&C.set(Re,Ri(_.subTree))};return Xn(me),Qn(me),lr(()=>{C.forEach(ye=>{var{subTree:Fe,suspense:Ae}=_,_t=Ri(Fe);if(ye.type===_t.type&&ye.key===_t.key){yi(_t);var At=_t.component.da;At&&or(At,Ae);return}Ye(ye)})}),()=>{if(Re=null,!f.default)return null;var ye=f.default(),Fe=ye[0];if(ye.length>1)return M=null,ye;if(!Wt(Fe)||!(Fe.shapeFlag&4)&&!(Fe.shapeFlag&128))return M=null,Fe;var Ae=Ri(Fe),_t=Ae.type,At=_o($r(Ae)?Ae.type.__asyncResolved||{}:_t),{include:Ke,exclude:Nt,max:L}=i;if(Ke&&(!At||!Ur(Ke,At))||Nt&&At&&Ur(Nt,At))return M=Ae,Fe;var j=Ae.key==null?_t:Ae.key,ae=C.get(j);return Ae.el&&(Ae=ei(Ae),Fe.shapeFlag&128&&(Fe.ssContent=Ae)),Re=j,ae?(Ae.el=ae.el,Ae.component=ae.component,Ae.transition&&Vr(Ae,Ae.transition),Ae.shapeFlag|=512,N.delete(j),N.add(j)):(N.add(j),L&&N.size>parseInt(L,10)&&Qe(N.values().next().value)),Ae.shapeFlag|=256,M=Ae,qo(Fe.type)?Fe:Ae}}},$i=ln;function Ur(i,l){return d.isArray(i)?i.some(f=>Ur(f,l)):d.isString(i)?i.split(",").includes(l):d.isRegExp(i)?i.test(l):!1}function to(i,l){Hr(i,"a",l)}function bn(i,l){Hr(i,"da",l)}function Hr(i,l){var f=arguments.length>2&&arguments[2]!==void 0?arguments[2]:pn,_=i.__wdc||(i.__wdc=()=>{for(var C=f;C;){if(C.isDeactivated)return;C=C.parent}return i()});if(vr(l,_,f),f)for(var A=f.parent;A&&A.parent;)ki(A.parent.vnode)&&ir(_,l,f,A),A=A.parent}function ir(i,l,f,_){var A=vr(l,i,_,!0);ho(()=>{d.remove(_[l],A)},f)}function yi(i){i.shapeFlag&=~256,i.shapeFlag&=~512}function Ri(i){return i.shapeFlag&128?i.ssContent:i}function vr(i,l){var f=arguments.length>2&&arguments[2]!==void 0?arguments[2]:pn,_=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1;if(f){if(B.isRootHook(i)&&f!==f.root&&(f=f.root,B.isRootImmediateHook(i))){var A=f.proxy;xt(l.bind(A),f,i,B.ON_LOAD===i?[A.$page.options]:[])}var{__page_container__:C}=f.root.vnode;C&&C.onInjectHook(i);var N=f[i]||(f[i]=[]),M=l.__weh||(l.__weh=function(){if(!f.isUnmounted){E.pauseTracking(),zn(f);for(var H=arguments.length,ne=new Array(H),ve=0;ve<H;ve++)ne[ve]=arguments[ve];var Le=xt(l,f,i,ne);return Ci(),E.resetTracking(),Le}});return _?N.unshift(M):N.push(M),M}}var Qr=i=>function(l){var f=arguments.length>1&&arguments[1]!==void 0?arguments[1]:pn;return(!S.isInSSRComponentSetup||i==="sp")&&vr(i,function(){return l(...arguments)},f)},Zn=Qr("bm"),Xn=Qr("m"),Hn=Qr("bu"),Qn=Qr("u"),lr=Qr("bum"),ho=Qr("um"),go=Qr("sp"),No=Qr("rtg"),no=Qr("rtc");function ko(i){var l=arguments.length>1&&arguments[1]!==void 0?arguments[1]:pn;vr("ec",i,l)}function jr(i,l){var f=dn;if(f===null)return i;for(var _=Li(f)||f.proxy,A=i.dirs||(i.dirs=[]),C=0;C<l.length;C++){var[N,M,H,ne=d.EMPTY_OBJ]=l[C];N&&(d.isFunction(N)&&(N={mounted:N,updated:N}),N.deep&&Ei(M),A.push({dir:N,instance:_,value:M,oldValue:void 0,arg:H,modifiers:ne}))}return i}function Rr(i,l,f,_){for(var A=i.dirs,C=l&&l.dirs,N=0;N<A.length;N++){var M=A[N];C&&(M.oldValue=C[N].value);var H=M.dir[_];H&&(E.pauseTracking(),xt(H,f,8,[i.el,M,i,l]),E.resetTracking())}}var ro="components",Ko="directives";function xi(i,l){return Hi(ro,i,!0,l)||i}var Ui=Symbol();function Ro(i){return d.isString(i)?Hi(ro,i,!1)||i:i||Ui}function Bi(i){return Hi(Ko,i)}function Hi(i,l){var f=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1,_=dn||pn;if(_){var A=_.type;if(i===ro){var C=_o(A,!1);if(C&&(C===l||C===d.camelize(l)||C===d.capitalize(d.camelize(l))))return A}var N=xo(_[i]||A[i],l)||xo(_.appContext[i],l);return!N&&f?A:N}}function xo(i,l){return i&&(i[l]||i[d.camelize(l)]||i[d.capitalize(d.camelize(l))])}function x(i,l,f,_){var A,C=f&&f[_];if(d.isArray(i)||d.isString(i)){A=new Array(i.length);for(var N=0,M=i.length;N<M;N++)A[N]=l(i[N],N,void 0,C&&C[N])}else if(typeof i=="number"){A=new Array(i);for(var H=0;H<i;H++)A[H]=l(H+1,H,void 0,C&&C[H])}else if(d.isObject(i))if(i[Symbol.iterator])A=Array.from(i,(ke,Ye)=>l(ke,Ye,void 0,C&&C[Ye]));else{var ne=Object.keys(i);A=new Array(ne.length);for(var ve=0,Le=ne.length;ve<Le;ve++){var ue=ne[ve];A[ve]=l(i[ue],ue,ve,C&&C[ve])}}else A=[];return f&&(f[_]=A),A}function Q(i,l){for(var f=function(A){var C=l[A];if(d.isArray(C))for(var N=0;N<C.length;N++)i[C[N].name]=C[N].fn;else C&&(i[C.name]=C.key?function(){var M=C.fn(...arguments);return M&&(M.key=C.key),M}:C.fn)},_=0;_<l.length;_++)f(_);return i}function he(i,l){var f=arguments.length>2&&arguments[2]!==void 0?arguments[2]:{},_=arguments.length>3?arguments[3]:void 0,A=arguments.length>4?arguments[4]:void 0;if(dn.isCE||dn.parent&&$r(dn.parent)&&dn.parent.isCE)return l!=="default"&&(f.name=l),qt("slot",f,_&&_());var C=i[l];C&&C._c&&(C._d=!1),ct();var N=C&&se(C(f)),M=cn(te,{key:f.key||N&&N.key||"_".concat(l)},N||(_?_():[]),N&&i._===1?64:-2);return!A&&M.scopeId&&(M.slotScopeIds=[M.scopeId+"-s"]),C&&C._c&&(C._d=!0),M}function se(i){return i.some(l=>Wt(l)?!(l.type===pe||l.type===te&&!se(l.children)):!0)?i:null}function de(i,l){var f={};for(var _ in i)f[l&&/[A-Z]/.test(_)?"on:".concat(_):d.toHandlerKey(_)]=i[_];return f}var mt=i=>i?us(i)?Li(i)||i.proxy:mt(i.parent):null,K=d.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=>mt(i.parent),$root:i=>mt(i.root),$emit:i=>i.emit,$options:i=>mr(i),$forceUpdate:i=>i.f||(i.f=()=>wr(i.update)),$nextTick:i=>i.n||(i.n=Sr.bind(i.proxy)),$watch:i=>eo.bind(i)}),z=(i,l)=>i!==d.EMPTY_OBJ&&!i.__isScriptSetup&&d.hasOwn(i,l),ie={get(i,l){var{_:f}=i,{ctx:_,setupState:A,data:C,props:N,accessCache:M,type:H,appContext:ne}=f,ve;if(l[0]!=="$"){var Le=M[l];if(Le!==void 0)switch(Le){case 1:return A[l];case 2:return C[l];case 4:return _[l];case 3:return N[l]}else{if(z(A,l))return M[l]=1,A[l];if(C!==d.EMPTY_OBJ&&d.hasOwn(C,l))return M[l]=2,C[l];if((ve=f.propsOptions[0])&&d.hasOwn(ve,l))return M[l]=3,N[l];if(_!==d.EMPTY_OBJ&&d.hasOwn(_,l))return M[l]=4,_[l];nt&&(M[l]=0)}}var ue=K[l],ke,Ye;if(ue)return l==="$attrs"&&E.track(f,"get",l),ue(f);if((ke=H.__cssModules)&&(ke=ke[l]))return ke;if(_!==d.EMPTY_OBJ&&d.hasOwn(_,l))return M[l]=4,_[l];if(Ye=ne.config.globalProperties,d.hasOwn(Ye,l))return Ye[l]},set(i,l,f){var{_}=i,{data:A,setupState:C,ctx:N}=_;return z(C,l)?(C[l]=f,!0):A!==d.EMPTY_OBJ&&d.hasOwn(A,l)?(A[l]=f,!0):d.hasOwn(_.props,l)||l[0]==="$"&&l.slice(1)in _?!1:(N[l]=f,!0)},has(i,l){var{_:{data:f,setupState:_,accessCache:A,ctx:C,appContext:N,propsOptions:M}}=i,H;return!!A[l]||f!==d.EMPTY_OBJ&&d.hasOwn(f,l)||z(_,l)||(H=M[0])&&d.hasOwn(H,l)||d.hasOwn(C,l)||d.hasOwn(K,l)||d.hasOwn(N.config.globalProperties,l)},defineProperty(i,l,f){return f.get!=null?i._.accessCache[l]=0:d.hasOwn(f,"value")&&this.set(i,l,f.value,null),Reflect.defineProperty(i,l,f)}},xe=d.extend({},ie,{get(i,l){if(l!==Symbol.unscopables)return ie.get(i,l,i)},has(i,l){var f=l[0]!=="_"&&!d.isGloballyWhitelisted(l);return f}}),nt=!0;function Yt(i){var l=mr(i),f=i.proxy,_=i.ctx;nt=!1,l.beforeCreate&&jn(l.beforeCreate,i,"bc");var{data:A,computed:C,methods:N,watch:M,provide:H,inject:ne,created:ve,beforeMount:Le,mounted:ue,beforeUpdate:ke,updated:Ye,activated:ft,deactivated:Qe,beforeDestroy:Re,beforeUnmount:me,destroyed:ye,unmounted:Fe,render:Ae,renderTracked:_t,renderTriggered:At,errorCaptured:Ke,serverPrefetch:Nt,expose:L,inheritAttrs:j,components:ae,directives:re,filters:oe}=l,$e=null;if(ne&&Tn(ne,_,$e,i.appContext.config.unwrapInjectedRef),N)for(var rt in N){var qe=N[rt];d.isFunction(qe)&&(_[rt]=qe.bind(f))}if(A){var Je=A.call(f,f);d.isObject(Je)&&(i.data=E.reactive(Je))}if(nt=!0,C){var Ue=function(hn){var mn=C[hn],ur=d.isFunction(mn)?mn.bind(f,f):d.isFunction(mn.get)?mn.get.bind(f,f):d.NOOP,ni=!d.isFunction(mn)&&d.isFunction(mn.set)?mn.set.bind(f):d.NOOP,Kt=ds({get:ur,set:ni});Object.defineProperty(_,hn,{enumerable:!0,configurable:!0,get:()=>Kt.value,set:rn=>Kt.value=rn})};for(var Vt in C)Ue(Vt)}if(M)for(var pt in M)xr(M[pt],_,f,pt);if(H){var kt=d.isFunction(H)?H.call(f):H;Reflect.ownKeys(kt).forEach(hn=>{In(hn,kt[hn])})}ve&&jn(ve,i,"c");function Rt(hn,mn){d.isArray(mn)?mn.forEach(ur=>hn(ur.bind(f))):mn&&hn(mn.bind(f))}if(Rt(Zn,Le),Rt(Xn,ue),Rt(Hn,ke),Rt(Qn,Ye),Rt(to,ft),Rt(bn,Qe),Rt(ko,Ke),Rt(no,_t),Rt(No,At),Rt(lr,me),Rt(ho,Fe),Rt(go,Nt),d.isArray(L))if(L.length){var xn=i.exposed||(i.exposed={});L.forEach(hn=>{Object.defineProperty(xn,hn,{get:()=>f[hn],set:mn=>f[hn]=mn})})}else i.exposed||(i.exposed={});Ae&&i.render===d.NOOP&&(i.render=Ae),j!=null&&(i.inheritAttrs=j),ae&&(i.components=ae),re&&(i.directives=re);var kn=i.appContext.config.globalProperties.$applyOptions;kn&&kn(l,i,f)}function Tn(i,l){var f=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1;d.isArray(i)&&(i=Yn(i));var _=function(C){var N=i[C],M=void 0;d.isObject(N)?"default"in N?M=Un(N.from||C,N.default,!0):M=Un(N.from||C):M=Un(N),E.isRef(M)&&f?Object.defineProperty(l,C,{enumerable:!0,configurable:!0,get:()=>M.value,set:H=>M.value=H}):l[C]=M};for(var A in i)_(A)}function jn(i,l,f){xt(d.isArray(i)?i.map(_=>_.bind(l.proxy)):i.bind(l.proxy),l,f)}function xr(i,l,f,_){var A=_.includes(".")?Fr(f,_):()=>f[_];if(d.isString(i)){var C=l[i];d.isFunction(C)&&sr(A,C)}else if(d.isFunction(i))sr(A,i.bind(f));else if(d.isObject(i))if(d.isArray(i))i.forEach(M=>xr(M,l,f,_));else{var N=d.isFunction(i.handler)?i.handler.bind(f):l[i.handler];d.isFunction(N)&&sr(A,N,i)}}function mr(i){var l=i.type,{mixins:f,extends:_}=l,{mixins:A,optionsCache:C,config:{optionMergeStrategies:N}}=i.appContext,M=C.get(l),H;return M?H=M:!A.length&&!f&&!_?H=l:(H={},A.length&&A.forEach(ne=>po(H,ne,N,!0)),po(H,l,N)),d.isObject(l)&&C.set(l,H),H}function po(i,l,f){var _=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1,{mixins:A,extends:C}=l;C&&po(i,C,f,!0),A&&A.forEach(H=>po(i,H,f,!0));for(var N in l)if(!(_&&N==="expose")){var M=vo[N]||f&&f[N];i[N]=M?M(i[N],l[N]):l[N]}return i}var vo={data:Jo,props:er,emits:er,methods:er,computed:er,beforeCreate:Bn,created:Bn,beforeMount:Bn,mounted:Bn,beforeUpdate:Bn,updated:Bn,beforeDestroy:Bn,beforeUnmount:Bn,destroyed:Bn,unmounted:Bn,activated:Bn,deactivated:Bn,errorCaptured:Bn,serverPrefetch:Bn,components:er,directives:er,watch:Si,provide:Jo,inject:mo};function Jo(i,l){return l?i?function(){return d.extend(d.isFunction(i)?i.call(this,this):i,d.isFunction(l)?l.call(this,this):l)}:l:i}function mo(i,l){return er(Yn(i),Yn(l))}function Yn(i){if(d.isArray(i)){for(var l={},f=0;f<i.length;f++)l[i[f]]=i[f];return l}return i}function Bn(i,l){return i?[...new Set([].concat(i,l))]:l}function er(i,l){return i?d.extend(d.extend(Object.create(null),i),l):l}function Si(i,l){if(!i)return l;if(!l)return i;var f=d.extend(Object.create(null),i);for(var _ in l)f[_]=Bn(i[_],l[_]);return f}function is(i,l,f){var _=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1,A={},C={};d.def(C,Rn,1),i.propsDefaults=Object.create(null),_r(i,l,A,C);for(var N in i.propsOptions[0])N in A||(A[N]=void 0);f?i.props=_?A:E.shallowReactive(A):i.type.props?i.props=A:i.props=C,i.attrs=C}function fa(i,l,f,_){var{props:A,attrs:C,vnode:{patchFlag:N}}=i,M=E.toRaw(A),[H]=i.propsOptions,ne=!1;if((_||N>0)&&!(N&16)){if(N&8)for(var ve=i.vnode.dynamicProps,Le=0;Le<ve.length;Le++){var ue=ve[Le];if(!On(i.emitsOptions,ue)){var ke=l[ue];if(H)if(d.hasOwn(C,ue))ke!==C[ue]&&(C[ue]=ke,ne=!0);else{var Ye=d.camelize(ue);A[Ye]=Pa(H,M,Ye,ke,i,!1)}else ke!==C[ue]&&(C[ue]=ke,ne=!0)}}}else{_r(i,l,A,C)&&(ne=!0);var ft;for(var Qe in M)(!l||!d.hasOwn(l,Qe)&&((ft=d.hyphenate(Qe))===Qe||!d.hasOwn(l,ft)))&&(H?f&&(f[Qe]!==void 0||f[ft]!==void 0)&&(A[Qe]=Pa(H,M,Qe,void 0,i,!0)):delete A[Qe]);if(C!==M)for(var Re in C)(!l||!d.hasOwn(l,Re)&&!0)&&(delete C[Re],ne=!0)}ne&&E.trigger(i,"set","$attrs")}function _r(i,l,f,_){var[A,C]=i.propsOptions,N=!1,M;if(l){for(var H in l)if(!d.isReservedProp(H)){var ne=l[H],ve=void 0;A&&d.hasOwn(A,ve=d.camelize(H))?!C||!C.includes(ve)?f[ve]=ne:(M||(M={}))[ve]=ne:On(i.emitsOptions,H)||(!(H in _)||ne!==_[H])&&(_[H]=ne,N=!0)}}if(C)for(var Le=E.toRaw(f),ue=M||d.EMPTY_OBJ,ke=0;ke<C.length;ke++){var Ye=C[ke];f[Ye]=Pa(A,Le,Ye,ue[Ye],i,!d.hasOwn(ue,Ye))}return N}function Pa(i,l,f,_,A,C){var N=i[f];if(N!=null){var M=d.hasOwn(N,"default");if(M&&_===void 0){var H=N.default;if(N.type!==Function&&d.isFunction(H)){var{propsDefaults:ne}=A;f in ne?_=ne[f]:(zn(A),_=ne[f]=H.call(null,l),Ci())}else _=H}N[0]&&(C&&!M?_=!1:N[1]&&(_===""||_===d.hyphenate(f))&&(_=!0))}return _}function $a(i,l){var f=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!1,_=l.propsCache,A=_.get(i);if(A)return A;var C=i.props,N={},M=[],H=!1;if(!d.isFunction(i)){var ne=ye=>{H=!0;var[Fe,Ae]=$a(ye,l,!0);d.extend(N,Fe),Ae&&M.push(...Ae)};!f&&l.mixins.length&&l.mixins.forEach(ne),i.extends&&ne(i.extends),i.mixins&&i.mixins.forEach(ne)}if(!C&&!H)return d.isObject(i)&&_.set(i,d.EMPTY_ARR),d.EMPTY_ARR;if(d.isArray(C))for(var ve=0;ve<C.length;ve++){var Le=d.camelize(C[ve]);Ua(Le)&&(N[Le]=d.EMPTY_OBJ)}else if(C)for(var ue in C){var ke=d.camelize(ue);if(Ua(ke)){var Ye=C[ue],ft=N[ke]=d.isArray(Ye)||d.isFunction(Ye)?{type:Ye}:Object.assign({},Ye);if(ft){var Qe=da(Boolean,ft.type),Re=da(String,ft.type);ft[0]=Qe>-1,ft[1]=Re<0||Qe<Re,(Qe>-1||d.hasOwn(ft,"default"))&&M.push(ke)}}}var me=[N,M];return d.isObject(i)&&_.set(i,me),me}function Ua(i){return i[0]!=="$"}function Ha(i){var l=i&&i.toString().match(/^\s*(function|class) (\w+)/);return l?l[2]:i===null?"null":""}function ja(i,l){return Ha(i)===Ha(l)}function da(i,l){return d.isArray(l)?l.findIndex(f=>ja(f,i)):d.isFunction(l)&&ja(l,i)?0:-1}var Ia=i=>i[0]==="_"||i==="$stable",Ln=i=>d.isArray(i)?i.map(Dn):[Dn(i)],Bo=(i,l,f)=>{if(l._n)return l;var _=Yo(function(){return Ln(l(...arguments))},f);return _._c=!1,_},Zo=(i,l,f)=>{var _=i._ctx;for(var A in i)if(!Ia(A)){var C=i[A];d.isFunction(C)?l[A]=Bo(A,C,_):C!=null&&function(){var N=Ln(C);l[A]=()=>N}()}},ji=(i,l)=>{var f=Ln(l);i.slots.default=()=>f},os=(i,l)=>{if(i.vnode.shapeFlag&32){var f=l._;f?(i.slots=E.toRaw(l),d.def(l,"_",f)):Zo(l,i.slots={})}else i.slots={},l&&ji(i,l);d.def(i.slots,Rn,1)},as=(i,l,f)=>{var{vnode:_,slots:A}=i,C=!0,N=d.EMPTY_OBJ;if(_.shapeFlag&32){var M=l._;M?f&&M===1?C=!1:(d.extend(A,l),!f&&M===1&&delete A._):(C=!l.$stable,Zo(l,A)),N=l}else l&&(ji(i,l),N={default:1});if(C)for(var H in A)!Ia(H)&&!(H in N)&&delete A[H]};function Lo(){return{app:null,config:{isNativeTag:d.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 ss=0;function io(i,l){return function(_){var A=arguments.length>1&&arguments[1]!==void 0?arguments[1]:null;d.isFunction(_)||(_=Object.assign({},_)),A!=null&&!d.isObject(A)&&(A=null);var C=Lo(),N=new Set,M=!1,H=C.app={_uid:ss++,_component:_,_props:A,_container:null,_context:C,_instance:null,version:dl,get config(){return C.config},set config(ne){},use(ne){for(var ve=arguments.length,Le=new Array(ve>1?ve-1:0),ue=1;ue<ve;ue++)Le[ue-1]=arguments[ue];return N.has(ne)||(ne&&d.isFunction(ne.install)?(N.add(ne),ne.install(H,...Le)):d.isFunction(ne)&&(N.add(ne),ne(H,...Le))),H},mixin(ne){return C.mixins.includes(ne)||C.mixins.push(ne),H},component(ne,ve){return ve?(C.components[ne]=ve,H):C.components[ne]},directive(ne,ve){return ve?(C.directives[ne]=ve,H):C.directives[ne]},mount(ne,ve,Le){if(!M){var ue=qt(_,A);return ue.appContext=C,ve&&l?l(ue,ne):i(ue,ne,Le),M=!0,H._container=ne,ne.__vue_app__=H,H._instance=ue.component,Li(ue.component)||ue.component.proxy}},unmount(){M&&(i(null,H._container),delete H._container.__vue_app__)},provide(ne,ve){return C.provides[ne]=ve,H}};return H}}function si(i,l,f,_){var A=arguments.length>4&&arguments[4]!==void 0?arguments[4]:!1;if(d.isArray(i)){i.forEach((ft,Qe)=>si(ft,l&&(d.isArray(l)?l[Qe]:l),f,_,A));return}if(!($r(_)&&!A)){var C=_.shapeFlag&4?Li(_.component)||_.component.proxy:_.el,N=A?null:C,{i:M,r:H}=i,ne=l&&l.r,ve=M.refs===d.EMPTY_OBJ?M.refs={}:M.refs,Le=M.setupState;if(ne!=null&&ne!==H&&(d.isString(ne)?(ve[ne]=null,d.hasOwn(Le,ne)&&(Le[ne]=null)):E.isRef(ne)&&(ne.value=null)),d.isFunction(H))en(H,M,12,[N,ve]);else{var ue=d.isString(H),ke=E.isRef(H);if(ue||ke){var Ye=()=>{if(i.f){var ft=ue?d.hasOwn(Le,H)?Le[H]:ve[H]:H.value;A?d.isArray(ft)&&d.remove(ft,C):d.isArray(ft)?ft.includes(C)||ft.push(C):ue?(ve[H]=[C],d.hasOwn(Le,H)&&(Le[H]=ve[H])):(H.value=[C],i.k&&(ve[i.k]=H.value))}else ue?(ve[H]=N,d.hasOwn(Le,H)&&(Le[H]=N)):ke&&(H.value=N,i.k&&(ve[i.k]=N))};N?(Ye.id=-1,or(Ye,f)):Ye()}}}}var wi=!1,zi=i=>/svg/.test(i.namespaceURI)&&i.tagName!=="foreignObject",li=i=>i.nodeType===8;function cr(i){var{mt:l,p:f,o:{patchProp:_,createText:A,nextSibling:C,parentNode:N,remove:M,insert:H,createComment:ne}}=i,ve=(Re,me)=>{if(!me.hasChildNodes()){f(null,Re,me),ot(),me._vnode=Re;return}wi=!1,Le(me.firstChild,Re,null,null,null),ot(),me._vnode=Re,wi&&console.error("Hydration completed but contains mismatches.")},Le=function(Re,me,ye,Fe,Ae){var _t=arguments.length>5&&arguments[5]!==void 0?arguments[5]:!1,At=li(Re)&&Re.data==="[",Ke=()=>ft(Re,me,ye,Fe,Ae,At),{type:Nt,ref:L,shapeFlag:j,patchFlag:ae}=me,re=Re.nodeType;me.el=Re,ae===-2&&(_t=!1,me.dynamicChildren=null);var oe=null;switch(Nt){case ce:re!==3?me.children===""?(H(me.el=A("",Re.parentNode),N(Re),Re),oe=Re):oe=Ke():(Re.data!==me.children&&(wi=!0,Re.data=me.children),oe=C(Re));break;case pe:re!==8||At?oe=Ke():oe=C(Re);break;case Pe:if(At&&(Re=C(Re),re=Re.nodeType),re===1||re===3){oe=Re;for(var $e=!me.children.length,rt=0;rt<me.staticCount;rt++)$e&&(me.children+=oe.nodeType===1?oe.outerHTML:oe.data),rt===me.staticCount-1&&(me.anchor=oe),oe=C(oe);return At?C(oe):oe}else Ke();break;case te:At?oe=Ye(Re,me,ye,Fe,Ae,_t):oe=Ke();break;default:if(j&1)re!==1||me.type.toLowerCase()!==Re.tagName.toLowerCase()?oe=Ke():oe=ue(Re,me,ye,Fe,Ae,_t);else if(j&6){me.slotScopeIds=Ae;var qe=N(Re);if(l(me,qe,null,ye,Fe,zi(qe),_t),oe=At?Qe(Re):C(Re),oe&&li(oe)&&oe.data==="teleport end"&&(oe=C(oe)),$r(me)){var Je;At?(Je=qt(te),Je.anchor=oe?oe.previousSibling:qe.lastChild):Je=Re.nodeType===3?Gi(""):qt("div"),Je.el=Re,me.component.subTree=Je}}else j&64?re!==8?oe=Ke():oe=me.type.hydrate(Re,me,ye,Fe,Ae,_t,i,ke):j&128&&(oe=me.type.hydrate(Re,me,ye,Fe,zi(N(Re)),Ae,_t,i,Le))}return L!=null&&si(L,null,Fe,me),oe},ue=(Re,me,ye,Fe,Ae,_t)=>{_t=_t||!!me.dynamicChildren;var{type:At,props:Ke,patchFlag:Nt,shapeFlag:L,dirs:j}=me,ae=At==="input"&&j||At==="option";if(ae||Nt!==-1){if(j&&Rr(me,null,ye,"created"),Ke)if(ae||!_t||Nt&(16|32))for(var re in Ke)(ae&&re.endsWith("value")||d.isOn(re)&&!d.isReservedProp(re))&&_(Re,re,null,Ke[re],!1,void 0,ye);else Ke.onClick&&_(Re,"onClick",null,Ke.onClick,!1,void 0,ye);var oe;if((oe=Ke&&Ke.onVnodeBeforeMount)&&zr(oe,ye,me),j&&Rr(me,null,ye,"beforeMount"),((oe=Ke&&Ke.onVnodeMounted)||j)&&Jn(()=>{oe&&zr(oe,ye,me),j&&Rr(me,null,ye,"mounted")},Fe),L&16&&!(Ke&&(Ke.innerHTML||Ke.textContent)))for(var $e=ke(Re.firstChild,me,Re,ye,Fe,Ae,_t);$e;){wi=!0;var rt=$e;$e=$e.nextSibling,M(rt)}else L&8&&Re.textContent!==me.children&&(wi=!0,Re.textContent=me.children)}return Re.nextSibling},ke=(Re,me,ye,Fe,Ae,_t,At)=>{At=At||!!me.dynamicChildren;for(var Ke=me.children,Nt=Ke.length,L=0;L<Nt;L++){var j=At?Ke[L]:Ke[L]=Dn(Ke[L]);if(Re)Re=Le(Re,j,Fe,Ae,_t,At);else{if(j.type===ce&&!j.children)continue;wi=!0,f(null,j,ye,null,Fe,Ae,zi(ye),_t)}}return Re},Ye=(Re,me,ye,Fe,Ae,_t)=>{var{slotScopeIds:At}=me;At&&(Ae=Ae?Ae.concat(At):At);var Ke=N(Re),Nt=ke(C(Re),me,Ke,ye,Fe,Ae,_t);return Nt&&li(Nt)&&Nt.data==="]"?C(me.anchor=Nt):(wi=!0,H(me.anchor=ne("]",Ke),Ke,Nt),Nt)},ft=(Re,me,ye,Fe,Ae,_t)=>{if(wi=!0,me.el=null,_t)for(var At=Qe(Re);;){var Ke=C(Re);if(Ke&&Ke!==At)M(Ke);else break}var Nt=C(Re),L=N(Re);return M(Re),f(null,me,L,Nt,ye,Fe,zi(L),Ae),Nt},Qe=Re=>{for(var me=0;Re;)if(Re=C(Re),Re&&li(Re)&&(Re.data==="["&&me++,Re.data==="]")){if(me===0)return C(Re);me--}return Re};return[ve,Le]}var or=Jn;function za(i){return Wi(i)}function Wa(i){return Wi(i,cr)}function Wi(i,l){var f=d.getGlobalThis();f.__VUE__=!0;var{insert:_,remove:A,patchProp:C,forcePatchProp:N,createElement:M,createText:H,createComment:ne,setText:ve,setElementText:Le,parentNode:ue,nextSibling:ke,setScopeId:Ye=d.NOOP,insertStaticContent:ft}=i,Qe=function(q,ee,be){var Me=arguments.length>3&&arguments[3]!==void 0?arguments[3]:null,De=arguments.length>4&&arguments[4]!==void 0?arguments[4]:null,Ze=arguments.length>5&&arguments[5]!==void 0?arguments[5]:null,vt=arguments.length>6&&arguments[6]!==void 0?arguments[6]:!1,et=arguments.length>7&&arguments[7]!==void 0?arguments[7]:null,tt=arguments.length>8&&arguments[8]!==void 0?arguments[8]:!!ee.dynamicChildren;if(q!==ee){q&&!ht(q,ee)&&(Me=ur(q),Rt(q,De,Ze,!0),q=null),ee.patchFlag===-2&&(tt=!1,ee.dynamicChildren=null);var{type:He,ref:Ht,shapeFlag:Dt}=ee;switch(He){case ce:Re(q,ee,be,Me);break;case pe:me(q,ee,be,Me);break;case Pe:q==null&&ye(ee,be,Me,vt);break;case te:re(q,ee,be,Me,De,Ze,vt,et,tt);break;default:Dt&1?_t(q,ee,be,Me,De,Ze,vt,et,tt):Dt&6?oe(q,ee,be,Me,De,Ze,vt,et,tt):(Dt&64||Dt&128)&&He.process(q,ee,be,Me,De,Ze,vt,et,tt,Kt)}Ht!=null&&De&&si(Ht,q&&q.ref,Ze,ee||q,!ee)}},Re=(q,ee,be,Me)=>{if(q==null)_(ee.el=H(ee.children,be),be,Me);else{var De=ee.el=q.el;ee.children!==q.children&&ve(De,ee.children)}},me=(q,ee,be,Me)=>{q==null?_(ee.el=ne(ee.children||"",be),be,Me):ee.el=q.el},ye=(q,ee,be,Me)=>{[q.el,q.anchor]=ft(q.children,ee,be,Me,q.el,q.anchor)},Fe=(q,ee,be)=>{for(var{el:Me,anchor:De}=q,Ze;Me&&Me!==De;)Ze=ke(Me),_(Me,ee,be),Me=Ze;_(De,ee,be)},Ae=q=>{for(var{el:ee,anchor:be}=q,Me;ee&&ee!==be;)Me=ke(ee),A(ee),ee=Me;A(be)},_t=(q,ee,be,Me,De,Ze,vt,et,tt)=>{vt=vt||ee.type==="svg",q==null?At(ee,be,Me,De,Ze,vt,et,tt):L(q,ee,De,Ze,vt,et,tt)},At=(q,ee,be,Me,De,Ze,vt,et)=>{var tt,He,{type:Ht,props:Dt,shapeFlag:zt,transition:wn,dirs:Gr}=q;if(tt=q.el=M(q.type,ee),zt&8?Le(tt,q.children):zt&16&&Nt(q.children,tt,null,Me,De,Ze&&Ht!=="foreignObject",vt,et),Gr&&Rr(q,null,Me,"created"),Ke(tt,q,q.scopeId,vt,Me),Dt){for(var qn in Dt)qn!=="value"&&!d.isReservedProp(qn)&&C(tt,qn,null,Dt[qn],Ze,q.children,Me,De,mn);"value"in Dt&&C(tt,"value",null,Dt.value),(He=Dt.onVnodeBeforeMount)&&zr(He,Me,q)}Object.defineProperty(tt,"__vueParentComponent",{value:Me,enumerable:!1}),Gr&&Rr(q,null,Me,"beforeMount");var ui=(!De||De&&!De.pendingBranch)&&wn&&!wn.persisted;ui&&wn.beforeEnter(tt),_(tt,ee,be),((He=Dt&&Dt.onVnodeMounted)||ui||Gr)&&or(()=>{He&&zr(He,Me,q),ui&&wn.enter(tt),Gr&&Rr(q,null,Me,"mounted")},De)},Ke=(q,ee,be,Me,De)=>{if(be&&Ye(q,be),Me)for(var Ze=0;Ze<Me.length;Ze++)Ye(q,Me[Ze]);if(De){var vt=De.subTree;if(ee===vt){var et=De.vnode;Ke(q,et,et.scopeId,et.slotScopeIds,De.parent)}}},Nt=function(q,ee,be,Me,De,Ze,vt,et){for(var tt=arguments.length>8&&arguments[8]!==void 0?arguments[8]:0,He=tt;He<q.length;He++){var Ht=q[He]=et?Ir(q[He]):Dn(q[He]);Qe(null,Ht,ee,be,Me,De,Ze,vt,et)}},L=(q,ee,be,Me,De,Ze,vt)=>{var et=ee.el=q.el,{patchFlag:tt,dynamicChildren:He,dirs:Ht}=ee;tt|=q.patchFlag&16;var Dt=q.props||d.EMPTY_OBJ,zt=ee.props||d.EMPTY_OBJ,wn;be&&oo(be,!1),(wn=zt.onVnodeBeforeUpdate)&&zr(wn,be,ee,q),Ht&&Rr(ee,q,be,"beforeUpdate"),be&&oo(be,!0);var Gr=De&&ee.type!=="foreignObject";if(He?j(q.dynamicChildren,He,et,be,Me,Gr,Ze):vt||Ue(q,ee,et,null,be,Me,Gr,Ze,!1),tt>0){if(tt&16)ae(et,ee,Dt,zt,be,Me,De);else if(tt&2&&Dt.class!==zt.class&&C(et,"class",null,zt.class,De),tt&4&&C(et,"style",Dt.style,zt.style,De),tt&8)for(var qn=ee.dynamicProps,ui=0;ui<qn.length;ui++){var Uo=qn[ui],es=Dt[Uo],Cs=zt[Uo];(Cs!==es||Uo==="value"||N&&N(et,Uo))&&C(et,Uo,es,Cs,De,q.children,be,Me,mn)}tt&1&&q.children!==ee.children&&Le(et,ee.children)}else!vt&&He==null&&ae(et,ee,Dt,zt,be,Me,De);((wn=zt.onVnodeUpdated)||Ht)&&or(()=>{wn&&zr(wn,be,ee,q),Ht&&Rr(ee,q,be,"updated")},Me)},j=(q,ee,be,Me,De,Ze,vt)=>{for(var et=0;et<ee.length;et++){var tt=q[et],He=ee[et],Ht=tt.el&&(tt.type===te||!ht(tt,He)||tt.shapeFlag&(6|64))?ue(tt.el):be;Qe(tt,He,Ht,null,Me,De,Ze,vt,!0)}},ae=(q,ee,be,Me,De,Ze,vt)=>{if(be!==Me){if(be!==d.EMPTY_OBJ)for(var et in be)!d.isReservedProp(et)&&!(et in Me)&&C(q,et,be[et],null,vt,ee.children,De,Ze,mn);for(var tt in Me)if(!d.isReservedProp(tt)){var He=Me[tt],Ht=be[tt];(He!==Ht&&tt!=="value"||N&&N(q,tt))&&C(q,tt,Ht,He,vt,ee.children,De,Ze,mn)}"value"in Me&&C(q,"value",be.value,Me.value)}},re=(q,ee,be,Me,De,Ze,vt,et,tt)=>{var He=ee.el=q?q.el:H("",be),Ht=ee.anchor=q?q.anchor:H("",be),{patchFlag:Dt,dynamicChildren:zt,slotScopeIds:wn}=ee;wn&&(et=et?et.concat(wn):wn),q==null?(_(He,be,Me),_(Ht,be,Me),Nt(ee.children,be,Ht,De,Ze,vt,et,tt)):Dt>0&&Dt&64&&zt&&q.dynamicChildren?(j(q.dynamicChildren,zt,be,De,Ze,vt,et),(ee.key!=null||De&&ee===De.subTree)&&ao(q,ee,!0)):Ue(q,ee,be,Ht,De,Ze,vt,et,tt)},oe=(q,ee,be,Me,De,Ze,vt,et,tt)=>{ee.slotScopeIds=et,q==null?ee.shapeFlag&512?De.ctx.activate(ee,be,Me,vt,tt):$e(ee,be,Me,De,Ze,vt,tt):rt(q,ee,tt)},$e=(q,ee,be,Me,De,Ze,vt)=>{var et=q.component=nn(q,Me,De);if(ki(q)&&(et.ctx.renderer=Kt),Ya(et),et.asyncDep){if(De&&De.registerDep(et,qe),!q.el){var tt=et.subTree=qt(pe);me(null,tt,ee,be)}return}if(qe(et,q,ee,be,De,Ze,vt),et.$wxsModules){var He=B.resolveOwnerEl(et,!0);He.length&&He.forEach(Ht=>{Ht.setAttribute(B.ATTR_V_OWNER_ID,et.uid);var{$renderjsModules:Dt}=et.type;Dt&&Ht.setAttribute(B.ATTR_V_RENDERJS,Dt)})}},rt=(q,ee,be)=>{var Me=ee.component=q.component;if(To(q,ee,be))if(Me.asyncDep&&!Me.asyncResolved){Je(Me,ee,be);return}else Me.next=ee,mi(Me.update),Me.update();else ee.el=q.el,Me.vnode=ee},qe=(q,ee,be,Me,De,Ze,vt)=>{var et=()=>{if(q.isMounted){var{next:tr,bu:La,u:As,parent:qi,vnode:Ho}=q,co=tr,ba;oo(q,!1),tr?(tr.el=Ho.el,Je(q,tr,vt)):tr=Ho,La&&d.invokeArrayFns(La),(ba=tr.props&&tr.props.onVnodeBeforeUpdate)&&zr(ba,qi,tr,Ho),oo(q,!0);var ts=Ji(q),aa=q.subTree;q.subTree=ts,Qe(aa,ts,ue(aa.el),ur(aa),q,De,Ze),tr.el=ts.el,co===null&&ii(q,ts.el),As&&or(As,De),(ba=tr.props&&tr.props.onVnodeUpdated)&&or(()=>zr(ba,qi,tr,Ho),De)}else{var Ht,{el:Dt,props:zt}=ee,{bm:wn,m:Gr,parent:qn}=q,ui=$r(ee);if(oo(q,!1),wn&&d.invokeArrayFns(wn),!ui&&(Ht=zt&&zt.onVnodeBeforeMount)&&zr(Ht,qn,ee),oo(q,!0),Dt&&lo){var Uo=()=>{q.subTree=Ji(q),lo(Dt,q.subTree,q,De,null)};ui?ee.type.__asyncLoader().then(()=>!q.isUnmounted&&Uo()):Uo()}else{var es=q.subTree=Ji(q);Qe(null,es,be,Me,q,De,Ze),ee.el=es.el}if(Gr&&or(Gr,De),!ui&&(Ht=zt&&zt.onVnodeMounted)){var Cs=ee;or(()=>zr(Ht,qn,Cs),De)}(ee.shapeFlag&256||qn&&$r(qn.vnode)&&qn.vnode.shapeFlag&256)&&q.a&&or(q.a,De),q.isMounted=!0,ee=be=Me=null}},tt=q.effect=new E.ReactiveEffect(et,()=>wr(He),q.scope),He=q.update=()=>tt.run();He.id=q.uid,oo(q,!0),He()},Je=(q,ee,be)=>{ee.component=q;var Me=q.vnode.props;q.vnode=ee,q.next=null,fa(q,ee.props,Me,be),as(q,ee.children,be),E.pauseTracking(),Ve(),E.resetTracking()},Ue=function(q,ee,be,Me,De,Ze,vt,et){var tt=arguments.length>8&&arguments[8]!==void 0?arguments[8]:!1,He=q&&q.children,Ht=q?q.shapeFlag:0,Dt=ee.children,{patchFlag:zt,shapeFlag:wn}=ee;if(zt>0){if(zt&128){pt(He,Dt,be,Me,De,Ze,vt,et,tt);return}else if(zt&256){Vt(He,Dt,be,Me,De,Ze,vt,et,tt);return}}wn&8?(Ht&16&&mn(He,De,Ze),Dt!==He&&Le(be,Dt)):Ht&16?wn&16?pt(He,Dt,be,Me,De,Ze,vt,et,tt):mn(He,De,Ze,!0):(Ht&8&&Le(be,""),wn&16&&Nt(Dt,be,Me,De,Ze,vt,et,tt))},Vt=(q,ee,be,Me,De,Ze,vt,et,tt)=>{q=q||d.EMPTY_ARR,ee=ee||d.EMPTY_ARR;var He=q.length,Ht=ee.length,Dt=Math.min(He,Ht),zt;for(zt=0;zt<Dt;zt++){var wn=ee[zt]=tt?Ir(ee[zt]):Dn(ee[zt]);Qe(q[zt],wn,be,null,De,Ze,vt,et,tt)}He>Ht?mn(q,De,Ze,!0,!1,Dt):Nt(ee,be,Me,De,Ze,vt,et,tt,Dt)},pt=(q,ee,be,Me,De,Ze,vt,et,tt)=>{for(var He=0,Ht=ee.length,Dt=q.length-1,zt=Ht-1;He<=Dt&&He<=zt;){var wn=q[He],Gr=ee[He]=tt?Ir(ee[He]):Dn(ee[He]);if(ht(wn,Gr))Qe(wn,Gr,be,null,De,Ze,vt,et,tt);else break;He++}for(;He<=Dt&&He<=zt;){var qn=q[Dt],ui=ee[zt]=tt?Ir(ee[zt]):Dn(ee[zt]);if(ht(qn,ui))Qe(qn,ui,be,null,De,Ze,vt,et,tt);else break;Dt--,zt--}if(He>Dt){if(He<=zt)for(var Uo=zt+1,es=Uo<Ht?ee[Uo].el:Me;He<=zt;)Qe(null,ee[He]=tt?Ir(ee[He]):Dn(ee[He]),be,es,De,Ze,vt,et,tt),He++}else if(He>zt)for(;He<=Dt;)Rt(q[He],De,Ze,!0),He++;else{var Cs=He,tr=He,La=new Map;for(He=tr;He<=zt;He++){var As=ee[He]=tt?Ir(ee[He]):Dn(ee[He]);As.key!=null&&La.set(As.key,He)}var qi,Ho=0,co=zt-tr+1,ba=!1,ts=0,aa=new Array(co);for(He=0;He<co;He++)aa[He]=0;for(He=Cs;He<=Dt;He++){var sa=q[He];if(Ho>=co){Rt(sa,De,Ze,!0);continue}var jo=void 0;if(sa.key!=null)jo=La.get(sa.key);else for(qi=tr;qi<=zt;qi++)if(aa[qi-tr]===0&&ht(sa,ee[qi])){jo=qi;break}jo===void 0?Rt(sa,De,Ze,!0):(aa[jo-tr]=He+1,jo>=ts?ts=jo:ba=!0,Qe(sa,ee[jo],be,null,De,Ze,vt,et,tt),Ho++)}var bl=ba?ls(aa):d.EMPTY_ARR;for(qi=bl.length-1,He=co-1;He>=0;He--){var Ys=tr+He,Ec=ee[Ys],Wl=Ys+1<Ht?ee[Ys+1].el:Me;aa[He]===0?Qe(null,Ec,be,Wl,De,Ze,vt,et,tt):ba&&(qi<0||He!==bl[qi]?kt(Ec,be,Wl,2):qi--)}}},kt=function(q,ee,be,Me){var De=arguments.length>4&&arguments[4]!==void 0?arguments[4]:null,{el:Ze,type:vt,transition:et,children:tt,shapeFlag:He}=q;if(He&6){kt(q.component.subTree,ee,be,Me);return}if(He&128){q.suspense.move(ee,be,Me);return}if(He&64){vt.move(q,ee,be,Kt);return}if(vt===te){_(Ze,ee,be);for(var Ht=0;Ht<tt.length;Ht++)kt(tt[Ht],ee,be,Me);_(q.anchor,ee,be);return}if(vt===Pe){Fe(q,ee,be);return}var Dt=Me!==2&&He&1&&et;if(Dt)if(Me===0)et.beforeEnter(Ze),_(Ze,ee,be),or(()=>et.enter(Ze),De);else{var{leave:zt,delayLeave:wn,afterLeave:Gr}=et,qn=()=>_(Ze,ee,be),ui=()=>{zt(Ze,()=>{qn(),Gr&&Gr()})};wn?wn(Ze,qn,ui):ui()}else _(Ze,ee,be)},Rt=function(q,ee,be){var Me=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1,De=arguments.length>4&&arguments[4]!==void 0?arguments[4]:!1,{type:Ze,props:vt,ref:et,children:tt,dynamicChildren:He,shapeFlag:Ht,patchFlag:Dt,dirs:zt}=q;if(et!=null&&si(et,null,be,q,!0),Ht&256){ee.ctx.deactivate(q);return}var wn=Ht&1&&zt,Gr=!$r(q),qn;if(Gr&&(qn=vt&&vt.onVnodeBeforeUnmount)&&zr(qn,ee,q),Ht&6)hn(q.component,be,Me);else{if(Ht&128){q.suspense.unmount(be,Me);return}wn&&Rr(q,null,ee,"beforeUnmount"),Ht&64?q.type.remove(q,ee,be,De,Kt,Me):He&&(Ze!==te||Dt>0&&Dt&64)?mn(He,ee,be,!1,!0):(Ze===te&&Dt&(128|256)||!De&&Ht&16)&&mn(tt,ee,be),Me&&xn(q)}(Gr&&(qn=vt&&vt.onVnodeUnmounted)||wn)&&or(()=>{qn&&zr(qn,ee,q),wn&&Rr(q,null,ee,"unmounted")},be)},xn=q=>{var{type:ee,el:be,anchor:Me,transition:De}=q;if(ee===te){kn(be,Me);return}if(ee===Pe){Ae(q);return}var Ze=()=>{A(be),De&&!De.persisted&&De.afterLeave&&De.afterLeave()};if(q.shapeFlag&1&&De&&!De.persisted){var{leave:vt,delayLeave:et}=De,tt=()=>vt(be,Ze);et?et(q.el,Ze,tt):tt()}else Ze()},kn=(q,ee)=>{for(var be;q!==ee;)be=ke(q),A(q),q=be;A(ee)},hn=(q,ee,be)=>{var{bum:Me,scope:De,update:Ze,subTree:vt,um:et}=q;Me&&d.invokeArrayFns(Me),De.stop(),Ze&&(Ze.active=!1,Rt(vt,q,ee,be)),et&&or(et,ee),or(()=>{q.isUnmounted=!0},ee),ee&&ee.pendingBranch&&!ee.isUnmounted&&q.asyncDep&&!q.asyncResolved&&q.suspenseId===ee.pendingId&&(ee.deps--,ee.deps===0&&ee.resolve())},mn=function(q,ee,be){for(var Me=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1,De=arguments.length>4&&arguments[4]!==void 0?arguments[4]:!1,Ze=arguments.length>5&&arguments[5]!==void 0?arguments[5]:0,vt=Ze;vt<q.length;vt++)Rt(q[vt],ee,be,Me,De)},ur=q=>q.shapeFlag&6?ur(q.component.subTree):q.shapeFlag&128?q.suspense.next():ke(q.anchor||q.el),ni=(q,ee,be)=>{q==null?ee._vnode&&Rt(ee._vnode,null,null,!0):Qe(ee._vnode||null,q,ee,null,null,null,be),Ve(),ot(),ee._vnode=q},Kt={p:Qe,um:Rt,m:kt,r:xn,mt:$e,mc:Nt,pc:Ue,pbc:j,n:ur,o:i},rn,lo;return l&&([rn,lo]=l(Kt)),{render:ni,hydrate:rn,createApp:io(ni,rn)}}function oo(i,l){var{effect:f,update:_}=i;f.allowRecurse=_.allowRecurse=l}function ao(i,l){var f=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!1,_=i.children,A=l.children;if(d.isArray(_)&&d.isArray(A))for(var C=0;C<_.length;C++){var N=_[C],M=A[C];M.shapeFlag&1&&!M.dynamicChildren&&((M.patchFlag<=0||M.patchFlag===32)&&(M=A[C]=Ir(A[C]),M.el=N.el),f||ao(N,M)),M.type===ce&&(M.el=N.el)}}function ls(i){var l=i.slice(),f=[0],_,A,C,N,M,H=i.length;for(_=0;_<H;_++){var ne=i[_];if(ne!==0){if(A=f[f.length-1],i[A]<ne){l[_]=A,f.push(_);continue}for(C=0,N=f.length-1;C<N;)M=C+N>>1,i[f[M]]<ne?C=M+1:N=M;ne<i[f[C]]&&(C>0&&(l[_]=f[C-1]),f[C]=_)}}for(C=f.length,N=f[C-1];C-- >0;)f[C]=N,N=l[N];return f}var ha=i=>i.__isTeleport,Mo=i=>i&&(i.disabled||i.disabled===""),ga=i=>typeof SVGElement!="undefined"&&i instanceof SVGElement,m=(i,l)=>{var f=i&&i.to;if(d.isString(f))if(l){var _=l(f);return _}else return null;else return f},R={__isTeleport:!0,process(i,l,f,_,A,C,N,M,H,ne){var{mc:ve,pc:Le,pbc:ue,o:{insert:ke,querySelector:Ye,createText:ft,createComment:Qe}}=ne,Re=Mo(l.props),{shapeFlag:me,children:ye,dynamicChildren:Fe}=l;if(i==null){var Ae=l.el=ft("",f),_t=l.anchor=ft("",f);ke(Ae,f,_),ke(_t,f,_);var At=l.target=m(l.props,Ye),Ke=l.targetAnchor=ft("",f);At&&(ke(Ke,At),N=N||ga(At));var Nt=(qe,Je)=>{me&16&&ve(ye,qe,Je,A,C,N,M,H)};Re?Nt(f,_t):At&&Nt(At,Ke)}else{l.el=i.el;var L=l.anchor=i.anchor,j=l.target=i.target,ae=l.targetAnchor=i.targetAnchor,re=Mo(i.props),oe=re?f:j,$e=re?L:ae;if(N=N||ga(j),Fe?(ue(i.dynamicChildren,Fe,oe,A,C,N,M),ao(i,l,!0)):H||Le(i,l,oe,$e,A,C,N,M,!1),Re)re||U(l,f,L,ne,1);else if((l.props&&l.props.to)!==(i.props&&i.props.to)){var rt=l.target=m(l.props,Ye);rt&&U(l,rt,null,ne,0)}else re&&U(l,j,ae,ne,1)}J(l)},remove(i,l,f,_,A,C){var{um:N,o:{remove:M}}=A,{shapeFlag:H,children:ne,anchor:ve,targetAnchor:Le,target:ue,props:ke}=i;if(ue&&M(Le),(C||!Mo(ke))&&(M(ve),H&16))for(var Ye=0;Ye<ne.length;Ye++){var ft=ne[Ye];N(ft,l,f,!0,!!ft.dynamicChildren)}},move:U,hydrate:$};function U(i,l,f,_){var{o:{insert:A},m:C}=_,N=arguments.length>4&&arguments[4]!==void 0?arguments[4]:2;N===0&&A(i.targetAnchor,l,f);var{el:M,anchor:H,shapeFlag:ne,children:ve,props:Le}=i,ue=N===2;if(ue&&A(M,l,f),(!ue||Mo(Le))&&ne&16)for(var ke=0;ke<ve.length;ke++)C(ve[ke],l,f,2);ue&&A(H,l,f)}function $(i,l,f,_,A,C,N,M){var{o:{nextSibling:H,parentNode:ne,querySelector:ve}}=N,Le=l.target=m(l.props,ve);if(Le){var ue=Le._lpa||Le.firstChild;if(l.shapeFlag&16)if(Mo(l.props))l.anchor=M(H(i),l,ne(i),f,_,A,C),l.targetAnchor=ue;else{l.anchor=H(i);for(var ke=ue;ke;)if(ke=H(ke),ke&&ke.nodeType===8&&ke.data==="teleport anchor"){l.targetAnchor=ke,Le._lpa=l.targetAnchor&&H(l.targetAnchor);break}M(ue,l,Le,f,_,A,C)}J(l)}return l.anchor&&H(l.anchor)}var X=R;function J(i){var l=i.ctx;if(l&&l.ut){for(var f=i.children[0].el;f!==i.targetAnchor;)f.nodeType===1&&f.setAttribute("data-v-owner",l.uid),f=f.nextSibling;l.ut()}}var te=Symbol(void 0),ce=Symbol(void 0),pe=Symbol(void 0),Pe=Symbol(void 0),fe=[],we=null;function ct(){var i=arguments.length>0&&arguments[0]!==void 0?arguments[0]:!1;fe.push(we=i?null:[])}function gt(){fe.pop(),we=fe[fe.length-1]||null}var $t=1;function Et(i){$t+=i}function je(i){return i.dynamicChildren=$t>0?we||d.EMPTY_ARR:null,gt(),$t>0&&we&&we.push(i),i}function Bt(i,l,f,_,A,C){return je(Ft(i,l,f,_,A,C,!0))}function cn(i,l,f,_,A){return je(qt(i,l,f,_,A,!0))}function Wt(i){return i?i.__v_isVNode===!0:!1}function ht(i,l){return i.type===l.type&&i.key===l.key}function Zt(i){}var Rn="__vInternal",Gt=i=>{var{key:l}=i;return l!=null?l:null},Ut=i=>{var{ref:l,ref_key:f,ref_for:_}=i;return l!=null?d.isString(l)||E.isRef(l)||d.isFunction(l)?{i:dn,r:l,k:f,f:!!_}:l:null};function Ft(i){var l=arguments.length>1&&arguments[1]!==void 0?arguments[1]:null,f=arguments.length>2&&arguments[2]!==void 0?arguments[2]:null,_=arguments.length>3&&arguments[3]!==void 0?arguments[3]:0,A=arguments.length>4&&arguments[4]!==void 0?arguments[4]:null,C=arguments.length>5&&arguments[5]!==void 0?arguments[5]:i===te?0:1,N=arguments.length>6&&arguments[6]!==void 0?arguments[6]:!1,M=arguments.length>7&&arguments[7]!==void 0?arguments[7]:!1,H={__v_isVNode:!0,__v_skip:!0,type:i,props:l,key:l&&Gt(l),ref:l&&Ut(l),scopeId:Tr,slotScopeIds:null,children:f,component:null,suspense:null,ssContent:null,ssFallback:null,dirs:null,transition:null,el:null,anchor:null,target:null,targetAnchor:null,staticCount:0,shapeFlag:C,patchFlag:_,dynamicProps:A,dynamicChildren:null,appContext:null,ctx:dn};return M?(Fn(H,f),C&128&&i.normalize(H)):f&&(H.shapeFlag|=d.isString(f)?8:16),$t>0&&!N&&we&&(H.patchFlag>0||C&6)&&H.patchFlag!==32&&we.push(H),H}var qt=Xo;function Xo(i){var l=arguments.length>1&&arguments[1]!==void 0?arguments[1]:null,f=arguments.length>2&&arguments[2]!==void 0?arguments[2]:null,_=arguments.length>3&&arguments[3]!==void 0?arguments[3]:0,A=arguments.length>4&&arguments[4]!==void 0?arguments[4]:null,C=arguments.length>5&&arguments[5]!==void 0?arguments[5]:!1;if((!i||i===Ui)&&(i=pe),Wt(i)){var N=ei(i,l,!0);return f&&Fn(N,f),$t>0&&!C&&we&&(N.shapeFlag&6?we[we.indexOf(i)]=N:we.push(N)),N.patchFlag|=-2,N}if(bo(i)&&(i=i.__vccOpts),l){l=ci(l);var{class:M,style:H}=l;M&&!d.isString(M)&&(l.class=d.normalizeClass(M)),d.isObject(H)&&(E.isProxy(H)&&!d.isArray(H)&&(H=d.extend({},H)),l.style=d.normalizeStyle(H))}var ne=d.isString(i)?1:qo(i)?128:ha(i)?64:d.isObject(i)?4:d.isFunction(i)?2:0;return Ft(i,l,f,_,A,ne,C,!0)}function ci(i){return i?E.isProxy(i)||Rn in i?d.extend({},i):i:null}function ei(i,l){var f=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!1,{props:_,ref:A,patchFlag:C,children:N}=i,M=l?br(_||{},l):_,H={__v_isVNode:!0,__v_skip:!0,type:i.type,props:M,key:M&&Gt(M),ref:l&&l.ref?f&&A?d.isArray(A)?A.concat(Ut(l)):[A,Ut(l)]:Ut(l):A,scopeId:i.scopeId,slotScopeIds:i.slotScopeIds,children:N,target:i.target,targetAnchor:i.targetAnchor,staticCount:i.staticCount,shapeFlag:i.shapeFlag,patchFlag:l&&i.type!==te?C===-1?16:C|16:C,dynamicProps:i.dynamicProps,dynamicChildren:i.dynamicChildren,appContext:i.appContext,dirs:i.dirs,transition:i.transition,component:i.component,suspense:i.suspense,ssContent:i.ssContent&&ei(i.ssContent),ssFallback:i.ssFallback&&ei(i.ssFallback),el:i.el,anchor:i.anchor,ctx:i.ctx,ce:i.ce};return H}function Gi(){var i=arguments.length>0&&arguments[0]!==void 0?arguments[0]:" ",l=arguments.length>1&&arguments[1]!==void 0?arguments[1]:0;return qt(ce,null,i,l)}function Ga(i,l){var f=qt(Pe,null,i);return f.staticCount=l,f}function Mn(){var i=arguments.length>0&&arguments[0]!==void 0?arguments[0]:"",l=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!1;return l?(ct(),cn(pe,null,i)):qt(pe,null,i)}function Dn(i){return i==null||typeof i=="boolean"?qt(pe):d.isArray(i)?qt(te,null,i.slice()):typeof i=="object"?Ir(i):qt(ce,null,String(i))}function Ir(i){return i.el===null&&i.patchFlag!==-1||i.memo?i:ei(i)}function Fn(i,l){var f=0,{shapeFlag:_}=i;if(l==null)l=null;else if(d.isArray(l))f=16;else if(typeof l=="object")if(_&(1|64)){var A=l.default;A&&(A._c&&(A._d=!1),Fn(i,A()),A._c&&(A._d=!0));return}else{f=32;var C=l._;!C&&!(Rn in l)?l._ctx=dn:C===3&&dn&&(dn.slots._===1?l._=1:(l._=2,i.patchFlag|=1024))}else d.isFunction(l)?(l={default:l,_ctx:dn},f=32):(l=String(l),_&64?(f=16,l=[Gi(l)]):f=8);i.children=l,i.shapeFlag|=f}function br(){for(var i={},l=0;l<arguments.length;l++){var f=l<0||arguments.length<=l?void 0:arguments[l];for(var _ in f)if(_==="class")i.class!==f.class&&(i.class=d.normalizeClass([i.class,f.class]));else if(_==="style")i.style=d.normalizeStyle([i.style,f.style]);else if(d.isOn(_)){var A=i[_],C=f[_];C&&A!==C&&!(d.isArray(A)&&A.includes(C))&&(i[_]=A?[].concat(A,C):C)}else _!==""&&(i[_]=f[_])}return i}function zr(i,l,f){var _=arguments.length>3&&arguments[3]!==void 0?arguments[3]:null;xt(i,l,7,[f,_])}var Qo=Lo(),cs=0;function nn(i,l,f){var _=i.type,A=(l?l.appContext:i.appContext)||Qo,C={uid:cs++,vnode:i,type:_,parent:l,appContext:A,root:null,next:null,subTree:null,effect:null,update:null,scope:new E.EffectScope(!0),render:null,proxy:null,exposed:null,exposeProxy:null,withProxy:null,provides:l?l.provides:Object.create(A.provides),accessCache:null,renderCache:[],components:null,directives:null,propsOptions:$a(_,A),emitsOptions:Or(_,A),emit:null,emitted:null,propsDefaults:d.EMPTY_OBJ,inheritAttrs:_.inheritAttrs,ctx:d.EMPTY_OBJ,data:d.EMPTY_OBJ,props:d.EMPTY_OBJ,attrs:d.EMPTY_OBJ,slots:d.EMPTY_OBJ,refs:d.EMPTY_OBJ,setupState:d.EMPTY_OBJ,setupContext:null,suspense:f,suspenseId:f?f.pendingId:0,asyncDep:null,asyncResolved:!1,isMounted:!1,isUnmounted:!1,isDeactivated:!1,bc:null,c:null,bm:null,m:null,bu:null,u:null,um:null,bum:null,da:null,a:null,rtg:null,rtc:null,ec:null,sp:null};return C.ctx={_:C},C.root=l?l.root:C,C.emit=Ar.bind(null,C),i.ce&&i.ce(C),C}var pn=null,Vn=()=>pn||dn,zn=i=>{pn=i,i.scope.on()},Ci=()=>{pn&&pn.scope.off(),pn=null};function us(i){return i.vnode.shapeFlag&4}S.isInSSRComponentSetup=!1;function Ya(i){var l=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!1;S.isInSSRComponentSetup=l;var{props:f,children:_}=i.vnode,A=us(i);is(i,f,A,l),os(i,_);var C=A?Na(i,l):void 0;return S.isInSSRComponentSetup=!1,C}function Na(i,l){var f=i.type;i.accessCache=Object.create(null),i.proxy=E.markRaw(new Proxy(i.ctx,ie));var{setup:_}=f;if(_){var A=i.setupContext=_.length>1?Do(i):null;zn(i),E.pauseTracking();var C=en(_,i,0,[i.props,A]);if(E.resetTracking(),Ci(),d.isPromise(C)){if(C.then(Ci,Ci),l)return C.then(N=>{ea(i,N,l)}).catch(N=>{I(N,i,0)});i.asyncDep=C}else ea(i,C,l)}else Ka(i,l)}function ea(i,l,f){d.isFunction(l)?i.type.__ssrInlineRender?i.ssrRender=l:i.render=l:d.isObject(l)&&(i.setupState=E.proxyRefs(l)),Ka(i,f)}var so,qa;function fs(i){so=i,qa=l=>{l.render._rc&&(l.withProxy=new Proxy(l.ctx,xe))}}var Wr=()=>!so;function Ka(i,l,f){var _=i.type;if(!i.render){if(!l&&so&&!_.render){var A=_.template||mr(i).template;if(A){var{isCustomElement:C,compilerOptions:N}=i.appContext.config,{delimiters:M,compilerOptions:H}=_,ne=d.extend(d.extend({isCustomElement:C,delimiters:M},N),H);_.render=so(A,ne)}}i.render=_.render||d.NOOP,qa&&qa(i)}zn(i),E.pauseTracking(),Yt(i),E.resetTracking(),Ci()}function Ja(i){return new Proxy(i.attrs,{get(l,f){return E.track(i,"get","$attrs"),l[f]}})}function Do(i){var l=_=>{i.exposed=_||{}},f;return{get attrs(){return f||(f=Ja(i))},slots:i.slots,emit:i.emit,expose:l}}function Li(i){if(i.exposed)return i.exposeProxy||(i.exposeProxy=new Proxy(E.proxyRefs(E.markRaw(i.exposed)),{get(l,f){if(f in l)return l[f];if(f in K)return K[f](i)},has(l,f){return f in l||f in K}}))}function _o(i){var l=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!0;return d.isFunction(i)?i.displayName||i.name:i.name||l&&i.__name}function bo(i){return d.isFunction(i)&&"__vccOpts"in i}var ds=(i,l)=>E.computed(i,l,S.isInSSRComponentSetup);function Fo(){return null}function Bs(){return null}function hs(i){}function Ls(i,l){return null}function Be(){return Ot().slots}function Pt(){return Ot().attrs}function Ot(){var i=Vn();return i.setupContext||(i.setupContext=Do(i))}function yn(i,l){var f=d.isArray(i)?i.reduce((C,N)=>(C[N]={},C),{}):i;for(var _ in l){var A=f[_];A?d.isArray(A)||d.isFunction(A)?f[_]={type:A,default:l[_]}:A.default=l[_]:A===null&&(f[_]={default:l[_]})}return f}function Er(i,l){var f={},_=function(C){l.includes(C)||Object.defineProperty(f,C,{enumerable:!0,get:()=>i[C]})};for(var A in i)_(A);return f}function Ai(i){var l=Vn(),f=i();return Ci(),d.isPromise(f)&&(f=f.catch(_=>{throw zn(l),_})),[f,()=>zn(l)]}function Yi(i,l,f){var _=arguments.length;return _===2?d.isObject(l)&&!d.isArray(l)?Wt(l)?qt(i,null,[l]):qt(i,l):qt(i,null,l):(_>3?f=Array.prototype.slice.call(arguments,2):_===3&&Wt(f)&&(f=[f]),qt(i,l,f))}var Eo=Symbol(""),ka=()=>{{var i=Un(Eo);return i}};function ta(){}function gs(i,l,f,_){var A=f[_];if(A&&ps(A,i))return A;var C=l();return C.memo=i.slice(),f[_]=C}function ps(i,l){var f=i.memo;if(f.length!=l.length)return!1;for(var _=0;_<f.length;_++)if(d.hasChanged(f[_],l[_]))return!1;return $t>0&&we&&we.push(i),!0}var dl="3.2.47",$l={createComponentInstance:nn,setupComponent:Ya,renderComponentRoot:Ji,setCurrentRenderingInstance:_i,isVNode:Wt,normalizeVNode:Dn},Ul=$l,pa=null,va=null;function na(i,l){return i==="input"?new B.UniInputElement(i,l):i==="textarea"?new B.UniTextAreaElement(i,l):new B.UniElement(i,l)}function ma(i,l){return new B.UniTextNode(i,l)}function Ra(i,l){return new B.UniCommentNode(i,l)}var vs,ra={insert:(i,l,f)=>{l.insertBefore(i,f||null)},remove:i=>{var l=i.parentNode;l&&l.removeChild(i)},createElement:(i,l)=>na(i,l),createText:(i,l)=>ma(i,l),createComment:(i,l)=>Ra(i,l),setText:(i,l)=>{i.nodeValue=l},setElementText:(i,l)=>{i.textContent=l},parentNode:i=>i.parentNode,nextSibling:i=>i.nextSibling,setScopeId(i,l){i.setAttribute(l,"")},cloneNode(i){var l=i.cloneNode(!0);return"_value"in i&&(l._value=i._value),l},insertStaticContent(i,l,f){var _=vs||(vs=na("div"));_.innerHTML=i;for(var A=_.firstChild,C=A,N=C;C;)N=C,ra.insert(C,l,f),C=_.firstChild;return[A,N]}};function Ms(i,l){l==null&&(l=""),i.setAttribute("class",l)}function Hl(i,l,f){if(!f)i.removeAttribute("style");else if(d.isString(f))l!==f&&i.setAttribute("style",f);else{var _={},A=l&&!d.isString(l);if(A){for(var C in l)f[C]==null&&(_[C]="");for(var N in f){var M=f[N];M!==l[N]&&(_[N]=M)}}else for(var H in f)_[H]=f[H];Object.keys(_).length&&i.setAttribute("style",_)}}function ms(i,l,f){f==null?i.removeAttribute(l):i.setAttribute(l,f)}function Ds(i,l,f,_){i.addEventListener(l,f,_)}function Fs(i,l,f,_){i.removeEventListener(l,f,_)}function Vs(i,l,f,_){var A=arguments.length>4&&arguments[4]!==void 0?arguments[4]:null,C=i._vei||(i._vei={}),N=C[l];if(_&&N)N.value=_;else{var[M,H]=xa(l);if(_){var ne=C[l]=hl(_,A);Ds(i,M,ne,H)}else N&&(Fs(i,M,N,H),C[l]=void 0)}}var _s=/(?:Once|Passive|Capture)$/;function xa(i){var l;if(_s.test(i)){l={};for(var f;f=i.match(_s);)i=i.slice(0,i.length-f[0].length),l[f[0].toLowerCase()]=!0}return[d.hyphenate(i.slice(2)),l]}function hl(i,l){var f=A=>{xt(f.value,l,5,[A])};f.value=i;var _=new Set;return d.isArray(f.value)?f.value.forEach(A=>{A.modifiers&&A.modifiers.forEach(C=>{_.add(C)})}):(f.value.modifiers&&f.value.modifiers.forEach(A=>{_.add(A)}),$s(f,l)),f.modifiers=[..._],f}function $s(i,l){if(!!l){var{$wxsModules:f}=l;if(!!f){var _=i.value.toString();!f.find(A=>_.indexOf("."+A+".")>-1)||(i.wxsEvent=i.value())}}}var jl=function(i,l,f,_){var A=arguments.length>6?arguments[6]:void 0;switch(l){case"class":Ms(i,_);break;case"style":Hl(i,f,_);break;default:if(d.isOn(l))d.isModelListener(l)||Vs(i,l,f,_,A);else{if(d.isObject(_)){var C=f===_;if(_=B.JSON_PROTOCOL+JSON.stringify(_),C&&i.getAttribute(l)===_)return}else if(f===_)return;ms(i,l,_)}break}};function Vo(){var i=arguments.length>0&&arguments[0]!==void 0?arguments[0]:"$style";{var l=Vn();if(!l)return d.EMPTY_OBJ;var f=l.type.__cssModules;if(!f)return d.EMPTY_OBJ;var _=f[i];return _||d.EMPTY_OBJ}}function Za(i){var l=Vn();if(!!l){var f=()=>_a(l.subTree,i(l.proxy));Xn(()=>qr(f,{flush:"post"})),Qn(f)}}function _a(i,l){if(i.shapeFlag&128){var f=i.suspense;i=f.activeBranch,f.pendingBranch&&!f.isHydrating&&f.effects.push(()=>{_a(f.activeBranch,l)})}for(;i.component;)i=i.component.subTree;if(i.shapeFlag&1&&i.el)Ba(i.el,l);else if(i.type===te)i.children.forEach(C=>_a(C,l));else if(i.type===Pe)for(var{el:_,anchor:A}=i;_&&(Ba(_,l),_!==A);)_=_.nextSibling}function Ba(i,l){if(i.nodeType===1)for(var f in l)i.setAttribute("--".concat(f),l[f])}var yo="transition",ia="animation",Xa=(i,l)=>{var{slots:f}=l;return Yi(Mt,Hs(i),f)};Xa.displayName="Transition";var Us={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},gl=Xa.props=d.extend({},Mt.props,Us),$o=function(i){var l=arguments.length>1&&arguments[1]!==void 0?arguments[1]:[];d.isArray(i)?i.forEach(f=>f(...l)):i&&i(...l)},bs=i=>i?d.isArray(i)?i.some(l=>l.length>1):i.length>1:!1;function Hs(i){var l={};for(var f in i)f in Us||(l[f]=i[f]);if(i.css===!1)return l;var{name:_="v",type:A,duration:C,enterFromClass:N="".concat(_,"-enter-from"),enterActiveClass:M="".concat(_,"-enter-active"),enterToClass:H="".concat(_,"-enter-to"),appearFromClass:ne=N,appearActiveClass:ve=M,appearToClass:Le=H,leaveFromClass:ue="".concat(_,"-leave-from"),leaveActiveClass:ke="".concat(_,"-leave-active"),leaveToClass:Ye="".concat(_,"-leave-to")}=i,ft=Qa(C),Qe=ft&&ft[0],Re=ft&&ft[1],{onBeforeEnter:me,onEnter:ye,onEnterCancelled:Fe,onLeave:Ae,onLeaveCancelled:_t,onBeforeAppear:At=me,onAppear:Ke=ye,onAppearCancelled:Nt=Fe}=l,L=(re,oe,$e)=>{oa(re,oe?Le:H),oa(re,oe?ve:M),$e&&$e()},j=(re,oe)=>{oa(re,Ye),oa(re,ke),oe&&oe()},ae=re=>(oe,$e)=>{var rt=re?Ke:ye,qe=()=>L(oe,re,$e);$o(rt,[oe,qe]),pl(()=>{oa(oe,re?ne:N),Br(oe,re?Le:H),bs(rt)||js(oe,A,Qe,qe)})};return d.extend(l,{onBeforeEnter(re){$o(me,[re]),Br(re,N),Br(re,M)},onBeforeAppear(re){$o(At,[re]),Br(re,ne),Br(re,ve)},onEnter:ae(!1),onAppear:ae(!0),onLeave(re,oe){var $e=()=>j(re,oe);Br(re,ue),vl(),Br(re,ke),pl(()=>{oa(re,ue),Br(re,Ye),bs(Ae)||js(re,A,Re,$e)}),$o(Ae,[re,$e])},onEnterCancelled(re){L(re,!1),$o(Fe,[re])},onAppearCancelled(re){L(re,!0),$o(Nt,[re])},onLeaveCancelled(re){j(re),$o(_t,[re])}})}function Qa(i){if(i==null)return null;if(d.isObject(i))return[ti(i.enter),ti(i.leave)];var l=ti(i);return[l,l]}function ti(i){var l=d.toNumber(i);return l}function Br(i,l){l.split(/\s+/).forEach(f=>f&&i.classList.add(f)),(i._vtc||(i._vtc=new Set)).add(l)}function oa(i,l){l.split(/\s+/).forEach(_=>_&&i.classList.remove(_));var{_vtc:f}=i;f&&(f.delete(l),f.size||(i._vtc=void 0))}function pl(i){requestAnimationFrame(()=>{requestAnimationFrame(i)})}var zl=0;function js(i,l,f,_){var A=i._endId=++zl,C=()=>{A===i._endId&&_()};if(f)return setTimeout(C,f);var{type:N,timeout:M,propCount:H}=Es(i,l);if(!N)return _();var ne=N+"end",ve=0,Le=()=>{i.removeEventListener(ne,ue),C()},ue=ke=>{ke.target===i&&++ve>=H&&Le()};setTimeout(()=>{ve<H&&Le()},M+1),i.addEventListener(ne,ue)}function Es(i,l){var f=window.getComputedStyle(i),_=Ye=>(f[Ye]||"").split(", "),A=_(yo+"Delay"),C=_(yo+"Duration"),N=zs(A,C),M=_(ia+"Delay"),H=_(ia+"Duration"),ne=zs(M,H),ve=null,Le=0,ue=0;l===yo?N>0&&(ve=yo,Le=N,ue=C.length):l===ia?ne>0&&(ve=ia,Le=ne,ue=H.length):(Le=Math.max(N,ne),ve=Le>0?N>ne?yo:ia:null,ue=ve?ve===yo?C.length:H.length:0);var ke=ve===yo&&/\b(transform|all)(,|$)/.test(f[yo+"Property"]);return{type:ve,timeout:Le,propCount:ue,hasTransform:ke}}function zs(i,l){for(;i.length<l.length;)i=i.concat(i);return Math.max(...l.map((f,_)=>Ws(f)+Ws(i[_])))}function Ws(i){return Number(i.slice(0,-1).replace(",","."))*1e3}function vl(){return document.body.offsetHeight}var Gs=new WeakMap,ys=new WeakMap,Ss={name:"TransitionGroup",props:d.extend({},gl,{tag:String,moveClass:String}),setup(i,l){var{slots:f}=l,_=Vn(),A=gr(),C,N;return Qn(()=>{if(!!C.length){var M=i.moveClass||"".concat(i.name||"v","-move");if(!!v(C[0].el,_.vnode.el,M)){C.forEach(_l),C.forEach(a);var H=C.filter(u);vl(),H.forEach(ne=>{var ve=ne.el,Le=ve.style;Br(ve,M),Le.transform=Le.webkitTransform=Le.transitionDuration="";var ue=ve._moveCb=ke=>{ke&&ke.target!==ve||(!ke||/transform$/.test(ke.propertyName))&&(ve.removeEventListener("transitionend",ue),ve._moveCb=null,oa(ve,M))};ve.addEventListener("transitionend",ue)})}}}),()=>{var M=E.toRaw(i),H=Hs(M),ne=M.tag||te;C=N,N=f.default?Ni(f.default()):[];for(var ve=0;ve<N.length;ve++){var Le=N[ve];Le.key!=null&&Vr(Le,Zr(Le,H,A,_))}if(C)for(var ue=0;ue<C.length;ue++){var ke=C[ue];Vr(ke,Zr(ke,H,A,_)),Gs.set(ke,ke.el.getBoundingClientRect())}return qt(ne,null,N)}}},ws=i=>delete i.mode;Ss.props;var ml=Ss;function _l(i){var l=i.el;l._moveCb&&l._moveCb(),l._enterCb&&l._enterCb()}function a(i){ys.set(i,i.el.getBoundingClientRect())}function u(i){var l=Gs.get(i),f=ys.get(i),_=l.left-f.left,A=l.top-f.top;if(_||A){var C=i.el.style;return C.transform=C.webkitTransform="translate(".concat(_,"px,").concat(A,"px)"),C.transitionDuration="0s",i}}function v(i,l,f){var _=i.cloneNode();i._vtc&&i._vtc.forEach(N=>{N.split(/\s+/).forEach(M=>M&&_.classList.remove(M))}),f.split(/\s+/).forEach(N=>N&&_.classList.add(N)),_.style.display="none";var A=l.nodeType===1?l:l.parentNode;A.appendChild(_);var{hasTransform:C}=Es(_);return A.removeChild(_),C}var y=i=>{var l=i.props["onUpdate:modelValue"];return d.isArray(l)?f=>d.invokeArrayFns(l,f):l},P={created(i,l,f){var{value:_,modifiers:{trim:A,number:C}}=l;i.value=_==null?"":_,i._assign=y(f),Ds(i,"input",N=>{var M=N.detail.value,H=i.pageNode;i.pageNode=null,i.value=M,i.pageNode=H,A?M=M.trim():C&&(M=d.toNumber(M)),i._assign(M)})},beforeUpdate(i,l,f){var{value:_}=l;i._assign=y(f);var A=_==null?"":_;i.value!==A&&(i.value=A)}},O=P,F=["ctrl","shift","alt","meta"],G={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,l)=>F.some(f=>i["".concat(f,"Key")]&&!l.includes(f))},Y=(i,l)=>{var f=function(_){for(var A=0;A<l.length;A++){var C=G[l[A]];if(C&&C(_,l))return}for(var N=arguments.length,M=new Array(N>1?N-1:0),H=1;H<N;H++)M[H-1]=arguments[H];return i(_,...M)};return f.modifiers=l,f},le={esc:"escape",space:" ",up:"arrow-up",left:"arrow-left",right:"arrow-right",down:"arrow-down",delete:"backspace"},ze=(i,l)=>f=>{if("key"in f){var _=d.hyphenate(f.key);if(l.some(A=>A===_||le[A]===_))return i(f)}},at={beforeMount(i,l){var{value:f}=l;ge(i,f)},updated(i,l){var{value:f,oldValue:_}=l;!f!=!_&&ge(i,f)},beforeUnmount(i,l){var{value:f}=l;ge(i,f)}};function ge(i,l){i.setAttribute(".vShow",!!l)}var Ge=d.extend({patchProp:jl,forcePatchProp:B.forcePatchProp},ra),Xe;function wt(){return Xe||(Xe=za(Ge))}var it=function(){wt().render(...arguments)},Ce=function(){var i=wt().createApp(...arguments),{mount:l}=i;return i.mount=f=>(d.isString(f)&&(f=Ra(f)),f&&l(f,!1,!1)),i},Ee=Ce;function Te(){}function lt(){}function Ne(i){return d.isObject(i)?B.JSON_PROTOCOL+JSON.stringify(i):i}var Ct=i=>Ne(i);return Object.defineProperty(S,"camelize",{enumerable:!0,get:function(){return d.camelize}}),Object.defineProperty(S,"capitalize",{enumerable:!0,get:function(){return d.capitalize}}),Object.defineProperty(S,"normalizeClass",{enumerable:!0,get:function(){return d.normalizeClass}}),Object.defineProperty(S,"normalizeProps",{enumerable:!0,get:function(){return d.normalizeProps}}),Object.defineProperty(S,"normalizeStyle",{enumerable:!0,get:function(){return d.normalizeStyle}}),Object.defineProperty(S,"toDisplayString",{enumerable:!0,get:function(){return d.toDisplayString}}),Object.defineProperty(S,"toHandlerKey",{enumerable:!0,get:function(){return d.toHandlerKey}}),Object.defineProperty(S,"EffectScope",{enumerable:!0,get:function(){return E.EffectScope}}),Object.defineProperty(S,"ReactiveEffect",{enumerable:!0,get:function(){return E.ReactiveEffect}}),Object.defineProperty(S,"customRef",{enumerable:!0,get:function(){return E.customRef}}),Object.defineProperty(S,"effect",{enumerable:!0,get:function(){return E.effect}}),Object.defineProperty(S,"effectScope",{enumerable:!0,get:function(){return E.effectScope}}),Object.defineProperty(S,"getCurrentScope",{enumerable:!0,get:function(){return E.getCurrentScope}}),Object.defineProperty(S,"isProxy",{enumerable:!0,get:function(){return E.isProxy}}),Object.defineProperty(S,"isReactive",{enumerable:!0,get:function(){return E.isReactive}}),Object.defineProperty(S,"isReadonly",{enumerable:!0,get:function(){return E.isReadonly}}),Object.defineProperty(S,"isRef",{enumerable:!0,get:function(){return E.isRef}}),Object.defineProperty(S,"isShallow",{enumerable:!0,get:function(){return E.isShallow}}),Object.defineProperty(S,"markRaw",{enumerable:!0,get:function(){return E.markRaw}}),Object.defineProperty(S,"onScopeDispose",{enumerable:!0,get:function(){return E.onScopeDispose}}),Object.defineProperty(S,"proxyRefs",{enumerable:!0,get:function(){return E.proxyRefs}}),Object.defineProperty(S,"reactive",{enumerable:!0,get:function(){return E.reactive}}),Object.defineProperty(S,"readonly",{enumerable:!0,get:function(){return E.readonly}}),Object.defineProperty(S,"ref",{enumerable:!0,get:function(){return E.ref}}),Object.defineProperty(S,"shallowReactive",{enumerable:!0,get:function(){return E.shallowReactive}}),Object.defineProperty(S,"shallowReadonly",{enumerable:!0,get:function(){return E.shallowReadonly}}),Object.defineProperty(S,"shallowRef",{enumerable:!0,get:function(){return E.shallowRef}}),Object.defineProperty(S,"stop",{enumerable:!0,get:function(){return E.stop}}),Object.defineProperty(S,"toRaw",{enumerable:!0,get:function(){return E.toRaw}}),Object.defineProperty(S,"toRef",{enumerable:!0,get:function(){return E.toRef}}),Object.defineProperty(S,"toRefs",{enumerable:!0,get:function(){return E.toRefs}}),Object.defineProperty(S,"triggerRef",{enumerable:!0,get:function(){return E.triggerRef}}),Object.defineProperty(S,"unref",{enumerable:!0,get:function(){return E.unref}}),S.BaseTransition=Mt,S.BaseTransitionPropsValidators=Jr,S.Comment=pe,S.Fragment=te,S.KeepAlive=$i,S.Static=Pe,S.Suspense=Nn,S.Teleport=X,S.Text=ce,S.Transition=Xa,S.TransitionGroup=ml,S.assertNumber=Lt,S.callWithAsyncErrorHandling=xt,S.callWithErrorHandling=en,S.cloneVNode=ei,S.compatUtils=va,S.computed=ds,S.createApp=Ce,S.createBlock=cn,S.createComment=Ra,S.createCommentVNode=Mn,S.createElement=na,S.createElementBlock=Bt,S.createElementVNode=Ft,S.createHydrationRenderer=Wa,S.createPropsRestProxy=Er,S.createRenderer=za,S.createSSRApp=Ee,S.createSlots=Q,S.createStaticVNode=Ga,S.createTextNode=ma,S.createTextVNode=Gi,S.createVNode=qt,S.createVueApp=Ce,S.defineAsyncComponent=Xr,S.defineComponent=pr,S.defineEmits=Bs,S.defineExpose=hs,S.defineProps=Fo,S.getCurrentInstance=Vn,S.getTransitionRawChildren=Ni,S.guardReactiveProps=ci,S.h=Yi,S.handleError=I,S.initCustomFormatter=ta,S.inject=Un,S.injectHook=vr,S.isMemoSame=ps,S.isRuntimeOnly=Wr,S.isVNode=Wt,S.mergeDefaults=yn,S.mergeProps=br,S.nextTick=Sr,S.onActivated=to,S.onBeforeActivate=Te,S.onBeforeDeactivate=lt,S.onBeforeMount=Zn,S.onBeforeUnmount=lr,S.onBeforeUpdate=Hn,S.onDeactivated=bn,S.onErrorCaptured=ko,S.onMounted=Xn,S.onRenderTracked=no,S.onRenderTriggered=No,S.onServerPrefetch=go,S.onUnmounted=ho,S.onUpdated=Qn,S.openBlock=ct,S.popScopeId=ca,S.provide=In,S.pushScopeId=Co,S.queuePostFlushCb=ri,S.registerRuntimeCompiler=fs,S.render=it,S.renderList=x,S.renderSlot=he,S.resolveComponent=xi,S.resolveDirective=Bi,S.resolveDynamicComponent=Ro,S.resolveFilter=pa,S.resolveTransitionHooks=Zr,S.setBlockTracking=Et,S.setDevtoolsHook=rr,S.setTransitionHooks=Vr,S.ssrContextKey=Eo,S.ssrUtils=Ul,S.toHandlers=de,S.transformVNodeArgs=Zt,S.useAttrs=Pt,S.useCssModule=Vo,S.useCssVars=Za,S.useSSRContext=ka,S.useSlots=Be,S.useTransitionState=gr,S.vModelDynamic=O,S.vModelText=P,S.vShow=at,S.version=dl,S.warn=We,S.watch=sr,S.watchEffect=qr,S.watchPostEffect=Io,S.watchSyncEffect=oi,S.withAsyncContext=Ai,S.withCtx=Yo,S.withDefaults=Ls,S.withDirectives=jr,S.withKeys=ze,S.withMemo=gs,S.withModifiers=Y,S.withScopeId=Fi,S.wp=Ct,Object.defineProperty(S,"__esModule",{value:!0}),S}({},p,w,s);return k.__TYPE__="vue",k}function av(g,s,p){let w=p.Vue,k=p.setTimeout,S=p.clearTimeout,d=p.setInterval,E=p.clearInterval,B=p.__uniConfig,We=p.__uniRoutes,Lt=p.VueShared,en=p.UniShared;var xt=function(W,Z,fn){"use strict";var sn="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",_n=function(){let e=new Uint8Array(256);for(var t=0;t<sn.length;t++)e[sn.charCodeAt(t)]=t;return e}();function Wn(e){var t=new Uint8Array(e),n,r=t.length,o="";for(n=0;n<r;n+=3)o+=sn[t[n]>>2],o+=sn[(t[n]&3)<<4|t[n+1]>>4],o+=sn[(t[n+1]&15)<<2|t[n+2]>>6],o+=sn[t[n+2]&63];return r%3===2?o=o.substring(0,o.length-1)+"=":r%3===1&&(o=o.substring(0,o.length-2)+"=="),o}function pi(e){var t=e.length*.75,n=e.length,r,o=0,c,h,b,V;e[e.length-1]==="="&&(t--,e[e.length-2]==="="&&t--);var T=new ArrayBuffer(t),D=new Uint8Array(T);for(r=0;r<n;r+=4)c=_n[e.charCodeAt(r)],h=_n[e.charCodeAt(r+1)],b=_n[e.charCodeAt(r+2)],V=_n[e.charCodeAt(r+3)],D[o++]=c<<2|h>>4,D[o++]=(h&15)<<4|b>>2,D[o++]=(b&3)<<6|V&63;return T}let vi=["original","compressed"],ar=["album","camera"],Sr=["GET","OPTIONS","HEAD","POST","PUT","DELETE","TRACE","CONNECT","PATCH"];function Cn(e,t){return!e||t.indexOf(e)===-1?t[0]:e}function wr(e,t){return!W.isArray(e)||e.length===0||e.find(n=>t.indexOf(n)===-1)?t:e}function Cr(e,t){console.warn(`${e}: ${t}`)}function mi(e,t,n,r){r||(r=Cr);for(let o in n){let c=Ve(o,t[o],n[o],!W.hasOwn(t,o));W.isString(c)&&r(e,c)}}function ri(e,t,n,r){if(!n)return;if(!W.isArray(n))return mi(e,t[0]||Object.create(null),n,r);let o=n.length,c=t.length;for(let h=0;h<o;h++){let b=n[h],V=Object.create(null);c>h&&(V[b.name]=t[h]),mi(e,V,{[b.name]:b},r)}}function Ve(e,t,n,r){W.isPlainObject(n)||(n={type:n});let{type:o,required:c,validator:h}=n;if(c&&r)return'Missing required args: "'+e+'"';if(!(t==null&&!c)){if(o!=null){let b=!1,V=W.isArray(o)?o:[o],T=[];for(let D=0;D<V.length&&!b;D++){let{valid:_e,expectedType:Se}=bt(t,V[D]);T.push(Se||""),b=_e}if(!b)return tn(e,t,T)}if(h)return h(t)}}let ot=W.makeMap("String,Number,Boolean,Function,Symbol");function bt(e,t){let n,r=Sn(t);if(ot(r)){let o=typeof e;n=o===r.toLowerCase(),!n&&o==="object"&&(n=e instanceof t)}else r==="Object"?n=W.isObject(e):r==="Array"?n=W.isArray(e):n=e instanceof t||W.toRawType(e)===Sn(t);return{valid:n,expectedType:r}}function tn(e,t,n){let r=`Invalid args: type check failed for args "${e}". Expected ${n.map(W.capitalize).join(", ")}`,o=n[0],c=W.toRawType(t),h=Jt(t,o),b=Jt(t,c);return n.length===1&&rr(o)&&!Ar(o,c)&&(r+=` with value ${h}`),r+=`, got ${c} `,rr(c)&&(r+=`with value ${b}.`),r}function Sn(e){let t=e&&e.toString().match(/^\s*function (\w+)/);return t?t[1]:""}function Jt(e,t){return t==="String"?`"${e}"`:t==="Number"?`${Number(e)}`:`${e}`}function rr(e){return["string","number","boolean"].some(n=>e.toLowerCase()===n)}function Ar(...e){return e.some(t=>t.toLowerCase()==="boolean")}function Or(e){return function(){try{return e.apply(e,arguments)}catch(t){console.error(t)}}}let On=1,dn={};function Tr(e,t,n,r=!1){return dn[e]={name:t,keepAlive:r,callback:n},e}function _i(e,t,n){if(typeof e=="number"){let r=dn[e];if(r)return r.keepAlive||delete dn[e],r.callback(t,n)}return t}function Co(e){for(let t in dn)if(dn[t].name===e)return!0;return!1}function ca(e,t){for(let n in dn){let r=dn[n];r.callback===t&&r.name===e&&delete dn[n]}}function Fi(e){st.off("api."+e)}function Yo(e){st.on("api."+e,t=>{for(let n in dn){let r=dn[n];r.name===e&&r.callback(t)}})}function Ao(e,t){return Tr(On++,e,t,!0)}let Ji="success",Mr="fail",ua="complete";function Oo(e){let t={};for(let n in e){let r=e[n];W.isFunction(r)&&(t[n]=Or(r),delete e[n])}return t}function To(e,t){return!e||e.indexOf(":fail")===-1?t+":ok":t+e.substring(e.indexOf(":fail"))}function Zi(e,t={},{beforeAll:n,beforeSuccess:r}={}){W.isPlainObject(t)||(t={});let{success:o,fail:c,complete:h}=Oo(t),b=W.isFunction(o),V=W.isFunction(c),T=W.isFunction(h),D=On++;return Tr(D,e,_e=>{_e=_e||{},_e.errMsg=To(_e.errMsg,e),W.isFunction(n)&&n(_e),_e.errMsg===e+":ok"?(W.isFunction(r)&&r(_e,t),b&&o(_e)):V&&c(_e),T&&h(_e)}),D}let ii="success",qo="fail",uo="complete",Nn={},hr={};function fo(e,t){return function(n){return e(n,t)||n}}function Gn(e,t,n){let r=!1;for(let o=0;o<e.length;o++){let c=e[o];if(r)r=Promise.resolve(fo(c,n));else{let h=c(t,n);if(W.isPromise(h)&&(r=Promise.resolve(h)),h===!1)return{then(){},catch(){}}}}return r||{then(o){return o(t)},catch(){}}}function Xi(e,t={}){return[ii,qo,uo].forEach(n=>{let r=e[n];if(!W.isArray(r))return;let o=t[n];t[n]=function(h){Gn(r,h,t).then(b=>W.isFunction(o)&&o(b)||b)}}),t}function Po(e,t){let n=[];W.isArray(Nn.returnValue)&&n.push(...Nn.returnValue);let r=hr[e];return r&&W.isArray(r.returnValue)&&n.push(...r.returnValue),n.forEach(o=>{t=o(t)||t}),t}function Qi(e){let t=Object.create(null);Object.keys(Nn).forEach(r=>{r!=="returnValue"&&(t[r]=Nn[r].slice())});let n=hr[e];return n&&Object.keys(n).forEach(r=>{r!=="returnValue"&&(t[r]=(t[r]||[]).concat(n[r]))}),t}function bi(e,t,n,r){let o=Qi(e);return o&&Object.keys(o).length?W.isArray(o.invoke)?Gn(o.invoke,n).then(h=>t(Xi(Qi(e),h),...r)):t(Xi(o,n),...r):t(n,...r)}function Jn(e){return!!(W.isPlainObject(e)&&[Ji,Mr,ua].find(t=>W.isFunction(e[t])))}function Dr(e){return e}function In(e,t){return(n={},...r)=>Jn(n)?Po(e,bi(e,t,n,r)):Po(e,new Promise((o,c)=>{bi(e,t,W.extend(n,{success:o,fail:c}),r)}))}function Un(e,t){let n=e[0];if(!t||!W.isPlainObject(t.formatArgs)&&W.isPlainObject(n))return;let r=t.formatArgs,o=Object.keys(r);for(let c=0;c<o.length;c++){let h=o[c],b=r[h];if(W.isFunction(b)){let V=b(e[0][h],n);if(W.isString(V))return V}else W.hasOwn(n,h)||(n[h]=b)}}function qr(e,t,n){return _i(e,W.extend(n||{},{errMsg:t+":ok"}))}function Io(e,t,n,r){return _i(e,W.extend({errMsg:t+":fail"+(n?" "+n:"")},r))}function oi(e,t,n,r){if(r&&r.beforeInvoke){let c=r.beforeInvoke(t);if(W.isString(c))return c}let o=Un(t,r);if(o)return o}function Kr(e){if(!W.isFunction(e))throw new Error('Invalid args: type check failed for args "callback". Expected Function')}function sr(e,t,n){return r=>{Kr(r);let o=oi(e,[r],void 0,n);if(o)throw new Error(o);let c=!Co(e);Ao(e,r),c&&(Yo(e),t())}}function Vi(e,t,n){return r=>{Kr(r);let o=oi(e,[r],void 0,n);if(o)throw new Error(o);e=e.replace("off","on"),ca(e,r),Co(e)||(Fi(e),t())}}function eo(e){return!e||W.isString(e)?e:e.stack?(console.error(e.message+Z.LINEFEED+e.stack),e.message):e}function Fr(e,t,n,r){return o=>{let c=Zi(e,o,r),h=oi(e,[o],n,r);return h?Io(c,e,h):t(o,{resolve:b=>qr(c,e,b),reject:(b,V)=>Io(c,e,eo(b),V)})}}function Ei(e,t,n,r){return(...o)=>{let c=oi(e,o,n,r);if(c)throw new Error(c);return t.apply(null,o)}}function gr(e,t,n,r){return Fr(e,t,n,r)}function gn(e,t,n){return sr(e,t,n)}function Jr(e,t,n){return Vi(e,t,n)}function kr(e,t,n,r){return In(e,Fr(e,t,void 0,r))}function Mt(e,t,n,r){return Ei(e,t,void 0,r)}function Oe(e,t,n,r){return In(e,gr(e,t,void 0,r))}let Zr="base64ToArrayBuffer",Ii=[{name:"base64",type:String,required:!0}],ai="arrayBufferToBase64",Vr=[{name:"arrayBuffer",type:[ArrayBuffer,Uint8Array],required:!0}],Ni=Mt(Zr,e=>pi(e),Ii),pr=Mt(ai,e=>Wn(e),Vr);function $r(){if(typeof __SYSTEM_INFO__!="undefined")return window.__SYSTEM_INFO__;let{resolutionWidth:e}=s.screen.getCurrentSize()||{resolutionWidth:0};return{platform:(s.os.name||"").toLowerCase(),pixelRatio:s.screen.scale,windowWidth:Math.round(e)}}function Xr(e,t,n){e.$page.meta.isNVue?ki(e,t,n):Pr(e,t,n)}function Pr(e,t,n){st.invokeViewMethod("requestComponentInfo",{reqs:t.map(r=>(r.component&&(r.component=r.component.$el.nodeId),r))},e.$page.id,n)}function ki(e,t,n){let r=ln(t),o=new Array(r.length);$i(r,e.$el,o),Ur(e.$requireNativePlugin("dom"),o,0,[],c=>{n(c)})}function ln(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 $i(e,t,n){let r=t.children;if(!W.isArray(r))return!1;for(let o=0;o<r.length;o++){let c=r[o];if(c.attr){let h=e.indexOf(c.attr.id);if(h>=0&&(n[h]={id:e[h],ref:c.ref,dataset:Z.parseNVueDataset(c.attr)},e.length===1))break}c.children&&$i(e,c,n)}}function Ur(e,t,n,r,o){let c=t[n];e.getComponentRect(c.ref,h=>{h.size.id=c.id,h.size.dataset=c.dataset,r.push(h.size),n+=1,n<t.length?Ur(e,t,n,r,o):o(r)})}function to(e,t){st.invokeViewMethod("setPageMeta",t,e.$page.id)}let bn=e=>e!==null&&typeof e=="object",Hr=["{","}"];class ir{constructor(){this._caches=Object.create(null)}interpolate(t,n,r=Hr){if(!n)return[t];let o=this._caches[t];return o||(o=vr(t,r),this._caches[t]=o),Qr(o,n)}}let yi=/^(?:\d)+/,Ri=/^(?:\w)+/;function vr(e,[t,n]){let r=[],o=0,c="";for(;o<e.length;){let h=e[o++];if(h===t){c&&r.push({type:"text",value:c}),c="";let b="";for(h=e[o++];h!==void 0&&h!==n;)b+=h,h=e[o++];let V=h===n,T=yi.test(b)?"list":V&&Ri.test(b)?"named":"unknown";r.push({value:b,type:T})}else c+=h}return c&&r.push({type:"text",value:c}),r}function Qr(e,t){let n=[],r=0,o=Array.isArray(t)?"list":bn(t)?"named":"unknown";if(o==="unknown")return n;for(;r<e.length;){let c=e[r];switch(c.type){case"text":n.push(c.value);break;case"list":n.push(t[parseInt(c.value,10)]);break;case"named":o==="named"&&n.push(t[c.value]);break;case"unknown":break}r++}return n}let Zn="zh-Hans",Xn="zh-Hant",Hn="en",Qn="fr",lr="es",ho=Object.prototype.hasOwnProperty,go=(e,t)=>ho.call(e,t),No=new ir;function no(e,t){return!!t.find(n=>e.indexOf(n)!==-1)}function ko(e,t){return t.find(n=>e.indexOf(n)===0)}function jr(e,t){if(!e)return;if(e=e.trim().replace(/_/g,"-"),t&&t[e])return e;if(e=e.toLowerCase(),e==="chinese")return Zn;if(e.indexOf("zh")===0)return e.indexOf("-hans")>-1?Zn:e.indexOf("-hant")>-1||no(e,["-tw","-hk","-mo","-cht"])?Xn:Zn;let n=[Hn,Qn,lr];t&&Object.keys(t).length>0&&(n=Object.keys(t));let r=ko(e,n);if(r)return r}class Rr{constructor({locale:t,fallbackLocale:n,messages:r,watcher:o,formater:c}){this.locale=Hn,this.fallbackLocale=Hn,this.message={},this.messages={},this.watchers=[],n&&(this.fallbackLocale=n),this.formater=c||No,this.messages=r||{},this.setLocale(t||Hn),o&&this.watchLocale(o)}setLocale(t){let n=this.locale;this.locale=jr(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 o=this.messages[t];o?r?Object.assign(o,n):Object.keys(n).forEach(c=>{go(o,c)||(o[c]=n[c])}):this.messages[t]=n}f(t,n,r){return this.formater.interpolate(t,n,r).join("")}t(t,n,r){let o=this.message;return typeof n=="string"?(n=jr(n,this.messages),n&&(o=this.messages[n])):r=n,go(o,t)?this.formater.interpolate(o[t],r).join(""):(console.warn(`Cannot translate the value of keypath ${t}. Use the value of keypath as default.`),t)}}function ro(e,t){e.$watchLocale?e.$watchLocale(n=>{t.setLocale(n)}):e.$watch(()=>e.$locale,n=>{t.setLocale(n)})}function Ko(){return typeof I!="undefined"&&I.getLocale?I.getLocale():typeof global!="undefined"&&global.getLocale?global.getLocale():Hn}function xi(e,t={},n,r){typeof e!="string"&&([e,t]=[t,e]),typeof e!="string"&&(e=Ko()),typeof n!="string"&&(n=typeof B!="undefined"&&B.fallbackLocale||Hn);let o=new Rr({locale:e,fallbackLocale:n,messages:t,watcher:r}),c=(h,b)=>{if(typeof St!="function")c=function(V,T){return o.t(V,T)};else{let V=!1;c=function(T,D){let _e=St().$vm;return _e&&(_e.$locale,V||(V=!0,ro(_e,o))),o.t(T,D)}}return c(h,b)};return{i18n:o,f(h,b,V){return o.f(h,b,V)},t(h,b){return c(h,b)},add(h,b,V=!0){return o.add(h,b,V)},watch(h){return o.watchLocale(h)},getLocale(){return o.getLocale()},setLocale(h){return o.setLocale(h)}}}function Ui(e,t){return e.indexOf(t[0])>-1}let Ro=Z.once(()=>typeof B!="undefined"&&B.locales&&!!Object.keys(B.locales).length),Bi;function Hi(){let e=I.getLocale(),t=B.locales;return t[e]||t[B.fallbackLocale]||t.en||{}}function xo(e){return Ui(e,Z.I18N_JSON_DELIMITERS)?se().f(e,Hi(),Z.I18N_JSON_DELIMITERS):e}function x(e,t){if(t.length===1){if(e){let r=b=>W.isString(b)&&Ui(b,Z.I18N_JSON_DELIMITERS),o=t[0],c=[];if(W.isArray(e)&&(c=e.filter(b=>r(b[o]))).length)return c;let h=e[t[0]];if(r(h))return e}return}let n=t.shift();return x(e&&e[n],t)}function Q(e,t){return t.map(n=>he(e,n))}function he(e,t){let n=x(e,t);if(!n)return!1;let r=t[t.length-1];if(W.isArray(n))n.forEach(o=>he(o,[r]));else{let o=n[r];Object.defineProperty(n,r,{get(){return xo(o)},set(c){o=c}})}return!0}function se(){if(!Bi){let e;if(typeof St=="function"?e=g.requireModule("plus").getLanguage():e=s.webview.currentWebview().getStyle().locale,Bi=xi(e),Ro()){let t=Object.keys(B.locales||{});t.length&&t.forEach(n=>Bi.add(n,B.locales[n])),Bi.setLocale(e)}}return Bi}function de(e,t,n){return t.reduce((r,o,c)=>(r[e+o]=n[c],r),{})}let mt=Z.once(()=>{let e="uni.app.",t=["quit"];se().add(Hn,de(e,t,["Press back button again to exit"]),!1),se().add(lr,de(e,t,["Pulse otra vez para salir"]),!1),se().add(Qn,de(e,t,["Appuyez \xE0 nouveau pour quitter l'application"]),!1),se().add(Zn,de(e,t,["\u518D\u6309\u4E00\u6B21\u9000\u51FA\u5E94\u7528"]),!1),se().add(Xn,de(e,t,["\u518D\u6309\u4E00\u6B21\u9000\u51FA\u61C9\u7528"]),!1)}),K=Z.once(()=>{let e="uni.showActionSheet.",t=["cancel"];se().add(Hn,de(e,t,["Cancel"]),!1),se().add(lr,de(e,t,["Cancelar"]),!1),se().add(Qn,de(e,t,["Annuler"]),!1),se().add(Zn,de(e,t,["\u53D6\u6D88"]),!1),se().add(Xn,de(e,t,["\u53D6\u6D88"]),!1)}),z=Z.once(()=>{let e="uni.showModal.",t=["cancel","confirm"];se().add(Hn,de(e,t,["Cancel","OK"]),!1),se().add(lr,de(e,t,["Cancelar","OK"]),!1),se().add(Qn,de(e,t,["Annuler","OK"]),!1),se().add(Zn,de(e,t,["\u53D6\u6D88","\u786E\u5B9A"]),!1),se().add(Xn,de(e,t,["\u53D6\u6D88","\u78BA\u5B9A"]),!1)}),ie=Z.once(()=>{let e="uni.chooseImage.",t=["cancel","sourceType.album","sourceType.camera"];se().add(Hn,de(e,t,["Cancel","Album","Camera"]),!1),se().add(lr,de(e,t,["Cancelar","\xC1lbum","C\xE1mara"]),!1),se().add(Qn,de(e,t,["Annuler","Album","Cam\xE9ra"]),!1),se().add(Zn,de(e,t,["\u53D6\u6D88","\u4ECE\u76F8\u518C\u9009\u62E9","\u62CD\u6444"]),!1),se().add(Xn,de(e,t,["\u53D6\u6D88","\u5F9E\u76F8\u518A\u9078\u64C7","\u62CD\u651D"]),!1)}),xe=Z.once(()=>{let e="uni.chooseVideo.",t=["cancel","sourceType.album","sourceType.camera"];se().add(Hn,de(e,t,["Cancel","Album","Camera"]),!1),se().add(lr,de(e,t,["Cancelar","\xC1lbum","C\xE1mara"]),!1),se().add(Qn,de(e,t,["Annuler","Album","Cam\xE9ra"]),!1),se().add(Zn,de(e,t,["\u53D6\u6D88","\u4ECE\u76F8\u518C\u9009\u62E9","\u62CD\u6444"]),!1),se().add(Xn,de(e,t,["\u53D6\u6D88","\u5F9E\u76F8\u518A\u9078\u64C7","\u62CD\u651D"]),!1)}),nt=Z.once(()=>{let e="uni.previewImage.",t=["cancel","button.save","save.success","save.fail"];se().add(Hn,de(e,t,["Cancel","Save Image","Saved successfully","Save failed"]),!1),se().add(lr,de(e,t,["Cancelar","Guardar imagen","Guardado exitosamente","Error al guardar"]),!1),se().add(Qn,de(e,t,["Annuler","Guardar imagen","Enregistr\xE9 avec succ\xE8s","\xC9chec de la sauvegarde"]),!1),se().add(Zn,de(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),se().add(Xn,de(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)}),Yt=Z.once(()=>{let e="uni.setClipboardData.",t=["success","fail"];se().add(Hn,de(e,t,["Content copied","Copy failed, please copy manually"]),!1),se().add(lr,de(e,t,["Contenido copiado","Error al copiar, copie manualmente"]),!1),se().add(Qn,de(e,t,["Contenu copi\xE9","\xC9chec de la copie, copiez manuellement"]),!1),se().add(Zn,de(e,t,["\u5185\u5BB9\u5DF2\u590D\u5236","\u590D\u5236\u5931\u8D25\uFF0C\u8BF7\u624B\u52A8\u590D\u5236"]),!1),se().add(Xn,de(e,t,["\u5167\u5BB9\u5DF2\u5FA9\u5236","\u5FA9\u5236\u5931\u6557\uFF0C\u8ACB\u624B\u52D5\u5FA9\u88FD"]),!1)}),Tn=Z.once(()=>{let e="uni.scanCode.",t=["title","album","fail","flash.on","flash.off"];se().add(Hn,de(e,t,["Scan code","Album","Recognition failure","Tap to turn light on","Tap to turn light off"]),!1),se().add(lr,de(e,t,["C\xF3digo de escaneo","\xC1lbum","\xC9chec de la reconnaissance","Toque para encender la luz","Toque para apagar la luz"]),!1),se().add(Qn,de(e,t,["Code d\u2019analyse","Album","Fallo de reconocimiento","Appuyez pour activer l'\xE9clairage","Appuyez pour d\xE9sactiver l'\xE9clairage"]),!1),se().add(Zn,de(e,t,["\u626B\u7801","\u76F8\u518C","\u8BC6\u522B\u5931\u8D25","\u8F7B\u89E6\u7167\u4EAE","\u8F7B\u89E6\u5173\u95ED"]),!1),se().add(Xn,de(e,t,["\u6383\u78BC","\u76F8\u518A","\u8B58\u5225\u5931\u6557","\u8F15\u89F8\u7167\u4EAE","\u8F15\u89F8\u95DC\u9589"]),!1)}),jn=Z.once(()=>{let e="uni.startSoterAuthentication.",t=["authContent","waitingContent"];se().add(Hn,de(e,t,["Fingerprint recognition","Unrecognizable"]),!1),se().add(lr,de(e,t,["Reconocimiento de huellas dactilares","Irreconocible"]),!1),se().add(Qn,de(e,t,["Reconnaissance de l'empreinte digitale","M\xE9connaissable"]),!1),se().add(Zn,de(e,t,["\u6307\u7EB9\u8BC6\u522B\u4E2D...","\u65E0\u6CD5\u8BC6\u522B"]),!1),se().add(Xn,de(e,t,["\u6307\u7D0B\u8B58\u5225\u4E2D...","\u7121\u6CD5\u8B58\u5225"]),!1)});function xr(e){if(Ro())return Q(e,[["titleText"],["searchInput","placeholder"],["buttons","text"]])}function mr(e){if(Ro()){let t="caption";return Q(e,[["contentdown",t],["contentover",t],["contentrefresh",t]])}}function po(e){let t=new Z.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,o=!1){t[o?"once":"on"](`${e}.${n}`,r)},unsubscribe(n,r){t.off(`${e}.${n}`,r)},subscribeHandler(n,r,o){t.emit(`${e}.${n}`,r,o)}}}let vo="invokeViewApi",Jo="invokeServiceApi";function mo(e){return e=e+"",e.indexOf("rpx")!==-1||e.indexOf("upx")!==-1}function Yn(e,t=!1){if(t)return Bn(e);if(W.isString(e)){let n=parseInt(e)||0;return mo(e)?I.upx2px(n):n}return e}function Bn(e){return mo(e)?e.replace(/(\d+(\.\d+)?)[ru]px/g,(t,n)=>I.upx2px(parseFloat(n))+"px"):e}function er(e){let t=Z.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 Si(){let e=Pn(),t=e.length;if(t)return e[t-1]}function is(){let e=Si();if(e)return e.$page.meta}function fa(){let e=is();return e?e.id:-1}function _r(){let e=Si();if(e)return e.$vm}let Pa=["navigationBar","pullToRefresh"];function $a(){return JSON.parse(JSON.stringify(B.globalStyle||{}))}function Ua(e,t){let n=$a(),r=W.extend({id:t},n,e);Pa.forEach(c=>{r[c]=W.extend({},n[c],e[c])});let{navigationBar:o}=r;return o.titleText&&o.titleImage&&(o.titleText=""),r}function Ha(e){return JSON.parse(Yn(JSON.stringify(e),!0))}function ja(e){return e.offset&&(e.offset=Yn(e.offset)),e.height&&(e.height=Yn(e.height)),e.range&&(e.range=Yn(e.range)),e}function da(e,t,n,r,o,c){let{id:h,route:b}=r,V=Z.normalizeStyles(r.navigationBar,B.themeConfig,c).titleColor;return{id:h,path:Z.addLeadingSlash(b),route:b,fullPath:t,options:n,meta:r,openType:e,eventChannel:o,statusBarStyle:V==="#ffffff"?"light":"dark"}}function Ia(e,t,n){let r=e.$[t];!W.isArray(r)||n.__weh&&W.remove(r,n.__weh)}function Ln(e,t,n){if(W.isString(e))n=t,t=e,e=_r();else if(typeof e=="number"){let o=Pn().find(c=>c.$page.id===e);o?e=o.$vm:e=_r()}if(!e)return;if(e.__call_hook)return e.__call_hook(t,n);let r=e.$[t];return r&&Z.invokeArrayFns(r,n)}function Bo(e){if(e.indexOf("/")===0)return e;let t="",n=Pn();return n.length&&(t=n[n.length-1].$page.route),Zo(t,e)}function Zo(e,t){if(t.indexOf("/")===0)return t;if(t.indexOf("./")===0)return Zo(e,t.slice(2));let n=t.split("/"),r=n.length,o=0;for(;o<r&&n[o]==="..";o++);n.splice(0,o),t=n.join("/");let c=e.length>0?e.split("/"):[];return c.splice(c.length-o-1,o+1),Z.addLeadingSlash(c.concat(n).join("/"))}function ji(e,t=!1){return t?We.find(n=>n.path===e||n.alias===e):We.find(n=>n.path===e)}function os(e){let t=ji(e);if(t)return t.meta}function as(e,t,n){let r=ji(Z.addLeadingSlash(t));if(r){let{meta:c}=r;delete c.tabBarIndex,c.isQuit=c.isTabBar=!1}let o=ji(Z.addLeadingSlash(n));if(o){let{meta:c}=o;c.tabBarIndex=e,c.isQuit=c.isTabBar=!0;let h=B.tabBar;h&&h.list&&h.list[e]&&(h.list[e].pagePath=Z.removeLeadingSlash(n))}}let Lo,ss,io;function si(){return typeof window=="object"&&typeof navigator=="object"&&typeof document=="object"?"webview":"v8"}function wi(){return Lo.webview.currentWebview().id}let zi,li,cr={};function or(e){let t=e.data&&e.data.__message;if(!t||!t.__page)return;let n=t.__page,r=cr[n];r&&r(t),t.keep||delete cr[n]}function za(e,t){si()==="v8"?io?(zi&&zi.close(),zi=new io(wi()),zi.onmessage=or):li||(li=ss.requireModule("globalEvent"),li.addEventListener("plusMessage",or)):window.__plusMessage=or,cr[e]=t}class Wa{constructor(t){this.webview=t}sendMessage(t){let n=JSON.parse(JSON.stringify({__message:{data:t}})),r=this.webview.id;io?new io(r).postMessage(n):Lo.webview.postMessageToUniNView&&Lo.webview.postMessageToUniNView(n,r)}close(){this.webview.close()}}function Wi({context:e={},url:t,data:n={},style:r={},onMessage:o,onClose:c}){let h=B.darkmode;Lo=e.plus||s,ss=e.weex||(typeof g=="object"?g:null),io=e.BroadcastChannel||(typeof BroadcastChannel=="object"?BroadcastChannel:null);let b={autoBackButton:!0,titleSize:"17px"},V=`page${Date.now()}`;r=W.extend({},r),r.titleNView!==!1&&r.titleNView!=="none"&&(r.titleNView=W.extend(b,r.titleNView));let T={top:0,bottom:0,usingComponents:{},popGesture:"close",scrollIndicator:"none",animationType:"pop-in",animationDuration:200,uniNView:{path:`/${t}.js`,defaultFontSize:16,viewport:Lo.screen.resolutionWidth}};r=W.extend(T,r);let D=Lo.webview.create("",V,r,{extras:{from:wi(),runtime:si(),data:W.extend({},n,{darkmode:h}),useGlobalEvent:!io}});return D.addEventListener("close",c),za(V,_e=>{W.isFunction(o)&&o(_e.data),_e.keep||D.close("auto")}),D.show(r.animationType,r.animationDuration),new Wa(D)}let oo=(e,t)=>st.emit("api."+e,t),ao=1;function ls(e){return(e||fa())+"."+vo}let ha=(e,t,n,r)=>{let{subscribe:o,publishHandler:c}=st,h=r?ao++:0;r&&o(vo+"."+h,r,!0),c(ls(n),{id:h,name:e,args:t},n)},Mo=(e,t,n,r)=>{let{subscribe:o,unsubscribe:c,publishHandler:h}=st,b=ao++,V=vo+"."+b;return o(V,n),h(ls(r),{id:b,name:e,args:t},r),()=>{c(V)}},ga=Object.create(null);function m(){st.subscribe(Jo,U)}function R(e,t){ga[e]||(ga[e]=t)}function U({id:e,name:t,args:n},r){let o=h=>{e&&st.publishHandler(Jo+"."+e,h,r)},c=ga[t];c?c(n,o):o({})}let $=W.extend(po("view"),{invokeOnCallback:oo,invokeViewMethod:ha,invokeViewMethodKeepAlive:Mo});function X(){let{on:e}=st;e(Z.ON_RESIZE,J),e(Z.ON_APP_ENTER_FOREGROUND,te),e(Z.ON_APP_ENTER_BACKGROUND,ce)}function J(e){Ln(Si(),Z.ON_RESIZE,e),st.invokeOnCallback("onWindowResize",e)}function te(e){let t=Si();Ln(St(),Z.ON_SHOW,e),Ln(t,Z.ON_SHOW)}function ce(){Ln(St(),Z.ON_HIDE),Ln(Si(),Z.ON_HIDE)}let pe=[Z.ON_PAGE_SCROLL,Z.ON_REACH_BOTTOM];function Pe(){pe.forEach(e=>st.subscribe(e,fe(e)))}function fe(e){return(t,n)=>{Ln(parseInt(n),e,t)}}function we(){X(),Pe()}function ct(e){e.$vm=e,e.$mpType="app";let t=fn.ref(se().getLocale());Object.defineProperty(e,"$locale",{get(){return t.value},set(n){t.value=n}})}function gt(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 $t(){return{path:"",query:{},scene:1001,referrerInfo:{appId:"",extraData:{}}}}function Et(e,t){let n=e.$options||{};n.globalData=W.extend(n.globalData||{},t),Object.defineProperty(e,"globalData",{get(){return n.globalData},set(r){n.globalData=r}})}function je(e){if(e.indexOf("//")===0)return"https:"+e;if(Z.SCHEME_RE.test(e)||Z.DATA_RE.test(e))return e;if(cn(e))return"file://"+Bt(e);let t="file://"+Bt("_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+Zo(Z.addLeadingSlash(__id__),e);{let n=Si();if(n)return t+Zo(Z.addLeadingSlash(n.route),e)}}return e}let Bt=Z.cacheStringFunction(e=>s.io.convertLocalFileSystemURL(e).replace(/^\/?apps\//,"/android_asset/apps/").replace(/\/$/,""));function cn(e){return e.indexOf("_www")===0||e.indexOf("_doc")===0||e.indexOf("_documents")===0||e.indexOf("_downloads")===0}let Wt="success",ht="fail",Rn=[Wt,ht,"complete"];function Gt(e,t,n,r){if(!e)return;if(typeof n=="undefined")return e[t]();let[,o]=Xo(n,r);return Object.keys(o).length?e[t](ci(t,o)):e[t]()}function Ut(e,t,n,r){if(!e)return;let[o,c]=Xo(n,r);return Object.keys(c).length?e[t](o,ci(t,c)):e[t](o)}function Ft(e,t){let n=qt(e,t.$el);return n||console.error("Can not find `"+e+"`")}function qt(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,o=n.length;r<o;r++){let c=qt(e,n[r]);if(c)return c}}function Xo(e={},t){let n=Object.create(null),r=function(c){let h=e[c];W.isFunction(h)&&(n[c]=h,delete e[c])};return Rn.forEach(r),t&&t.forEach(r),[e,n]}function ci(e,t){return function(r){let o=r.type;delete r.type;let c=t[o];if(o===Wt?r.errMsg=`${e}:ok`:o===ht&&(r.errMsg=e+":fail "+(r.msg?" "+r.msg:"")),delete r.code,delete r.msg,W.isFunction(c)&&c(r),o===Wt||o===ht){let h=t.complete;W.isFunction(h)&&h(r)}}}let ei;function Gi(){return ei}function Ga(e){let t=e.$;Object.defineProperty(t.ctx,"$children",{get(){return Fn().map(r=>r.$vm)}});let n=t.appContext;ei=W.extend(n.app,{mountPage(r,o,c){let h=fn.createVNode(r,o);h.appContext=n,h.__page_container__=c,fn.render(h,c);let b=h.component.proxy;return b.__page_container__=c,b},unmountPage:r=>{let{__page_container__:o}=r;o&&(o.isUnmounted=!0,fn.render(null,o))}})}let Mn=[];function Dn(e){if(!e.$page.meta.isNVue)return Mn.push(e);let n=Mn.findIndex(r=>r.$page.id===e.$page.id);n>-1?Mn.splice(n,1,e):Mn.push(e)}function Ir(e){return Mn.find(t=>t.$page.id===e)}function Fn(){return Mn}function br(){let e=[];return Mn.forEach(t=>{t.$.__isTabBar?t.$.__isActive&&e.push(t):e.push(t)}),e}function zr(){let e=Si();!e||Qo(e)}function Qo(e){let t=Mn.findIndex(n=>n===e);t!==-1&&(e.$page.meta.isNVue||Gi().unmountPage(e),Mn.splice(t,1))}let cs={play(e){return Gt(e,"play")},pause(e){return Gt(e,"pause")},seek(e,t){return Ut(e,"seek",t.position)},stop(e){return Gt(e,"stop")},sendDanmu(e,t){return Ut(e,"sendDanmu",t)},playbackRate(e,t){return Ut(e,"playbackRate",t.rate)},requestFullScreen(e,t={}){return Ut(e,"requestFullScreen",t)},exitFullScreen(e){return Gt(e,"exitFullScreen")},showStatusBar(e){return Gt(e,"showStatusBar")},hideStatusBar(e){return Gt(e,"hideStatusBar")}};function nn(e,t,n,r){let o=Ir(t);if(o==null?void 0:o.$page.meta.isNVue){let c=o.$vm;return cs[n](Ft(e,c),r)}st.invokeViewMethod("video."+e,{videoId:e,type:n,data:r},t)}let pn={getCenterLocation(e,t){return Gt(e,"getCenterLocation",t)},moveToLocation(e,t){return Ut(e,"moveToLocation",t)},translateMarker(e,t){return Ut(e,"translateMarker",t,["animationEnd"])},includePoints(e,t){return Ut(e,"includePoints",t)},getRegion(e,t){return Gt(e,"getRegion",t)},getScale(e,t){return Gt(e,"getScale",t)},addCustomLayer(e,t){return Ut(e,"addCustomLayer",t)},removeCustomLayer(e,t){return Ut(e,"removeCustomLayer",t)},addGroundOverlay(e,t){return Ut(e,"addGroundOverlay",t)},removeGroundOverlay(e,t){return Ut(e,"removeGroundOverlay",t)},updateGroundOverlay(e,t){return Ut(e,"updateGroundOverlay",t)},initMarkerCluster(e,t){return Ut(e,"initMarkerCluster",t)},addMarkers(e,t){return Ut(e,"addMarkers",t)},removeMarkers(e,t){return Ut(e,"removeMarkers",t)},moveAlong(e,t){return Ut(e,"moveAlong",t)},setLocMarkerIcon(e,t){return Ut(e,"setLocMarkerIcon",t)},openMapApp(e,t){return Ut(e,"openMapApp",t)},on(e,t){return e.on(t.name,t.callback)}};function Vn(e,t,n,r,o){let c=Ir(t);if(c==null?void 0:c.$page.meta.isNVue){let h=c.$vm;return pn[n](Ft(e,h),r)}st.invokeViewMethod("map."+e,{type:n,data:r},t,o)}function zn(e){return`IntersectionObserver.${e}`}function Ci({reqId:e,component:t,options:n,callback:r},o){let c=zn(e);st.invokeViewMethod("addIntersectionObserver",{reqId:e,component:t.$el.nodeId,options:n,eventName:c},o),st.subscribe(c,r)}function us({reqId:e,component:t},n){st.invokeViewMethod("removeIntersectionObserver",{reqId:e,component:t.$el.nodeId},n),st.unsubscribe(zn(e))}function Ya(e){return`MediaQueryObserver.${e}`}function Na({reqId:e,component:t,options:n,callback:r},o){let c=Ya(e);st.invokeViewMethod("addMediaQueryObserver",{reqId:e,component:t.$el.nodeId,options:n,eventName:c},o),st.subscribe(c,r)}function ea({reqId:e,component:t},n){st.invokeViewMethod("removeMediaQueryObserver",{reqId:e,component:t.$el.nodeId},n),st.unsubscribe(Ya(e))}let so=200,qa=["unknown","none","ethernet","wifi","2g","3g","4g","5g"],fs="_doc/uniapp_temp",Wr=`${fs}_${Date.now()}`;function Ka(e){let t=e.split("/");return t[t.length-1]}function Ja(e){let t=e.split(".");return t.length>1?"."+t[t.length-1]:""}let Do="backbutton";function Li(){I.navigateBack({from:"backbutton",success(){}})}let _o=$t(),bo=$t();function ds(){return W.extend({},bo)}function Fo(){return W.extend({},_o)}function Bs({path:e,query:t,referrerInfo:n}){W.extend(_o,{path:e,query:t?Z.parseQuery(t):{},referrerInfo:n||{}})}function hs({path:e,query:t,referrerInfo:n}){return W.extend(bo,{path:e,query:t?Z.parseQuery(t):{},referrerInfo:n||{},channel:s.runtime.channel,launcher:s.runtime.launcher}),W.extend(_o,bo),W.extend({},bo)}function Ls(){let e=g.requireModule("plus");if(e.getRedirectInfo){let{path:t,query:n,extraData:r,userAction:o,fromAppid:c}=e.getRedirectInfo()||{},h={appId:c,extraData:{}};return r&&(h.extraData=r),{path:t||"",query:n?"?"+n:"",referrerInfo:h,userAction:o}}}var Be={};(function(e){var t=typeof Uint8Array!="undefined"&&typeof Uint16Array!="undefined"&&typeof Int32Array!="undefined";function n(c,h){return Object.prototype.hasOwnProperty.call(c,h)}e.assign=function(c){for(var h=Array.prototype.slice.call(arguments,1);h.length;){var b=h.shift();if(!!b){if(typeof b!="object")throw new TypeError(b+"must be non-object");for(var V in b)n(b,V)&&(c[V]=b[V])}}return c},e.shrinkBuf=function(c,h){return c.length===h?c:c.subarray?c.subarray(0,h):(c.length=h,c)};var r={arraySet:function(c,h,b,V,T){if(h.subarray&&c.subarray){c.set(h.subarray(b,b+V),T);return}for(var D=0;D<V;D++)c[T+D]=h[b+D]},flattenChunks:function(c){var h,b,V,T,D,_e;for(V=0,h=0,b=c.length;h<b;h++)V+=c[h].length;for(_e=new Uint8Array(V),T=0,h=0,b=c.length;h<b;h++)D=c[h],_e.set(D,T),T+=D.length;return _e}},o={arraySet:function(c,h,b,V,T){for(var D=0;D<V;D++)c[T+D]=h[b+D]},flattenChunks:function(c){return[].concat.apply([],c)}};e.setTyped=function(c){c?(e.Buf8=Uint8Array,e.Buf16=Uint16Array,e.Buf32=Int32Array,e.assign(e,r)):(e.Buf8=Array,e.Buf16=Array,e.Buf32=Array,e.assign(e,o))},e.setTyped(t)})(Be);var Pt={},Ot={},yn={},Er=Be,Ai=4,Yi=0,Eo=1,ka=2;function ta(e){for(var t=e.length;--t>=0;)e[t]=0}var gs=0,ps=1,dl=2,$l=3,Ul=258,pa=29,va=256,na=va+1+pa,ma=30,Ra=19,vs=2*na+1,ra=15,Ms=16,Hl=7,ms=256,Ds=16,Fs=17,Vs=18,_s=[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],xa=[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],hl=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7],$s=[16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15],jl=512,Vo=new Array((na+2)*2);ta(Vo);var Za=new Array(ma*2);ta(Za);var _a=new Array(jl);ta(_a);var Ba=new Array(Ul-$l+1);ta(Ba);var yo=new Array(pa);ta(yo);var ia=new Array(ma);ta(ia);function Xa(e,t,n,r,o){this.static_tree=e,this.extra_bits=t,this.extra_base=n,this.elems=r,this.max_length=o,this.has_stree=e&&e.length}var Us,gl,$o;function bs(e,t){this.dyn_tree=e,this.max_code=0,this.stat_desc=t}function Hs(e){return e<256?_a[e]:_a[256+(e>>>7)]}function Qa(e,t){e.pending_buf[e.pending++]=t&255,e.pending_buf[e.pending++]=t>>>8&255}function ti(e,t,n){e.bi_valid>Ms-n?(e.bi_buf|=t<<e.bi_valid&65535,Qa(e,e.bi_buf),e.bi_buf=t>>Ms-e.bi_valid,e.bi_valid+=n-Ms):(e.bi_buf|=t<<e.bi_valid&65535,e.bi_valid+=n)}function Br(e,t,n){ti(e,n[t*2],n[t*2+1])}function oa(e,t){var n=0;do n|=e&1,e>>>=1,n<<=1;while(--t>0);return n>>>1}function pl(e){e.bi_valid===16?(Qa(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 zl(e,t){var n=t.dyn_tree,r=t.max_code,o=t.stat_desc.static_tree,c=t.stat_desc.has_stree,h=t.stat_desc.extra_bits,b=t.stat_desc.extra_base,V=t.stat_desc.max_length,T,D,_e,Se,Ie,ut,dt=0;for(Se=0;Se<=ra;Se++)e.bl_count[Se]=0;for(n[e.heap[e.heap_max]*2+1]=0,T=e.heap_max+1;T<vs;T++)D=e.heap[T],Se=n[n[D*2+1]*2+1]+1,Se>V&&(Se=V,dt++),n[D*2+1]=Se,!(D>r)&&(e.bl_count[Se]++,Ie=0,D>=b&&(Ie=h[D-b]),ut=n[D*2],e.opt_len+=ut*(Se+Ie),c&&(e.static_len+=ut*(o[D*2+1]+Ie)));if(dt!==0){do{for(Se=V-1;e.bl_count[Se]===0;)Se--;e.bl_count[Se]--,e.bl_count[Se+1]+=2,e.bl_count[V]--,dt-=2}while(dt>0);for(Se=V;Se!==0;Se--)for(D=e.bl_count[Se];D!==0;)_e=e.heap[--T],!(_e>r)&&(n[_e*2+1]!==Se&&(e.opt_len+=(Se-n[_e*2+1])*n[_e*2],n[_e*2+1]=Se),D--)}}function js(e,t,n){var r=new Array(ra+1),o=0,c,h;for(c=1;c<=ra;c++)r[c]=o=o+n[c-1]<<1;for(h=0;h<=t;h++){var b=e[h*2+1];b!==0&&(e[h*2]=oa(r[b]++,b))}}function Es(){var e,t,n,r,o,c=new Array(ra+1);for(n=0,r=0;r<pa-1;r++)for(yo[r]=n,e=0;e<1<<_s[r];e++)Ba[n++]=r;for(Ba[n-1]=r,o=0,r=0;r<16;r++)for(ia[r]=o,e=0;e<1<<xa[r];e++)_a[o++]=r;for(o>>=7;r<ma;r++)for(ia[r]=o<<7,e=0;e<1<<xa[r]-7;e++)_a[256+o++]=r;for(t=0;t<=ra;t++)c[t]=0;for(e=0;e<=143;)Vo[e*2+1]=8,e++,c[8]++;for(;e<=255;)Vo[e*2+1]=9,e++,c[9]++;for(;e<=279;)Vo[e*2+1]=7,e++,c[7]++;for(;e<=287;)Vo[e*2+1]=8,e++,c[8]++;for(js(Vo,na+1,c),e=0;e<ma;e++)Za[e*2+1]=5,Za[e*2]=oa(e,5);Us=new Xa(Vo,_s,va+1,na,ra),gl=new Xa(Za,xa,0,ma,ra),$o=new Xa(new Array(0),hl,0,Ra,Hl)}function zs(e){var t;for(t=0;t<na;t++)e.dyn_ltree[t*2]=0;for(t=0;t<ma;t++)e.dyn_dtree[t*2]=0;for(t=0;t<Ra;t++)e.bl_tree[t*2]=0;e.dyn_ltree[ms*2]=1,e.opt_len=e.static_len=0,e.last_lit=e.matches=0}function Ws(e){e.bi_valid>8?Qa(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){Ws(e),r&&(Qa(e,n),Qa(e,~n)),Er.arraySet(e.pending_buf,e.window,t,n,e.pending),e.pending+=n}function Gs(e,t,n,r){var o=t*2,c=n*2;return e[o]<e[c]||e[o]===e[c]&&r[t]<=r[n]}function ys(e,t,n){for(var r=e.heap[n],o=n<<1;o<=e.heap_len&&(o<e.heap_len&&Gs(t,e.heap[o+1],e.heap[o],e.depth)&&o++,!Gs(t,r,e.heap[o],e.depth));)e.heap[n]=e.heap[o],n=o,o<<=1;e.heap[n]=r}function Ss(e,t,n){var r,o,c=0,h,b;if(e.last_lit!==0)do r=e.pending_buf[e.d_buf+c*2]<<8|e.pending_buf[e.d_buf+c*2+1],o=e.pending_buf[e.l_buf+c],c++,r===0?Br(e,o,t):(h=Ba[o],Br(e,h+va+1,t),b=_s[h],b!==0&&(o-=yo[h],ti(e,o,b)),r--,h=Hs(r),Br(e,h,n),b=xa[h],b!==0&&(r-=ia[h],ti(e,r,b)));while(c<e.last_lit);Br(e,ms,t)}function ws(e,t){var n=t.dyn_tree,r=t.stat_desc.static_tree,o=t.stat_desc.has_stree,c=t.stat_desc.elems,h,b,V=-1,T;for(e.heap_len=0,e.heap_max=vs,h=0;h<c;h++)n[h*2]!==0?(e.heap[++e.heap_len]=V=h,e.depth[h]=0):n[h*2+1]=0;for(;e.heap_len<2;)T=e.heap[++e.heap_len]=V<2?++V:0,n[T*2]=1,e.depth[T]=0,e.opt_len--,o&&(e.static_len-=r[T*2+1]);for(t.max_code=V,h=e.heap_len>>1;h>=1;h--)ys(e,n,h);T=c;do h=e.heap[1],e.heap[1]=e.heap[e.heap_len--],ys(e,n,1),b=e.heap[1],e.heap[--e.heap_max]=h,e.heap[--e.heap_max]=b,n[T*2]=n[h*2]+n[b*2],e.depth[T]=(e.depth[h]>=e.depth[b]?e.depth[h]:e.depth[b])+1,n[h*2+1]=n[b*2+1]=T,e.heap[1]=T++,ys(e,n,1);while(e.heap_len>=2);e.heap[--e.heap_max]=e.heap[1],zl(e,t),js(n,V,e.bl_count)}function ml(e,t,n){var r,o=-1,c,h=t[0*2+1],b=0,V=7,T=4;for(h===0&&(V=138,T=3),t[(n+1)*2+1]=65535,r=0;r<=n;r++)c=h,h=t[(r+1)*2+1],!(++b<V&&c===h)&&(b<T?e.bl_tree[c*2]+=b:c!==0?(c!==o&&e.bl_tree[c*2]++,e.bl_tree[Ds*2]++):b<=10?e.bl_tree[Fs*2]++:e.bl_tree[Vs*2]++,b=0,o=c,h===0?(V=138,T=3):c===h?(V=6,T=3):(V=7,T=4))}function _l(e,t,n){var r,o=-1,c,h=t[0*2+1],b=0,V=7,T=4;for(h===0&&(V=138,T=3),r=0;r<=n;r++)if(c=h,h=t[(r+1)*2+1],!(++b<V&&c===h)){if(b<T)do Br(e,c,e.bl_tree);while(--b!==0);else c!==0?(c!==o&&(Br(e,c,e.bl_tree),b--),Br(e,Ds,e.bl_tree),ti(e,b-3,2)):b<=10?(Br(e,Fs,e.bl_tree),ti(e,b-3,3)):(Br(e,Vs,e.bl_tree),ti(e,b-11,7));b=0,o=c,h===0?(V=138,T=3):c===h?(V=6,T=3):(V=7,T=4)}}function a(e){var t;for(ml(e,e.dyn_ltree,e.l_desc.max_code),ml(e,e.dyn_dtree,e.d_desc.max_code),ws(e,e.bl_desc),t=Ra-1;t>=3&&e.bl_tree[$s[t]*2+1]===0;t--);return e.opt_len+=3*(t+1)+5+5+4,t}function u(e,t,n,r){var o;for(ti(e,t-257,5),ti(e,n-1,5),ti(e,r-4,4),o=0;o<r;o++)ti(e,e.bl_tree[$s[o]*2+1],3);_l(e,e.dyn_ltree,t-1),_l(e,e.dyn_dtree,n-1)}function v(e){var t=4093624447,n;for(n=0;n<=31;n++,t>>>=1)if(t&1&&e.dyn_ltree[n*2]!==0)return Yi;if(e.dyn_ltree[9*2]!==0||e.dyn_ltree[10*2]!==0||e.dyn_ltree[13*2]!==0)return Eo;for(n=32;n<va;n++)if(e.dyn_ltree[n*2]!==0)return Eo;return Yi}var y=!1;function P(e){y||(Es(),y=!0),e.l_desc=new bs(e.dyn_ltree,Us),e.d_desc=new bs(e.dyn_dtree,gl),e.bl_desc=new bs(e.bl_tree,$o),e.bi_buf=0,e.bi_valid=0,zs(e)}function O(e,t,n,r){ti(e,(gs<<1)+(r?1:0),3),vl(e,t,n,!0)}function F(e){ti(e,ps<<1,3),Br(e,ms,Vo),pl(e)}function G(e,t,n,r){var o,c,h=0;e.level>0?(e.strm.data_type===ka&&(e.strm.data_type=v(e)),ws(e,e.l_desc),ws(e,e.d_desc),h=a(e),o=e.opt_len+3+7>>>3,c=e.static_len+3+7>>>3,c<=o&&(o=c)):o=c=n+5,n+4<=o&&t!==-1?O(e,t,n,r):e.strategy===Ai||c===o?(ti(e,(ps<<1)+(r?1:0),3),Ss(e,Vo,Za)):(ti(e,(dl<<1)+(r?1:0),3),u(e,e.l_desc.max_code+1,e.d_desc.max_code+1,h+1),Ss(e,e.dyn_ltree,e.dyn_dtree)),zs(e),r&&Ws(e)}function Y(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[(Ba[n]+va+1)*2]++,e.dyn_dtree[Hs(t)*2]++),e.last_lit===e.lit_bufsize-1}yn._tr_init=P,yn._tr_stored_block=O,yn._tr_flush_block=G,yn._tr_tally=Y,yn._tr_align=F;function le(e,t,n,r){for(var o=e&65535|0,c=e>>>16&65535|0,h=0;n!==0;){h=n>2e3?2e3:n,n-=h;do o=o+t[r++]|0,c=c+o|0;while(--h);o%=65521,c%=65521}return o|c<<16|0}var ze=le;function at(){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 ge=at();function Ge(e,t,n,r){var o=ge,c=r+n;e^=-1;for(var h=r;h<c;h++)e=e>>>8^o[(e^t[h])&255];return e^-1}var Xe=Ge,wt={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"},it=Be,Ce=yn,Ee=ze,Te=Xe,lt=wt,Ne=0,Ct=1,i=3,l=4,f=5,_=0,A=1,C=-2,N=-3,M=-5,H=-1,ne=1,ve=2,Le=3,ue=4,ke=0,Ye=2,ft=8,Qe=9,Re=15,me=8,ye=29,Fe=256,Ae=Fe+1+ye,_t=30,At=19,Ke=2*Ae+1,Nt=15,L=3,j=258,ae=j+L+1,re=32,oe=42,$e=69,rt=73,qe=91,Je=103,Ue=113,Vt=666,pt=1,kt=2,Rt=3,xn=4,kn=3;function hn(e,t){return e.msg=lt[t],t}function mn(e){return(e<<1)-(e>4?9:0)}function ur(e){for(var t=e.length;--t>=0;)e[t]=0}function ni(e){var t=e.state,n=t.pending;n>e.avail_out&&(n=e.avail_out),n!==0&&(it.arraySet(e.output,t.pending_buf,t.pending_out,n,e.next_out),e.next_out+=n,t.pending_out+=n,e.total_out+=n,e.avail_out-=n,t.pending-=n,t.pending===0&&(t.pending_out=0))}function Kt(e,t){Ce._tr_flush_block(e,e.block_start>=0?e.block_start:-1,e.strstart-e.block_start,t),e.block_start=e.strstart,ni(e.strm)}function rn(e,t){e.pending_buf[e.pending++]=t}function lo(e,t){e.pending_buf[e.pending++]=t>>>8&255,e.pending_buf[e.pending++]=t&255}function q(e,t,n,r){var o=e.avail_in;return o>r&&(o=r),o===0?0:(e.avail_in-=o,it.arraySet(t,e.input,e.next_in,o,n),e.state.wrap===1?e.adler=Ee(e.adler,t,o,n):e.state.wrap===2&&(e.adler=Te(e.adler,t,o,n)),e.next_in+=o,e.total_in+=o,o)}function ee(e,t){var n=e.max_chain_length,r=e.strstart,o,c,h=e.prev_length,b=e.nice_match,V=e.strstart>e.w_size-ae?e.strstart-(e.w_size-ae):0,T=e.window,D=e.w_mask,_e=e.prev,Se=e.strstart+j,Ie=T[r+h-1],ut=T[r+h];e.prev_length>=e.good_match&&(n>>=2),b>e.lookahead&&(b=e.lookahead);do if(o=t,!(T[o+h]!==ut||T[o+h-1]!==Ie||T[o]!==T[r]||T[++o]!==T[r+1])){r+=2,o++;do;while(T[++r]===T[++o]&&T[++r]===T[++o]&&T[++r]===T[++o]&&T[++r]===T[++o]&&T[++r]===T[++o]&&T[++r]===T[++o]&&T[++r]===T[++o]&&T[++r]===T[++o]&&r<Se);if(c=j-(Se-r),r=Se-j,c>h){if(e.match_start=t,h=c,c>=b)break;Ie=T[r+h-1],ut=T[r+h]}}while((t=_e[t&D])>V&&--n!==0);return h<=e.lookahead?h:e.lookahead}function be(e){var t=e.w_size,n,r,o,c,h;do{if(c=e.window_size-e.lookahead-e.strstart,e.strstart>=t+(t-ae)){it.arraySet(e.window,e.window,t,t,0),e.match_start-=t,e.strstart-=t,e.block_start-=t,r=e.hash_size,n=r;do o=e.head[--n],e.head[n]=o>=t?o-t:0;while(--r);r=t,n=r;do o=e.prev[--n],e.prev[n]=o>=t?o-t:0;while(--r);c+=t}if(e.strm.avail_in===0)break;if(r=q(e.strm,e.window,e.strstart+e.lookahead,c),e.lookahead+=r,e.lookahead+e.insert>=L)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+L-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<L)););}while(e.lookahead<ae&&e.strm.avail_in!==0)}function Me(e,t){var n=65535;for(n>e.pending_buf_size-5&&(n=e.pending_buf_size-5);;){if(e.lookahead<=1){if(be(e),e.lookahead===0&&t===Ne)return pt;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,Kt(e,!1),e.strm.avail_out===0)||e.strstart-e.block_start>=e.w_size-ae&&(Kt(e,!1),e.strm.avail_out===0))return pt}return e.insert=0,t===l?(Kt(e,!0),e.strm.avail_out===0?Rt:xn):(e.strstart>e.block_start&&(Kt(e,!1),e.strm.avail_out===0),pt)}function De(e,t){for(var n,r;;){if(e.lookahead<ae){if(be(e),e.lookahead<ae&&t===Ne)return pt;if(e.lookahead===0)break}if(n=0,e.lookahead>=L&&(e.ins_h=(e.ins_h<<e.hash_shift^e.window[e.strstart+L-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-ae&&(e.match_length=ee(e,n)),e.match_length>=L)if(r=Ce._tr_tally(e,e.strstart-e.match_start,e.match_length-L),e.lookahead-=e.match_length,e.match_length<=e.max_lazy_match&&e.lookahead>=L){e.match_length--;do e.strstart++,e.ins_h=(e.ins_h<<e.hash_shift^e.window[e.strstart+L-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=Ce._tr_tally(e,0,e.window[e.strstart]),e.lookahead--,e.strstart++;if(r&&(Kt(e,!1),e.strm.avail_out===0))return pt}return e.insert=e.strstart<L-1?e.strstart:L-1,t===l?(Kt(e,!0),e.strm.avail_out===0?Rt:xn):e.last_lit&&(Kt(e,!1),e.strm.avail_out===0)?pt:kt}function Ze(e,t){for(var n,r,o;;){if(e.lookahead<ae){if(be(e),e.lookahead<ae&&t===Ne)return pt;if(e.lookahead===0)break}if(n=0,e.lookahead>=L&&(e.ins_h=(e.ins_h<<e.hash_shift^e.window[e.strstart+L-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=L-1,n!==0&&e.prev_length<e.max_lazy_match&&e.strstart-n<=e.w_size-ae&&(e.match_length=ee(e,n),e.match_length<=5&&(e.strategy===ne||e.match_length===L&&e.strstart-e.match_start>4096)&&(e.match_length=L-1)),e.prev_length>=L&&e.match_length<=e.prev_length){o=e.strstart+e.lookahead-L,r=Ce._tr_tally(e,e.strstart-1-e.prev_match,e.prev_length-L),e.lookahead-=e.prev_length-1,e.prev_length-=2;do++e.strstart<=o&&(e.ins_h=(e.ins_h<<e.hash_shift^e.window[e.strstart+L-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=L-1,e.strstart++,r&&(Kt(e,!1),e.strm.avail_out===0))return pt}else if(e.match_available){if(r=Ce._tr_tally(e,0,e.window[e.strstart-1]),r&&Kt(e,!1),e.strstart++,e.lookahead--,e.strm.avail_out===0)return pt}else e.match_available=1,e.strstart++,e.lookahead--}return e.match_available&&(r=Ce._tr_tally(e,0,e.window[e.strstart-1]),e.match_available=0),e.insert=e.strstart<L-1?e.strstart:L-1,t===l?(Kt(e,!0),e.strm.avail_out===0?Rt:xn):e.last_lit&&(Kt(e,!1),e.strm.avail_out===0)?pt:kt}function vt(e,t){for(var n,r,o,c,h=e.window;;){if(e.lookahead<=j){if(be(e),e.lookahead<=j&&t===Ne)return pt;if(e.lookahead===0)break}if(e.match_length=0,e.lookahead>=L&&e.strstart>0&&(o=e.strstart-1,r=h[o],r===h[++o]&&r===h[++o]&&r===h[++o])){c=e.strstart+j;do;while(r===h[++o]&&r===h[++o]&&r===h[++o]&&r===h[++o]&&r===h[++o]&&r===h[++o]&&r===h[++o]&&r===h[++o]&&o<c);e.match_length=j-(c-o),e.match_length>e.lookahead&&(e.match_length=e.lookahead)}if(e.match_length>=L?(n=Ce._tr_tally(e,1,e.match_length-L),e.lookahead-=e.match_length,e.strstart+=e.match_length,e.match_length=0):(n=Ce._tr_tally(e,0,e.window[e.strstart]),e.lookahead--,e.strstart++),n&&(Kt(e,!1),e.strm.avail_out===0))return pt}return e.insert=0,t===l?(Kt(e,!0),e.strm.avail_out===0?Rt:xn):e.last_lit&&(Kt(e,!1),e.strm.avail_out===0)?pt:kt}function et(e,t){for(var n;;){if(e.lookahead===0&&(be(e),e.lookahead===0)){if(t===Ne)return pt;break}if(e.match_length=0,n=Ce._tr_tally(e,0,e.window[e.strstart]),e.lookahead--,e.strstart++,n&&(Kt(e,!1),e.strm.avail_out===0))return pt}return e.insert=0,t===l?(Kt(e,!0),e.strm.avail_out===0?Rt:xn):e.last_lit&&(Kt(e,!1),e.strm.avail_out===0)?pt:kt}function tt(e,t,n,r,o){this.good_length=e,this.max_lazy=t,this.nice_length=n,this.max_chain=r,this.func=o}var He;He=[new tt(0,0,0,0,Me),new tt(4,4,8,4,De),new tt(4,5,16,8,De),new tt(4,6,32,32,De),new tt(4,4,16,16,Ze),new tt(8,16,32,32,Ze),new tt(8,16,128,128,Ze),new tt(8,32,128,256,Ze),new tt(32,128,258,1024,Ze),new tt(32,258,258,4096,Ze)];function Ht(e){e.window_size=2*e.w_size,ur(e.head),e.max_lazy_match=He[e.level].max_lazy,e.good_match=He[e.level].good_length,e.nice_match=He[e.level].nice_length,e.max_chain_length=He[e.level].max_chain,e.strstart=0,e.block_start=0,e.lookahead=0,e.insert=0,e.match_length=e.prev_length=L-1,e.match_available=0,e.ins_h=0}function Dt(){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=ft,this.last_flush=-1,this.w_size=0,this.w_bits=0,this.w_mask=0,this.window=null,this.window_size=0,this.prev=null,this.head=null,this.ins_h=0,this.hash_size=0,this.hash_bits=0,this.hash_mask=0,this.hash_shift=0,this.block_start=0,this.match_length=0,this.prev_match=0,this.match_available=0,this.strstart=0,this.match_start=0,this.lookahead=0,this.prev_length=0,this.max_chain_length=0,this.max_lazy_match=0,this.level=0,this.strategy=0,this.good_match=0,this.nice_match=0,this.dyn_ltree=new it.Buf16(Ke*2),this.dyn_dtree=new it.Buf16((2*_t+1)*2),this.bl_tree=new it.Buf16((2*At+1)*2),ur(this.dyn_ltree),ur(this.dyn_dtree),ur(this.bl_tree),this.l_desc=null,this.d_desc=null,this.bl_desc=null,this.bl_count=new it.Buf16(Nt+1),this.heap=new it.Buf16(2*Ae+1),ur(this.heap),this.heap_len=0,this.heap_max=0,this.depth=new it.Buf16(2*Ae+1),ur(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 zt(e){var t;return!e||!e.state?hn(e,C):(e.total_in=e.total_out=0,e.data_type=Ye,t=e.state,t.pending=0,t.pending_out=0,t.wrap<0&&(t.wrap=-t.wrap),t.status=t.wrap?oe:Ue,e.adler=t.wrap===2?0:1,t.last_flush=Ne,Ce._tr_init(t),_)}function wn(e){var t=zt(e);return t===_&&Ht(e.state),t}function Gr(e,t){return!e||!e.state||e.state.wrap!==2?C:(e.state.gzhead=t,_)}function qn(e,t,n,r,o,c){if(!e)return C;var h=1;if(t===H&&(t=6),r<0?(h=0,r=-r):r>15&&(h=2,r-=16),o<1||o>Qe||n!==ft||r<8||r>15||t<0||t>9||c<0||c>ue)return hn(e,C);r===8&&(r=9);var b=new Dt;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=o+7,b.hash_size=1<<b.hash_bits,b.hash_mask=b.hash_size-1,b.hash_shift=~~((b.hash_bits+L-1)/L),b.window=new it.Buf8(b.w_size*2),b.head=new it.Buf16(b.hash_size),b.prev=new it.Buf16(b.w_size),b.lit_bufsize=1<<o+6,b.pending_buf_size=b.lit_bufsize*4,b.pending_buf=new it.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=c,b.method=n,wn(e)}function ui(e,t){return qn(e,t,ft,Re,me,ke)}function Uo(e,t){var n,r,o,c;if(!e||!e.state||t>f||t<0)return e?hn(e,C):C;if(r=e.state,!e.output||!e.input&&e.avail_in!==0||r.status===Vt&&t!==l)return hn(e,e.avail_out===0?M:C);if(r.strm=e,n=r.last_flush,r.last_flush=t,r.status===oe)if(r.wrap===2)e.adler=0,rn(r,31),rn(r,139),rn(r,8),r.gzhead?(rn(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)),rn(r,r.gzhead.time&255),rn(r,r.gzhead.time>>8&255),rn(r,r.gzhead.time>>16&255),rn(r,r.gzhead.time>>24&255),rn(r,r.level===9?2:r.strategy>=ve||r.level<2?4:0),rn(r,r.gzhead.os&255),r.gzhead.extra&&r.gzhead.extra.length&&(rn(r,r.gzhead.extra.length&255),rn(r,r.gzhead.extra.length>>8&255)),r.gzhead.hcrc&&(e.adler=Te(e.adler,r.pending_buf,r.pending,0)),r.gzindex=0,r.status=$e):(rn(r,0),rn(r,0),rn(r,0),rn(r,0),rn(r,0),rn(r,r.level===9?2:r.strategy>=ve||r.level<2?4:0),rn(r,kn),r.status=Ue);else{var h=ft+(r.w_bits-8<<4)<<8,b=-1;r.strategy>=ve||r.level<2?b=0:r.level<6?b=1:r.level===6?b=2:b=3,h|=b<<6,r.strstart!==0&&(h|=re),h+=31-h%31,r.status=Ue,lo(r,h),r.strstart!==0&&(lo(r,e.adler>>>16),lo(r,e.adler&65535)),e.adler=1}if(r.status===$e)if(r.gzhead.extra){for(o=r.pending;r.gzindex<(r.gzhead.extra.length&65535)&&!(r.pending===r.pending_buf_size&&(r.gzhead.hcrc&&r.pending>o&&(e.adler=Te(e.adler,r.pending_buf,r.pending-o,o)),ni(e),o=r.pending,r.pending===r.pending_buf_size));)rn(r,r.gzhead.extra[r.gzindex]&255),r.gzindex++;r.gzhead.hcrc&&r.pending>o&&(e.adler=Te(e.adler,r.pending_buf,r.pending-o,o)),r.gzindex===r.gzhead.extra.length&&(r.gzindex=0,r.status=rt)}else r.status=rt;if(r.status===rt)if(r.gzhead.name){o=r.pending;do{if(r.pending===r.pending_buf_size&&(r.gzhead.hcrc&&r.pending>o&&(e.adler=Te(e.adler,r.pending_buf,r.pending-o,o)),ni(e),o=r.pending,r.pending===r.pending_buf_size)){c=1;break}r.gzindex<r.gzhead.name.length?c=r.gzhead.name.charCodeAt(r.gzindex++)&255:c=0,rn(r,c)}while(c!==0);r.gzhead.hcrc&&r.pending>o&&(e.adler=Te(e.adler,r.pending_buf,r.pending-o,o)),c===0&&(r.gzindex=0,r.status=qe)}else r.status=qe;if(r.status===qe)if(r.gzhead.comment){o=r.pending;do{if(r.pending===r.pending_buf_size&&(r.gzhead.hcrc&&r.pending>o&&(e.adler=Te(e.adler,r.pending_buf,r.pending-o,o)),ni(e),o=r.pending,r.pending===r.pending_buf_size)){c=1;break}r.gzindex<r.gzhead.comment.length?c=r.gzhead.comment.charCodeAt(r.gzindex++)&255:c=0,rn(r,c)}while(c!==0);r.gzhead.hcrc&&r.pending>o&&(e.adler=Te(e.adler,r.pending_buf,r.pending-o,o)),c===0&&(r.status=Je)}else r.status=Je;if(r.status===Je&&(r.gzhead.hcrc?(r.pending+2>r.pending_buf_size&&ni(e),r.pending+2<=r.pending_buf_size&&(rn(r,e.adler&255),rn(r,e.adler>>8&255),e.adler=0,r.status=Ue)):r.status=Ue),r.pending!==0){if(ni(e),e.avail_out===0)return r.last_flush=-1,_}else if(e.avail_in===0&&mn(t)<=mn(n)&&t!==l)return hn(e,M);if(r.status===Vt&&e.avail_in!==0)return hn(e,M);if(e.avail_in!==0||r.lookahead!==0||t!==Ne&&r.status!==Vt){var V=r.strategy===ve?et(r,t):r.strategy===Le?vt(r,t):He[r.level].func(r,t);if((V===Rt||V===xn)&&(r.status=Vt),V===pt||V===Rt)return e.avail_out===0&&(r.last_flush=-1),_;if(V===kt&&(t===Ct?Ce._tr_align(r):t!==f&&(Ce._tr_stored_block(r,0,0,!1),t===i&&(ur(r.head),r.lookahead===0&&(r.strstart=0,r.block_start=0,r.insert=0))),ni(e),e.avail_out===0))return r.last_flush=-1,_}return t!==l?_:r.wrap<=0?A:(r.wrap===2?(rn(r,e.adler&255),rn(r,e.adler>>8&255),rn(r,e.adler>>16&255),rn(r,e.adler>>24&255),rn(r,e.total_in&255),rn(r,e.total_in>>8&255),rn(r,e.total_in>>16&255),rn(r,e.total_in>>24&255)):(lo(r,e.adler>>>16),lo(r,e.adler&65535)),ni(e),r.wrap>0&&(r.wrap=-r.wrap),r.pending!==0?_:A)}function es(e){var t;return!e||!e.state?C:(t=e.state.status,t!==oe&&t!==$e&&t!==rt&&t!==qe&&t!==Je&&t!==Ue&&t!==Vt?hn(e,C):(e.state=null,t===Ue?hn(e,N):_))}function Cs(e,t){var n=t.length,r,o,c,h,b,V,T,D;if(!e||!e.state||(r=e.state,h=r.wrap,h===2||h===1&&r.status!==oe||r.lookahead))return C;for(h===1&&(e.adler=Ee(e.adler,t,n,0)),r.wrap=0,n>=r.w_size&&(h===0&&(ur(r.head),r.strstart=0,r.block_start=0,r.insert=0),D=new it.Buf8(r.w_size),it.arraySet(D,t,n-r.w_size,r.w_size,0),t=D,n=r.w_size),b=e.avail_in,V=e.next_in,T=e.input,e.avail_in=n,e.next_in=0,e.input=t,be(r);r.lookahead>=L;){o=r.strstart,c=r.lookahead-(L-1);do r.ins_h=(r.ins_h<<r.hash_shift^r.window[o+L-1])&r.hash_mask,r.prev[o&r.w_mask]=r.head[r.ins_h],r.head[r.ins_h]=o,o++;while(--c);r.strstart=o,r.lookahead=L-1,be(r)}return r.strstart+=r.lookahead,r.block_start=r.strstart,r.insert=r.lookahead,r.lookahead=0,r.match_length=r.prev_length=L-1,r.match_available=0,e.next_in=V,e.input=T,e.avail_in=b,r.wrap=h,_}Ot.deflateInit=ui,Ot.deflateInit2=qn,Ot.deflateReset=wn,Ot.deflateResetKeep=zt,Ot.deflateSetHeader=Gr,Ot.deflate=Uo,Ot.deflateEnd=es,Ot.deflateSetDictionary=Cs,Ot.deflateInfo="pako deflate (from Nodeca project)";var tr={},La=Be,As=!0,qi=!0;try{String.fromCharCode.apply(null,[0])}catch(e){As=!1}try{String.fromCharCode.apply(null,new Uint8Array(1))}catch(e){qi=!1}for(var Ho=new La.Buf8(256),co=0;co<256;co++)Ho[co]=co>=252?6:co>=248?5:co>=240?4:co>=224?3:co>=192?2:1;Ho[254]=Ho[254]=1,tr.string2buf=function(e){var t,n,r,o,c,h=e.length,b=0;for(o=0;o<h;o++)n=e.charCodeAt(o),(n&64512)===55296&&o+1<h&&(r=e.charCodeAt(o+1),(r&64512)===56320&&(n=65536+(n-55296<<10)+(r-56320),o++)),b+=n<128?1:n<2048?2:n<65536?3:4;for(t=new La.Buf8(b),c=0,o=0;c<b;o++)n=e.charCodeAt(o),(n&64512)===55296&&o+1<h&&(r=e.charCodeAt(o+1),(r&64512)===56320&&(n=65536+(n-55296<<10)+(r-56320),o++)),n<128?t[c++]=n:n<2048?(t[c++]=192|n>>>6,t[c++]=128|n&63):n<65536?(t[c++]=224|n>>>12,t[c++]=128|n>>>6&63,t[c++]=128|n&63):(t[c++]=240|n>>>18,t[c++]=128|n>>>12&63,t[c++]=128|n>>>6&63,t[c++]=128|n&63);return t};function ba(e,t){if(t<65534&&(e.subarray&&qi||!e.subarray&&As))return String.fromCharCode.apply(null,La.shrinkBuf(e,t));for(var n="",r=0;r<t;r++)n+=String.fromCharCode(e[r]);return n}tr.buf2binstring=function(e){return ba(e,e.length)},tr.binstring2buf=function(e){for(var t=new La.Buf8(e.length),n=0,r=t.length;n<r;n++)t[n]=e.charCodeAt(n);return t},tr.buf2string=function(e,t){var n,r,o,c,h=t||e.length,b=new Array(h*2);for(r=0,n=0;n<h;){if(o=e[n++],o<128){b[r++]=o;continue}if(c=Ho[o],c>4){b[r++]=65533,n+=c-1;continue}for(o&=c===2?31:c===3?15:7;c>1&&n<h;)o=o<<6|e[n++]&63,c--;if(c>1){b[r++]=65533;continue}o<65536?b[r++]=o:(o-=65536,b[r++]=55296|o>>10&1023,b[r++]=56320|o&1023)}return ba(b,r)},tr.utf8border=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+Ho[e[n]]>t?n:t};function ts(){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 aa=ts,sa=Ot,jo=Be,bl=tr,Ys=wt,Ec=aa,Wl=Object.prototype.toString,Dv=0,vu=4,El=0,$f=1,Uf=2,Fv=-1,Vv=0,$v=8;function qs(e){if(!(this instanceof qs))return new qs(e);this.options=jo.assign({level:Fv,method:$v,chunkSize:16384,windowBits:15,memLevel:8,strategy:Vv,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 Ec,this.strm.avail_out=0;var n=sa.deflateInit2(this.strm,t.level,t.method,t.windowBits,t.memLevel,t.strategy);if(n!==El)throw new Error(Ys[n]);if(t.header&&sa.deflateSetHeader(this.strm,t.header),t.dictionary){var r;if(typeof t.dictionary=="string"?r=bl.string2buf(t.dictionary):Wl.call(t.dictionary)==="[object ArrayBuffer]"?r=new Uint8Array(t.dictionary):r=t.dictionary,n=sa.deflateSetDictionary(this.strm,r),n!==El)throw new Error(Ys[n]);this._dict_set=!0}}qs.prototype.push=function(e,t){var n=this.strm,r=this.options.chunkSize,o,c;if(this.ended)return!1;c=t===~~t?t:t===!0?vu:Dv,typeof e=="string"?n.input=bl.string2buf(e):Wl.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 jo.Buf8(r),n.next_out=0,n.avail_out=r),o=sa.deflate(n,c),o!==$f&&o!==El)return this.onEnd(o),this.ended=!0,!1;(n.avail_out===0||n.avail_in===0&&(c===vu||c===Uf))&&(this.options.to==="string"?this.onData(bl.buf2binstring(jo.shrinkBuf(n.output,n.next_out))):this.onData(jo.shrinkBuf(n.output,n.next_out)))}while((n.avail_in>0||n.avail_out===0)&&o!==$f);return c===vu?(o=sa.deflateEnd(this.strm),this.onEnd(o),this.ended=!0,o===El):(c===Uf&&(this.onEnd(El),n.avail_out=0),!0)},qs.prototype.onData=function(e){this.chunks.push(e)},qs.prototype.onEnd=function(e){e===El&&(this.options.to==="string"?this.result=this.chunks.join(""):this.result=jo.flattenChunks(this.chunks)),this.chunks=[],this.err=e,this.msg=this.strm.msg};function mu(e,t){var n=new qs(t);if(n.push(e,!0),n.err)throw n.msg||Ys[n.err];return n.result}function Uv(e,t){return t=t||{},t.raw=!0,mu(e,t)}function Hv(e,t){return t=t||{},t.gzip=!0,mu(e,t)}Pt.Deflate=qs,Pt.deflate=mu,Pt.deflateRaw=Uv,Pt.gzip=Hv;var Gl={},Ea={},yc=30,jv=12,zv=function(t,n){var r,o,c,h,b,V,T,D,_e,Se,Ie,ut,dt,Tt,It,vn,un,jt,yt,En,an,Xt,An,dr,Qt;r=t.state,o=t.next_in,dr=t.input,c=o+(t.avail_in-5),h=t.next_out,Qt=t.output,b=h-(n-t.avail_out),V=h+(t.avail_out-257),T=r.dmax,D=r.wsize,_e=r.whave,Se=r.wnext,Ie=r.window,ut=r.hold,dt=r.bits,Tt=r.lencode,It=r.distcode,vn=(1<<r.lenbits)-1,un=(1<<r.distbits)-1;e:do{dt<15&&(ut+=dr[o++]<<dt,dt+=8,ut+=dr[o++]<<dt,dt+=8),jt=Tt[ut&vn];t:for(;;){if(yt=jt>>>24,ut>>>=yt,dt-=yt,yt=jt>>>16&255,yt===0)Qt[h++]=jt&65535;else if(yt&16){En=jt&65535,yt&=15,yt&&(dt<yt&&(ut+=dr[o++]<<dt,dt+=8),En+=ut&(1<<yt)-1,ut>>>=yt,dt-=yt),dt<15&&(ut+=dr[o++]<<dt,dt+=8,ut+=dr[o++]<<dt,dt+=8),jt=It[ut&un];n:for(;;){if(yt=jt>>>24,ut>>>=yt,dt-=yt,yt=jt>>>16&255,yt&16){if(an=jt&65535,yt&=15,dt<yt&&(ut+=dr[o++]<<dt,dt+=8,dt<yt&&(ut+=dr[o++]<<dt,dt+=8)),an+=ut&(1<<yt)-1,an>T){t.msg="invalid distance too far back",r.mode=yc;break e}if(ut>>>=yt,dt-=yt,yt=h-b,an>yt){if(yt=an-yt,yt>_e&&r.sane){t.msg="invalid distance too far back",r.mode=yc;break e}if(Xt=0,An=Ie,Se===0){if(Xt+=D-yt,yt<En){En-=yt;do Qt[h++]=Ie[Xt++];while(--yt);Xt=h-an,An=Qt}}else if(Se<yt){if(Xt+=D+Se-yt,yt-=Se,yt<En){En-=yt;do Qt[h++]=Ie[Xt++];while(--yt);if(Xt=0,Se<En){yt=Se,En-=yt;do Qt[h++]=Ie[Xt++];while(--yt);Xt=h-an,An=Qt}}}else if(Xt+=Se-yt,yt<En){En-=yt;do Qt[h++]=Ie[Xt++];while(--yt);Xt=h-an,An=Qt}for(;En>2;)Qt[h++]=An[Xt++],Qt[h++]=An[Xt++],Qt[h++]=An[Xt++],En-=3;En&&(Qt[h++]=An[Xt++],En>1&&(Qt[h++]=An[Xt++]))}else{Xt=h-an;do Qt[h++]=Qt[Xt++],Qt[h++]=Qt[Xt++],Qt[h++]=Qt[Xt++],En-=3;while(En>2);En&&(Qt[h++]=Qt[Xt++],En>1&&(Qt[h++]=Qt[Xt++]))}}else if((yt&64)===0){jt=It[(jt&65535)+(ut&(1<<yt)-1)];continue n}else{t.msg="invalid distance code",r.mode=yc;break e}break}}else if((yt&64)===0){jt=Tt[(jt&65535)+(ut&(1<<yt)-1)];continue t}else if(yt&32){r.mode=jv;break e}else{t.msg="invalid literal/length code",r.mode=yc;break e}break}}while(o<c&&h<V);En=dt>>3,o-=En,dt-=En<<3,ut&=(1<<dt)-1,t.next_in=o,t.next_out=h,t.avail_in=o<c?5+(c-o):5-(o-c),t.avail_out=h<V?257+(V-h):257-(h-V),r.hold=ut,r.bits=dt},Hf=Be,yl=15,jf=852,zf=592,Wf=0,_u=1,Gf=2,Wv=[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],Gv=[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],Yv=[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],qv=[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],Kv=function(t,n,r,o,c,h,b,V){var T=V.bits,D=0,_e=0,Se=0,Ie=0,ut=0,dt=0,Tt=0,It=0,vn=0,un=0,jt,yt,En,an,Xt,An=null,dr=0,Qt,Oa=new Hf.Buf16(yl+1),Zc=new Hf.Buf16(yl+1),Xc=null,Op=0,Tp,Qc,eu;for(D=0;D<=yl;D++)Oa[D]=0;for(_e=0;_e<o;_e++)Oa[n[r+_e]]++;for(ut=T,Ie=yl;Ie>=1&&Oa[Ie]===0;Ie--);if(ut>Ie&&(ut=Ie),Ie===0)return c[h++]=1<<24|64<<16|0,c[h++]=1<<24|64<<16|0,V.bits=1,0;for(Se=1;Se<Ie&&Oa[Se]===0;Se++);for(ut<Se&&(ut=Se),It=1,D=1;D<=yl;D++)if(It<<=1,It-=Oa[D],It<0)return-1;if(It>0&&(t===Wf||Ie!==1))return-1;for(Zc[1]=0,D=1;D<yl;D++)Zc[D+1]=Zc[D]+Oa[D];for(_e=0;_e<o;_e++)n[r+_e]!==0&&(b[Zc[n[r+_e]]++]=_e);if(t===Wf?(An=Xc=b,Qt=19):t===_u?(An=Wv,dr-=257,Xc=Gv,Op-=257,Qt=256):(An=Yv,Xc=qv,Qt=-1),un=0,_e=0,D=Se,Xt=h,dt=ut,Tt=0,En=-1,vn=1<<ut,an=vn-1,t===_u&&vn>jf||t===Gf&&vn>zf)return 1;for(;;){Tp=D-Tt,b[_e]<Qt?(Qc=0,eu=b[_e]):b[_e]>Qt?(Qc=Xc[Op+b[_e]],eu=An[dr+b[_e]]):(Qc=32+64,eu=0),jt=1<<D-Tt,yt=1<<dt,Se=yt;do yt-=jt,c[Xt+(un>>Tt)+yt]=Tp<<24|Qc<<16|eu|0;while(yt!==0);for(jt=1<<D-1;un&jt;)jt>>=1;if(jt!==0?(un&=jt-1,un+=jt):un=0,_e++,--Oa[D]===0){if(D===Ie)break;D=n[r+b[_e]]}if(D>ut&&(un&an)!==En){for(Tt===0&&(Tt=ut),Xt+=Se,dt=D-Tt,It=1<<dt;dt+Tt<Ie&&(It-=Oa[dt+Tt],!(It<=0));)dt++,It<<=1;if(vn+=1<<dt,t===_u&&vn>jf||t===Gf&&vn>zf)return 1;En=un&an,c[En]=ut<<24|dt<<16|Xt-h|0}}return un!==0&&(c[Xt+un]=D-Tt<<24|64<<16|0),V.bits=ut,0},zo=Be,bu=ze,Ma=Xe,Jv=zv,Yl=Kv,Zv=0,Yf=1,qf=2,Kf=4,Xv=5,Sc=6,Ks=0,Qv=1,em=2,la=-2,Jf=-3,Zf=-4,tm=-5,Xf=8,Qf=1,ed=2,td=3,nd=4,rd=5,id=6,od=7,ad=8,sd=9,ld=10,wc=11,ns=12,Eu=13,cd=14,yu=15,ud=16,fd=17,dd=18,hd=19,Cc=20,Ac=21,gd=22,pd=23,vd=24,md=25,_d=26,Su=27,bd=28,Ed=29,yr=30,yd=31,nm=32,rm=852,im=592,om=15,am=om;function Sd(e){return(e>>>24&255)+(e>>>8&65280)+((e&65280)<<8)+((e&255)<<24)}function sm(){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 zo.Buf16(320),this.work=new zo.Buf16(288),this.lendyn=null,this.distdyn=null,this.sane=0,this.back=0,this.was=0}function wd(e){var t;return!e||!e.state?la:(t=e.state,e.total_in=e.total_out=t.total=0,e.msg="",t.wrap&&(e.adler=t.wrap&1),t.mode=Qf,t.last=0,t.havedict=0,t.dmax=32768,t.head=null,t.hold=0,t.bits=0,t.lencode=t.lendyn=new zo.Buf32(rm),t.distcode=t.distdyn=new zo.Buf32(im),t.sane=1,t.back=-1,Ks)}function Cd(e){var t;return!e||!e.state?la:(t=e.state,t.wsize=0,t.whave=0,t.wnext=0,wd(e))}function Ad(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))?la:(r.window!==null&&r.wbits!==t&&(r.window=null),r.wrap=n,r.wbits=t,Cd(e))}function Od(e,t){var n,r;return e?(r=new sm,e.state=r,r.window=null,n=Ad(e,t),n!==Ks&&(e.state=null),n):la}function lm(e){return Od(e,am)}var Td=!0,wu,Cu;function cm(e){if(Td){var t;for(wu=new zo.Buf32(512),Cu=new zo.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(Yl(Yf,e.lens,0,288,wu,0,e.work,{bits:9}),t=0;t<32;)e.lens[t++]=5;Yl(qf,e.lens,0,32,Cu,0,e.work,{bits:5}),Td=!1}e.lencode=wu,e.lenbits=9,e.distcode=Cu,e.distbits=5}function Pd(e,t,n,r){var o,c=e.state;return c.window===null&&(c.wsize=1<<c.wbits,c.wnext=0,c.whave=0,c.window=new zo.Buf8(c.wsize)),r>=c.wsize?(zo.arraySet(c.window,t,n-c.wsize,c.wsize,0),c.wnext=0,c.whave=c.wsize):(o=c.wsize-c.wnext,o>r&&(o=r),zo.arraySet(c.window,t,n-r,o,c.wnext),r-=o,r?(zo.arraySet(c.window,t,n-r,r,0),c.wnext=r,c.whave=c.wsize):(c.wnext+=o,c.wnext===c.wsize&&(c.wnext=0),c.whave<c.wsize&&(c.whave+=o))),0}function um(e,t){var n,r,o,c,h,b,V,T,D,_e,Se,Ie,ut,dt,Tt=0,It,vn,un,jt,yt,En,an,Xt,An=new zo.Buf8(4),dr,Qt,Oa=[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 la;n=e.state,n.mode===ns&&(n.mode=Eu),h=e.next_out,o=e.output,V=e.avail_out,c=e.next_in,r=e.input,b=e.avail_in,T=n.hold,D=n.bits,_e=b,Se=V,Xt=Ks;e:for(;;)switch(n.mode){case Qf:if(n.wrap===0){n.mode=Eu;break}for(;D<16;){if(b===0)break e;b--,T+=r[c++]<<D,D+=8}if(n.wrap&2&&T===35615){n.check=0,An[0]=T&255,An[1]=T>>>8&255,n.check=Ma(n.check,An,2,0),T=0,D=0,n.mode=ed;break}if(n.flags=0,n.head&&(n.head.done=!1),!(n.wrap&1)||(((T&255)<<8)+(T>>8))%31){e.msg="incorrect header check",n.mode=yr;break}if((T&15)!==Xf){e.msg="unknown compression method",n.mode=yr;break}if(T>>>=4,D-=4,an=(T&15)+8,n.wbits===0)n.wbits=an;else if(an>n.wbits){e.msg="invalid window size",n.mode=yr;break}n.dmax=1<<an,e.adler=n.check=1,n.mode=T&512?ld:ns,T=0,D=0;break;case ed:for(;D<16;){if(b===0)break e;b--,T+=r[c++]<<D,D+=8}if(n.flags=T,(n.flags&255)!==Xf){e.msg="unknown compression method",n.mode=yr;break}if(n.flags&57344){e.msg="unknown header flags set",n.mode=yr;break}n.head&&(n.head.text=T>>8&1),n.flags&512&&(An[0]=T&255,An[1]=T>>>8&255,n.check=Ma(n.check,An,2,0)),T=0,D=0,n.mode=td;case td:for(;D<32;){if(b===0)break e;b--,T+=r[c++]<<D,D+=8}n.head&&(n.head.time=T),n.flags&512&&(An[0]=T&255,An[1]=T>>>8&255,An[2]=T>>>16&255,An[3]=T>>>24&255,n.check=Ma(n.check,An,4,0)),T=0,D=0,n.mode=nd;case nd:for(;D<16;){if(b===0)break e;b--,T+=r[c++]<<D,D+=8}n.head&&(n.head.xflags=T&255,n.head.os=T>>8),n.flags&512&&(An[0]=T&255,An[1]=T>>>8&255,n.check=Ma(n.check,An,2,0)),T=0,D=0,n.mode=rd;case rd:if(n.flags&1024){for(;D<16;){if(b===0)break e;b--,T+=r[c++]<<D,D+=8}n.length=T,n.head&&(n.head.extra_len=T),n.flags&512&&(An[0]=T&255,An[1]=T>>>8&255,n.check=Ma(n.check,An,2,0)),T=0,D=0}else n.head&&(n.head.extra=null);n.mode=id;case id:if(n.flags&1024&&(Ie=n.length,Ie>b&&(Ie=b),Ie&&(n.head&&(an=n.head.extra_len-n.length,n.head.extra||(n.head.extra=new Array(n.head.extra_len)),zo.arraySet(n.head.extra,r,c,Ie,an)),n.flags&512&&(n.check=Ma(n.check,r,Ie,c)),b-=Ie,c+=Ie,n.length-=Ie),n.length))break e;n.length=0,n.mode=od;case od:if(n.flags&2048){if(b===0)break e;Ie=0;do an=r[c+Ie++],n.head&&an&&n.length<65536&&(n.head.name+=String.fromCharCode(an));while(an&&Ie<b);if(n.flags&512&&(n.check=Ma(n.check,r,Ie,c)),b-=Ie,c+=Ie,an)break e}else n.head&&(n.head.name=null);n.length=0,n.mode=ad;case ad:if(n.flags&4096){if(b===0)break e;Ie=0;do an=r[c+Ie++],n.head&&an&&n.length<65536&&(n.head.comment+=String.fromCharCode(an));while(an&&Ie<b);if(n.flags&512&&(n.check=Ma(n.check,r,Ie,c)),b-=Ie,c+=Ie,an)break e}else n.head&&(n.head.comment=null);n.mode=sd;case sd:if(n.flags&512){for(;D<16;){if(b===0)break e;b--,T+=r[c++]<<D,D+=8}if(T!==(n.check&65535)){e.msg="header crc mismatch",n.mode=yr;break}T=0,D=0}n.head&&(n.head.hcrc=n.flags>>9&1,n.head.done=!0),e.adler=n.check=0,n.mode=ns;break;case ld:for(;D<32;){if(b===0)break e;b--,T+=r[c++]<<D,D+=8}e.adler=n.check=Sd(T),T=0,D=0,n.mode=wc;case wc:if(n.havedict===0)return e.next_out=h,e.avail_out=V,e.next_in=c,e.avail_in=b,n.hold=T,n.bits=D,em;e.adler=n.check=1,n.mode=ns;case ns:if(t===Xv||t===Sc)break e;case Eu:if(n.last){T>>>=D&7,D-=D&7,n.mode=Su;break}for(;D<3;){if(b===0)break e;b--,T+=r[c++]<<D,D+=8}switch(n.last=T&1,T>>>=1,D-=1,T&3){case 0:n.mode=cd;break;case 1:if(cm(n),n.mode=Cc,t===Sc){T>>>=2,D-=2;break e}break;case 2:n.mode=fd;break;case 3:e.msg="invalid block type",n.mode=yr}T>>>=2,D-=2;break;case cd:for(T>>>=D&7,D-=D&7;D<32;){if(b===0)break e;b--,T+=r[c++]<<D,D+=8}if((T&65535)!==(T>>>16^65535)){e.msg="invalid stored block lengths",n.mode=yr;break}if(n.length=T&65535,T=0,D=0,n.mode=yu,t===Sc)break e;case yu:n.mode=ud;case ud:if(Ie=n.length,Ie){if(Ie>b&&(Ie=b),Ie>V&&(Ie=V),Ie===0)break e;zo.arraySet(o,r,c,Ie,h),b-=Ie,c+=Ie,V-=Ie,h+=Ie,n.length-=Ie;break}n.mode=ns;break;case fd:for(;D<14;){if(b===0)break e;b--,T+=r[c++]<<D,D+=8}if(n.nlen=(T&31)+257,T>>>=5,D-=5,n.ndist=(T&31)+1,T>>>=5,D-=5,n.ncode=(T&15)+4,T>>>=4,D-=4,n.nlen>286||n.ndist>30){e.msg="too many length or distance symbols",n.mode=yr;break}n.have=0,n.mode=dd;case dd:for(;n.have<n.ncode;){for(;D<3;){if(b===0)break e;b--,T+=r[c++]<<D,D+=8}n.lens[Oa[n.have++]]=T&7,T>>>=3,D-=3}for(;n.have<19;)n.lens[Oa[n.have++]]=0;if(n.lencode=n.lendyn,n.lenbits=7,dr={bits:n.lenbits},Xt=Yl(Zv,n.lens,0,19,n.lencode,0,n.work,dr),n.lenbits=dr.bits,Xt){e.msg="invalid code lengths set",n.mode=yr;break}n.have=0,n.mode=hd;case hd:for(;n.have<n.nlen+n.ndist;){for(;Tt=n.lencode[T&(1<<n.lenbits)-1],It=Tt>>>24,vn=Tt>>>16&255,un=Tt&65535,!(It<=D);){if(b===0)break e;b--,T+=r[c++]<<D,D+=8}if(un<16)T>>>=It,D-=It,n.lens[n.have++]=un;else{if(un===16){for(Qt=It+2;D<Qt;){if(b===0)break e;b--,T+=r[c++]<<D,D+=8}if(T>>>=It,D-=It,n.have===0){e.msg="invalid bit length repeat",n.mode=yr;break}an=n.lens[n.have-1],Ie=3+(T&3),T>>>=2,D-=2}else if(un===17){for(Qt=It+3;D<Qt;){if(b===0)break e;b--,T+=r[c++]<<D,D+=8}T>>>=It,D-=It,an=0,Ie=3+(T&7),T>>>=3,D-=3}else{for(Qt=It+7;D<Qt;){if(b===0)break e;b--,T+=r[c++]<<D,D+=8}T>>>=It,D-=It,an=0,Ie=11+(T&127),T>>>=7,D-=7}if(n.have+Ie>n.nlen+n.ndist){e.msg="invalid bit length repeat",n.mode=yr;break}for(;Ie--;)n.lens[n.have++]=an}}if(n.mode===yr)break;if(n.lens[256]===0){e.msg="invalid code -- missing end-of-block",n.mode=yr;break}if(n.lenbits=9,dr={bits:n.lenbits},Xt=Yl(Yf,n.lens,0,n.nlen,n.lencode,0,n.work,dr),n.lenbits=dr.bits,Xt){e.msg="invalid literal/lengths set",n.mode=yr;break}if(n.distbits=6,n.distcode=n.distdyn,dr={bits:n.distbits},Xt=Yl(qf,n.lens,n.nlen,n.ndist,n.distcode,0,n.work,dr),n.distbits=dr.bits,Xt){e.msg="invalid distances set",n.mode=yr;break}if(n.mode=Cc,t===Sc)break e;case Cc:n.mode=Ac;case Ac:if(b>=6&&V>=258){e.next_out=h,e.avail_out=V,e.next_in=c,e.avail_in=b,n.hold=T,n.bits=D,Jv(e,Se),h=e.next_out,o=e.output,V=e.avail_out,c=e.next_in,r=e.input,b=e.avail_in,T=n.hold,D=n.bits,n.mode===ns&&(n.back=-1);break}for(n.back=0;Tt=n.lencode[T&(1<<n.lenbits)-1],It=Tt>>>24,vn=Tt>>>16&255,un=Tt&65535,!(It<=D);){if(b===0)break e;b--,T+=r[c++]<<D,D+=8}if(vn&&(vn&240)===0){for(jt=It,yt=vn,En=un;Tt=n.lencode[En+((T&(1<<jt+yt)-1)>>jt)],It=Tt>>>24,vn=Tt>>>16&255,un=Tt&65535,!(jt+It<=D);){if(b===0)break e;b--,T+=r[c++]<<D,D+=8}T>>>=jt,D-=jt,n.back+=jt}if(T>>>=It,D-=It,n.back+=It,n.length=un,vn===0){n.mode=_d;break}if(vn&32){n.back=-1,n.mode=ns;break}if(vn&64){e.msg="invalid literal/length code",n.mode=yr;break}n.extra=vn&15,n.mode=gd;case gd:if(n.extra){for(Qt=n.extra;D<Qt;){if(b===0)break e;b--,T+=r[c++]<<D,D+=8}n.length+=T&(1<<n.extra)-1,T>>>=n.extra,D-=n.extra,n.back+=n.extra}n.was=n.length,n.mode=pd;case pd:for(;Tt=n.distcode[T&(1<<n.distbits)-1],It=Tt>>>24,vn=Tt>>>16&255,un=Tt&65535,!(It<=D);){if(b===0)break e;b--,T+=r[c++]<<D,D+=8}if((vn&240)===0){for(jt=It,yt=vn,En=un;Tt=n.distcode[En+((T&(1<<jt+yt)-1)>>jt)],It=Tt>>>24,vn=Tt>>>16&255,un=Tt&65535,!(jt+It<=D);){if(b===0)break e;b--,T+=r[c++]<<D,D+=8}T>>>=jt,D-=jt,n.back+=jt}if(T>>>=It,D-=It,n.back+=It,vn&64){e.msg="invalid distance code",n.mode=yr;break}n.offset=un,n.extra=vn&15,n.mode=vd;case vd:if(n.extra){for(Qt=n.extra;D<Qt;){if(b===0)break e;b--,T+=r[c++]<<D,D+=8}n.offset+=T&(1<<n.extra)-1,T>>>=n.extra,D-=n.extra,n.back+=n.extra}if(n.offset>n.dmax){e.msg="invalid distance too far back",n.mode=yr;break}n.mode=md;case md:if(V===0)break e;if(Ie=Se-V,n.offset>Ie){if(Ie=n.offset-Ie,Ie>n.whave&&n.sane){e.msg="invalid distance too far back",n.mode=yr;break}Ie>n.wnext?(Ie-=n.wnext,ut=n.wsize-Ie):ut=n.wnext-Ie,Ie>n.length&&(Ie=n.length),dt=n.window}else dt=o,ut=h-n.offset,Ie=n.length;Ie>V&&(Ie=V),V-=Ie,n.length-=Ie;do o[h++]=dt[ut++];while(--Ie);n.length===0&&(n.mode=Ac);break;case _d:if(V===0)break e;o[h++]=n.length,V--,n.mode=Ac;break;case Su:if(n.wrap){for(;D<32;){if(b===0)break e;b--,T|=r[c++]<<D,D+=8}if(Se-=V,e.total_out+=Se,n.total+=Se,Se&&(e.adler=n.check=n.flags?Ma(n.check,o,Se,h-Se):bu(n.check,o,Se,h-Se)),Se=V,(n.flags?T:Sd(T))!==n.check){e.msg="incorrect data check",n.mode=yr;break}T=0,D=0}n.mode=bd;case bd:if(n.wrap&&n.flags){for(;D<32;){if(b===0)break e;b--,T+=r[c++]<<D,D+=8}if(T!==(n.total&4294967295)){e.msg="incorrect length check",n.mode=yr;break}T=0,D=0}n.mode=Ed;case Ed:Xt=Qv;break e;case yr:Xt=Jf;break e;case yd:return Zf;case nm:default:return la}return e.next_out=h,e.avail_out=V,e.next_in=c,e.avail_in=b,n.hold=T,n.bits=D,(n.wsize||Se!==e.avail_out&&n.mode<yr&&(n.mode<Su||t!==Kf))&&Pd(e,e.output,e.next_out,Se-e.avail_out),_e-=e.avail_in,Se-=e.avail_out,e.total_in+=_e,e.total_out+=Se,n.total+=Se,n.wrap&&Se&&(e.adler=n.check=n.flags?Ma(n.check,o,Se,e.next_out-Se):bu(n.check,o,Se,e.next_out-Se)),e.data_type=n.bits+(n.last?64:0)+(n.mode===ns?128:0)+(n.mode===Cc||n.mode===yu?256:0),(_e===0&&Se===0||t===Kf)&&Xt===Ks&&(Xt=tm),Xt}function fm(e){if(!e||!e.state)return la;var t=e.state;return t.window&&(t.window=null),e.state=null,Ks}function dm(e,t){var n;return!e||!e.state||(n=e.state,(n.wrap&2)===0)?la:(n.head=t,t.done=!1,Ks)}function hm(e,t){var n=t.length,r,o,c;return!e||!e.state||(r=e.state,r.wrap!==0&&r.mode!==wc)?la:r.mode===wc&&(o=1,o=bu(o,t,n,0),o!==r.check)?Jf:(c=Pd(e,t,n,n),c?(r.mode=yd,Zf):(r.havedict=1,Ks))}Ea.inflateReset=Cd,Ea.inflateReset2=Ad,Ea.inflateResetKeep=wd,Ea.inflateInit=lm,Ea.inflateInit2=Od,Ea.inflate=um,Ea.inflateEnd=fm,Ea.inflateGetHeader=dm,Ea.inflateSetDictionary=hm,Ea.inflateInfo="pako inflate (from Nodeca project)";var Id={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 gm(){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 pm=gm,Sl=Ea,ql=Be,Oc=tr,Yr=Id,Au=wt,vm=aa,mm=pm,Nd=Object.prototype.toString;function Js(e){if(!(this instanceof Js))return new Js(e);this.options=ql.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 vm,this.strm.avail_out=0;var n=Sl.inflateInit2(this.strm,t.windowBits);if(n!==Yr.Z_OK)throw new Error(Au[n]);if(this.header=new mm,Sl.inflateGetHeader(this.strm,this.header),t.dictionary&&(typeof t.dictionary=="string"?t.dictionary=Oc.string2buf(t.dictionary):Nd.call(t.dictionary)==="[object ArrayBuffer]"&&(t.dictionary=new Uint8Array(t.dictionary)),t.raw&&(n=Sl.inflateSetDictionary(this.strm,t.dictionary),n!==Yr.Z_OK)))throw new Error(Au[n])}Js.prototype.push=function(e,t){var n=this.strm,r=this.options.chunkSize,o=this.options.dictionary,c,h,b,V,T,D=!1;if(this.ended)return!1;h=t===~~t?t:t===!0?Yr.Z_FINISH:Yr.Z_NO_FLUSH,typeof e=="string"?n.input=Oc.binstring2buf(e):Nd.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 ql.Buf8(r),n.next_out=0,n.avail_out=r),c=Sl.inflate(n,Yr.Z_NO_FLUSH),c===Yr.Z_NEED_DICT&&o&&(c=Sl.inflateSetDictionary(this.strm,o)),c===Yr.Z_BUF_ERROR&&D===!0&&(c=Yr.Z_OK,D=!1),c!==Yr.Z_STREAM_END&&c!==Yr.Z_OK)return this.onEnd(c),this.ended=!0,!1;n.next_out&&(n.avail_out===0||c===Yr.Z_STREAM_END||n.avail_in===0&&(h===Yr.Z_FINISH||h===Yr.Z_SYNC_FLUSH))&&(this.options.to==="string"?(b=Oc.utf8border(n.output,n.next_out),V=n.next_out-b,T=Oc.buf2string(n.output,b),n.next_out=V,n.avail_out=r-V,V&&ql.arraySet(n.output,n.output,b,V,0),this.onData(T)):this.onData(ql.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)&&c!==Yr.Z_STREAM_END);return c===Yr.Z_STREAM_END&&(h=Yr.Z_FINISH),h===Yr.Z_FINISH?(c=Sl.inflateEnd(this.strm),this.onEnd(c),this.ended=!0,c===Yr.Z_OK):(h===Yr.Z_SYNC_FLUSH&&(this.onEnd(Yr.Z_OK),n.avail_out=0),!0)},Js.prototype.onData=function(e){this.chunks.push(e)},Js.prototype.onEnd=function(e){e===Yr.Z_OK&&(this.options.to==="string"?this.result=this.chunks.join(""):this.result=ql.flattenChunks(this.chunks)),this.chunks=[],this.err=e,this.msg=this.strm.msg};function Ou(e,t){var n=new Js(t);if(n.push(e,!0),n.err)throw n.msg||Au[n.err];return n.result}function _m(e,t){return t=t||{},t.raw=!0,Ou(e,t)}Gl.Inflate=Js,Gl.inflate=Ou,Gl.inflateRaw=_m,Gl.ungzip=Ou;var bm=Be.assign,Em=Pt,ym=Gl,Sm=Id,kd={};bm(kd,Em,ym,Sm);var Rd=kd;let wm="upx2px",Cm=[{name:"upx",type:[Number,String],required:!0}],Am=1e-4,Om=750,xd=!1,Tu=0,Bd=0,Ld=960,Md=375,Dd=750;function Tm(){let{platform:e,pixelRatio:t,windowWidth:n}=$r();Tu=n,Bd=t,xd=e==="ios"}function Pu(e,t){let n=Number(e);return isNaN(n)?t:n}function Pm(){let e=B.globalStyle||{};Ld=Pu(e.rpxCalcMaxDeviceWidth,960),Md=Pu(e.rpxCalcBaseDeviceWidth,375),Dd=Pu(e.rpxCalcBaseDeviceWidth,750)}let Im=Mt(wm,(e,t)=>{if(Tu===0&&(Tm(),Pm()),e=Number(e),e===0)return 0;let n=t||Tu;n=e===Dd||n<=Ld?n:Md;let r=e/Om*n;return r<0&&(r=-r),r=Math.floor(r+Am),r===0&&(Bd===1||!xd?r=1:r=.5),e<0?-r:r},Cm),Nm="addInterceptor",km="removeInterceptor",Fd=[{name:"method",type:[String,Object],required:!0}],Rm=Fd;function Vd(e,t){Object.keys(t).forEach(n=>{W.isFunction(t[n])&&(e[n]=xm(e[n],t[n]))})}function $d(e,t){!e||!t||Object.keys(t).forEach(n=>{let r=e[n],o=t[n];W.isArray(r)&&W.isFunction(o)&&W.remove(r,o)})}function xm(e,t){let n=t?e?e.concat(t):W.isArray(t)?t:[t]:e;return n&&Bm(n)}function Bm(e){let t=[];for(let n=0;n<e.length;n++)t.indexOf(e[n])===-1&&t.push(e[n]);return t}let Lm=Mt(Nm,(e,t)=>{W.isString(e)&&W.isPlainObject(t)?Vd(hr[e]||(hr[e]={}),t):W.isPlainObject(e)&&Vd(Nn,e)},Fd),Mm=Mt(km,(e,t)=>{W.isString(e)?W.isPlainObject(t)?$d(hr[e],t):delete hr[e]:W.isPlainObject(e)&&$d(Nn,e)},Rm),Dm={},Fm="$on",Ud=[{name:"event",type:String,required:!0},{name:"callback",type:Function,required:!0}],Vm="$once",$m=Ud,Um="$off",Hm=[{name:"event",type:[String,Array]},{name:"callback",type:Function}],jm="$emit",zm=[{name:"event",type:String,required:!0}],Zs=new Z.Emitter,Wm=Mt(Fm,(e,t)=>(Zs.on(e,t),()=>Zs.off(e,t)),Ud),Gm=Mt(Vm,(e,t)=>(Zs.once(e,t),()=>Zs.off(e,t)),$m),Ym=Mt(Um,(e,t)=>{if(!e){Zs.e={};return}W.isArray(e)||(e=[e]),e.forEach(n=>Zs.off(n,t))},Hm),qm=Mt(jm,(e,...t)=>{Zs.emit(e,...t)},zm),Hd=[{name:"id",type:String,required:!0}],Km="createVideoContext",Jm="createMapContext",Zm=Hd,Xm="createCanvasContext",Qm=[{name:"canvasId",type:String,required:!0},{name:"componentInstance",type:Object}],e_="createInnerAudioContext",t_="createLivePusherContext",n_=Hd.concat({name:"componentInstance",type:Object}),r_=[.5,.8,1,1.25,1.5,2];class Iu{constructor(t,n){this.id=t,this.pageId=n}play(){nn(this.id,this.pageId,"play")}pause(){nn(this.id,this.pageId,"pause")}stop(){nn(this.id,this.pageId,"stop")}seek(t){nn(this.id,this.pageId,"seek",{position:t})}sendDanmu(t){nn(this.id,this.pageId,"sendDanmu",t)}playbackRate(t){~r_.indexOf(t)||(t=1),nn(this.id,this.pageId,"playbackRate",{rate:t})}requestFullScreen(t={}){nn(this.id,this.pageId,"requestFullScreen",t)}exitFullScreen(){nn(this.id,this.pageId,"exitFullScreen")}showStatusBar(){nn(this.id,this.pageId,"showStatusBar")}hideStatusBar(){nn(this.id,this.pageId,"hideStatusBar")}}let i_=Mt(Km,(e,t)=>t?new Iu(e,er(t)):new Iu(e,er(_r()))),o_=(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)},Oi=(e,t,n,r)=>{Vn(e,t,n,r,o=>{r&&o_(r,o)})};class Nu{constructor(t,n){this.id=t,this.pageId=n}getCenterLocation(t){Oi(this.id,this.pageId,"getCenterLocation",t)}moveToLocation(t){Oi(this.id,this.pageId,"moveToLocation",t)}getScale(t){Oi(this.id,this.pageId,"getScale",t)}getRegion(t){Oi(this.id,this.pageId,"getRegion",t)}includePoints(t){Oi(this.id,this.pageId,"includePoints",t)}translateMarker(t){Oi(this.id,this.pageId,"translateMarker",t)}$getAppMap(){return s.maps.getMapById(this.pageId+"-map-"+this.id)}addCustomLayer(t){Oi(this.id,this.pageId,"addCustomLayer",t)}removeCustomLayer(t){Oi(this.id,this.pageId,"removeCustomLayer",t)}addGroundOverlay(t){Oi(this.id,this.pageId,"addGroundOverlay",t)}removeGroundOverlay(t){Oi(this.id,this.pageId,"removeGroundOverlay",t)}updateGroundOverlay(t){Oi(this.id,this.pageId,"updateGroundOverlay",t)}initMarkerCluster(t){Oi(this.id,this.pageId,"initMarkerCluster",t)}addMarkers(t){Oi(this.id,this.pageId,"addMarkers",t)}removeMarkers(t){Oi(this.id,this.pageId,"removeMarkers",t)}moveAlong(t){Oi(this.id,this.pageId,"moveAlong",t)}setLocMarkerIcon(t){Oi(this.id,this.pageId,"setLocMarkerIcon",t)}openMapApp(t){Oi(this.id,this.pageId,"openMapApp",t)}on(t){Oi(this.id,this.pageId,"on",t)}}let a_=Mt(Jm,(e,t)=>t?new Nu(e,er(t)):new Nu(e,er(_r())),Zm);function Os(e,t){return function(n,r){n?r[e]=Math.round(n):typeof t!="undefined"&&(r[e]=t)}}let jd=Os("width"),zd=Os("height"),s_="canvasGetImageData",Wd={formatArgs:{x:Os("x"),y:Os("y"),width:jd,height:zd}},Gd={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}},l_="canvasPutImageData",c_=Wd,u_=W.extend({data:{type:Uint8ClampedArray,required:!0}},Gd,{height:{type:Number}}),Yd={PNG:"png",JPG:"jpg",JPEG:"jpg"},f_="canvasToTempFilePath",d_={formatArgs:{x:Os("x",0),y:Os("y",0),width:jd,height:zd,destWidth:Os("destWidth"),destHeight:Os("destHeight"),fileType(e,t){e=(e||"").toUpperCase();let n=Yd[e];n||(n=Yd.PNG),t.fileType=n},quality(e,t){t.quality=e&&e>0&&e<1?e:1}}},h_={x:Number,y:Number,width:Number,height:Number,destWidth:Number,destHeight:Number,canvasId:{type:String,required:!0},fileType:String,quality:Number};function Tc(e,t,n,r,o){st.invokeViewMethod(`canvas.${e}`,{type:n,data:r},t,c=>{o&&o(c)})}var g_=["scale","rotate","translate","setTransform","transform"],p_=["drawImage","fillText","fill","stroke","fillRect","strokeRect","clearRect","strokeText"],v_=["setFillStyle","setTextAlign","setStrokeStyle","setGlobalAlpha","setShadow","setFontSize","setLineCap","setLineJoin","setLineWidth","setMiterLimit","setTextBaseline","setLineDash"];function m_(e,t){let r=document.createElement("canvas").getContext("2d");return r.font=t,r.measureText(e).width||0}let qd={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 ku(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),o=parseInt(t[1].slice(2,4),16),c=parseInt(t[1].slice(4),16);return[r,o,c,255]}if((t=/^#([0-9|A-F|a-f]{3})$/.exec(e))!=null){let r=t[1].slice(0,1),o=t[1].slice(1,2),c=t[1].slice(2,3);return r=parseInt(r+r,16),o=parseInt(o+o,16),c=parseInt(c+c,16),[r,o,c,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,o){return o===3?Math.floor(255*parseFloat(r.trim())):Math.min(255,parseInt(r.trim()))});var n=e.toLowerCase();if(W.hasOwn(qd,n)){t=/^#([0-9|A-F|a-f]{6,8})$/.exec(qd[n]);let r=parseInt(t[1].slice(0,2),16),o=parseInt(t[1].slice(2,4),16),c=parseInt(t[1].slice(4,6),16),h=parseInt(t[1].slice(6,8),16);return h=h>=0?h:255,[r,o,c,h]}return console.error("unsupported color:"+e),[0,0,0,255]}class Kd{constructor(t,n){this.type=t,this.data=n,this.colorStop=[]}addColorStop(t,n){this.colorStop.push([t,ku(n)])}}class __{constructor(t,n){this.type="pattern",this.data=t,this.colorStop=n}}class b_{constructor(t){this.width=t}}class Kl{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=[],Tc(this.id,this.pageId,"actionsChanged",{actions:r,reserve:t},n)}createLinearGradient(t,n,r,o){return new Kd("linear",[t,n,r,o])}createCircularGradient(t,n,r){return new Kd("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 __(t,n)}measureText(t){let n=this.state.font,r=0;{let o=s.webview.all().find(c=>c.getURL().endsWith("www/__uniappview.html"));o&&(r=Number(o.evalJSSync(`(${m_.toString()})(${JSON.stringify(t)},${JSON.stringify(n)})`)))}return new b_(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,o){this.path.push({method:"quadraticCurveTo",data:[t,n,r,o]}),this.subpath.push([r,o])}bezierCurveTo(t,n,r,o,c,h){this.path.push({method:"bezierCurveTo",data:[t,n,r,o,c,h]}),this.subpath.push([c,h])}arc(t,n,r,o,c,h=!1){this.path.push({method:"arc",data:[t,n,r,o,c,h]}),this.subpath.push([t,n])}rect(t,n,r,o){this.path.push({method:"rect",data:[t,n,r,o]}),this.subpath=[[t,n]]}arcTo(t,n,r,o,c){this.path.push({method:"arcTo",data:[t,n,r,o,c]}),this.subpath.push([r,o])}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 o=r[1].trim().split(/\s/),c=parseFloat(r[3]),h=r[7],b=[];o.forEach(function(T,D){["italic","oblique","normal"].indexOf(T)>-1?(b.push({method:"setFontStyle",data:[T]}),n.state.fontStyle=T):["bold","normal"].indexOf(T)>-1?(b.push({method:"setFontWeight",data:[T]}),n.state.fontWeight=T):D===0?(b.push({method:"setFontStyle",data:["normal"]}),n.state.fontStyle="normal"):D===1&&V()}),o.length===1&&V(),o=b.map(function(T){return T.data[0]}).join(" "),this.state.fontSize=c,this.state.fontFamily=h,this.actions.push({method:"setFont",data:[`${o} ${c}px ${h}`]})}else console.warn("Failed to set 'font' on 'CanvasContext': invalid format.");function V(){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 E_=Z.once(()=>{[...g_,...p_].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,o,c,h){this.actions.push({method:"fillPath",data:[{method:"rect",data:[r,o,c,h]}]})};case"strokeRect":return function(r,o,c,h){this.actions.push({method:"strokePath",data:[{method:"rect",data:[r,o,c,h]}]})};case"fillText":case"strokeText":return function(r,o,c,h){var b=[r.toString(),o,c];typeof h=="number"&&b.push(h),this.actions.push({method:n,data:b})};case"drawImage":return function(r,o,c,h,b,V,T,D,_e){_e===void 0&&(V=o,T=c,D=h,_e=b,o=void 0,c=void 0,h=void 0,b=void 0);var Se;function Ie(ut){return typeof ut=="number"}Se=Ie(o)&&Ie(c)&&Ie(h)&&Ie(b)?[r,V,T,D,_e,o,c,h,b]:Ie(D)&&Ie(_e)?[r,V,T,D,_e]:[r,V,T],this.actions.push({method:n,data:Se})};default:return function(...r){this.actions.push({method:n,data:r})}}}Kl.prototype[e]=t(e)}),v_.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",ku(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,o,c,h){h=ku(h),this.actions.push({method:n,data:[r,o,c,h]}),this.state.shadowBlur=c,this.state.shadowColor=h,this.state.shadowOffsetX=r,this.state.shadowOffsetY=o};case"setLineDash":return function(r,o){r=r||[0,0],o=o||0,this.actions.push({method:n,data:[r,o]}),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})}}}Kl.prototype[e]=t(e)})}),y_=Mt(Xm,(e,t)=>{if(E_(),t)return new Kl(e,er(t));let n=er(_r());if(n)return new Kl(e,n);st.emit(Z.ON_ERROR,"createCanvasContext:fail")},Qm),S_=Oe(s_,({canvasId:e,x:t,y:n,width:r,height:o},{resolve:c,reject:h})=>{let b=er(_r());if(!b){h();return}function V(T){if(T.errMsg&&T.errMsg.indexOf("fail")!==-1){h("",T);return}let D=T.data;D&&D.length&&(T.compressed&&(D=Rd.inflateRaw(D)),T.data=new Uint8ClampedArray(D)),delete T.compressed,c(T)}Tc(e,b,"getImageData",{x:t,y:n,width:r,height:o},V)},Gd,Wd),w_=Oe(l_,({canvasId:e,data:t,x:n,y:r,width:o,height:c},{resolve:h,reject:b})=>{var V=er(_r());if(!V){b();return}let T,D=()=>{Tc(e,V,"putImageData",{data:t,x:n,y:r,width:o,height:c,compressed:T},_e=>{if(_e.errMsg&&_e.errMsg.indexOf("fail")!==-1){b();return}h(_e)})};s.os.name!=="iOS"||typeof __WEEX_DEVTOOL__=="boolean"?(t=Rd.deflateRaw(t,{to:"string"}),T=!0):t=Array.prototype.slice.call(t),D()},u_,c_),C_=Oe(f_,({x:e=0,y:t=0,width:n,height:r,destWidth:o,destHeight:c,canvasId:h,fileType:b,quality:V},{resolve:T,reject:D})=>{var _e=er(_r());if(!_e){D();return}let Se=`${Wr}/canvas`;Tc(h,_e,"toTempFilePath",{x:e,y:t,width:n,height:r,destWidth:o,destHeight:c,fileType:b,quality:V,dirname:Se},Ie=>{if(Ie.errMsg&&Ie.errMsg.indexOf("fail")!==-1){D("",Ie);return}T(Ie)})},h_,d_),Jd=["onCanplay","onPlay","onPause","onStop","onEnded","onTimeUpdate","onError","onWaiting","onSeeking","onSeeked"],A_=["offCanplay","offPlay","offPause","offStop","offEnded","offTimeUpdate","offError","offWaiting","offSeeking","offSeeked"],O_={thresholds:[0],initialRatio:0,observeAll:!1},T_=["top","right","bottom","left"],P_=1;function Zd(e={}){return T_.map(t=>`${Number(e[t])||0}px`).join(" ")}class Xd{constructor(t,n){this._pageId=er(t),this._component=t,this._options=W.extend({},O_,n)}relativeTo(t,n){return this._options.relativeToSelector=t,this._options.rootMargin=Zd(n),this}relativeToViewport(t){return this._options.relativeToSelector=void 0,this._options.rootMargin=Zd(t),this}observe(t,n){!W.isFunction(n)||(this._options.selector=t,this._reqId=P_++,Ci({reqId:this._reqId,component:this._component,options:this._options,callback:n},this._pageId))}disconnect(){this._reqId&&us({reqId:this._reqId,component:this._component},this._pageId)}}let I_=Mt("createIntersectionObserver",(e,t)=>(e=Z.resolveComponentInstance(e),e&&!er(e)&&(t=e,e=null),e?new Xd(e,t):new Xd(_r(),t))),N_=1;class Qd{constructor(t){this._pageId=t.$page&&t.$page.id,this._component=t}observe(t,n){!W.isFunction(n)||(this._reqId=N_++,Na({reqId:this._reqId,component:this._component,options:t,callback:n},this._pageId))}disconnect(){this._reqId&&ea({reqId:this._reqId,component:this._component},this._pageId)}}let k_=Mt("createMediaQueryObserver",e=>(e=Z.resolveComponentInstance(e),e&&!er(e)&&(e=null),e?new Qd(e):new Qd(_r()))),R_=0,Ru={};function x_(e,t,n,r){let o={options:r},c=r&&("success"in r||"fail"in r||"complete"in r);if(c){let h=String(R_++);o.callbackId=h,Ru[h]=r}st.invokeViewMethod(`editor.${e}`,{type:n,data:o},t,({callbackId:h,data:b})=>{c&&(Z.callOptions(Ru[h],b),delete Ru[h])})}class B_{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){x_(this.id,this.pageId,t,n)}}let L_={canvas:Kl,map:Nu,video:Iu,editor:B_};function eh(e){if(e&&e.contextInfo){let{id:t,type:n,page:r}=e.contextInfo,o=L_[n];e.context=new o(t,r),delete e.contextInfo}}class xu{constructor(t,n,r,o){this._selectorQuery=t,this._component=n,this._selector=r,this._single=o}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 M_{constructor(t){this._component=void 0,this._page=t,this._queue=[],this._queueCb=[]}exec(t){return Xr(this._page,this._queue,n=>{let r=this._queueCb;n.forEach((o,c)=>{W.isArray(o)?o.forEach(eh):eh(o);let h=r[c];W.isFunction(h)&&h.call(this,o)}),W.isFunction(t)&&t.call(this,n)}),this._nodesRef}in(t){return this._component=Z.resolveComponentInstance(t),this}select(t){return this._nodesRef=new xu(this,this._component,t,!0)}selectAll(t){return this._nodesRef=new xu(this,this._component,t,!1)}selectViewport(){return this._nodesRef=new xu(this,null,"",!0)}_push(t,n,r,o,c){this._queue.push({component:n,selector:t,single:r,fields:o}),this._queueCb.push(c)}}let D_=Mt("createSelectorQuery",e=>(e=Z.resolveComponentInstance(e),e&&!er(e)&&(e=null),new M_(e||_r()))),F_="createAnimation",V_={formatArgs:{}},$_={duration:Number,timingFunction:String,delay:Number,transformOrigin:String},U_={duration:400,timingFunction:"linear",delay:0,transformOrigin:"50% 50% 0"};class th{constructor(t){this.actions=[],this.currentTransform={},this.currentStepAnimates=[],this.option=W.extend({},U_,t)}_getOption(t){let n={transition:W.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 H_=Z.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=>{th.prototype[r]=function(...o){return t.concat(n).includes(r)?this._pushAnimates("style",[this._converType(r),n.includes(r)?this._getValue(o[0]):o[0]]):this._pushAnimates(r,o),this}})}),j_=Mt(F_,e=>(H_(),new th(e)),$_,V_),nh="onTabBarMidButtonTap",z_=gn(nh,()=>{}),W_="onWindowResize",G_="offWindowResize",Y_=gn(W_,()=>{}),q_=Jr(G_,()=>{}),rh="setLocale",K_="getLocale",ih="onLocaleChange",Jl=Mt(K_,()=>{let e=St({allowDefault:!0});return e&&e.$vm?e.$vm.$locale:se().getLocale()}),J_=gn(ih,()=>{}),Z_=Mt(rh,e=>{let t=St();return t&&t.$vm.$locale!==e?(t.$vm.$locale=e,Pn().forEach(o=>{st.publishHandler(rh,e,o.$page.id)}),g.requireModule("plus").setLanguage(e),st.invokeOnCallback(ih,{locale:e}),!0):!1}),X_=Oe("setPageMeta",(e,{resolve:t})=>{t(to(_r(),e))}),oh="getSelectedTextRange",Q_=Oe(oh,(e,{resolve:t,reject:n})=>{st.invokeViewMethod(oh,{},fa(),r=>{typeof r.end=="undefined"&&typeof r.start=="undefined"?n("no focused"):t(r)})}),Pc={[Z.ON_UNHANDLE_REJECTION]:[],[Z.ON_PAGE_NOT_FOUND]:[],[Z.ON_ERROR]:[],[Z.ON_SHOW]:[],[Z.ON_HIDE]:[]};function Zl(e,t){let n=St({allowDefault:!0});if(n&&n.$vm)return fn.injectHook(e,t,n.$vm.$);Pc[e].push(t)}function eb(e){Object.keys(Pc).forEach(t=>{Pc[t].forEach(n=>{fn.injectHook(t,n,e)})})}function Xl(e,t){let n=St({allowDefault:!0});if(n&&n.$vm)return Ia(n.$vm,e,t);W.remove(Pc[e],t)}function tb(e){Zl(Z.ON_UNHANDLE_REJECTION,e)}function nb(e){Xl(Z.ON_UNHANDLE_REJECTION,e)}function rb(e){Zl(Z.ON_PAGE_NOT_FOUND,e)}function ib(e){Xl(Z.ON_PAGE_NOT_FOUND,e)}function ob(e){Zl(Z.ON_ERROR,e)}function ab(e){Xl(Z.ON_ERROR,e)}function sb(e){Zl(Z.ON_SHOW,e)}function lb(e){Xl(Z.ON_SHOW,e)}function cb(e){Zl(Z.ON_HIDE,e)}function ub(e){Xl(Z.ON_HIDE,e)}let fb=Mt("getEnterOptionsSync",()=>Fo()),db=Mt("getLaunchOptionsSync",()=>ds()),Ql,Bu,Lu,ah;function sh(e){try{return JSON.parse(e)}catch(t){}return e}function Mu(e){if(e.type==="enabled")Lu=!0,ah=e.offline;else if(e.type==="clientId")Ql=e.cid,Bu=e.errMsg,lh(Ql,e.errMsg);else if(e.type==="pushMsg"){let t={type:"receive",data:sh(e.message)};for(let n=0;n<Ts.length&&(Ts[n](t),!t.stopped);n++);}else e.type==="click"&&Ts.forEach(t=>{t({type:"click",data:sh(e.message)})})}let Du=[];function lh(e,t){Du.forEach(n=>{n(e,t)}),Du.length=0}let hb=Oe("getPushClientId",(e,{resolve:t,reject:n})=>{if(ah){s.push.getClientInfoAsync(r=>{t({cid:r.clientid})},r=>{n(r.code+": "+r.message)});return}Promise.resolve().then(()=>{typeof Lu=="undefined"&&(Lu=!1,Ql="",Bu="uniPush is not enabled"),Du.push((r,o)=>{r?t({cid:r}):n(o)}),typeof Ql!="undefined"&&lh(Ql,Bu)})}),Ts=[],ch=!1,gb=e=>{Ts.indexOf(e)===-1&&Ts.push(e),ch||(ch=!0,s.push.addEventListener("click",t=>{Mu({type:"click",message:t})}),s.push.addEventListener("receive",t=>{Mu({type:"pushMsg",message:t})}))},pb=e=>{if(!e)Ts.length=0;else{let t=Ts.indexOf(e);t>-1&&Ts.splice(t,1)}},vb="canIUse",mb=[{name:"schema",type:String,required:!0}],_b="getBackgroundAudioManager",bb="makePhoneCall",Eb={phoneNumber:String},yb="addPhoneContact",Sb={formatArgs:{firstName(e){if(!e)return"addPhoneContact:fail parameter error: parameter.firstName should not be empty;"}}},wb={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},Cb="getClipboardData",Ab="setClipboardData",Ob={formatArgs:{showToast:!0},beforeInvoke(){Yt()},beforeSuccess(e,t){if(!t.showToast)return;let{t:n}=se(),r=n("uni.setClipboardData.success");r&&I.showToast({title:r,icon:"success",mask:!1})}},Tb={data:{type:String,required:!0},showToast:{type:Boolean}},uh="onAccelerometer",Pb="offAccelerometer",Ib="startAccelerometer",Nb="stopAccelerometer",fh="onCompass",kb="offCompass",Rb="startCompass",xb="stopCompass",Bb="vibrateShort",Lb="vibrateLong",dh="onBluetoothDeviceFound",hh="onBluetoothAdapterStateChange",gh="onBLEConnectionStateChange",ph="onBLECharacteristicValueChange",Mb="startBluetoothDevicesDiscovery",Db={services:Array,allowDuplicatesKey:Boolean,interval:Number},Fb="getConnectedBluetoothDevices",Vb={services:{type:Array,required:!0}},$b="createBLEConnection",Ub={deviceId:{type:String,required:!0}},Hb="closeBLEConnection",jb={deviceId:{type:String,required:!0}},zb="getBLEDeviceServices",Wb={deviceId:{type:String,required:!0}},Gb="getBLEDeviceCharacteristics",Yb={deviceId:{type:String,required:!0},serviceId:{type:String,required:!0}},qb="notifyBLECharacteristicValueChange",Kb={deviceId:{type:String,required:!0},serviceId:{type:String,required:!0},characteristicId:{type:String,required:!0},state:{type:Boolean,required:!0}},Jb="readBLECharacteristicValue",Zb={deviceId:{type:String,required:!0},serviceId:{type:String,required:!0},characteristicId:{type:String,required:!0}},Xb="writeBLECharacteristicValue",Qb={deviceId:{type:String,required:!0},serviceId:{type:String,required:!0},characteristicId:{type:String,required:!0},value:{type:Array,required:!0}},e0="setBLEMTU",t0={deviceId:{type:String,required:!0},mtu:{type:Number,required:!0}},n0="getBLEDeviceRSSI",r0={deviceId:{type:String,required:!0}},vh="onBeaconUpdate",mh="onBeaconServiceChange",i0="getBeacons",o0="startBeaconDiscovery",a0={uuids:{type:Array,required:!0}},s0="stopBeaconDiscovery",l0="getScreenBrightness",c0="setScreenBrightness",u0="setKeepScreenOn",f0="checkIsSupportSoterAuthentication",d0="checkIsSoterEnrolledInDevice",h0=["fingerPrint","facial","speech"],g0={formatArgs:{checkAuthMode(e,t){if(!e||!h0.includes(e))return"checkAuthMode \u586B\u5199\u9519\u8BEF"}}},p0={checkAuthMode:String},v0="startSoterAuthentication",m0={formatArgs:{requestAuthModes(e,t){if(!e.includes("fingerPrint")&&!e.includes("facial"))return"requestAuthModes \u586B\u5199\u9519\u8BEF"}}},_0={requestAuthModes:{type:Array,required:!0},challenge:String,authContent:String},b0="scanCode",E0={onlyFromCamera:Boolean,scanType:Array,autoDecodeCharSet:Boolean,sound:String,autoZoom:Boolean},y0=["default","none"],S0={formatArgs:{sound(e,t){y0.includes(e)||(t.sound="none")},autoZoom(e,t){typeof e=="undefined"&&(t.autoZoom=!0)}}},w0="getSystemSetting",C0="getAppAuthorizeSetting",A0="openAppAuthorizeSetting",O0="getStorage",_h={key:{type:String,required:!0}},T0="getStorageSync",bh=[{name:"key",type:String,required:!0}],P0="setStorage",I0={key:{type:String,required:!0},data:{required:!0}},N0="setStorageSync",k0=[{name:"key",type:String,required:!0},{name:"data",required:!0}],Eh="removeStorage",R0=_h,x0=bh,B0="saveFile",L0={formatArgs:{tempFilePath(e,t){t.tempFilePath=je(e)}}},M0={tempFilePath:{type:String,required:!0}},D0="getSavedFileList",F0="removeSavedFile",V0={formatArgs:{filePath(e,t){t.filePath=je(e)}}},$0={filePath:{type:String,required:!0}},U0="getFileInfo",H0={formatArgs:{filePath(e,t){t.filePath=je(e)}}},j0={filePath:{type:String,required:!0}},z0="getSavedFileInfo",W0={formatArgs:{filePath(e,t){t.filePath=je(e)}}},G0={filePath:{type:String,required:!0}},Y0="openDocument",q0={formatArgs:{filePath(e,t){t.filePath=je(e)}}},K0={filePath:{type:String,required:!0},fileType:String},J0="hideKeyboard",Z0="showKeyboard",X0="chooseLocation",Q0={keyword:String,latitude:Number,longitude:Number},eE="getLocation",yh=["wgs84","gcj02"],tE={formatArgs:{type(e,t){e=(e||"").toLowerCase(),yh.indexOf(e)===-1?t.type=yh[0]:t.type=e},altitude(e,t){t.altitude=e||!1}}},nE={type:String,altitude:Boolean},rE="openLocation",Sh=(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)}.`}},iE={formatArgs:{latitude(e,t){let n=Sh("latitude",e);if(n)return n;t.latitude=e},longitude(e,t){let n=Sh("longitude",e);if(n)return n;t.longitude=e},scale(e,t){e=Math.floor(e),t.scale=e>=5&&e<=18?e:18}}},oE={latitude:Number,longitude:Number,scale:Number,name:String,address:String},aE="chooseImage",sE={formatArgs:{count(e,t){(!e||e<=0)&&(t.count=9)},sizeType(e,t){t.sizeType=wr(e,vi)},sourceType(e,t){t.sourceType=wr(e,ar)},extension(e,t){if(e instanceof Array&&e.length===0)return"param extension should not be empty.";e||(t.extension=["*"])}}},lE={count:Number,sizeType:[Array,String],sourceType:Array,extension:Array},cE="chooseVideo",uE={formatArgs:{sourceType(e,t){t.sourceType=wr(e,ar)},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=["*"])}}},fE={sourceType:Array,compressed:Boolean,maxDuration:Number,camera:String,extension:Array},dE="getImageInfo",hE={formatArgs:{src(e,t){t.src=je(e)}}},gE={src:{type:String,required:!0}},pE="previewImage",vE={formatArgs:{urls(e,t){t.urls=e.map(n=>W.isString(n)&&n?je(n):"")},current(e,t){typeof e=="number"?t.current=e>0&&e<t.urls.length?e:0:W.isString(e)&&e&&(t.current=je(e))}}},mE={urls:{type:Array,required:!0},current:{type:[Number,String]}},_E="closePreviewImage",bE="getVideoInfo",EE={formatArgs:{src(e,t){t.src=je(e)}}},yE={src:{type:String,required:!0}},SE="saveImageToPhotosAlbum",wE={formatArgs:{filePath(e,t){t.filePath=je(e)}}},CE={filePath:{type:String,required:!0}},AE="saveVideoToPhotosAlbum",OE={formatArgs:{filePath(e,t){t.filePath=je(e)}}},TE={filePath:{type:String,required:!0}},PE="getRecorderManager",IE="compressImage",NE={formatArgs:{src(e,t){t.src=je(e)}}},kE={src:{type:String,required:!0}},RE="compressVideo",xE={formatArgs:{src(e,t){t.src=je(e)}}},BE={src:{type:String,required:!0},quality:String,bitrate:Number,fps:Number,resolution:Number},LE="request",ME={JSON:"json"},DE=["text","arraybuffer"],FE="text",wh=encodeURIComponent;function VE(e,t){let n=e.split("#"),r=n[1]||"";n=n[0].split("?");let o=n[1]||"";e=n[0];let c=o.split("&").filter(b=>b),h={};c.forEach(b=>{let V=b.split("=");h[V[0]]=V[1]});for(let b in t)if(W.hasOwn(t,b)){let V=t[b];typeof V=="undefined"||V===null?V="":W.isPlainObject(V)&&(V=JSON.stringify(V)),h[wh(b)]=wh(V)}return o=Object.keys(h).map(b=>`${b}=${h[b]}`).join("&"),e+(o?"?"+o:"")+(r?"#"+r:"")}let $E={method:String,data:[Object,String,Array,ArrayBuffer],url:{type:String,required:!0},header:Object,dataType:String,responseType:String,withCredentials:Boolean},UE={formatArgs:{method(e,t){t.method=Cn((e||"").toUpperCase(),Sr)},data(e,t){t.data=e||""},url(e,t){t.method===Sr[0]&&W.isPlainObject(t.data)&&Object.keys(t.data).length&&(t.url=VE(e,t.data))},header(e,t){let n=t.header=e||{};t.method!==Sr[0]&&(Object.keys(n).find(r=>r.toLowerCase()==="content-type")||(n["Content-Type"]="application/json"))},dataType(e,t){t.dataType=(e||ME.JSON).toLowerCase()},responseType(e,t){t.responseType=(e||"").toLowerCase(),DE.indexOf(t.responseType)===-1&&(t.responseType=FE)}}},HE="configMTLS",jE={certificates:{type:Array,required:!0}},zE={formatArgs:{certificates(e){if(e.some(t=>W.toRawType(t.host)!=="String"))return"\u53C2\u6570\u914D\u7F6E\u9519\u8BEF\uFF0C\u8BF7\u786E\u8BA4\u540E\u91CD\u8BD5"}}},WE="downloadFile",GE={formatArgs:{header(e,t){t.header=e||{}}}},YE={url:{type:String,required:!0},header:Object,timeout:Number},qE="uploadFile",KE={formatArgs:{filePath(e,t){e&&(t.filePath=je(e))},header(e,t){t.header=e||{}},formData(e,t){t.formData=e||{}}}},JE={url:{type:String,required:!0},files:Array,filePath:String,name:String,header:Object,formData:Object,timeout:Number},ZE="connectSocket",XE={formatArgs:{header(e,t){t.header=e||{}},method(e,t){t.method=Cn((e||"").toUpperCase(),Sr)},protocols(e,t){W.isString(e)&&(t.protocols=[e])}}},QE={url:{type:String,required:!0},header:{type:Object},method:String,protocols:[Array,String]},ey="sendSocketMessage",ty={data:[String,ArrayBuffer]},ny="closeSocket",ry={code:Number,reason:String},iy="startLocationUpdate",Ch="onLocationChange",oy="stopLocationUpdate",ay="offLocationChange",sy="offLocationChangeError",Ah="onLocationChangeError",Oh=["wgs84","gcj02"],ly={type:String},cy={formatArgs:{type(e,t){e=(e||"").toLowerCase(),Oh.indexOf(e)===-1?t.type=Oh[1]:t.type=e}}};function uy(e){if(!W.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(o=>{let c=o.replace(/\+/g," ").split("="),h=c.shift(),b=c.length>0?c.join("="):"";r.push(h+"="+encodeURIComponent(b))}),r.length?e+"?"+r.join("&"):e}let fy=["slide-in-right","slide-in-left","slide-in-top","slide-in-bottom","fade-in","zoom-out","zoom-fade-out","pop-in","none"],dy=["slide-out-right","slide-out-left","slide-out-top","slide-out-bottom","fade-out","zoom-in","zoom-fade-in","pop-out","none"],wl={url:{type:String,required:!0}},Fu="navigateTo",Vu="redirectTo",Th="reLaunch",Ic="switchTab",hy="navigateBack",$u="preloadPage",Ph="unPreloadPage",gy=W.extend({},wl,Ih(fy)),py=W.extend({delta:{type:Number}},Ih(dy)),vy=wl,my=wl,_y=wl,by=wl,Ey=wl,yy=kc(Fu),Sy=kc(Vu),wy=kc(Th),Cy=kc(Ic),Ay={formatArgs:{delta(e,t){e=parseInt(e+"")||1,t.delta=Math.min(Pn().length-1,e)}}};function Ih(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 Nc;function Oy(){Nc=""}function kc(e){return{formatArgs:{url:Ty(e)},beforeAll:Oy}}function Ty(e){return function(n,r){if(!n)return'Missing required args: "url"';n=Bo(n);let o=n.split("?")[0],c=ji(o,!0);if(!c)return"page `"+n+"` is not found";if(e===Fu||e===Vu){if(c.meta.isTabBar)return`can not ${e} a tabbar page`}else if(e===Ic&&!c.meta.isTabBar)return"can not switch to no-tabBar page";if((e===Ic||e===$u)&&c.meta.isTabBar&&r.openType!=="appLaunch"&&(n=o),c.meta.isEntry&&(n=n.replace(c.alias,"/")),r.url=uy(n),e!==Ph){if(e===$u){if(!c.meta.isNVue)return"can not preload vue page";if(c.meta.isTabBar){let h=Pn(),b=c.path.slice(1);if(h.find(V=>V.route===b))return"tabBar page `"+b+"` already exists"}return}if(Nc===n&&r.openType!=="appLaunch")return`${Nc} locked`;B.ready&&(Nc=n)}}}let Py="hideLoading",Iy="hideToast",Nh="loadFontFace",Ny={family:{type:String,required:!0},source:{type:String,required:!0},desc:Object},ky=["#ffffff","#000000"],Ry="setNavigationBarColor",xy={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(ky.indexOf(e)===-1)return`invalid frontColor "${e}"`}},backgroundColor:{type:String,required:!0},animation:Object},Ly="setNavigationBarTitle",My={title:{type:String,required:!0}},Dy="showNavigationBarLoading",Fy="hideNavigationBarLoading",kh="pageScrollTo",Vy={scrollTop:Number,selector:String,duration:Number},$y={formatArgs:{duration:300}},Uy="showActionSheet",Hy={itemList:{type:Array,required:!0},title:String,itemColor:String,popover:Object},jy={formatArgs:{itemColor:"#000"}},zy="showLoading",Wy={title:String,mask:Boolean},Gy={formatArgs:{title:"",mask:!1}},Yy="showModal",qy={title:String,content:String,showCancel:Boolean,cancelText:String,cancelColor:String,confirmText:String,confirmColor:String},Ky={beforeInvoke(){z()},formatArgs:{title:"",content:"",placeholderText:"",showCancel:!0,editable:!1,cancelText(e,t){if(!W.hasOwn(t,"cancelText")){let{t:n}=se();t.cancelText=n("uni.showModal.cancel")}},cancelColor:"#000",confirmText(e,t){if(!W.hasOwn(t,"confirmText")){let{t:n}=se();t.confirmText=n("uni.showModal.confirm")}},confirmColor:Z.PRIMARY_COLOR}},Jy="showToast",Zy=["success","loading","none","error"],Xy={title:String,icon:String,image:String,duration:Number,mask:Boolean},Qy={formatArgs:{title:"",icon(e,t){t.icon=Cn(e,Zy)},image(e,t){e?t.image=je(e):t.image=""},duration:1500,mask:!1}},eS="startPullDownRefresh",tS="stopPullDownRefresh",ec={index:{type:Number,required:!0}},Ps={beforeInvoke(){let e=is();if(e&&!e.isTabBar)return"not TabBar page"},formatArgs:{index(e){if(!B.tabBar.list[e])return"tabbar item not found"}}},nS="setTabBarItem",rS=W.extend({text:String,iconPath:String,selectedIconPath:String,pagePath:String},ec),iS={beforeInvoke:Ps.beforeInvoke,formatArgs:W.extend({pagePath(e,t){e&&(t.pagePath=Z.removeLeadingSlash(e))}},Ps.formatArgs)},oS="setTabBarStyle",aS={color:String,selectedColor:String,backgroundColor:String,backgroundImage:String,backgroundRepeat:String,borderStyle:String},sS=/^(linear|radial)-gradient\(.+?\);?$/,lS={beforeInvoke:Ps.beforeInvoke,formatArgs:{backgroundImage(e,t){e&&!sS.test(e)&&(t.backgroundImage=je(e))},borderStyle(e,t){e&&(t.borderStyle=e==="white"?"white":"black")}}},cS="hideTabBar",Rh={animation:Boolean},uS="showTabBar",fS=Rh,dS="hideTabBarRedDot",hS=ec,gS=Ps,pS="showTabBarRedDot",vS=ec,mS=Ps,_S="removeTabBarBadge",bS=ec,ES=Ps,yS="setTabBarBadge",SS=W.extend({text:{type:String,required:!0}},ec),wS={beforeInvoke:Ps.beforeInvoke,formatArgs:W.extend({text(e,t){Z.getLen(e)>=4&&(t.text="...")}},Ps.formatArgs)},CS="getProvider",AS={service:{type:String,required:!0}},OS="login",TS={provider:String,scopes:[String,Array],timeout:Number,univerifyStyle:Object,onlyAuthorize:Boolean},PS="getUserInfo",IS={provider:String,withCredentials:Boolean,timeout:Number,lang:String},NS="ggetUserProfilegetUserProfile",kS={provider:String,withCredentials:Boolean,timeout:Number,lang:String},RS="preLogin",xS={UNIVERIFY:"univerify"},BS={formatArgs:{provider(e,t){if(Object.values(xS).indexOf(String(e))<0)return"provider error"}}},LS={provider:{type:String,required:!0}},MS="closeAuthView",DS="getCheckBoxState",FS="getUniverifyManager",VS="share",xh=["WXSceneSession","WXSceneTimeline","WXSceneFavorite"],$S={formatArgs:{scene(e,t){let{provider:n,openCustomerServiceChat:r}=t;if(n==="weixin"&&!r&&(!e||!xh.includes(e)))return`\u5206\u4EAB\u5230\u5FAE\u4FE1\u65F6\uFF0Cscene\u5FC5\u987B\u4E3A\u4EE5\u4E0B\u5176\u4E2D\u4E00\u4E2A\uFF1A${xh.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"}}},US={provider:{type:String,required:!0},type:Number,title:String,scene:String,summary:String,href:String,imageUrl:String,mediaUrl:String,miniProgram:Object},HS="shareWithSystem",Bh=["text","image"],jS={formatArgs:{type(e,t){if(e&&!Bh.includes(e))return"\u5206\u4EAB\u53C2\u6570 type \u4E0D\u6B63\u786E\u3002\u53EA\u652F\u6301text\u3001image";t.type=Cn(e,Bh)}}},zS={type:String,summary:String,href:String,imageUrl:String},WS="requestPayment",GS={provider:{type:String,required:!0},orderInfo:{type:[String,Object],required:!0},timeStamp:String,nonceStr:String,package:String,signType:String,paySign:String},YS="createPushMessage",qS={formatArgs:{content(e){if(!e)return"content is required"}}},KS="createRewardedVideoAd",JS={formatArgs:{adpid:"",adUnitId:""}},ZS={adpid:String,adUnitId:String},XS="createFullScreenVideoAd",QS={formatArgs:{adpid:""}},ew={adpid:String},tw="createInterstitialAd",nw={formatArgs:{adpid:"",adUnitId:""}},rw={adpid:String,adUnitId:String},iw="createInteractiveAd",ow={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)}}},aw={adpid:{type:String,required:!0},provider:{type:String,required:!0}};function Xs(e,t){return function(r){delete r.code,delete r.message,W.isFunction(t)&&(r=t(r)),e(r)}}function fr(e,t){return function(r){r=r||{},t=r.message||t||"",delete r.message,e(t,W.extend({code:0},r))}}function Cl(e,t){return function(){e()(function(r){r&&(delete r.code,delete r.message),st.invokeOnCallback(t,r)})}}function fi(e,t,n){return function(r,{resolve:o,reject:c}){e()(W.extend({},W.isFunction(t)?t(r):r,{success:Xs(o,n),fail:fr(c)}))}}function tc(e=""){if(!(B.tabBar&&W.isArray(B.tabBar.list)))return!1;try{if(!e){let n=Pn();if(!n.length)return!1;let r=n[n.length-1];return r?r.$page.meta.isTabBar:!1}/^\//.test(e)||(e=Z.addLeadingSlash(e));let t=ji(e);return t&&t.meta.isTabBar}catch(t){}return!1}let ya="__TYPE",sw="uni-storage-keys";function Uu(e){let t=["object","string","number","boolean","undefined"];try{let n=W.isString(e)?JSON.parse(e):e,r=n.type;if(t.indexOf(r)>=0){let o=Object.keys(n);if(o.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(o.length===1)return""}}catch(n){}}let lw=Mt(N0,(e,t)=>{let n=typeof t,r=n==="string"?t:JSON.stringify({type:n,data:t});try{n==="string"&&Uu(r)!==void 0?s.storage.setItem(e+ya,n):s.storage.removeItem(e+ya),s.storage.setItem(e,r)}catch(o){}},k0),cw=Oe(P0,({key:e,data:t},{resolve:n,reject:r})=>{let o=typeof t,c=o==="string"?t:JSON.stringify({type:o,data:t});try{let h=s.storage;o==="string"&&Uu(c)!==void 0?h.setItemAsync(e+ya,o,()=>{}):h.removeItemAsync(e+ya,()=>{}),h.setItemAsync(e,c,n,fr(r))}catch(h){r(h.message)}},I0);function Hu(e,t){let n=t;if(e!=="string"||e==="string"&&t==='{"type":"undefined"}')try{let r=JSON.parse(t),o=Uu(r);if(o!==void 0)n=o;else if(e&&(n=r,W.isString(r))){r=JSON.parse(r);let c=typeof r;c==="number"&&e==="date"?n=new Date(r):c===(["null","array"].indexOf(e)<0?e:"object")&&(n=r)}}catch(r){}return n}let uw=Mt(T0,e=>{let t=s.storage.getItem(e),r=(s.storage.getItem(e+ya)||"").toLowerCase();return W.isString(t)?Hu(r,t):""},bh),fw=Oe(O0,({key:e},{resolve:t,reject:n})=>{let r=s.storage;r.getItemAsync(e,function(o){r.getItemAsync(e+ya,function(c){let b=(c.data||"").toLowerCase();t({data:Hu(b,o.data)})},function(){t({data:Hu("",o.data)})})},fr(n))},_h),dw=Mt(Eh,e=>{s.storage.removeItem(e+ya),s.storage.removeItem(e)},x0),hw=Oe(Eh,({key:e},{resolve:t,reject:n})=>{s.storage.removeItemAsync(e+ya,()=>{}),s.storage.removeItemAsync(e,t,fr(n))},R0),gw=Mt("clearStorageSync",()=>{s.storage.clear()}),pw=Oe("clearStorage",(e,{resolve:t,reject:n})=>{s.storage.clearAsync(t,fr(n))}),Lh=Mt("getStorageInfoSync",()=>{let e=s.storage.getLength()||0,t=[],n=0;for(let r=0;r<e;r++){let o=s.storage.key(r);if(o!==sw&&(o.indexOf(ya)<0||o.indexOf(ya)+ya.length!==o.length)){let c=s.storage.getItem(o);n+=o.length+c.length,t.push(o)}}return{keys:t,currentSize:Math.ceil(n*2/1024),limitSize:Number.MAX_VALUE}}),vw=Oe("getStorageInfo",(e,{resolve:t})=>{t(Lh())}),mw=Oe(U0,(e,{resolve:t,reject:n})=>{s.io.getFileInfo(W.extend(e,{success:Xs(t),fail:fr(n)}))},j0,H0),_w=0,Mh="uniapp_save",bw=`_doc/${Mh}`;function Ew(e,t){t=t||function(){},s.io.requestFileSystem(s.io.PRIVATE_DOC,n=>{n.root.getDirectory(Mh,{create:!0},e,t)},t)}let yw=Oe(B0,({tempFilePath:e},{resolve:t,reject:n})=>{let r=fr(n),o=`${Date.now()}${_w++}${Ja(e)}`;s.io.resolveLocalFileSystemURL(e,c=>{Ew(h=>{c.copyTo(h,o,()=>{let b=bw+"/"+o;t({savedFilePath:b})},r)},r)},r)},M0,L0),Sw="uniapp_save";function ww(e,t){t=t||function(){},s.io.requestFileSystem(s.io.PRIVATE_DOC,n=>{n.root.getDirectory(Sw,{create:!0},e,t)},t)}let Cw=Oe(D0,(e,{resolve:t,reject:n})=>{let r=fr(n);ww(o=>{var c=o.createReader(),h=[];c.readEntries(b=>{b&&b.length?b.forEach(V=>{V.getMetadata(T=>{h.push({filePath:s.io.convertAbsoluteFileSystem(V.fullPath),createTime:T.modificationTime.getTime(),size:T.size}),h.length===b.length&&t({fileList:h})},r,!1)}):t({fileList:h})},r)},r)}),Aw=Oe(z0,({filePath:e},{resolve:t,reject:n})=>{let r=fr(n);s.io.resolveLocalFileSystemURL(e,o=>{o.getMetadata(c=>{t({createTime:c.modificationTime.getTime(),size:c.size})},r,!1)},r)},G0,W0),Ow=Oe(F0,({filePath:e},{resolve:t,reject:n})=>{let r=fr(n);s.io.resolveLocalFileSystemURL(e,o=>{o.remove(()=>{t()},r)},r)},$0,V0),Tw=Oe(Y0,({filePath:e,fileType:t},{resolve:n,reject:r})=>{let o=fr(r);s.runtime.openDocument(je(e),void 0,n,o)},K0,q0),Pw=Mt(vb,e=>!!W.hasOwn(I,e),mb),nc,Dh=s.navigator.setStatusBarStyle;function Iw(e){Dh=e}function Fh(e){nc=e,Dh(e)}s.navigator.setStatusBarStyle=Fh;function Da(e){if(!e){let t=Si();if(!t||(e=t.$page.statusBarStyle,!e||e===nc))return}e!==nc&&(nc=e,s.navigator.setStatusBarStyle(e))}function Vh(e){st.on(Z.ON_THEME_CHANGE,e)}function Nw(e){st.off(Z.ON_THEME_CHANGE,e)}function kw(){return $h()==="dark"?"light":"dark"}function $h(){return s.navigator.getUIStyle()}function Rw(){if(B.darkmode){let e=kw();Da(e),Fn().forEach(n=>{n.$page.statusBarStyle=e})}}function ju(e){if(B.darkmode){let t={},n=s.navigator.getUIStyle(),r=ic();return r&&r.hostTheme&&(n=r.hostTheme),t=Z.normalizeStyles(e,B.themeConfig,n),t}return e}function xw(e,t){if(B.darkmode){let n=()=>{let{list:r=[],color:o,selectedColor:c,backgroundColor:h,borderStyle:b}=ju(t);e&&e.setTabBarStyle({color:o,selectedColor:c,backgroundColor:h,borderStyle:b}),e&&e.setTabBarItems({list:r.map(V=>({iconPath:V.iconPath,selectedIconPath:V.selectedIconPath,visible:V.visible}))})};n(),Vh(n)}}function Uh(e,t){if(B.darkmode){let n=()=>{let r=t();r.animationAlphaBGColor,r.background,r.backgroundColorBottom,r.backgroundColorTop;var o=r.titleNView;typeof o!="undefined"&&typeof o=="object"&&(o.backgroundColor,o.titleColor),e&&e.setStyle(r)};Vh(n),e.addEventListener("close",()=>Nw(n))}}let rc,zu=!0,nr;function Bw(e,t,n){!nr||(e==="none"?(nr.hideTabBarRedDot({index:t}),nr.removeTabBarBadge({index:t})):e==="text"?nr.setTabBarBadge({index:t,text:n}):e==="redDot"&&nr.showTabBarRedDot({index:t}))}function Lw(e){nr&&nr.setTabBarItems(e)}function Mw(e,t,n,r,o,c){let h={index:e};if(t!==void 0&&(h.text=t),n&&(h.iconPath=je(n)),r&&(h.selectedIconPath=je(r)),c!==void 0&&(h.iconfont=c),o!==void 0){h.visible=rc.list[e].visible=o,delete h.index;let b=rc.list.map(V=>({visible:V.visible}));b[e]=h,Lw({list:b})}else nr&&nr.setTabBarItem(h)}function Dw(e){nr&&nr.setTabBarStyle(e)}function Fw(e){zu=!1,nr&&nr.hideTabBar({animation:e})}function Vw(e){zu=!0,nr&&nr.showTabBar({animation:e})}let Rc=[];var di={id:"0",init(e,t){e&&e.list.length&&(rc=e);try{nr=g.requireModule("uni-tabview")}catch(n){console.log(`uni.requireNativePlugin("uni-tabview") error ${n}`)}nr.onMaskClick(()=>{Rc.forEach(n=>{n()})}),nr&&nr.onClick(({index:n})=>{t(rc.list[n],n)}),nr&&nr.onMidButtonClick(()=>st.invokeOnCallback(nh)),xw(nr,e)},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?(nr&&nr.switchSelect({index:t}),!0):!1},setTabBarBadge:Bw,setTabBarItem:Mw,setTabBarStyle:Dw,hideTabBar:Fw,showTabBar:Vw,append(e){nr&&nr.append({id:e.id},({code:t})=>{t!==0&&k(()=>{this.append(e)},20)})},get config(){return rc||B.tabBar},get visible(){return zu},get height(){let e=this.config;return(e&&e.height?parseFloat(e.height):Z.TABBAR_HEIGHT)+s.navigator.getSafeAreaInsets().deviceBottom},get cover(){let e=this.config;return e&&["extralight","light","dark"].indexOf(e.blurEffect)>=0},setStyle({mask:e}){nr.setMask({color:e})},addEventListener(e,t){Rc.push(t)},removeEventListener(e,t){let n=Rc.indexOf(t);Rc.splice(n,1)}};function xc(){let e=Si();return e?e.$getAppWebview():null}function Hh(e){return e?e.$getAppWebview():xc()}let jh=null;function zh(){return jh}function Wu(e){jh=e}function Gu(){return s.navigator.isImmersedStatusbar()?Math.round(s.os.name==="iOS"?s.navigator.getSafeAreaInsets().top:s.navigator.getStatusbarHeight()):0}function Wh(){let e=s.navigator.getStatusBarStyle();return e==="UIStatusBarStyleBlackTranslucent"||e==="UIStatusBarStyleBlackOpaque"||e==="null"?e="light":e==="UIStatusBarStyleDefault"&&(e="dark"),e}function $w(){let{resolutionWidth:e,resolutionHeight:t}=s.screen.getCurrentSize()||{resolutionWidth:0,resolutionHeight:0};return{screenWidth:Math.round(e),screenHeight:Math.round(t)}}let Gh=Mt("getWindowInfo",()=>{let e=s.os.name.toLowerCase()==="ios",{screenWidth:t,screenHeight:n}=$w(),r=Gu(),o,c={height:0,cover:!1},h=xc();if(h){let ut=h.getStyle(),dt=ut&&ut.titleNView;dt&&dt.type&&dt.type!=="none"&&(c.height=dt.type==="transparent"?0:r+Z.NAVBAR_HEIGHT,c.cover=dt.type==="transparent"||dt.type==="float"),o=h.getSafeAreaInsets()}else o=s.navigator.getSafeAreaInsets();let b={height:0,cover:!1};tc()&&(b.height=di.visible?di.height:0,b.cover=di.cover);let V=c.cover?c.height:0,T=b.cover?b.height:0,D=n-c.height-b.height,_e=n-(c.cover?0:c.height)-(b.cover?0:b.height),Se=t;(!b.height||b.cover)&&!o.bottom&&o.deviceBottom&&(D-=o.deviceBottom,_e-=o.deviceBottom),o=e?o:{left:0,right:0,top:c.height&&!c.cover?0:r,bottom:0};let Ie={left:o.left,right:Se-o.right,top:o.top,bottom:_e-o.bottom,width:Se-o.left-o.right,height:_e-o.top-o.bottom};return{pixelRatio:s.screen.scale,screenWidth:t,screenHeight:n,windowWidth:Se,windowHeight:D,statusBarHeight:r,safeArea:Ie,safeAreaInsets:{top:o.top,right:o.right,bottom:o.bottom,left:o.left},windowTop:V,windowBottom:T,screenTop:n-D}}),Sa,Bc=!0;function ic(){if(!Bc)return;let{getSystemInfoSync:e}=g.requireModule("plus");if(Sa=e(),W.isString(Sa))try{Sa=JSON.parse(Sa)}catch(t){}return Sa}let Yh=Mt("getDeviceInfo",()=>{ic();let{deviceBrand:e="",deviceModel:t,osName:n,osVersion:r,deviceOrientation:o,deviceType:c,deviceId:h}=Sa,b=e.toLowerCase(),V=n.toLowerCase();return{brand:b,deviceBrand:b,deviceModel:t,devicePixelRatio:s.screen.scale,deviceId:h,deviceOrientation:o,deviceType:c,model:t,platform:V,system:`${V==="ios"?"iOS":"Android"} ${r}`}}),qh=Mt("getAppBaseInfo",()=>{ic();let{hostPackageName:e,hostName:t,hostVersion:n,hostLanguage:r,osLanguage:o,hostTheme:c,appId:h,appName:b,appVersion:V,appVersionCode:T,appWgtVersion:D}=Sa;return{appId:h,appName:b,appVersion:V,appVersionCode:T,appWgtVersion:D,appLanguage:Jl?Jl():o,enableDebug:!1,hostPackageName:e,hostName:t,hostVersion:n,hostLanguage:r,hostTheme:c,hostFontSizeSetting:void 0,hostSDKVersion:void 0,language:o,SDKVersion:"",theme:$h(),version:s.runtime.innerVersion}}),Kh=Mt("getSystemInfoSync",()=>{Bc=!0,ic(),Bc=!1;let e=Gh(),t=Yh(),n=qh();Bc=!0;let r={fontSizeSetting:n.hostFontSizeSetting,osName:Sa.osName.toLowerCase()};Sa.hostName&&(r.hostSDKVersion=Sa.uniRuntimeVersion);let o=W.extend(Sa,e,t,n,r);return delete o.screenTop,delete o.enableDebug,B.darkmode||delete o.theme,Z.sortObject(o)}),Uw=Oe("getSystemInfo",(e,{resolve:t})=>t(Kh())),Al=null,Hw=gn(fh,()=>{Jh()}),jw=Jr(kb,()=>{Zh()}),Jh=Oe(Rb,(e,{resolve:t,reject:n})=>{Al||(Al=s.orientation.watchOrientation(r=>{st.invokeOnCallback(fh,{direction:r.magneticHeading})},r=>{n(r.message),Al=null},{frequency:so})),k(t,so)}),Zh=Oe(xb,(e,{resolve:t})=>{Al&&(s.orientation.clearWatch(Al),Al=null),t()}),zw=Oe(Bb,(e,{resolve:t})=>{s.device.vibrate(15),t()}),Ww=Oe(Lb,(e,{resolve:t})=>{s.device.vibrate(400),t()}),Ol=null,Gw=gn(uh,()=>{Xh()}),Yw=Jr(Pb,()=>{Qh()}),Xh=Oe(Ib,(e,{resolve:t,reject:n})=>{Ol||(Ol=s.accelerometer.watchAcceleration(r=>{st.invokeOnCallback(uh,{x:r&&r.xAxis||0,y:r&&r.yAxis||0,z:r&&r.zAxis||0})},r=>{Ol=null,n(`startAccelerometer:fail ${r.message}`)},{frequency:so})),k(t,so)}),Qh=Oe(Nb,(e,{resolve:t})=>{Ol&&(s.accelerometer.clearWatch(Ol),Ol=null),t()}),qw=gn(dh,Cl(()=>s.bluetooth.onBluetoothDeviceFound.bind(s.bluetooth),dh)),Kw=gn(hh,Cl(()=>s.bluetooth.onBluetoothAdapterStateChange.bind(s.bluetooth),hh)),Jw=gn(gh,Cl(()=>s.bluetooth.onBLEConnectionStateChange.bind(s.bluetooth),gh)),Zw=gn(ph,Cl(()=>s.bluetooth.onBLECharacteristicValueChange.bind(s.bluetooth),ph)),Xw=Oe("openBluetoothAdapter",fi(()=>s.bluetooth.openBluetoothAdapter.bind(s.bluetooth))),Qw=Oe("closeBluetoothAdapter",fi(()=>s.bluetooth.closeBluetoothAdapter.bind(s.bluetooth))),eC=Oe("getBluetoothAdapterState",fi(()=>s.bluetooth.getBluetoothAdapterState.bind(s.bluetooth))),tC=Oe(Mb,fi(()=>s.bluetooth.startBluetoothDevicesDiscovery.bind(s.bluetooth)),Db),nC=Oe("stopBluetoothDevicesDiscovery",fi(()=>s.bluetooth.stopBluetoothDevicesDiscovery.bind(s.bluetooth))),rC=Oe("getBluetoothDevices",fi(()=>s.bluetooth.getBluetoothDevices.bind(s.bluetooth))),iC=Oe(Fb,fi(()=>s.bluetooth.getConnectedBluetoothDevices.bind(s.bluetooth)),Vb),oC=Oe($b,fi(()=>s.bluetooth.createBLEConnection.bind(s.bluetooth)),Ub),aC=Oe(Hb,fi(()=>s.bluetooth.closeBLEConnection.bind(s.bluetooth)),jb),sC=Oe(zb,fi(()=>s.bluetooth.getBLEDeviceServices.bind(s.bluetooth)),Wb),lC=Oe(Gb,fi(()=>s.bluetooth.getBLEDeviceCharacteristics.bind(s.bluetooth)),Yb),cC=Oe(qb,fi(()=>s.bluetooth.notifyBLECharacteristicValueChange.bind(s.bluetooth)),Kb),uC=Oe(Jb,fi(()=>s.bluetooth.readBLECharacteristicValue.bind(s.bluetooth)),Zb),fC=Oe(Xb,fi(()=>s.bluetooth.writeBLECharacteristicValue.bind(s.bluetooth)),Qb),dC=Oe(e0,fi(()=>s.bluetooth.setBLEMTU.bind(s.bluetooth)),t0),hC=Oe(n0,fi(()=>s.bluetooth.getBLEDeviceRSSI.bind(s.bluetooth)),r0),gC=gn(vh,Cl(()=>s.ibeacon.onBeaconUpdate.bind(s.ibeacon),vh)),pC=gn(mh,Cl(()=>s.ibeacon.onBeaconServiceChange.bind(s.ibeacon),mh)),vC=Oe(i0,fi(()=>s.ibeacon.getBeacons.bind(s.ibeacon))),mC=Oe(o0,fi(()=>s.ibeacon.startBeaconDiscovery.bind(s.ibeacon)),a0),_C=Oe(s0,fi(()=>s.ibeacon.stopBeaconDiscovery.bind(s.ibeacon))),bC=Oe(bb,({phoneNumber:e},{resolve:t})=>(s.device.dial(e),t()),Eb),EC={name:{givenName:"firstName",middleName:"middleName",familyName:"lastName"},nickname:"nickName",photos:{type:"url",value:"photoFilePath"},note:"remark",phoneNumbers:[{type:"mobile",value:"mobilePhoneNumber"},{type:"work",value:"workPhoneNumber"},{type:"company",value:"hostNumber"},{type:"home fax",value:"homeFaxNumber"},{type:"work fax",value:"workFaxNumber"}],emails:[{type:"home",value:"email"}],urls:[{type:"other",value:"url"}],organizations:[{type:"company",name:"organization",title:"title"}],ims:[{type:"other",value:"weChatNumber"}],addresses:[{type:"other",preferred:!0,country:"addressCountry",region:"addressState",locality:"addressCity",streetAddress:"addressStreet",postalCode:"addressPostalCode"},{type:"home",country:"homeAddressCountry",region:"homeAddressState",locality:"homeAddressCity",streetAddress:"homeAddressStreet",postalCode:"homeAddressPostalCode"},{type:"company",country:"workAddressCountry",region:"workAddressState",locality:"workAddressCity",streetAddress:"workAddressStreet",postalCode:"workAddressPostalCode"}]},yC=["type","preferred"];function Yu(e,t,n){let r=0;return Object.keys(n).forEach(o=>{let c=n[o];typeof c!=="object"?yC.indexOf(o)!==-1?e[o]=n[o]:typeof t[c]!="undefined"?(r++,e[o]=t[c]):delete e[o]:c instanceof Array?(e[o]=[],c.forEach(b=>{let V={};Yu(V,t,b)&&e[o].push(V)}),e[o].length?r++:delete e[o]):(e[o]={},Yu(e[o],t,c)?r++:delete e[o])}),r}let SC=Oe(yb,(e,{resolve:t,reject:n})=>{!e.photoFilePath&&(e.photoFilePath=""),s.contacts.getAddressBook(s.contacts.ADDRESSBOOK_PHONE,r=>{let o=r.create();Yu(o,e,EC),o.save(()=>t(),c=>n())},r=>n())},wb,Sb);function Wo(e){return typeof g!="undefined"?g.requireModule(e):__requireNativePlugin__(e)}function eg(e,t,n){return Wo("plus").sendNativeEvent(e,t,n)}let wC=Oe(Cb,(e,{resolve:t,reject:n})=>{Wo("clipboard").getString(o=>{o.result==="success"?t({data:o.data}):n("getClipboardData:fail")})}),CC=Oe(Ab,(e,{resolve:t})=>{Wo("clipboard").setString(e.data),t()},Tb,Ob),tg="onNetworkStatusChange";function ng(){rg().then(({networkType:e})=>{st.invokeOnCallback(tg,{isConnected:e!=="none",networkType:e})})}let AC=gn(tg,()=>{s.globalEvent.addEventListener("netchange",ng)}),OC=Jr("offNetworkStatusChange",()=>{s.globalEvent.removeEventListener("netchange",ng)}),rg=Oe("getNetworkType",(e,{resolve:t})=>{let n=qa[s.networkinfo.getCurrentType()]||"unknown";return t({networkType:n})});function ig(){if(s.os.name.toLowerCase()!=="ios")return!1;let t=Wo("faceID");return!!(t&&t.isSupport())}function og(){return!!(s.fingerprint&&s.fingerprint.isSupport())}let ag=e=>{let t=[];return og()&&t.push("fingerPrint"),ig()&&t.push("facial"),e&&e({supportMode:t}),{supportMode:t,errMsg:"checkIsSupportSoterAuthentication:ok"}},TC=Oe(f0,(e,{resolve:t,reject:n})=>{ag(t)}),sg=({checkAuthMode:e,resolve:t,reject:n})=>{let r=(c,h)=>n&&n(c,h),o=c=>t&&t(c);if(e==="fingerPrint"){if(og()){let c=s.fingerprint.isKeyguardSecure()&&s.fingerprint.isEnrolledFingerprints();return o({isEnrolled:c}),{isEnrolled:c,errMsg:"checkIsSoterEnrolledInDevice:ok"}}return r("not support",{isEnrolled:!1}),{isEnrolled:!1,errMsg:"checkIsSoterEnrolledInDevice:fail not support"}}else if(e==="facial"){if(ig()){let c=Wo("faceID"),h=c&&c.isKeyguardSecure()&&c.isEnrolledFaceID();return o({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"}},PC=Oe(d0,({checkAuthMode:e},{resolve:t,reject:n})=>{sg({checkAuthMode:e,resolve:t,reject:n})},p0,g0),IC=Oe(v0,({requestAuthModes:e,challenge:t=!1,authContent:n},{resolve:r,reject:o})=>{jn();let{t:c}=se(),{supportMode:h}=ag();if(!h.length)return o("not support",{authMode:"fingerPrint",errCode:90001});let b=[];if(e.forEach(ut=>{h.indexOf(ut)>-1&&b.push(ut)}),!b.length)return o("startSoterAuthentication:fail no corresponding mode",{authMode:"fingerPrint",errCode:90003});let V=[];if(b.forEach(ut=>{sg({checkAuthMode:ut}).isEnrolled&&V.push(ut)}),!V.length)return o(`startSoterAuthentication:fail no ${b[0]} enrolled`,{authMode:b[0],errCode:90011});let T=V[0],D=null,_e,Se=n||c("uni.startSoterAuthentication.authContent"),Ie=ut=>{let{code:dt}=ut,Tt={authMode:T},It={4:()=>{D?(S(_e),D.setTitle(c("uni.startSoterAuthentication.waitingContent")),_e=k(()=>{D&&D.setTitle(Se)},1e3)):o("",W.extend(Tt,{errCode:90009}))},5:()=>{s.nativeUI.closeWaiting(),o("authenticate freeze. please try again later",W.extend(Tt,{errCode:90010}))},6:()=>{s.nativeUI.closeWaiting(),o("cancel",W.extend(Tt,{errCode:90008}))}};dt&&It[dt]?It[dt]():(s.nativeUI.closeWaiting(),o("",W.extend(Tt,{errCode:90007})))};T==="fingerPrint"?(s.os.name.toLowerCase()==="android"&&(D=s.nativeUI.showWaiting(Se),D.onclose=function(){s.fingerprint.cancel()}),s.fingerprint.authenticate(()=>{s.nativeUI.closeWaiting(),r({authMode:T,errCode:0})},Ie,{message:Se})):T==="facial"&&Wo("faceID").authenticate({message:Se},dt=>{dt.type==="success"&&dt.code===0?r({authMode:T,errCode:0}):Ie(dt)})},_0,m0),NC=Oe(b0,(e,{resolve:t,reject:n})=>{Tn();let{t:r}=se(),c=Wh()!=="light",h,b=!1,V=Wi({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:()=>{V.sendMessage({type:"gallery"})}}]},popGesture:"close",background:"#000000",backButtonAutoControl:"close"},onMessage({event:T,detail:D}){h=D,b=T==="marked"},onClose(){c&&s.navigator.setStatusBarStyle("dark"),h?b?(delete h.message,t(h)):n(h.message):n("cancel")}});c&&(s.navigator.setStatusBarStyle("light"),V.webview.addEventListener("popGesture",({type:T,result:D})=>{T==="start"?s.navigator.setStatusBarStyle("dark"):T==="end"&&!D&&s.navigator.setStatusBarStyle("light")}))},E0,S0),lg=e=>{st.invokeOnCallback(Z.ON_THEME_CHANGE,e)},kC=gn(Z.ON_THEME_CHANGE,()=>{st.on(Z.ON_THEME_CHANGE,lg)}),RC=Jr(Z.OFF_THEME_CHANGE,()=>{st.off(Z.ON_THEME_CHANGE,lg)}),xC=Oe(l0,(e,{resolve:t})=>{let n=s.screen.getBrightness(!1);t({value:n})}),BC=Oe(c0,(e,{resolve:t})=>{s.screen.setBrightness(e.value,!1),t()}),LC=Oe(u0,(e,{resolve:t})=>{s.device.setWakelock(!!e.keepScreenOn),t()}),MC=Mt(w0,()=>{let{getSystemSetting:e}=g.requireModule("plus"),t=e();try{typeof t=="string"&&(t=JSON.parse(t))}catch(n){}return t}),cg=Mt(C0,()=>{let{getAppAuthorizeSetting:e}=g.requireModule("plus"),t=e();try{typeof t=="string"&&(t=JSON.parse(t))}catch(n){}for(let n in t)W.hasOwn(t,n)&&t[n]==="undefined"&&(t[n]=void 0);return t}),DC=Oe(A0,(e,{resolve:t,reject:n})=>{let{openAppAuthorizeSetting:r}=g.requireModule("plus");r(c=>{c.type==="success"?t():n()})}),FC=Oe(dE,(e,{resolve:t,reject:n})=>{let r=Wr+"/download/";s.io.getImageInfo(W.extend(e,{savePath:r,filename:r,success:Xs(t),fail:fr(n)}))},gE,hE),VC=Oe(bE,(e,{resolve:t,reject:n})=>{s.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:fr(n)})},yE,EE),$C=Oe(pE,({current:e=0,indicator:t="number",loop:n=!1,urls:r,longPressActions:o},{resolve:c,reject:h})=>{nt();let{t:b}=se();r=r.map(T=>je(T));let V=Number(e);isNaN(V)?(e=r.indexOf(je(e)),e=e<0?0:e):e=V,s.nativeUI.previewImage(r,{current:e,indicator:t,loop:n,onLongPress:function(T){let D=[],_e="",Se=o&&W.isPlainObject(o);Se?(D=o.itemList?o.itemList:[],_e=o.itemColor?o.itemColor:"#000000"):(D=[b("uni.previewImage.button.save")],_e="#000000");let Ie={buttons:D.map(ut=>({title:ut,color:_e})),cancel:b("uni.previewImage.cancel")};s.nativeUI.actionSheet(Ie,ut=>{if(ut.index>0){if(Se){W.isFunction(o.success)&&o.success({tapIndex:ut.index-1,index:T.index});return}s.gallery.save(T.url,()=>{s.nativeUI.toast(b("uni.previewImage.save.success"))},function(){s.nativeUI.toast(b("uni.previewImage.save.fail"))})}else Se&&W.isFunction(o.fail)&&o.fail({errMsg:"showActionSheet:fail cancel"})})}}),c()},mE,vE),UC=Oe(_E,(e,{resolve:t,reject:n})=>{try{s.nativeUI.closePreviewImage(),t()}catch(r){n()}}),qu,Tl=!1,Ku,Pl=(e,t={})=>{HC(W.extend({state:e},t))},oc={start({duration:e=6e4,sampleRate:t,numberOfChannels:n,encodeBitRate:r,format:o="mp3",frameSize:c}={}){if(Tl)return Pl("start");qu=s.audio.getRecorder(),qu.record({format:o,samplerate:t?String(t):void 0,filename:Wr+"/recorder/"},h=>Pl("stop",{tempFilePath:h}),h=>Pl("error",{errMsg:h.message})),Ku=k(()=>{oc.stop()},e),Pl("start"),Tl=!0},stop(){Tl&&(qu.stop(),Tl=!1,Ku&&S(Ku))},pause(){Tl&&Pl("error",{errMsg:"Unsupported operation: pause"})},resume(){Tl&&Pl("error",{errMsg:"Unsupported operation: resume"})}},Qs={pause:null,resume:null,start:null,stop:null,error:null};function HC(e){let t=e.state;delete e.state,delete e.errMsg,t&&W.isFunction(Qs[t])&&Qs[t](e)}class jC{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(){oc.pause()}resume(){oc.resume()}start(t={}){oc.start(t)}stop(){oc.stop()}}let ug,zC=Mt(PE,()=>ug||(ug=new jC)),WC=Oe(AE,(e,{resolve:t,reject:n})=>{s.gallery.save(e.filePath,Xs(t),fr(n))},TE,OE),GC=Oe(SE,(e,{resolve:t,reject:n})=>{s.gallery.save(e.filePath,Xs(t),fr(n))},CE,wE),YC=Oe(IE,(e,{resolve:t,reject:n})=>{let r=`${Wr}/compressed/${Date.now()}_${Ka(e.src)}`,{compressedWidth:o,compressedHeight:c}=e;typeof o=="number"&&(e.width=o+"px"),typeof c=="number"&&(e.height=c+"px"),s.zip.compressImage(W.extend({},e,{dst:r}),()=>{t({tempFilePath:r})},n)},kE,NE),qC=Oe(RE,(e,{resolve:t,reject:n})=>{let r=`${Wr}/compressed/${Date.now()}_${Ka(e.src)}`;s.zip.compressVideo(W.extend({},e,{filename:r}),o=>{t({tempFilePath:r,size:o.size})},n)},BE,xE);function KC(e){return new Promise((t,n)=>{s.io.resolveLocalFileSystemURL(e,function(r){r.getMetadata(t,n,!1)},n)})}let JC=Oe(aE,({count:e,sizeType:t,sourceType:n,crop:r}={},{resolve:o,reject:c})=>{ie();let{t:h}=se(),b=fr(c);function V(_e){let Se=[],Ie=[];Promise.all(_e.map(ut=>KC(ut))).then(ut=>{ut.forEach((dt,Tt)=>{let It=_e[Tt];Ie.push(It),Se.push({path:It,size:dt.size})}),o({tempFilePaths:Ie,tempFiles:Se})}).catch(b)}function T(){s.camera.getCamera().captureImage(Se=>V([Se]),b,{filename:Wr+"/camera/",resolution:"high",crop:r,sizeType:t})}function D(){s.gallery.pick(({files:_e})=>V(_e),b,{maximum:e,multiple:!0,system:!1,filename:Wr+"/gallery/",permissionAlert:!0,crop:r,sizeType:t})}if(n.length===1){if(n.includes("album")){D();return}else if(n.includes("camera")){T();return}}s.nativeUI.actionSheet({cancel:h("uni.chooseImage.cancel"),buttons:[{title:h("uni.chooseImage.sourceType.camera")},{title:h("uni.chooseImage.sourceType.album")}]},_e=>{switch(_e.index){case 1:T();break;case 2:D();break;default:b();break}})},lE,sE),ZC=Oe(cE,({sourceType:e,compressed:t,maxDuration:n,camera:r},{resolve:o,reject:c})=>{xe();let{t:h}=se(),b=fr(c);function V(_e){s.io.getVideoInfo({filePath:_e,success(Se){let Ie={errMsg:"chooseVideo:ok",tempFilePath:_e,size:Se.size,duration:Se.duration,width:Se.width,height:Se.height};o(Ie)},fail:b})}function T(){s.gallery.pick(({files:_e})=>V(_e[0]),b,{filter:"video",system:!1,multiple:!0,maximum:1,filename:Wr+"/gallery/",permissionAlert:!0,videoCompress:t})}function D(){s.camera.getCamera().startVideoCapture(V,b,{index:r==="front"?"2":"1",videoMaximumDuration:n,filename:Wr+"/camera/",videoCompress:t})}if(e.length===1){if(e.includes("album")){T();return}else if(e.includes("camera")){D();return}}s.nativeUI.actionSheet({cancel:h("uni.chooseVideo.cancel"),buttons:[{title:h("uni.chooseVideo.sourceType.camera")},{title:h("uni.chooseVideo.sourceType.album")}]},_e=>{switch(_e.index){case 1:D();break;case 2:T();break;default:b();break}})},fE,uE),XC=Oe(Z0,(e,{resolve:t})=>{s.key.showSoftKeybord(),t()}),QC=Oe(J0,(e,{resolve:t})=>{s.key.hideSoftKeybord(),t()});function fg(e){st.invokeOnCallback(Z.ON_KEYBOARD_HEIGHT_CHANGE,e)}let eA=gn(Z.ON_KEYBOARD_HEIGHT_CHANGE,()=>{st.on(Z.ON_KEYBOARD_HEIGHT_CHANGE,fg)}),tA=Jr(Z.ON_KEYBOARD_HEIGHT_CHANGE,()=>{st.off(Z.ON_KEYBOARD_HEIGHT_CHANGE,fg)});class nA{constructor(t){this._callbacks=[],this._downloader=t,t.addEventListener("statechanged",(n,r)=>{n.downloadedSize&&n.totalSize&&this._callbacks.forEach(o=>{o({progress:Math.round(n.downloadedSize/n.totalSize*100),totalBytesWritten:n.downloadedSize,totalBytesExpectedToWrite:n.totalSize})})})}abort(){this._downloader.abort()}onProgressUpdate(t){!W.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 rA=kr(WE,({url:e,header:t,timeout:n},{resolve:r,reject:o})=>{n=(n||B.networkTimeout&&B.networkTimeout.request||60*1e3)/1e3;let c=s.downloader.createDownload(e,{timeout:n,filename:Wr+"/download/",retry:0,retryInterval:0},(b,V)=>{V?r({tempFilePath:b.filename,statusCode:V}):o(`statusCode: ${V}`)}),h=new nA(c);for(let b in t)W.hasOwn(t,b)&&c.setRequestHeader(b,t[b]);return c.start(),h},YE,GE),iA=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 o=0;o<r.length;o++)r[o].indexOf("Expires=")!==-1||r[o].indexOf("expires=")!==-1?n.push(r[o].replace(",","")):n.push(r[o]);return n=n.join(";").split(","),n};function oA(e,t){if(W.isString(e.data)&&e.data.charCodeAt(0)===65279&&(e.data=e.data.slice(1)),e.statusCode=parseInt(String(e.statusCode),10),W.isPlainObject(e.header)&&(e.header=Object.keys(e.header).reduce(function(n,r){let o=e.header[r];return W.isArray(o)?n[r]=o.join(","):W.isString(o)&&(n[r]=o),n},{})),t.dataType&&t.dataType.toLowerCase()==="json")try{e.data=JSON.parse(e.data)}catch(n){}return e}class aA{constructor(t){this._requestTask=t}abort(){this._requestTask.abort()}offHeadersReceived(){}onHeadersReceived(){}}let sA=kr(LE,(e,{resolve:t,reject:n})=>{let{header:r,method:o,data:c,timeout:h,url:b,responseType:V,sslVerify:T,firstIpv4:D,tls:_e}=e,Se;for(let yt in r)if(yt.toLowerCase()==="content-type"){Se=r[yt];break}o!=="GET"&&Se.indexOf("application/json")===0&&W.isPlainObject(c)&&(c=JSON.stringify(c));let Ie=Wo("stream"),ut={},dt,Tt,It=!1;for(let yt in r)if(!It&&yt.toLowerCase()==="content-type"){if(It=!0,ut["Content-Type"]=r[yt],o!=="GET"&&r[yt].indexOf("application/x-www-form-urlencoded")===0&&!W.isString(c)&&!(c instanceof ArrayBuffer)){let En=[];for(let an in c)W.hasOwn(c,an)&&En.push(encodeURIComponent(an)+"="+encodeURIComponent(c[an]));c=En.join("&")}}else ut[yt]=r[yt];!It&&o==="POST"&&(ut["Content-Type"]="application/x-www-form-urlencoded; charset=UTF-8"),h&&(dt=k(()=>{Tt=!0,n("timeout")},h+200));let vn={method:o,url:b.trim(),headers:ut,type:V==="arraybuffer"?"base64":"text",timeout:h||6e5,sslVerify:!T,firstIpv4:D,tls:_e},un=!1;o!=="GET"&&(toString.call(c)==="[object ArrayBuffer]"?un=!0:vn.body=W.isString(c)?c:JSON.stringify(c));let jt=({ok:yt,status:En,data:an,headers:Xt,errorMsg:An})=>{if(Tt)return;dt&&S(dt);let dr=En;if(dr>0)t(oA({data:yt&&V==="arraybuffer"?Ni(an):an,statusCode:dr,header:Xt,cookies:iA(Xt)},e));else{let Qt="abort statusCode:"+dr;An&&(Qt=Qt+" "+An),n(Qt)}};return un?Ie.fetchWithArrayBuffer({"@type":"binary",base64:pr(c)},vn,jt):Ie.fetch(vn,jt),new aA({abort(){Tt=!0,dt&&S(dt),n("abort")}})},$E,UE),lA=Oe(HE,({certificates:e},{resolve:t,reject:n})=>{Wo("stream").configMTLS(e,({type:o,code:c,message:h})=>{switch(o){case"success":t({code:c});break;case"fail":n(h,{code:c});break}})},jE,zE),Il=[],Nl={},Ju={open:"",close:"",error:"",message:""},ac;function cA(e){let t=String(Date.now()),n;try{ac||(ac=Wo("uni-webSocket"),uA(ac)),ac.WebSocket({id:t,url:e.url,protocol:W.isArray(e.protocols)?e.protocols.join(","):e.protocols,header:e.header})}catch(r){n=r}return{socket:ac,socketId:t,errMsg:n}}function uA(e){e.onopen(t=>{let n=Nl[t.id];!n||n._socketOnOpen()}),e.onmessage(t=>{let n=Nl[t.id];!n||n._socketOnMessage(t)}),e.onerror(t=>{let n=Nl[t.id];!n||n._socketOnError()}),e.onclose(t=>{let{id:n,code:r,reason:o}=t,c=Nl[n];!c||c._socketOnClose({code:r,reason:o})})}class fA{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"?Ni(t.data.base64):t.data})}_socketOnError(){this.socketStateChange("error"),this.onErrorOrClose()}_socketOnClose(t){this.socketStateChange("close",t),this.onErrorOrClose()}onErrorOrClose(){this.readyState=this.CLOSED,delete Nl[this.id];let t=Il.indexOf(this);t>=0&&Il.splice(t,1)}socketStateChange(t,n={}){let{code:r,reason:o}=n,c=t==="message"?{data:n.data}:t==="close"?{code:r,reason:o}:{};this===Il[0]&&Ju[t]&&st.invokeOnCallback(Ju[t],c),this._callbacks[t].forEach(h=>{W.isFunction(h)&&h(c)})}send(t,n=!0){this.readyState!==this.OPEN&&Z.callOptions(t,"sendSocketMessage:fail WebSocket is not connected");try{this._socket.send({id:this.id,data:typeof t.data=="object"?{"@type":"binary",base64:pr(t.data)}:t.data}),n&&Z.callOptions(t,"sendSocketMessage:ok")}catch(r){n&&Z.callOptions(t,`sendSocketMessage:fail ${r}`)}}close(t,n=!0){this.readyState=this.CLOSING;try{this._socket.close(W.extend({id:this.id,args:t})),n&&Z.callOptions(t,"closeSocket:ok")}catch(r){n&&Z.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 dA=kr(ZE,({url:e,protocols:t,header:n,method:r},{resolve:o,reject:c})=>{let{socket:h,socketId:b,errMsg:V}=cA({url:e,protocols:t,header:n,method:r}),T=new fA(h,b);return V?k(()=>{c(V)},0):(Il.push(T),Nl[b]=T),k(()=>{o()},0),T},QE,XE),hA=Oe(ey,(e,{resolve:t,reject:n})=>{let r=Il[0];if(!r||r.readyState!==r.OPEN){n("WebSocket is not connected");return}r.send({data:e.data},!1),t()},ty),gA=Oe(ny,(e,{resolve:t,reject:n})=>{let r=Il[0];if(!r){n("WebSocket is not connected");return}r.readyState=r.CLOSING,r.close(e,!1),t()},ry);function Lc(e){let t=`onSocket${W.capitalize(e)}`;return gn(t,()=>{Ju[e]=t})}let pA=Lc("open"),vA=Lc("error"),mA=Lc("message"),_A=Lc("close");class bA{constructor(t){this._callbacks=[],this._uploader=t,t.addEventListener("statechanged",(n,r)=>{n.uploadedSize&&n.totalSize&&this._callbacks.forEach(o=>{o({progress:parseInt(String(n.uploadedSize/n.totalSize*100)),totalBytesSent:n.uploadedSize,totalBytesExpectedToSend:n.totalSize})})})}abort(){this._uploader.abort()}onProgressUpdate(t){!W.isFunction(t)||this._callbacks.push(t)}onHeadersReceived(){}offProgressUpdate(t){let n=this._callbacks.indexOf(t);n>=0&&this._callbacks.splice(n,1)}offHeadersReceived(){}}let EA=kr(qE,({url:e,timeout:t,header:n,formData:r,files:o,filePath:c,name:h},{resolve:b,reject:V})=>{t=(t||B.networkTimeout&&B.networkTimeout.uploadFile||60*1e3)/1e3;let T=s.uploader.createUpload(e,{timeout:t,retry:0,retryInterval:0},(_e,Se)=>{Se?b({data:_e.responseText,statusCode:Se}):V(`statusCode: ${Se}`)});for(let _e in n)W.hasOwn(n,_e)&&T.setRequestHeader(_e,String(n[_e]));for(let _e in r)W.hasOwn(r,_e)&&T.addData(_e,String(r[_e]));o&&o.length?o.forEach(_e=>{T.addFile(je(_e.uri),{key:_e.name||"file"})}):T.addFile(je(c),{key:h});let D=new bA(T);return T.start(),D},JE,KE),Is={},yA=["play","canplay","ended","stop","waiting","seeking","seeked","pause"],dg="playback",SA=200,wA=e=>{let t=Is[e];!t||t.initStateChage||(t.initStateChage=!0,t.addEventListener("error",n=>{hg({state:"error",audioId:e,errMsg:"MediaError",errCode:n.code})}),yA.forEach(n=>{t.addEventListener(n,()=>{n==="play"?t.isStopped=!1:n==="stop"&&(t.isStopped=!0),hg({state:n,audioId:e})})}))};function CA(){let e=`${Date.now()}${Math.random()}`,t=Is[e]=s.audio.createPlayer("");return t.src="",t.volume=1,t.startTime=0,t.setSessionCategory(dg),{errMsg:"createAudioInstance:ok",audioId:e}}function AA({audioId:e,src:t,startTime:n,autoplay:r=!1,loop:o=!1,obeyMuteSwitch:c,volume:h,sessionCategory:b=dg,playbackRate:V}){let T=Is[e];if(T){let D={loop:o,autoplay:r};if(t){let _e=je(t);T.src!==_e&&(T.src=D.src=_e)}n&&(T.startTime=D.startTime=n),typeof h=="number"&&(T.volume=D.volume=h),T.setStyles(D),b&&T.setSessionCategory(b),V&&T.playbackRate&&T.playbackRate(V),wA(e)}return{errMsg:"setAudioState:ok"}}function OA({audioId:e}){let t=Is[e];if(!t)return{errMsg:"getAudioState:fail"};let{src:n,startTime:r,volume:o}=t;return{errMsg:"getAudioState:ok",duration:1e3*(t.getDuration()||0),currentTime:t.isStopped?0:1e3*t.getPosition(),paused:t.isPaused(),src:n,volume:o,startTime:1e3*r,buffered:1e3*t.getBuffered()}}function TA({operationType:e,audioId:t,currentTime:n}){let r=Is[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 Zu=Object.create(null),hg=({state:e,audioId:t,errMsg:n,errCode:r})=>{let o=Zu[t];if(o)if(Qu(o,e,n,r),e==="play"){let c=o.currentTime;Qu(o,"timeUpdate"),o.__timing=d(()=>{o.currentTime!==c&&Qu(o,"timeUpdate")},SA)}else(e==="pause"||e==="stop"||e==="error")&&E(o.__timing)},PA=[{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 Xu{constructor(t){this.id=t,this._callbacks={},this._options={},Jd.forEach(n=>{this._callbacks[n]=[]}),PA.forEach(n=>{let r=n.name;Object.defineProperty(this,r,{get:()=>{let o=n.cache?this._options:OA({audioId:this.id}),c=r in o?o[r]:n.default;return typeof c=="number"&&r!=="volume"?c/1e3:c},set:n.readonly?void 0:o=>{this._options[r]=o,AA(W.extend({},this._options,{audioId:this.id}))}})}),IA()}play(){this._operate("play")}pause(){this._operate("pause")}stop(){this._operate("stop")}seek(t){this._operate("seek",{currentTime:t*1e3})}destroy(){E(this.__timing),Is[this.id]&&(Is[this.id].close(),delete Is[this.id]),delete Zu[this.id]}_operate(t,n){TA(W.extend({},n,{audioId:this.id,operationType:t}))}}let IA=Z.once(()=>{Jd.forEach(e=>{Xu.prototype[e]=function(t){W.isFunction(t)&&this._callbacks[e].push(t)}}),A_.forEach(e=>{Xu.prototype[e]=function(t){let n=this._callbacks[e],r=n.indexOf(t);r>=0&&n.splice(r,1)}})});function Qu(e,t,n,r){let o=`on${W.capitalize(t)}`;e._callbacks[o].forEach(c=>{W.isFunction(c)&&c(t==="error"?{errMsg:n,errCode:r}:{})})}let NA=Mt(e_,()=>{let{audioId:e}=CA(),t=new Xu(e);return Zu[e]=t,t}),kA=["canplay","play","pause","stop","ended","timeUpdate","prev","next","error","waiting"],gg={canplay:[],play:[],pause:[],stop:[],ended:[],timeUpdate:[],prev:[],next:[],error:[],waiting:[]},on,ef=null,RA=250,xA=["play","pause","ended","stop","canplay"];function BA(){Mc(),el({state:"timeUpdate"}),ef=d(()=>{el({state:"timeUpdate"})},RA)}function Mc(){ef!==null&&E(ef)}function LA(){if(on)return;let e=st.invokeOnCallback;on=s.audio.createPlayer({autoplay:!0,backgroundControl:!0}),on.src=on.title=on.epname=on.singer=on.coverImgUrl=on.webUrl="",on.startTime=0,xA.forEach(t=>{on.addEventListener(t,()=>{t==="play"?(on.isStopped=!1,BA()):t==="stop"&&(on.isStopped=!0),(t==="pause"||t==="ended"||t==="stop")&&Mc();let n=`onMusic${t[0].toUpperCase()+t.slice(1)}`;e(n,{dataUrl:on.src,errMsg:`${n}:ok`}),el({state:t,dataUrl:on.src})})}),on.addEventListener("waiting",()=>{Mc(),el({state:"waiting",dataUrl:on.src})}),on.addEventListener("error",t=>{Mc(),e("onMusicError",{dataUrl:on.src,errMsg:"Error:"+t.message}),el({state:"error",dataUrl:on.src,errMsg:t.message,errCode:t.code})}),on.addEventListener("prev",()=>{el({state:"prev"})}),on.addEventListener("next",()=>{el({state:"next"})})}function MA(){let e={duration:0,currentTime:0,paused:!1,src:"",buffered:0,title:"",epname:"",singer:"",coverImgUrl:"",webUrl:"",startTime:0,errMsg:"getBackgroundAudioState:ok"};if(on){let t={duration:on.getDuration()||0,currentTime:on.isStopped?0:on.getPosition(),paused:on.isPaused(),src:on.src,buffered:on.getBuffered(),title:on.title,epname:on.epname,singer:on.singer,coverImgUrl:on.coverImgUrl,webUrl:on.webUrl,startTime:on.startTime};e=W.extend(e,t)}return e}function pg(e,t){LA();let n=["src","startTime","coverImgUrl","webUrl","singer","epname","title"];if(t==="playbackRate"){let o=e[t];on.playbackRate&&on.playbackRate(parseFloat(o));return}let r={};Object.keys(e).forEach(o=>{if(n.indexOf(o)>=0){let c=e[o];o===n[0]&&c&&(c=je(c)),on[o]=r[o]=c}}),on.setStyles(r)}function DA({operationType:e,src:t,position:n,api:r="operateMusicPlayer",title:o,coverImgUrl:c}){var h=["resume","pause","stop"];return h.indexOf(e)>0?on&&on[e]():e==="play"?(pg({src:t,startTime:n,title:o,coverImgUrl:c}),on.play()):e==="seek"&&on&&on.seekTo(n),{errMsg:`${r}:ok`}}function FA({operationType:e,src:t,startTime:n,currentTime:r}){return DA({operationType:e,src:t,position:n||r||0,api:"operateBackgroundAudio"})}function el({state:e,errMsg:t,errCode:n,dataUrl:r}){gg[e].forEach(o=>{W.isFunction(o)&&o(e==="error"?{errMsg:t,errCode:n}:{})})}let VA=Z.once(()=>{kA.forEach(e=>{vg.prototype[`on${W.capitalize(e)}`]=function(t){gg[e].push(t)}})}),$A=[{name:"duration",readonly:!0},{name:"currentTime",readonly:!0},{name:"paused",readonly:!0},{name:"src",cache:!0},{name:"startTime",default:0,cache:!0},{name:"buffered",readonly:!0},{name:"title",cache:!0},{name:"epname",cache:!0},{name:"singer",cache:!0},{name:"coverImgUrl",cache:!0},{name:"webUrl",cache:!0},{name:"protocol",readonly:!0,default:"http"},{name:"playbackRate",default:1,cache:!0}];class vg{constructor(){this._options={},$A.forEach(t=>{let n=t.name;Object.defineProperty(this,n,{get:()=>{let r=t.cache?this._options:MA();return n in r?r[n]:t.default},set:t.readonly?void 0:r=>{this._options[n]=r,pg(this._options,n)}})}),VA()}play(){this._operate("play")}pause(){this._operate("pause")}stop(){this._operate("stop")}seek(t){this._operate("seek",{currentTime:t})}_operate(t,n){FA(W.extend({},n,{operationType:t}))}}let mg,UA=Mt(_b,()=>mg||(mg=new vg));class HA{constructor(t,n){this.id=t,this.ctx=n}start(t){return Gt(this.ctx,"start",t)}stop(t){return Gt(this.ctx,"stop",t)}pause(t){return Gt(this.ctx,"pause",t)}resume(t){return Gt(this.ctx,"resume",t)}switchCamera(t){return Gt(this.ctx,"switchCamera",t)}snapshot(t){return Gt(this.ctx,"snapshot",t)}toggleTorch(t){return Gt(this.ctx,"toggleTorch",t)}playBGM(t){return Ut(this.ctx,"playBGM",t)}stopBGM(t){return Gt(this.ctx,"stopBGM",t)}pauseBGM(t){return Gt(this.ctx,"pauseBGM",t)}resumeBGM(t){return Gt(this.ctx,"resumeBGM",t)}setBGMVolume(t){return Ut(this.ctx,"setBGMVolume",t)}startPreview(t){return Gt(this.ctx,"startPreview",t)}stopPreview(t){return Gt(this.ctx,"stopPreview",t)}}function Ns(e,t,n,r){st.invokeViewMethod("livepusher."+e,{livePusherId:e,type:n,data:r},t)}class jA{constructor(t,n){this.id=t,this.pageId=n}start(){Ns(this.id,this.pageId,"start")}stop(){Ns(this.id,this.pageId,"stop")}pause(){Ns(this.id,this.pageId,"pause")}resume(){Ns(this.id,this.pageId,"resume")}switchCamera(){Ns(this.id,this.pageId,"switchCamera")}startPreview(){Ns(this.id,this.pageId,"preview")}stopPreview(){Ns(this.id,this.pageId,"stop")}snapshot(){Ns(this.id,this.pageId,"snapshot")}}let zA=Mt(t_,(e,t)=>{if(t.$page.meta.isNVue){if(!t)return console.warn("uni.createLivePusherContext: 2 arguments required, but only 1 present");let n=Ft(e,t);return n?new HA(e,n):console.warn("Can not find `"+e+"`")}return new jA(e,t.$page.id)},n_),Ti=3.141592653589793,Dc=6378245,Fc=.006693421622965943;function WA(e,t){if(t=+t,e=+e,_g(e,t))return[e,t];let n=bg(e-105,t-35),r=Eg(e-105,t-35),o=t/180*Ti,c=Math.sin(o);c=1-Fc*c*c;let h=Math.sqrt(c);n=n*180/(Dc*(1-Fc)/(c*h)*Ti),r=r*180/(Dc/h*Math.cos(o)*Ti);let b=t+n,V=e+r;return[e*2-V,t*2-b]}function GA(e,t){if(t=+t,e=+e,_g(e,t))return[e,t];let n=bg(e-105,t-35),r=Eg(e-105,t-35),o=t/180*Ti,c=Math.sin(o);c=1-Fc*c*c;let h=Math.sqrt(c);n=n*180/(Dc*(1-Fc)/(c*h)*Ti),r=r*180/(Dc/h*Math.cos(o)*Ti);let b=t+n;return[e+r,b]}let _g=function(e,t){return e<72.004||e>137.8347||t<.8293||t>55.8271||!1},bg=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*Ti)+20*Math.sin(2*e*Ti))*2/3,n+=(20*Math.sin(t*Ti)+40*Math.sin(t/3*Ti))*2/3,n+=(160*Math.sin(t/12*Ti)+320*Math.sin(t*Ti/30))*2/3,n},Eg=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*Ti)+20*Math.sin(2*e*Ti))*2/3,n+=(20*Math.sin(e*Ti)+40*Math.sin(e/3*Ti))*2/3,n+=(150*Math.sin(e/12*Ti)+300*Math.sin(e/30*Ti))*2/3,n};function yg(e,t,n){let r=t.coords;if(e!==t.coordsType){let o;e==="wgs84"?o=WA(r.longitude,r.latitude):e==="gcj02"&&(o=GA(r.longitude,r.latitude)),o&&(r.longitude=o[0],r.latitude=o[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 YA=Oe(eE,({type:e="wgs84",geocode:t=!1,altitude:n=!1,highAccuracyExpireTime:r,isHighAccuracy:o=!1},{resolve:c,reject:h})=>{s.geolocation.getCurrentPosition(b=>{yg(e,b,c)},b=>{if(b.code===1501){yg(e,b,c);return}h("getLocation:fail "+b.message)},{geocode:t,enableHighAccuracy:o||n,timeout:r,coordsType:e})},nE,tE),qA=Oe(X0,(e,{resolve:t,reject:n})=>{let o=Wh()!=="light",c,h=Wi({url:"__uniappchooselocation",data:W.extend({},e,{locale:Jl()}),style:{animationType:e.animationType||"slide-in-bottom",titleNView:!1,popGesture:"close",scrollIndicator:"none"},onMessage({event:b,detail:V}){b==="selected"&&(c=V)},onClose(){o&&s.navigator.setStatusBarStyle("dark"),c?t(c):n("cancel")}});o&&(s.navigator.setStatusBarStyle("light"),h.webview.addEventListener("popGesture",({type:b,result:V})=>{b==="start"?s.navigator.setStatusBarStyle("dark"):b==="end"&&!V&&s.navigator.setStatusBarStyle("light")}))},Q0),KA=Oe(rE,(e,{resolve:t,reject:n})=>(Wi({url:"__uniappopenlocation",data:W.extend({},e,{locale:Jl()}),style:{titleNView:{type:"transparent"},popGesture:"close",backButtonAutoControl:"close"},onClose(){n("cancel")}}),t()),oE,iE),Vc=!1,sc=0,JA=Oe(iy,(e,{resolve:t,reject:n})=>{sc=sc||s.geolocation.watchPosition(r=>{Vc=!0,st.invokeOnCallback(Ch,r.coords)},r=>{Vc||(n(r.message),Vc=!0),st.invokeOnCallback(Ah,{errMsg:`onLocationChange:fail ${r.message}`})},{coordsType:e==null?void 0:e.type}),k(t,100)},ly,cy),ZA=Oe(oy,(e,{resolve:t})=>{sc&&(s.geolocation.clearWatch(sc),Vc=!1,sc=0),t()}),XA=gn(Ch,()=>{}),QA=Jr(ay,()=>{}),eO=gn(Ah,()=>{}),tO=Jr(sy,()=>{}),nO=Oe(Yy,({title:e="",content:t="",showCancel:n=!0,cancelText:r,cancelColor:o,confirmText:c,confirmColor:h,editable:b=!1,placeholderText:V=""}={},{resolve:T})=>{let D=n?[r,c]:[c],_e=b?V:D;t=t||" ",s.nativeUI[b?"prompt":"confirm"](t,Se=>{if(n){let Ie=Se.index===1,ut={confirm:Ie,cancel:Se.index===0||Se.index===-1};Ie&&b&&(ut.content=Se.value),T(ut)}else{let Ie={confirm:Se.index===0,cancel:!1};b&&(Ie.content=Se.value),T(Ie)}},e,_e,D)},qy,Ky),rO={light:{itemColor:"#000000"},dark:{itemColor:"rgba(255, 255, 255, 0.8)"}},iO=Oe(Uy,({itemList:e=[],itemColor:t,title:n="",popover:r},{resolve:o,reject:c})=>{t==="#000"&&B.darkmode&&(t=rO[s.navigator.getUIStyle()].itemColor),K();let{t:h}=se(),b={title:n,cancel:h("uni.showActionSheet.cancel"),buttons:e.map(V=>({title:V,color:t}))};s.nativeUI.actionSheet(W.extend(b,{popover:r}),V=>{V.index>0?o({tapIndex:V.index-1}):c("showActionSheet:fail cancel")})},Hy,jy),lc,tf=!1,$c="",Uc,oO=Oe(zy,(e,t)=>Sg(W.extend({},e,{type:"loading",icon:"loading"}),t),Wy,Gy),Sg=({title:e="",icon:t="success",image:n="",duration:r=1500,mask:o=!1,position:c,type:h="toast",style:b},{resolve:V,reject:T})=>{if(Hc(""),$c=h,["top","center","bottom"].includes(String(c)))s.nativeUI.toast(e,{verticalAlign:c}),tf=!0;else{t&&!~["success","loading","error","none"].indexOf(t)&&(t="success");let D={modal:o,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=s.nativeUI.showWaiting(e,W.extend(D,b))}catch(_e){T(`${_e}`)}}return $c==="toast"&&(Uc=k(()=>{Hc("")},r)),V()},aO=Oe(Jy,Sg,Xy,Qy),sO=Oe(Iy,(e,t)=>Hc("toast",t)),lO=Oe(Py,(e,t)=>Hc("loading",t));function Hc(e="toast",t){return e&&e!==$c||(Uc&&(S(Uc),Uc=null),tf?s.nativeUI.closeToast():lc&&lc.close&&lc.close(),lc=null,tf=!1,$c=""),t&&t.resolve()}let cO=Oe(eS,(e,{resolve:t,reject:n})=>{let r=zh();if(r&&r.endPullToRefresh(),r=xc(),!r)return n();r.beginPullToRefresh(),Wu(r),t()}),uO=Oe(tS,(e,{resolve:t,reject:n})=>{let r=zh()||xc();if(!r)return n();r.endPullToRefresh(),Wu(null),t()}),fO=Oe(Nh,(e,{resolve:t,reject:n})=>{let r=er(_r());st.invokeViewMethod(Nh,e,r,o=>{o?n(o):t()})},Ny),dO=Oe(kh,(e,{resolve:t})=>{let n=er(_r());st.invokeViewMethod(kh,e,n,t)},Vy,$y),hO=Oe(Ly,({__page__:e,title:t},{resolve:n,reject:r})=>{let o=Hh(e);if(o){let c=o.getStyle();c&&c.titleNView&&o.setStyle({titleNView:{titleText:t}}),n()}else r()},My),gO=Oe(Dy,(e,{resolve:t})=>{s.nativeUI.showWaiting("",{modal:!1}),t()}),pO=Oe(Fy,(e,{resolve:t})=>{s.nativeUI.closeWaiting(),t()});function vO(e){let t=Pn();!t.length||(t[t.length-1].$page.statusBarStyle=e)}let mO=Oe(Ry,({__page__:e,frontColor:t,backgroundColor:n},{resolve:r,reject:o})=>{let c=Hh(e);if(c){let h={};t&&(h.titleColor=t),n&&(h.backgroundColor=n);let b=t==="#000000"?"dark":"light";s.navigator.setStatusBarStyle(b),vO(b);let V=c.getStyle();V&&V.titleNView&&(V.titleNView.autoBackButton&&(h.backButton=h.backButton||{},h.backButton.color=t),c.setStyle({titleNView:h})),r()}else o()},By,xy),_O=Oe(yS,({index:e,text:t},{resolve:n,reject:r})=>{di.setTabBarBadge("text",e,t),n()},SS,wS),bO=Oe(nS,({index:e,text:t,iconPath:n,selectedIconPath:r,pagePath:o,visible:c,iconfont:h},{resolve:b})=>{if(di.setTabBarItem(e,t,n,r,c,h),o){let V=B.tabBar.list[e];if(V){let T=V.pagePath,D=Z.removeLeadingSlash(o);D!==T&&as(e,T,D)}}b()},rS,iS),EO=Oe(oS,(e={},{resolve:t,reject:n})=>{if(!tc())return n("not TabBar page");e.borderStyle=Z.normalizeTabBarStyles(e.borderStyle),di.setTabBarStyle(e),t()},aS,lS),yO=Oe(cS,(e,{resolve:t,reject:n})=>{let r=e&&e.animation;if(!tc())return n("not TabBar page");di.hideTabBar(Boolean(r)),t()},Rh),SO=Oe(uS,(e,{resolve:t,reject:n})=>{let r=e&&e.animation;if(!tc())return n("not TabBar page");di.showTabBar(Boolean(r)),t()},fS),wO=Oe(pS,({index:e},{resolve:t,reject:n})=>{di.setTabBarBadge("redDot",e),t()},vS,mS),wg=e=>di.setTabBarBadge("none",e),CO=Oe(_S,({index:e},{resolve:t,reject:n})=>{wg(e),t()},bS,ES),AO=Oe(dS,({index:e},{resolve:t,reject:n})=>{wg(e),t()},hS,gS),Cg="vdSync",OO="__uniapp__service",kl="onWebviewReady",TO=0,PO="webviewInserted",IO="webviewRemoved",Ag="UniAppSubNVue";class NO{constructor(t,n){this.callbacks=[];let r=this.webview=s.webview.getWebviewById(t);if(this.isSub=n||!1,r.__uniapp_mask_id){let o=this.maskWebview=r.__uniapp_mask_id==="0"?{setStyle({mask:h}){Wo("uni-tabview").setMask({color:h})}}:s.webview.getWebviewById(r.__uniapp_mask_id),c=function(){o.setStyle({mask:"none"})};r.addEventListener("hide",c),r.addEventListener("close",c)}}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===Ag){let o=r.data.target;o.id===this.webview.id&&o.isSub===this.isSub&&this.callbacks.forEach(c=>{c({origin:this.webview.__uniapp_host,data:r.data.data})})}};Wo("globalEvent").addEventListener("plusMessage",t),this.webview.addEventListener("close",()=>{this.callbacks.length=0})}postMessage(t){s.webview.postMessageToUniNView({type:Ag,data:t,target:{id:this.webview.id,isSub:!this.isSub}},OO)}onMessage(t){this.initMessage(),this.callbacks.push(t)}}let kO=function(e,t){return new NO(e,t)};function RO(e,t,n,r,o,c,h){s!==n&&(w=fn=e,g=t,s=n,Iw(s.navigator.setStatusBarStyle),s.navigator.setStatusBarStyle=Fh,k=r,S=o,d=c,E=h),B.serviceReady=!0}function xO(){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}function BO(e){W.extend(global,e)}let Og={oauth(e){s.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){s.share.getServices(t=>{t=t;let n=[];t.forEach(({id:r})=>{n.push(r)}),e(null,n,t)},t=>{e(t)})},payment(e){s.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 s!="undefined"){let t=s.push.getClientInfo();e(null,[t.id],[t])}else e(null,[])}},LO=Oe(CS,({service:e},{resolve:t,reject:n})=>{Og[e]?Og[e]((r,o=[],c=[])=>{r?n(r.message):t({service:e,provider:o,providers:c.map(h=>(typeof h.serviceReady=="boolean"&&(h.isAppExist=h.serviceReady),typeof h.nativeClient=="boolean"&&(h.isAppExist=h.nativeClient),h))})}):n("service not found")},AS),jc;function cc(e){return new Promise((t,n)=>{s.oauth.getServices(r=>{let o=r.find(({id:c})=>c===e);o?t(o):n(new Error("provider not find"))},n)})}let Tg=Oe(OS,(e,{resolve:t,reject:n})=>{let r=e.provider||"weixin",o=fr(n),c=r==="apple",h=c?{scope:"email"}:e.univerifyStyle?{univerifyStyle:FO(e.univerifyStyle,o)}:{};cc(r).then(b=>{function V(){if(e.onlyAuthorize&&r==="weixin"){b.authorize(({code:T})=>{t({code:T,authResult:""})},o);return}b.login(T=>{let D=T.target.authResult,_e=T.target.appleInfo;t({code:D.code,authResult:D,appleInfo:_e})},o,h)}c||r==="univerify"?V():b.logout(V,V)}).catch(o)},TS),Pg=(e,{resolve:t,reject:n})=>{let r=e.provider||"weixin",o=fr(n);cc(r).then(c=>{c.getUserInfo(h=>{let b={nickName:""};if(r==="weixin"){let T=c.userInfo;T&&(b={openId:T.openid,nickName:T.nickname,gender:T.sex,city:T.city,province:T.province,country:T.country,avatarUrl:T.headimgurl,unionId:T.unionid})}else if(r==="apple"){let T=c.appleInfo;T&&(b={openId:T.user,fullName:T.fullName,email:T.email,authorizationCode:T.authorizationCode,identityToken:T.identityToken,realUserStatus:T.realUserStatus})}else b=c.userInfo,b&&(b.openId=b.openId||b.openid||c.authResult.openid,b.nickName=b.nickName||b.nickname,b.avatarUrl=b.avatarUrl||b.headimgurl);let V={};e.data&&e.data.api_name==="webapi_getuserinfo"?V.data={data:JSON.stringify(b),rawData:"",signature:"",encryptedData:"",iv:""}:V.userInfo=b,t(V)},o)}).catch(()=>{n("\u8BF7\u5148\u8C03\u7528 uni.login")})},MO=Oe(PS,Pg,IS),DO=Oe(NS,Pg,kS),Ig=Oe(RS,({provider:e},{resolve:t,reject:n})=>{let r=Xs(t),o=fr(n);cc(e).then(c=>c.preLogin(r,o)).catch(o)},LS,BS),Ng=()=>cc("univerify").then(e=>e.closeAuthView()),kg=Mt(MS,Ng),Rg=Oe(DS,(e,{resolve:t,reject:n})=>{let r=Xs(t),o=fr(n);try{cc("univerify").then(c=>{let h=c.getCheckBoxState();r({state:h})})}catch(c){o(c)}});function FO(e,t){return W.isPlainObject(e)&&W.isPlainObject(e.buttons)&&W.toTypeString(e.buttons.list)==="[object Array]"&&e.buttons.list.forEach((n,r)=>{e.buttons.list[r].onclick=function(){let o={code:"30008",message:"\u7528\u6237\u70B9\u51FB\u4E86\u81EA\u5B9A\u4E49\u6309\u94AE",index:r,provider:n.provider};W.isPlainObject(jc)?jc._triggerUniverifyButtonsClick(o):Ng().then(()=>{t(o)})}}),e}class VO{constructor(){this.provider="univerify",this.eventName="api.univerifyButtonsClick"}close(){return kg()}login(t){return Tg(this._getOptions(t))}getCheckBoxState(t){return Rg(t)}preLogin(t){return Ig(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 W.extend({},t,{provider:this.provider})}}let $O=Mt(FS,()=>jc||(jc=new VO)),UO=Oe(YS,(e,{resolve:t,reject:n})=>{let r=cg();if(r.notificationAuthorized!=="authorized")return n("notificationAuthorized: "+r.notificationAuthorized);let o=W.extend({},e);delete o.content,delete o.payload,s.push.createMessage(e.content,e.payload,o),t()},void 0,qS),HO=Mt("registerRuntime",e=>{W.extend(jsRuntime,e)}),jO={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"}},zO=e=>{e.type=e.type||0;let{provider:t,type:n,title:r,summary:o,href:c,imageUrl:h,mediaUrl:b,scene:V,miniProgram:T,openCustomerServiceChat:D,corpid:_e,customerUrl:Se}=e;W.isString(h)&&h&&(h=je(h));let Ie=jO[n];if(Ie){let ut={provider:t,type:Ie.name,title:r,content:o,href:c,pictures:[h],thumbs:h?[h]:void 0,media:b,miniProgram:T,extra:{scene:V},openCustomerServiceChat:D,corpid:_e,url:Se};return t==="weixin"&&(n===1||n===2)&&delete ut.thumbs,ut}return"\u5206\u4EAB\u53C2\u6570 type \u4E0D\u6B63\u786E"},xg=function(e,t,n,r,o="share"){let c=fr(r),h=t.openCustomerServiceChat?"openCustomerServiceChat":"send";try{e[h](t,()=>{n()},c)}catch(b){c({message:`${t.provider} ${h} \u65B9\u6CD5\u8C03\u7528\u5931\u8D25`})}},WO=Oe(VS,(e,{resolve:t,reject:n})=>{let r=zO(e),o=fr(n);if(W.isString(r))return n(r);s.share.getServices(c=>{let h=c.find(({id:b})=>b===r.provider);h?h.authenticated?xg(h,r,t,n):h.authorize(()=>xg(h,r,t,n),o):n("service not found")},o)},US,$S),GO=Oe(HS,({type:e,imageUrl:t,summary:n,href:r},{resolve:o,reject:c})=>{let h=fr(c);W.isString(t)&&t&&(t=je(t)),s.share.sendWithSystem({type:e,pictures:t?[t]:void 0,content:n,href:r},()=>o(),h)},zS,jS),YO=Oe(WS,(e,{resolve:t,reject:n})=>{let r=e.provider,o=fr(n);s.payment.getChannels(c=>{let h=c.find(({id:b})=>b===r);h?s.payment.request(h,e.orderInfo,b=>{t(b)},o):n("service not found")},o)},GS),Bg=eg,qO=Oe("navigateToMiniProgram",(e,{resolve:t,reject:n})=>{Bg("navigateToUniMP",e,r=>{if(r.errMsg&&r.errMsg.indexOf(":ok")===-1)return n(r.errMsg.split(" ")[1]);t()})}),Lg=[];function Mg(e){Lg.push(e)}let KO=Mg;function JO(e,t){Lg.forEach(n=>n(e,t))}function ZO(e,t,...n){let r=eT(e,t,n);r&&console[e](r)}function XO(){return typeof __channelId__=="string"&&__channelId__}function QO(e,t){switch(W.toRawType(t)){case"Function":return"function() { [native code] }";default:return t}}function eT(e,t,n){return XO()?(n.push(t.replace("at ","uni-app:///")),console[e].apply(console,n)):n.map(function(o){let c=W.toTypeString(o).toLowerCase();if(["[object object]","[object array]","[object module]"].indexOf(c)!==-1)try{o="---BEGIN:JSON---"+JSON.stringify(o,QO)+"---END:JSON---"}catch(h){o=c}else if(o===null)o="---NULL---";else if(o===void 0)o="---UNDEFINED---";else{let h=W.toRawType(o).toUpperCase();h==="NUMBER"||h==="BOOLEAN"?o="---BEGIN:"+h+"---"+o+"---END:"+h+"---":o=String(o)}return o}).join("---COMMA---")+" "+t}let tT=1,nf,uc={};function Dg(e){if(typeof e=="function"){let t=Object.keys(uc).find(r=>uc[r]===e),n=t?parseInt(t):tT++;return uc[n]=e,n}else W.isPlainObject(e)&&Object.keys(e).forEach(t=>{e[t]=Dg(e[t])});return e}function nT(e,t,n,r){return of(e,t,n,r)}function rf(){return nf||(nf=I.requireNativePlugin("UTS-Proxy")),nf}function Fg(e,t,n,r,o){if(!t)throw new Error(JSON.stringify(e));if(W.isString(t))try{t=JSON.parse(t)}catch(c){throw new Error(`JSON.parse(${t}): `+c)}if(t.errMsg)throw new Error(t.errMsg);if(n&&n.type==="interface"&&typeof t.params=="number"){if(!t.params)return null;if(t.params===r&&o)return o;if(af[n.options]){let c=jg(W.extend({instanceId:t.params},af[n.options]));return new c}}return t.params}function Vg(e){if(e.errMsg)throw new Error(e.errMsg);return delete e.errMsg,Fg(e,rf().invokeSync(e,()=>{}))}function of(e,{moduleName:t,moduleType:n,package:r,class:o,name:c,method:h,companion:b,params:V,return:T,errMsg:D},_e,Se){let Ie=({id:dt,name:Tt,params:It,keepAlive:vn})=>{let un=uc[dt];un?(un(...It),vn||delete uc[dt]):console.error(`${r}${o}.${c} ${Tt} is not found`)},ut=_e?{moduleName:t,moduleType:n,id:_e,name:c,method:V}:{moduleName:t,moduleType:n,package:r,class:o,name:h||c,companion:b,method:V};return(...dt)=>{if(D)throw new Error(D);let Tt=W.extend({},ut,{params:dt.map(It=>Dg(It))});return e?new Promise((It,vn)=>{rf().invokeAsync(Tt,un=>{un.type!=="return"?Ie(un):un.errMsg?vn(un.errMsg):It(un.params)})}):Fg(Tt,rf().invokeSync(Tt,Ie),T,_e,Se)}}function $g(e,t){return t.main&&!t.method&&typeof s!="undefined"&&s.os.name==="iOS"&&(t.method="s_"+t.name),of(e,t,0)}let rT=$g;function Ug(e,t){return W.hasOwn(t,e+"ByJs")?e+"ByJs":e}function Hg(e){return typeof e=="undefined"}function iT(e){return!Hg(e.instanceId)}function jg(e){let{moduleName:t,moduleType:n,package:r,class:o,methods:c,props:h,errMsg:b}=e,V={moduleName:t,moduleType:n,package:r,class:o,errMsg:b},T,D=[],_e={},Se=[];iT(e)?T=e.instanceId:(D=e.constructor.params,_e=e.staticMethods,Se=e.staticProps),typeof s!="undefined"&&s.os.name==="iOS"&&D.find(dt=>dt.type==="UTSCallback"||dt.type.indexOf("JSONObject")>0)&&D.push({name:"_byJs",type:"boolean"});let Ie=class{constructor(...Tt){if(b)throw new Error(b);let It={};if(Hg(T)&&(T=of(!1,W.extend({name:"constructor",params:D},V),0).apply(null,Tt)),!T)throw new Error(`new ${o} is failed`);let vn=new Proxy(this,{get(un,jt){if(!It[jt]){if(jt=Ug(jt,c),W.hasOwn(c,jt)){let{async:yt,params:En,return:an}=c[jt];It[jt]=nT(!!yt,W.extend({name:jt,params:En,return:an},V),T,vn)}else if(h.includes(jt))return Vg({moduleName:t,moduleType:n,id:T,name:jt,errMsg:b})}return It[jt]}});return vn}},ut={};return new Proxy(Ie,{get(dt,Tt,It){if(Tt=Ug(Tt,_e),W.hasOwn(_e,Tt)){if(!ut[Tt]){let{async:vn,params:un,return:jt}=_e[Tt];ut[Tt]=$g(!!vn,W.extend({name:Tt,companion:!0,params:un,return:jt},V))}return ut[Tt]}return Se.includes(Tt)?Vg(W.extend({name:Tt,companion:!0},V)):Reflect.get(dt,Tt,It)}})}function oT(e,t){return typeof s!="undefined"&&s.os.name==="Android"?"uts.sdk."+(t?"modules.":"")+e:""}function aT(e,t){return typeof s=="undefined"?"":zg(e,s.os.name==="iOS"?"IndexSwift":"IndexKt",t)}function zg(e,t,n){return typeof s=="undefined"?"":s.os.name==="Android"?t:s.os.name==="iOS"?"UTSSDK"+(n?"Modules":"")+W.capitalize(e)+W.capitalize(t):""}let af={};function sT(e,t){af[e]=t}let Wg={};function lT(e,t){Wg[e]=t}function cT(e){let t=Wg[e];return t||console.error(`${e} is not found`),t}let So={load:"load",close:"close",error:"error",adClicked:"adClicked"};class Gg{constructor(){this._callbacks={}}onLoad(t){this._addEventListener(So.load,t)}onClose(t){this._addEventListener(So.close,t)}onError(t){this._addEventListener(So.error,t)}offLoad(t){this._removeEventListener(So.load,t)}offClose(t){this._removeEventListener(So.close,t)}offError(t){this._removeEventListener(So.error,t)}_addEventListener(t,n){!W.isFunction(n)||(this._callbacks[t]||(this._callbacks[t]=[]),this._callbacks[t].push(n))}_removeEventListener(t,n){let r=this._callbacks[t],o=r.indexOf(n);o>-1&&r.splice(o,1)}_dispatchEvent(t,n){this._callbacks[t].forEach(r=>{r(n||{})})}}class sf extends Gg{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(So.load,{})}),r.onClose(o=>{this._isLoaded=!1,this._isLoading=!1,this._dispatchEvent(So.close,o),this.preload===!0&&this._loadAd()}),r.onError(o=>{this._isLoading=!1;let c={code:o.code,errMsg:o.message};this._dispatchEvent(So.error,c);let h=new Error(JSON.stringify(c));this._loadPromiseReject!=null&&(this._loadPromiseReject(h),this._loadPromiseReject=null),this._showPromiseReject!=null&&(this._showPromiseReject(h),this._showPromiseReject=null)}),r.onAdClicked&&r.onAdClicked(()=>{this._dispatchEvent(So.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 uT extends sf{constructor(t){super(s.ad.createRewardedVideoAd(t),t);this._loadAd()}}let fT=Mt(KS,e=>new uT(e),ZS,JS);class dT extends sf{constructor(t){super(s.ad.createFullScreenVideoAd(t),t);this.preload=!1}}let hT=Mt(XS,e=>new dT(e),ew,QS);class gT extends sf{constructor(t){super(s.ad.createInterstitialAd(t),t);this.preload=!1,this._loadAd()}}let pT=Mt(tw,e=>new gT(e),rw,nw),wa={},tl={};function vT(e){let t=e.provider;if(wa[t]||(wa[t]={}),typeof wa[t].plugin=="object"){e.success(wa[t].plugin);return}if(tl[t]||(tl[t]=[]),tl[t].push(e),wa[t].status===!0){e.__plugin=wa[t].plugin;return}wa[t].status=!0;let n=Wo(t);if(!n||!n.initSDK){tl[t].forEach(r=>{r.fail({code:-1,message:"provider ["+t+"] invalid"})}),tl[t].length=0,wa[t].status=!1;return}wa[t].plugin=n,e.__plugin=n,n.initSDK(r=>{let o=r.code===1||r.code==="1";o?wa[t].plugin=n:wa[t].status=!1,tl[t].forEach(c=>{o?c.success(c.__plugin):c.fail(r)}),tl[t].length=0})}class mT extends Gg{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="",vT({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(So.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(So.load,t)},t=>{this._isLoading=!1,this._showPromiseReject!=null&&(this._showPromiseReject(this._createError(t)),this._showPromiseReject=null),this._dispatchEvent(So.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(So.error,t)})}_createError(t){return new Error(JSON.stringify(t))}}let _T=Mt(iw,e=>new mT(e),aw,ow),Yg=s.os.name==="Android"&&parseInt(s.os.version)<6,bT=Yg?"slide-in-right":"pop-in",zc=300,qg=Yg?"slide-out-right":"pop-out",ET="_www/__uniappview.html",yT="webviewId",ST="uniMPNativeEvent";function wT(e,t,n){n&&t.isNVue&&(e.uniNView={path:n,defaultFontSize:B.defaultFontSize,viewport:B.viewport})}let CT=/^#[a-z0-9]{6}$/i;function AT(e){return e&&(CT.test(e)||e==="transparent")}function OT(e,t){let{backgroundColor:n}=t;!n||!AT(n)||(e.background?n=e.background:e.background=n,e.backgroundColorTop||(e.backgroundColorTop=n),e.backgroundColorBottom||(e.backgroundColorBottom=n),e.animationAlphaBGColor||(e.animationAlphaBGColor=n),typeof e.webviewBGTransparent=="undefined"&&(e.webviewBGTransparent=!0))}function TT(e,t){e.popGesture==="hide"&&delete e.popGesture,t.isQuit&&(e.popGesture=s.os.name==="iOS"?"appback":"none")}function PT(e,t){if(!t.enablePullDownRefresh)return;let n=ja(W.extend({},s.os.name==="Android"?NT:kT,t.pullToRefresh));e.pullToRefresh=IT(n,t)}function IT(e,t){let n=mr(e);if(!n)return e;let[r,o,c]=n;return(r||o||c)&&I.onLocaleChange(()=>{let h=s.webview.getWebviewById(t.id+"");if(!h)return;let b={support:!0};r&&(b.contentdown={caption:e.contentdown.caption}),o&&(b.contentover={caption:e.contentover.caption}),c&&(b.contentrefresh={caption:e.contentrefresh.caption}),h.setStyle({pullToRefresh:b})}),e}let NT={support:!0,style:"circle"},kT={support:!0,style:"default",height:"50px",range:"200px",contentdown:{caption:""},contentover:{caption:""},contentrefresh:{caption:""}};function RT(e,t){let{navigationBar:n}=t;if(n.style==="custom")return!1;let r=!0;t.isQuit&&(r=!1);let o={autoBackButton:r};Object.keys(n).forEach(c=>{let h=n[c];c==="titleImage"&&h?o.tags=BT(h):c==="buttons"&&W.isArray(h)?o.buttons=h.map((b,V)=>(b.onclick=LT(V),b)):o[c]=h}),e.titleNView=xT(o,t)}function xT(e,t){let n=xr(e);if(!n)return e;let[r,o]=n;return(r||o)&&I.onLocaleChange(()=>{let c=s.webview.getWebviewById(t.id+"");if(!c)return;let h={};r&&(h.titleText=e.titleText),o&&(h.searchInput={placeholder:e.searchInput.placeholder}),c.setStyle({titleNView:h})}),e}function BT(e){return[{tag:"img",src:e,position:{left:"auto",top:"auto",width:"auto",height:"26px"}}]}function LT(e){return function(n){n.index=e,Ln(Z.ON_NAVIGATION_BAR_BUTTON_TAP,n)}}function Kg(e,t,n){let r={bounce:"vertical"};return Object.keys(t).forEach(o=>{MT.indexOf(o)===-1&&(r[o]=t[o])}),n.id!=="1"&&wT(r,t,e),TT(r,t),OT(r,t),RT(r,t),PT(r,t),r}let MT=["id","route","isNVue","isQuit","isEntry","isTabBar","tabBarIndex","windowTop","topWindow","leftWindow","rightWindow","maxWidth","usingComponents","disableScroll","enablePullDownRefresh","navigationBar","pullToRefresh","onReachBottomDistance","pageOrientation","backgroundColor"],Jg=2;function Zg(){return Jg}function Xg(){return Jg++}function Qg(e){return e}function ep(e,t){let n=t?Z.stringifyQuery(t,Qg):"";return{path:e.slice(1),query:n&&n.slice(1)}}function DT(e,t,n){let r=n?Z.stringifyQuery(n,Qg):"";return{isTab:e,arguments:JSON.stringify({path:t.slice(1),query:r&&r.slice(1)})}}function FT({path:e,query:t,routeOptions:n,webviewExtras:r}){let o=()=>Kg(e,ju(n.meta),{id:c+""}),c=Xg(),h=o();h.uniPageUrl=ep(e,t),h.isTab=!!n.meta.isTabBar;let b=s.webview.create("",String(c),h,W.extend({nvue:!0,__path__:e,__query__:JSON.stringify(t)},r));return Uh(b,o),b}let Mi;function tp(e){Mi=e}function VT(){return Mi}function $T(){return(!Mi||Mi.__uniapp_route)&&(Mi=s.webview.create(ET,String(Xg()),{contentAdjust:!1})),Mi}function UT(e){let{popupSubNVueWebviews:t}=e;!t||e.addEventListener("close",()=>{Object.keys(t).forEach(n=>{t[n].close("none")})})}function np(e){return B.realEntryPagePath&&e.$page.route===B.entryPagePath}function rp(){B.entryPagePath=B.realEntryPagePath,delete B.realEntryPagePath,I.reLaunch({url:Z.addLeadingSlash(B.entryPagePath)})}function HT(e){let t;e.addEventListener("popGesture",n=>{if(n.type==="start"){let r=Pn(),o=r[r.length-2];t=nc;let c=o&&o.$page.statusBarStyle;c&&Da(c)}else if(n.type==="end"&&!n.result)Da(t);else if(n.type==="end"&&n.result){let r=Pn().length,o=Si();zr(),Da(),o&&r===1&&np(o)?rp():Ln(Z.ON_SHOW)}})}function jT(e){if(e.nvue)return;let t=e.id,{subscribe:n,unsubscribe:r}=st,o=(c,h)=>{if(t!==h)return;r(kl,o);let b=Ir(parseInt(h));b&&b.__page_container__.restore()};e.addEventListener("recovery",()=>{n(kl,o)})}function zT(e){let{emit:t}=st,n=function({width:r,height:o}){let h={deviceOrientation:Math.abs(s.navigator.getOrientation())===90?"landscape":"portrait",size:{windowWidth:Math.ceil(r),windowHeight:Math.ceil(o)}};t(Z.ON_RESIZE,h,parseInt(e.id))};e.addEventListener("resize",Z.debounce(n,50,{setTimeout:k,clearTimeout:S}))}let ip={pullToRefresh:Z.ON_PULL_DOWN_REFRESH,titleNViewSearchInputChanged:Z.ON_NAVIGATION_BAR_SEARCH_INPUT_CHANGED,titleNViewSearchInputConfirmed:Z.ON_NAVIGATION_BAR_SEARCH_INPUT_CONFIRMED,titleNViewSearchInputClicked:Z.ON_NAVIGATION_BAR_SEARCH_INPUT_CLICKED,titleNViewSearchInputFocusChanged:Z.ON_NAVIGATION_BAR_SEARCH_INPUT_FOCUS_CHANGED};function WT(e){let t=parseInt(e.id);Object.keys(ip).forEach(n=>{let r=ip[n];e.addEventListener(n,o=>{r===Z.ON_PULL_DOWN_REFRESH&&Wu(e),Ln(t,r,o)})}),UT(e),zT(e),s.os.name==="iOS"&&(jT(e),HT(e))}function GT(e,t,n,r){let o=()=>Kg(t,ju(r),e),c=o();c.uniPageUrl=ep(t,n);let h=!!r.isTabBar;r.isNVue?c.isTab=h:c.debugRefresh=DT(h,t,n),c.locale=g.requireModule("plus").getLanguage(),Uh(e,o),e.setStyle(c)}function YT(e,t,n){(n.subNVues||[]).forEach(o=>{if(!o.path)return;let c=Ha(o.style||{}),h=o.type==="navigationBar",b=o.type==="popup";c.uniNView={path:o.path.replace(".nvue",".js"),defaultFontSize:B.defaultFontSize,viewport:B.viewport};let V={__uniapp_host:t,__uniapp_origin:c.uniNView.path.split("?")[0].replace(".js",""),__uniapp_origin_id:e.id,__uniapp_origin_type:e.__uniapp_type},T;h?(c.position="dock",c.dock="top",c.top="0",c.width="100%",c.height=String(Z.NAVBAR_HEIGHT+Gu()),delete c.left,delete c.right,delete c.bottom,delete c.margin):b&&(c.position="absolute",tc(t)?T=di:T=e,V.__uniapp_mask=c.mask||"rgba(0,0,0,0.5)",V.__uniapp_mask_id=T.id),delete c.mask;let D=s.webview.create("",o.id,c,V);if(b){T.popupSubNVueWebviews||(T.popupSubNVueWebviews={}),T.popupSubNVueWebviews[D.id]=D;let _e=function(){T.setStyle({mask:"none"}),D.hide("auto")};T.addEventListener("maskClick",_e);let Se=!1;D.addEventListener("show",()=>{Se||(s.key.removeEventListener("backbutton",Li),s.key.addEventListener("backbutton",_e),Se=!0)}),D.addEventListener("hide",()=>{Se&&(s.key.removeEventListener("backbutton",_e),s.key.addEventListener("backbutton",Li),Se=!1)}),D.addEventListener("close",()=>{delete T.popupSubNVueWebviews[D.id],Se&&(s.key.removeEventListener("backbutton",_e),s.key.addEventListener("backbutton",Li),Se=!1)})}else e.append(D)})}function qT(e,t,n,r){(e.id==="1"||!r.isNVue)&&GT(e,t,n,r),YT(e,t,r),WT(e)}function op(e){return e.routeOptions.meta.isNVue?FT(e):Zg()===2?s.webview.getLaunchWebview():VT()}function ap(e,t){st.once(kl+"."+e,t)}let Ca=!1;function sp(e,t,n){Ca={path:e,nvue:os(e).isNVue,callback:t}}function lp(e,t,n){Qo(e),nl(e.$getAppWebview(),t,n)}function Wc(e,t,n=!1){if(!n&&Ca)return console.error(`Waiting to navigate to: ${Ca.path}, do not operate continuously: ${e}.`);if(B.renderer==="native")return Pn().length===0?sp(e,t,"waitForReady"):t();let r=!Mi||Mi&&Mi.__uniapp_route,o=Mi&&!Mi.loaded;r||o?sp(e,t,r?"waitForCreate":"waitForReady"):t(),o&&ap(Mi.id,Gc)}function Gc(){if(!Ca)return;let{callback:e}=Ca;return Ca=!1,e()}function cp(){if(B.renderer==="native")return Ca&&Ca.nvue?Gc():void 0;let e=$T();if(!!Ca){if(Ca.nvue)return Gc();e.loaded?Ca.callback():ap(e.id,Gc)}}function nl(e,t,n){e[e.__preload__?"hide":"close"](t,n)}function Yc(e,t,n,r,o){typeof o=="undefined"&&(o=e.nvue?0:100);let c=function(){c._called||(c._called=!0,r&&r(),cp())};c._called=!1,k(()=>{let h=k(()=>{c()},n+150);e.show(t,n,()=>{c._called||S(h),c()})},o)}function KT(e,t){let n=e.children();if(!n||!n.length)return t();let r=n.find(o=>o.id.indexOf(yT)===0)||n[0];r.canBack(({canBack:o})=>{o?r.back():t()})}let JT=Oe(hy,(e,{resolve:t,reject:n})=>{let r=Si();if(!r)return n("getCurrentPages is empty");if(Ln(r,Z.ON_BACK_PRESS,{from:e.from||"navigateBack"}))return t();if(I.hideToast(),I.hideLoading(),r.$page.meta.isQuit)ZT();else if(np(r))rp();else{let{delta:o,animationType:c,animationDuration:h}=e;XT(o,c,h)}return t()},py,Ay),qc=0;function ZT(){mt(),qc?Date.now()-qc<2e3&&s.runtime.quit():(qc=Date.now(),s.nativeUI.toast(se().t("uni.app.quit")),k(()=>{qc=0},2e3))}function XT(e,t,n){let r=Pn(),o=r.length,c=r[o-1];e>1&&r.slice(o-e,o-1).reverse().forEach(V=>{nl(s.webview.getWebviewById(V.$page.id+""),"none",0)});let h=function(V){t?nl(V,t,n||zc):c.$page.openType==="redirectTo"?nl(V,qg,zc):nl(V,"auto"),r.slice(o-e,o).forEach(T=>Qo(T)),Da(),Ln(Z.ON_SHOW)},b=s.webview.getWebviewById(c.$page.id+"");if(!c.__uniapp_webview)return h(b);KT(b,()=>{h(b)})}class QT extends Z.UniNode{constructor(t,n,r=!1){super(Z.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=[Z.ACTION_TYPE_PAGE_CREATE,n],this.createdAction=[Z.ACTION_TYPE_PAGE_CREATED],this.normalizeDict=this._normalizeDict.bind(this),this._update=this.update.bind(this),r&&this.setup()}_normalizeDict(t,n=!0){if(!W.isPlainObject(t))return this.addDict(t);let r=[];return Object.keys(t).forEach(o=>{let c=[this.addDict(o)],h=t[o];n?c.push(this.addDict(h)):c.push(h),r.push(c)}),r}addDict(t){let{dicts:n}=this,r=n.indexOf(t);return r>-1?r:n.push(t)-1}onInjectHook(t){(t===Z.ON_PAGE_SCROLL||t===Z.ON_REACH_BOTTOM)&&!this.scrollAction&&(this.scrollAction=[Z.ACTION_TYPE_PAGE_SCROLL,this.options.onReachBottomDistance],this.push(this.scrollAction))}onCreate(t,n){return nP(this,t.nodeId,n),t}onInsertBefore(t,n,r){return rP(this,n,t.nodeId,r&&r.nodeId||-1),n}onRemoveChild(t){return iP(this,t.nodeId),t}onAddEvent(t,n,r){t.parentNode&&oP(this,t.nodeId,n,r)}onAddWxsEvent(t,n,r,o){t.parentNode&&aP(this,t.nodeId,n,r,o)}onRemoveEvent(t,n){t.parentNode&&sP(this,t.nodeId,n)}onSetAttribute(t,n,r){t.parentNode&&cP(this,t.nodeId,n,r)}onRemoveAttribute(t,n){t.parentNode&&uP(this,t.nodeId,n)}onTextContent(t,n){t.parentNode&&fp(this,t.nodeId,n)}onNodeValue(t,n){t.parentNode&&fp(this,t.nodeId,n)}genId(){return this._id++}push(t,n){if(!this.isUnmounted){switch(t[0]){case Z.ACTION_TYPE_CREATE:this._createActionMap.set(t[1],t);break;case Z.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]!==Z.ACTION_TYPE_INSERT&&this.updateActions.push(t),this._updating||(this._updating=!0,fn.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([TO,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(Cg,t,this.pageId)}fireEvent(t,n){let r=up(t,this);r&&r.dispatchEvent(n)}}function eP(e){let t=Ir(e);return t?t.__page_container__:null}function lf(e,t,n){if(typeof n=="number"&&(n=eP(n)),n[e]===t)return n;let{childNodes:r}=n;for(let o=0;o<r.length;o++){let c=lf(e,t,r[o]);if(c)return c}return null}function up(e,t){return lf("nodeId",e,t)}function tP(e,t){return lf("nodeName",e.toUpperCase(),t)}function nP(e,t,n){e.push([Z.ACTION_TYPE_CREATE,t,e.addDict(n),-1,-1])}function rP(e,t,n,r){let o=t.toJSON({attr:!0,normalize:e.normalizeDict});e.push([Z.ACTION_TYPE_INSERT,t.nodeId,n,r],Object.keys(o).length?o:void 0)}function iP(e,t){e.push([Z.ACTION_TYPE_REMOVE,t])}function oP(e,t,n,r){e.push([Z.ACTION_TYPE_ADD_EVENT,t,e.addDict(n),r])}function aP(e,t,n,r,o){e.push([Z.ACTION_TYPE_ADD_WXS_EVENT,t,e.addDict(n),e.addDict(r),o])}function sP(e,t,n){e.push([Z.ACTION_TYPE_REMOVE_EVENT,t,e.addDict(n)])}function lP(e,t,n){return t==="style"&&W.isPlainObject(n)?e.normalizeDict(n):e.addDict(n)}function cP(e,t,n,r){e.push([Z.ACTION_TYPE_SET_ATTRIBUTE,t,e.addDict(n),lP(e,n,r)])}function uP(e,t,n){e.push([Z.ACTION_TYPE_REMOVE_ATTRIBUTE,t,e.addDict(n)])}function fp(e,t,n){e.push([Z.ACTION_TYPE_SET_TEXT,t,e.addDict(n)])}function fP(e,t,n){return new QT(e,t,n)}function dp(e){let t=e.setup;return e.inheritAttrs=!1,e.setup=(n,r)=>{let{attrs:{__pageId:o,__pagePath:c,__pageQuery:h,__pageInstance:b}}=r,T=fn.getCurrentInstance().proxy;if(gt(T,b),Dn(hp(o,T,b)),fn.onMounted(()=>{fn.nextTick(()=>{Ln(T,Z.ON_READY)})}),fn.onBeforeUnmount(()=>{Ln(T,Z.ON_UNLOAD)}),t)return t(h,r)},e}function hp(e,t,n){let r=()=>s.webview.getWebviewById(e+"");return t.$getAppWebview=r,t.$.ctx.$scope={$getAppWebview:r},t.getOpenerEventChannel=()=>(n.eventChannel||(n.eventChannel=new Z.EventChannel(e)),n.eventChannel),t}function dP(e){return W.isFunction(e)}let gp=new Map;function hP(e,t){gp.set(e,Z.once(pP(t)))}function gP(e,t,n,r,o){let c=fP(e,o,!0),h=Gi(),b=gp.get(t)(),V=T=>h.mountPage(T,{__pageId:e,__pagePath:t,__pageQuery:n,__pageInstance:r},c);return W.isPromise(b)?b.then(T=>V(T)):V(b)}function pP(e){return()=>dP(e)?e().then(t=>dp(t)):dp(e)}let pp=!1;function vp(){if(pp)return;pp=!0;let e,t;if(g.requireModule("plus").getRedirectInfo){let{path:c,query:h,referrerInfo:b}=Ls();c&&(e=c,t=h),B.referrerInfo=b}else{let c=s.runtime.arguments;if(!c)return;try{let h=JSON.parse(c);e=h.path||h.pathName,t=h.query?"?"+h.query:""}catch(h){}}if(!e||e===B.entryPagePath){t&&(B.entryPageQuery=t);return}let r=Z.addLeadingSlash(e),o=ji(r);!o||(o.meta.isTabBar||(B.realEntryPagePath=B.realEntryPagePath||B.entryPagePath),B.entryPagePath=e,B.entryPageQuery=t)}function Kc(e,t){let n=JSON.parse(JSON.stringify(ji(e)));return n.meta=Ua(n.meta),t!=="preloadPage"&&!B.realEntryPagePath&&(t==="reLaunch"||Pn().length===0)?n.meta.isQuit=!0:n.meta.isTabBar||(n.meta.isQuit=!1),n}let Aa={};function vP(e){let t=Object.keys(Aa).find(n=>Aa[n].id===e.id);t&&delete Aa[t]}function mP({url:e}){let t=Aa[e];return t&&(t.__page__&&Pn().find(n=>n===t.__page__)?t.__preload__=!1:t.close("none"),delete Aa[e]),t}function _P({url:e,path:t,query:n}){if(!Aa[e]){let r=Kc(t,"preloadPage");Aa[e]=op({path:t,routeOptions:r,query:n,webviewExtras:{__preload__:!0}})}return Aa[e]}function fc({url:e,path:t,query:n,openType:r,webview:o,nvuePageVm:c,eventChannel:h}){if(o&&vp(),Aa[e]){o=Aa[e];let Se=o;if(Se.__page__)if(Pn().find(Ie=>Ie===Se.__page__))o=void 0;else return h&&(Se.__page__.$page.eventChannel=h),r==="launch"?bP(e,t,n,Se,c,h):Dn(Se.__page__),Se}let b=Kc(t,r);o?(o=s.webview.getWebviewById(o.id),o.nvue=b.meta.isNVue):o=op({path:t,routeOptions:b,query:n}),b.meta.id=parseInt(o.id),!!b.meta.isTabBar&&di.append(o),qT(o,t,n,b.meta);let T=t.slice(1);o.__uniapp_route=T;let D=da(r,e,n,b.meta,h,B.darkmode?s.navigator.getUIStyle():"light"),_e=parseInt(o.id);return o.nvue?c?yP(_e,c,D):mp(_e,o,D):gP(_e,T,n,D,EP(b)),o}function bP(e,t,n,r,o,c){let h=Kc(t,"preloadPage");h.meta.id=parseInt(r.id);let b=da("preloadPage",e,n,h.meta,c,B.darkmode?s.navigator.getUIStyle():"light");gt(o,b),r.__page__=o}function EP({meta:e}){let t=Gu(),{platform:n,pixelRatio:r,windowWidth:o}=$r();return{css:!0,route:e.route,version:1,locale:"",platform:n,pixelRatio:r,windowWidth:o,disableScroll:e.disableScroll===!0,onPageScroll:!1,onPageReachBottom:!1,onReachBottomDistance:W.hasOwn(e,"onReachBottomDistance")?e.onReachBottomDistance:Z.ON_REACH_BOTTOM_DISTANCE,statusbarHeight:t,windowTop:e.navigationBar.type==="float"?t+Z.NAVBAR_HEIGHT:0,windowBottom:di.indexOf(e.route)>=0&&di.cover?di.height:0}}function yP(e,t,n){gt(t,n),Dn(hp(e,t,n)),e===1&&(B.splashscreen&&B.splashscreen.autoclose&&!B.splashscreen.alwaysShowBeforeRender&&s.navigator.closeSplashscreen(),B.onReady(function(){cp()}))}function mp(e,t,n){let r={$:{},$getAppWebview(){return t},getOpenerEventChannel(){return n.eventChannel||(n.eventChannel=new Z.EventChannel(e)),n.eventChannel},__setup(o,c){o.$getAppWebview=()=>t,o.getOpenerEventChannel=c.getOpenerEventChannel,gt(o,n),t.__preload__&&(t.__page__=o);let h=Fn(),b=h.findIndex(V=>V===c);b>-1&&h.splice(b,1,o)}};gt(r,n),t.__preload__?(t.__page__=r,t.addEventListener("show",()=>{Ln(t.__page__,Z.ON_SHOW)}),t.addEventListener("hide",()=>{Ln(t.__page__,Z.ON_HIDE)})):Dn(r)}let _p=(e,{resolve:t,reject:n})=>{let{url:r,events:o,animationType:c,animationDuration:h}=e,{path:b,query:V}=Z.parseUrl(r),[T,D]=CP(b,c,h);Wc(b,()=>{wP({url:r,path:b,query:V,events:o,aniType:T,aniDuration:D}).then(t).catch(n)},e.openType==="appLaunch")},SP=Oe(Fu,_p,gy,yy);function wP({url:e,path:t,query:n,events:r,aniType:o,aniDuration:c}){Ln(Z.ON_HIDE);let h=new Z.EventChannel(Zg()+1,r);return new Promise(b=>{Yc(fc({url:e,path:t,query:n,openType:"navigateTo",eventChannel:h}),o,c,()=>{b({eventChannel:h})}),Da()})}function CP(e,t,n){let{globalStyle:r}=B,o=os(e);return[t||o.animationType||r.animationType||bT,n||o.animationDuration||r.animationDuration||zc]}let AP=Oe(Vu,({url:e},{resolve:t,reject:n})=>{let{path:r,query:o}=Z.parseUrl(e);Wc(r,()=>{OP({url:e,path:r,query:o}).then(t).catch(n)})},vy,Sy);function OP({url:e,path:t,query:n}){let r=Si();return r&&Qo(r),new Promise(o=>{Yc(fc({url:e,path:t,query:n,openType:"redirectTo"}),"none",0,()=>{if(r){let c=r.$getAppWebview();c.__preload__&&vP(c),c.close("none")}o(void 0)}),Da()})}let TP=({url:e},{resolve:t,reject:n})=>{let{path:r,query:o}=Z.parseUrl(e);Wc(r,()=>{PP({url:e,path:r,query:o}).then(t).catch(n)})};function PP({url:e,path:t,query:n}){return new Promise(r=>{let o=Fn().slice(0);We.find(h=>h.path===t).meta.isTabBar&&di.switchTab(t.slice(1)),Yc(fc({url:e,path:t,query:n,openType:"reLaunch"}),"none",0,()=>{o.forEach(h=>lp(h,"none")),r(void 0)}),Da()})}let IP=Oe(Th,TP,my,wy),bp=(e,{resolve:t,reject:n})=>{let{url:r}=e,{path:o,query:c}=Z.parseUrl(r);Wc(o,()=>{kP({url:r,path:o,query:c}).then(t).catch(n)},e.openType==="appLaunch")},NP=Oe(Ic,bp,_y,Cy);function kP({url:e,path:t,query:n}){di.switchTab(t.slice(1));let r=Pn(),o=r.length,c=!1,h=!1,b;o>=1&&(b=r[o-1],b&&!b.$.__isTabBar?(h=!0,r.reverse().forEach(T=>{!T.$.__isTabBar&&T!==b&&lp(T,"none")}),Qo(b),k(()=>{b.$page.openType==="redirectTo"?nl(b.$getAppWebview(),qg,zc):nl(b.$getAppWebview(),"auto")},100)):c=!0);let V;return Fn().forEach(T=>{Z.addLeadingSlash(T.route)===t?(T.$.__isActive||(h=!0),T.$.__isActive=!0,V=T):T.$.__isTabBar&&(T.$.__isActive=!1)}),b===V&&(c=!1),b&&c&&Ln(b,Z.ON_HIDE),new Promise(T=>{if(V){let D=V.$getAppWebview();D.show("none"),h&&!D.__preload__&&Ln(V,Z.ON_SHOW),Da(),T(void 0)}else Yc(fc({url:e,path:t,query:n,openType:"switchTab"}),"none",0,()=>{Da(),T(void 0)},70)})}let RP=Mt(Ph,({url:e})=>{let t=mP({url:e});return t?{id:t.id,url:e,errMsg:"unPreloadPage:ok"}:{url:e,errMsg:"unPreloadPage:fail not found"}},Ey),xP=Oe($u,({url:e},{resolve:t})=>{if(Aa[e])return;let n=e.split("?"),r=n[0],o=Z.parseQuery(n[1]||""),c=_P({url:e,path:r,query:o}),h=Kc(r,"preloadPage");h.meta.id=parseInt(c.id);let b=da("preloadPage",e,o,h.meta,void 0,B.darkmode?s.navigator.getUIStyle():"light");mp(parseInt(c.id),c,b),t({id:c.id,url:e,errMsg:"preloadPage:ok"})},by);var BP={__proto__:null,$emit:qm,$off:Ym,$on:Wm,$once:Gm,__log__:ZO,addInterceptor:Lm,addPhoneContact:SC,arrayBufferToBase64:pr,base64ToArrayBuffer:Ni,canIUse:Pw,canvasGetImageData:S_,canvasPutImageData:w_,canvasToTempFilePath:C_,checkIsSoterEnrolledInDevice:PC,checkIsSupportSoterAuthentication:TC,chooseImage:JC,chooseLocation:qA,chooseVideo:ZC,clearStorage:pw,clearStorageSync:gw,closeAuthView:kg,closeBLEConnection:aC,closeBluetoothAdapter:Qw,closePreviewImage:UC,closeSocket:gA,compressImage:YC,compressVideo:qC,configMTLS:lA,connectSocket:dA,createAnimation:j_,createBLEConnection:oC,createCanvasContext:y_,createFullScreenVideoAd:hT,createInnerAudioContext:NA,createInteractiveAd:_T,createIntersectionObserver:I_,createInterstitialAd:pT,createLivePusherContext:zA,createMapContext:a_,createMediaQueryObserver:k_,createPushMessage:UO,createRewardedVideoAd:fT,createSelectorQuery:D_,createVideoContext:i_,downloadFile:rA,getAppAuthorizeSetting:cg,getAppBaseInfo:qh,getBLEDeviceCharacteristics:lC,getBLEDeviceRSSI:hC,getBLEDeviceServices:sC,getBackgroundAudioManager:UA,getBeacons:vC,getBluetoothAdapterState:eC,getBluetoothDevices:rC,getCheckBoxState:Rg,getClipboardData:wC,getConnectedBluetoothDevices:iC,getDeviceInfo:Yh,getEnterOptionsSync:fb,getFileInfo:mw,getImageInfo:FC,getLaunchOptionsSync:db,getLocale:Jl,getLocation:YA,getNetworkType:rg,getProvider:LO,getPushClientId:hb,getRecorderManager:zC,getSavedFileInfo:Aw,getSavedFileList:Cw,getScreenBrightness:xC,getSelectedTextRange:Q_,getStorage:fw,getStorageInfo:vw,getStorageInfoSync:Lh,getStorageSync:uw,getSubNVueById:kO,getSystemInfo:Uw,getSystemInfoSync:Kh,getSystemSetting:MC,getUniverifyManager:$O,getUserInfo:MO,getUserProfile:DO,getVideoInfo:VC,getWindowInfo:Gh,hideKeyboard:QC,hideLoading:lO,hideNavigationBarLoading:pO,hideTabBar:yO,hideTabBarRedDot:AO,hideToast:sO,initUTSClassName:zg,initUTSIndexClassName:aT,initUTSPackageName:oT,initUTSProxyClass:jg,initUTSProxyFunction:rT,interceptors:Dm,invokePushCallback:Mu,loadFontFace:fO,login:Tg,makePhoneCall:bC,navigateBack:JT,navigateTo:SP,navigateToMiniProgram:qO,notifyBLECharacteristicValueChange:cC,offAccelerometerChange:Yw,offAppHide:ub,offAppShow:lb,offCompassChange:jw,offError:ab,offKeyboardHeightChange:tA,offLocationChange:QA,offLocationChangeError:tO,offNetworkStatusChange:OC,offPageNotFound:ib,offPushMessage:pb,offThemeChange:RC,offUnhandledRejection:nb,offWindowResize:q_,onAccelerometerChange:Gw,onAppHide:cb,onAppShow:sb,onBLECharacteristicValueChange:Zw,onBLEConnectionStateChange:Jw,onBeaconServiceChange:pC,onBeaconUpdate:gC,onBluetoothAdapterStateChange:Kw,onBluetoothDeviceFound:qw,onCompassChange:Hw,onCreateVueApp:Z.onCreateVueApp,onError:ob,onHostEventReceive:Mg,onKeyboardHeightChange:eA,onLocaleChange:J_,onLocationChange:XA,onLocationChangeError:eO,onNativeEventReceive:KO,onNetworkStatusChange:AC,onPageNotFound:rb,onPushMessage:gb,onSocketClose:_A,onSocketError:vA,onSocketMessage:mA,onSocketOpen:pA,onTabBarMidButtonTap:z_,onThemeChange:kC,onUnhandledRejection:tb,onWindowResize:Y_,openAppAuthorizeSetting:DC,openBluetoothAdapter:Xw,openDocument:Tw,openLocation:KA,pageScrollTo:dO,preLogin:Ig,preloadPage:xP,previewImage:$C,reLaunch:IP,readBLECharacteristicValue:uC,redirectTo:AP,registerRuntime:HO,registerUTSInterface:sT,registerUTSPlugin:lT,removeInterceptor:Mm,removeSavedFile:Ow,removeStorage:hw,removeStorageSync:dw,removeTabBarBadge:CO,request:sA,requestPayment:YO,requireGlobal:xO,requireNativePlugin:Wo,requireUTSPlugin:cT,restoreGlobal:RO,saveFile:yw,saveImageToPhotosAlbum:GC,saveVideoToPhotosAlbum:WC,scanCode:NC,sendHostEvent:Bg,sendNativeEvent:eg,sendSocketMessage:hA,setBLEMTU:dC,setClipboardData:CC,setKeepScreenOn:LC,setLocale:Z_,setNavigationBarColor:mO,setNavigationBarTitle:hO,setPageMeta:X_,setScreenBrightness:BC,setStorage:cw,setStorageSync:lw,setTabBarBadge:_O,setTabBarItem:bO,setTabBarStyle:EO,share:WO,shareWithSystem:GO,showActionSheet:iO,showKeyboard:XC,showLoading:oO,showModal:nO,showNavigationBarLoading:gO,showTabBar:SO,showTabBarRedDot:wO,showToast:aO,startAccelerometer:Xh,startBeaconDiscovery:mC,startBluetoothDevicesDiscovery:tC,startCompass:Jh,startLocationUpdate:JA,startPullDownRefresh:cO,startSoterAuthentication:IC,stopAccelerometer:Qh,stopBeaconDiscovery:_C,stopBluetoothDevicesDiscovery:nC,stopCompass:Zh,stopLocationUpdate:ZA,stopPullDownRefresh:uO,switchTab:NP,syncDataToGlobal:BO,unPreloadPage:RP,uploadFile:EA,upx2px:Im,vibrateLong:Ww,vibrateShort:zw,weexGetSystemInfoSync:ic,writeBLECharacteristicValue:fC};let LP=W.extend($,{publishHandler:MP});function MP(e,t,n){t=JSON.stringify(t),W.isArray(n)||(n=[n]);let r=`typeof UniViewJSBridge !== 'undefined' && UniViewJSBridge.subscribeHandler("${e}",${t},__PAGE_ID__)`;n.forEach(o=>{let c=String(o),h=s.webview.getWebviewById(c);h&&h.evalJS(r.replace("__PAGE_ID__",c))})}function DP(){let{tabBar:e}=B;if(!(e&&e.list&&e.list.length))return;let{entryPagePath:n}=B;e.selectedIndex=0;let r=e.list.findIndex(o=>o.pagePath===n);di.init(e,(o,c)=>{I.switchTab({url:Z.addLeadingSlash(o.pagePath),openType:"switchTab",from:"tabBar",success(){Ln(Z.ON_TAB_ITEM_TAP,{index:c,text:o.text,pagePath:o.pagePath})}})}),r!==-1&&(e.selectedIndex=r,r!==0&&di.switchTab(n))}function FP(){let e=s.globalEvent,t=g.requireModule("globalEvent"),{emit:n,publishHandler:r}=st;g.config.preload?s.key.addEventListener(Do,Li):e.addEventListener("splashclosed",()=>{s.key.addEventListener(Do,Li)}),e.addEventListener("pause",()=>{n(Z.ON_APP_ENTER_BACKGROUND)}),e.addEventListener("resume",()=>{let c=Ls();c&&c.userAction&&Bs(c),n(Z.ON_APP_ENTER_FOREGROUND,Fo())}),t.addEventListener("uistylechange",function(c){let h={theme:c.uistyle};n(Z.ON_THEME_CHANGE,h),r(Z.ON_THEME_CHANGE,h,fa()),Rw()});let o=0;e.addEventListener("KeyboardHeightChange",function(c){o!==c.height&&(o=c.height,n(Z.ON_KEYBOARD_HEIGHT_CHANGE,{height:o}))}),t.addEventListener(ST,function(c){c&&c.event&&JO(c.event,c.data)}),e.addEventListener("plusMessage",Ep),e.addEventListener("WebviewPostMessage",Ep)}function Ep({data:e}){e&&e.type&&st.subscribeHandler("plusMessage."+e.type,e.args)}function yp(e,t,n=!1){st.subscribe("plusMessage."+e,t,n)}function VP(e){eb(e.$);let{entryPagePath:t,entryPageQuery:n,referrerInfo:r}=B,o=hs({path:t,query:n,referrerInfo:r});Ln(e,Z.ON_LAUNCH,o),Ln(e,Z.ON_SHOW,o);let c=g.requireModule("plus").getAppState;(c&&Number(c()))===2&&Ln(e,Z.ON_HIDE,o)}function Sp(e){return e=e.replace(/\/$/,""),e.indexOf("_")===0?s.io.convertLocalFileSystemURL(e):e}function $P(){let e=Sp(fs),t=Sp(Wr),n=t.split("/");n.pop();let r=n.join("/");s.io.resolveLocalFileSystemURL(s.io.convertAbsoluteFileSystem(r),o=>{o.createReader().readEntries(function(h){let b=h;b&&b.length&&b.forEach(function(V){V.isDirectory&&V.fullPath.indexOf(e)===0&&V.fullPath.indexOf(t)!==0&&V.removeRecursively()})})})}let wp=0,Rl=0,Jc=null,rl=null;function UP(e,t){if(Jc=null,rl&&(S(rl),rl=null),e.type==="onFocus")if(Rl>0)e.detail.height=Rl;else{rl=k(function(){e.detail.height=Rl,t(e)},wp),Jc=function(){rl&&(S(rl),rl=null),e.detail.height=Rl,t(e)};return}t(e)}function HP(){wp=s.os.name.toLowerCase()==="android"?300:700,st.on(Z.ON_KEYBOARD_HEIGHT_CHANGE,t=>{if(Rl=t.height,Rl>0){let n=Jc;Jc=null,n&&n()}})}function jP(e,t,n){let r=t.type;r==="onFocus"||r==="onBlur"?UP(t,o=>{n.fireEvent(e,o)}):n.fireEvent(e,t)}function zP(e,t){let n=Ir(parseInt(t));if(!n)return;let r=n.__page_container__;e.forEach(o=>{switch(o[0]){case Z.ACTION_TYPE_EVENT:jP(o[1],o[2],r);break}})}let Cp={};function WP(e,t,n){let{adpid:r,width:o}=e,c=r+"-"+o,h=Cp[c];if(h&&h.length>0){t(h.splice(0,1)[0]);return}s.ad.getAds(e,b=>{let V=b.ads;t(V.splice(0,1)[0]),Cp[c]=h?h.concat(V):V},b=>{n({errCode:b.code,errMsg:b.message})})}function GP(){R("getAdData",(e,t)=>{WP(e,n=>{t({code:0,data:n})},n=>{t({code:1,message:n})})})}let YP=["switchTab","reLaunch","redirectTo","navigateTo","navigateBack"];function qP(){YP.forEach(e=>{R(e,t=>{I[e](W.extend(t,{fail(n){console.error(n.errMsg)}}))})})}let Ap=!1;function KP(e,t){let n=t==="1";if(!(n&&Ap)){if(n?(Ap=!0,tp(s.webview.getLaunchWebview())):Mi||tp(s.webview.getWebviewById(t)),!Mi.loaded){if(Mi.id!==t)return console.error(`webviewReady[${Mi.id}][${t}] not match`);Mi.loaded=!0}st.emit(kl+"."+t),n&&JP()}}function JP(){let{autoclose:e,alwaysShowBeforeRender:t}=B.splashscreen;e&&!t&&s.navigator.closeSplashscreen();let n=Z.addLeadingSlash(B.entryPagePath),r=ji(n);if(!r.meta.isNVue){let o={url:n+(B.entryPageQuery||""),openType:"appLaunch"},c={resolve(){},reject(){}};return r.meta.isTabBar?bp(o,c):_p(o,c)}}function ZP(e,t){let n=Ir(parseInt(t));n&&(n.__uniapp_webview=!0)}function XP(e,t){let n=Ir(parseInt(t));n&&delete n.__uniapp_webview}let QP=({name:e,arg:t},n)=>{e==="postMessage"?eI(n[0],t):I[e](W.extend(t,{fail(r){console.error(r.errMsg)}}))};function eI(e,t){let n=tP("web-view",parseInt(e));n&&n.dispatchEvent(Z.createUniEvent({type:"onMessage",target:Object.create(null),currentTarget:Object.create(null),detail:{data:[t]}}))}function tI({nodeId:e,ownerId:t,method:n,args:r},o){let c=up(e,parseInt(o));if(!c)return;let h=nI(t,c.__vueParentComponent);!h||!h[n]||h[n](r)}function nI(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 rI(){let{subscribe:e,subscribeHandler:t,publishHandler:n}=st;if(yp("subscribeHandler",({type:r,data:o,pageId:c})=>{t(r,o,c)}),yp(Z.WEB_INVOKE_APPSERVICE,({data:r,webviewIds:o})=>{QP(r,o)}),B.renderer!=="native"){e(kl,KP),e(Cg,zP),m(),GP(),qP(),e(PO,ZP),e(IO,XP),e(Z.ON_WXS_INVOKE_CALL_METHOD,tI);let r=ji(Z.addLeadingSlash(B.entryPagePath));r&&!r.meta.isNVue&&n(kl,{},1)}}let xl,cf={globalData:{}};function iI({allowDefault:e=!1}={}){if(xl)return xl;if(e)return cf;console.error("[warn]: getApp() failed. Learn more: https://uniapp.dcloud.io/collocation/frame/window?id=getapp.")}function oI(e){if(I.Vuex&&e.$store){let{useStore:t}=I.Vuex;I.Vuex.useStore=n=>n?t(n):e.$store}Ga(e),xl=e,ct(xl),W.extend(xl,cf),Et(xl,cf.globalData),we(),vp(),DP(),FP(),HP(),rI(),VP(e),k($P,1e4),B.ready=!0}var aI={uni:BP,getApp:iI,getCurrentPages:br,__definePage:hP,__registerApp:oI,__registerPage:fc,UniServiceJSBridge:LP};return aI}(Lt,en,w);xt=xt.default||xt;let I=xt.uni,St=xt.getApp,Pn=xt.getCurrentPages,st=xt.UniServiceJSBridge;return xt}var sv=WN(qN);var lv=g=>{let{registerUTSInterface:s,initUTSProxyClass:p,initUTSProxyFunction:w,initUTSPackageName:k,initUTSIndexClassName:S,initUTSClassName:d}=g,E="DCloudUniFacialRecognitionVerify",B="FacialRecognitionVerify(\u5B9E\u4EBA\u8BA4\u8BC1)",We="built-in",Lt="",en=!0,xt=k(E,en),I=S(E,en);g.startFacialRecognitionVerify=w(!1,{moduleName:B,moduleType:We,errMsg:Lt,main:!0,package:xt,class:I,name:"startFacialRecognitionVerifyByJs",params:[{name:"faceStyle",type:"UTSSDKModulesDCloudUniFacialRecognitionVerifyStartFacialRecognitionVerifyOptionsJSONObject"}],return:""}),g.getFacialRecognitionMetaInfo=w(!1,{moduleName:B,moduleType:We,errMsg:Lt,main:!0,package:xt,class:I,name:"getFacialRecognitionMetaInfoByJs",params:[],return:""})};var cv=g=>{};var uv=g=>{};var fv=g=>{};var dv=g=>{};var hv=g=>{};var gv=g=>{};var pv=g=>{};var vv=g=>{};function mv(g){lv(g),cv(g),uv(g),fv(g),dv(g),hv(g),gv(g),pv(g),vv(g)}var If,Nf,kf,Va,Rf,xf,Bf;function _v(){return Va?{__definePage:If,__registerApp:Nf,__registerPage:kf,uni:Va,wx:Va,getApp:Rf,getCurrentPages:xf,UniServiceJSBridge:Bf}:{}}function bv(g){let{weex:s,plus:p,VueShared:w}=g;return Va||({__definePage:If,__registerApp:Nf,__registerPage:kf,uni:Va,getApp:Rf,getCurrentPages:xf,UniServiceJSBridge:Bf}=av(s,p,g),Va.VueShared=w,mv(Va),Ip(Va)),{__definePage:If,__registerApp:Nf,__registerPage:kf,plus:p,uni:Va,wx:Va,getApp:Rf,getCurrentPages:xf,UniServiceJSBridge:Bf}}function Ev(g,s){let{__uniConfig:p}=s;if(!p)return;let w=s.weex;w.document.__$automator__=!!p.automator;let k=p.renderer!=="native"&&w.config.bundleUrl.indexOf("app-service.js")!==-1;if(hi(s,_v()),k?sv(s):(xp(g,s),Qp(s.Vue.parseClassStyles)),hi(s,bv(s)),w.config.plus_web_id==="1"){let B=w.requireModule("plus");B.setDefaultFontSize&&B.setDefaultFontSize(Math.round(s.plus.screen.resolutionWidth/20))}let{scale:S,deviceWidth:d,platform:E}=global.WXEnvironment;if(E.toLowerCase()==="ios"){let B=Math.ceil(d/S);w.requireModule("meta").setViewport({width:B,roundOffDeviation:!1})}}var cl=class extends ll{constructor(s){super();this.nodeType=8;this.type="comment";this.value="";this.value=s}toString(){return"<!-- "+this.value+" -->"}};function wo(g,s=[]){return{module:"dom",method:g,args:s}}var Vl=class{constructor(s,p){this.id=s,this.batched=!1,this.updates=[],$n(p)?Object.defineProperty(this,"handler",{configurable:!0,enumerable:!0,writable:!0,value:p}):console.error("[JS Runtime] invalid parameter, handler must be a function")}createFinish(s){return this.handler([wo("createFinish")],s)}updateFinish(s){return this.handler([wo("updateFinish")],s)}refreshFinish(s){return this.handler([wo("refreshFinish")],s)}createBody(s){let p=s.toJSON(),w=p.children;delete p.children;let k=[wo("createBody",[p])];return w&&k.push.apply(k,w.map(S=>wo("addElement",[p.ref,S,-1]))),this.addActions(k)}addElement(s,p,w){return w>=0||(w=-1),this.addActions(wo("addElement",[p,s.toJSON(),w]))}removeElement(s){if(Pi(s)){let p=s.map(w=>wo("removeElement",[w]));return this.addActions(p)}return this.addActions(wo("removeElement",[s]))}moveElement(s,p,w){return this.addActions(wo("moveElement",[s,p,w]))}setAttr(s,p,w){return this.addActions(wo("updateAttrs",[s,{[p]:w}]))}setStyle(s,p,w){return this.addActions(wo("updateStyle",[s,{[p]:w}]))}setStyles(s,p){return this.addActions(wo("updateStyle",[s,p]))}addEvent(s,p){return this.addActions(wo("addEvent",[s,p]))}removeEvent(s,p){return this.addActions(wo("removeEvent",[s,p]))}handler(s,p){return p&&p()}addActions(s){let p=this.updates,w=this.handler;if(Pi(s)||(s=[s]),this.batched)p.push.apply(p,s);else return w(s)}};var Lf={createBody:"callCreateBody",addElement:"callAddElement",removeElement:"callRemoveElement",moveElement:"callMoveElement",updateAttrs:"callUpdateAttrs",updateStyle:"callUpdateStyle",addEvent:"callAddEvent",removeEvent:"callRemoveEvent"};function yv(g,s){let p=s||global.callNative;return $n(p)||console.error("[JS Runtime] no default handler"),function(k){Pi(k)||(k=[k]);for(let S=0;S<k.length;S++){let d=JN(g,k[S],p);if(d===-1)return d}}}function KN(g,s){return g==="dom"&&Lf[s]&&$n(global[Lf[s]])}function JN(g,s,p){let{module:w,method:k,args:S}=s;return KN(w,k)?global[Lf[k]](g,...S,"-1"):p(g,[s],"-1")}var hu=class extends Ki{constructor(s){super();this.value=s,this.nodeType=3,this.type="text",this.value=""}toString(){return""+this.value}};var Sv={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 wv(g){let{attr:s,offsetLeft:p,offsetTop:w}=g,k={};return s&&Object.keys(s).forEach(S=>{S.indexOf("data-")===0&&(k[S.replace("data-","")]=s[S])}),{id:s&&s.id||"",dataset:k,offsetLeft:p||0,offsetTop:w||0}}var ZN=["a","div","list","cell","loading","refresh","recycle-list","scroller","indicator","waterfall","web","richtext"],XN=["viewappear","viewdisappear"],QN={markertap:["markerId"],controltap:["controlId"],regionchange:["causedBy"],end:["causedBy"],appear:["direction"],disappear:["direction"]};function Cv(g,s){let p=g.type;if(XN.indexOf(p)!==-1)return g;let w=g.currentTarget,k=w.type.replace("u-","");if(ZN.indexOf(k)!==-1)return g;let{timestamp:S,target:d}=g;if(!s){let We=Sv[k];We?$n(We[p])?s=We[p](g):s=g.detail||{}:s=g.detail||{}}let E={type:p,timeStamp:S,target:wv(d),currentTarget:wv(w),detail:s,touches:p==="touchend"||p==="panend"?[]:g.changedTouches,changedTouches:g.changedTouches};g.componentId&&(E.componentId=g.componentId);let B=QN[p];return B&&B.forEach(We=>{il(g,We)&&(E[We]=g[We])}),E}function e1(g,s){let p=s.attrs||{};for(let k in p)g.setAttr(k,p[k],!0);let w=s.style||{};for(let k in w)g.setStyle(k,w[k],!0)}var Go=class{constructor(s,p="",w){s=s?s.toString():"",this.id=s,this.URL=p,Wp(s,this),this.nodeMap={};let k=Go.Listener||Vl;this.listener=new k(s,w||yv(s,Go.handler)),this.taskCenter=new Fl(s,w?(S,d)=>w(d):Go.handler),this.createDocumentElement()}getRef(s){return this.nodeMap[s]}open(){this.listener.batched=!1}close(){this.listener.batched=!0}createDocumentElement(){if(!this.documentElement){let s=new Ki("document");s.docId=this.id,s.ownerDocument=this,s.role="documentElement",s.ref="_documentElement",this.nodeMap._documentElement=s,this.documentElement=s,Object.defineProperty(s,"appendChild",{configurable:!0,enumerable:!0,writable:!0,value:p=>{pf(this,p)}}),Object.defineProperty(s,"insertBefore",{configurable:!0,enumerable:!0,writable:!0,value:(p,w)=>{pf(this,p,w)}}),Kn("debug")&&Di(`Create document element (id: "${s.docId}", ref: "${s.ref}")`)}return this.documentElement}createBody(s,p){if(!this.body){let w=new Ki(s,p);vf(this,w),Kn("debug")&&Di(`[createBody](${this.id},${w.type},${w.ref}) (${JSON.stringify(w.toJSON(!0))}).`)}return this.body}createElement(s,p){let w=new Ki(s,p);return Kn("debug")&&Di(`[createElement](${this.id},${w.type},${w.ref}) (${JSON.stringify(w.toJSON(!0))}).`),w}createComment(s){return new cl(s)}createText(s){return new hu(s)}fireEvent(s,p,w,k,S){if(!s)return;w=w||{},w.type=w.type||p,w.target=s,w.currentTarget=s,w.timestamp=Date.now(),k&&e1(s,k);let d=!0,E=this.getRef("_root");if(E&&E.attr){let B=E.attr.bubble;d=B==="true"||B===!0||d&&B===void 0}return w=Cv(w),s.fireEvent(p,w,d,S)}destroy(){Kn("debug")&&Di(`[destroy](${this.id},document) Destroy document (id: "${this.id}", URL: "${this.URL}")`),this.taskCenter.destroyCallback(),delete this.listener,delete this.nodeMap,delete this.taskCenter,Gp(this.id)}};Go.handler=null;var Av={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 Ov(g,s,p){var w=[s];function k(d){var E=new RegExp;return E.compile(d.replace(/<([^>]+)>/g,function(B,We){return g[We]?(w.push(We),g[We]instanceof RegExp?"("+g[We].source+")":"("+k(g[We]).source+")"):""}),p),E}var S=k(g[s]);this.exec=function(d){var E=S.exec(d);if(E==null)return null;for(var B=new String(E[0]),We=0;We<w.length;We++)E[We]&&(B[w[We]]=E[We]);return B},Object.defineProperty(this,"lastIndex",{get:function(){return S.lastIndex},set:function(d){S.lastIndex=d}})}function t1(){var g=new Ov(Av,"InputElementDiv","g"),s=new Ov(Av,"InputElementRegExp","g"),p;Object.defineProperty(this,"source",{get:function(){return p},set:function(w){p=w,g.lastIndex=0,s.lastIndex=0}}),this.reset=function(){g.lastIndex=0,s.lastIndex=0},this.getNextToken=function(w){var k=g.lastIndex,S;w?S=g:S=s;var d=S.exec(p);if(d&&S.lastIndex-k>d.length)throw new SyntaxError("Unexpected token ILLEGAL");return g.lastIndex=S.lastIndex,s.lastIndex=S.lastIndex,d}}var Tv={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,s){this.name=g,this.token=s,this.childNodes=[],this.toString=function(p){if(p||(p=""),this.childNodes.length==1)return this.childNodes[0].toString(p);for(var w=p+this.name+(this.token!=null&&this.name!=this.token?":"+this.token:"")+`
`,k=0;k<this.childNodes.length;k++)w+=this.childNodes[k].toString(p+"    ");return w}}function n1(){var g,s={Program:"$"},p={};function w(E){p[JSON.stringify(E)]=E;for(var B=Object.getOwnPropertyNames(E);B.length;){var We=B.shift();!Tv[We]||Tv[We].forEach(function(en){E[en[0]]||B.push(en[0]);var xt=E,I=null;en.forEach(function(St){xt[St]||(xt[St]={}),I=xt,xt=xt[St]}),E[We].$div&&(xt.$div=!0),xt.$reduce=We,xt.$count=en.length})}for(var Lt in E)typeof E[Lt]!="object"||Lt.charAt(0)=="$"||E[Lt].$closure||(p[JSON.stringify(E[Lt])]?E[Lt]=p[JSON.stringify(E[Lt])]:w(E[Lt]));E.$closure=!0}w(s);var k=[],S=[s],d=s;this.insertSymbol=function(B,We){for(;!d[B.name]&&d.$reduce;){for(var Lt=d.$count,en=new mc(d.$reduce);Lt--;)en.childNodes.push(k.pop()),S.pop();d=S[S.length-1],this.insertSymbol(en)}if(d=d[B.name],k.push(B),S.push(d),!d)throw new Error;return d.$div},this.reset=function(){d=s,k=[],S=[s]},Object.defineProperty(this,"grammarTree",{get:function(){try{for(;d.$reduce;){for(var E=d.$count,B=new mc(d.$reduce);E--;)B.childNodes.push(k.pop()),S.pop();d=S[S.length-1],this.insertSymbol(B)}if(k.length>0&&d[";"])return this.insertSymbol(new mc(";",";")),this.grammarTree;if(k.length!=1||k[0].name!="Program")throw new Error}catch(We){throw new SyntaxError("Unexpected end of input")}return k[0]}})}function r1(){this.lexicalParser=new t1,this.syntacticalParser=new n1;var g=["NullLiteral","BooleanLiteral","NumericLiteral","StringLiteral","RegularExpressionLiteral","Identifier","**","=>","{","}","(",")","[","]",".",";",",","<",">","<=",">=","==","!=","===","!==","+","-","*","%","++","--","<<",">>",">>>","&","|","^","!","~","&&","||","?",":","=","+=","-=","*=","%=","<<=",">>=",">>>=","&=","|=","^=","/","/=","instanceof","typeof","new","void","debugger","this","delete","in"],s={};g.forEach(function(p){Object.defineProperty(s,p,{})}),this.reset=function(){this.lexicalParser.reset(),this.syntacticalParser.reset()},this.parse=function(p,w){var k,S=!1;this.lexicalParser.source=p;for(var d=!1;k=this.lexicalParser.getNextToken(d);){w&&w(k);try{if(Object.getOwnPropertyNames(k).some(E=>s.hasOwnProperty(E)?(d=this.syntacticalParser.insertSymbol(new mc(E,k),S),S=!1,!0):!1))continue;(k.Keyword||k.Punctuator||k.DivPunctuator)&&s.hasOwnProperty(k.toString())&&(d=this.syntacticalParser.insertSymbol(new mc(k.toString(),k),S))}catch(E){throw new SyntaxError("Unexpected token "+k)}}return this.syntacticalParser.grammarTree}}var Pv=new r1;function i1(g){Pv.reset(),this.tree=Pv.parse(g),this.paths=[];var s=Object.create(null),p=this,w=Object.create(null);this.isSimple,this.isConst,S(this.tree),k(this.tree),this.paths.length===0&&(this.isConst=!0),this.setter=function(B){for(var We=s,Lt=0;Lt<B.length-1;Lt++)We[B[Lt]]||(We[B[Lt]]=Object.create(null)),We=We[B[Lt]];return{isCompleted:function(){for(var en in w)if(!w[en])return!1;return!0},set:function(en){if(w[B.join(".")]||(w[B.join(".")]=!0),We[B[Lt]]=en,this.isCompleted())return p.exec()}}},this.valueOf=this.exec=function(){try{return function(){return(0,eval)(g)}.call(s)}catch(B){}};function k(B){for(var We=B;We.childNodes.length<=1&&We.name!=="MemberExpression";)We=We.childNodes[0];We.name==="MemberExpression"?p.isSimple=!0:p.isSimple=!1}function S(B){if(B.name==="CallExpression"&&B.childNodes[B.childNodes.length-1].name!=="CallExpression"){var We=d(B.childNodes[1]);S(B.childNodes[0])}else if(B.name==="NewExpression"&&B.childNodes.length===1)var We=d(B.childNodes[0]);else if(B.name==="MemberExpression"&&B.childNodes.length===1)var We=d(B);else for(var Lt=0;Lt<B.childNodes.length;Lt++)S(B.childNodes[Lt])}function d(B){if(B.childNodes[0].name==="IdentifierName"){var We=d(B.childNodes[2]);return We&&(We=We.concat(B.childNodes[0].childNodes[0].token.toString())),E(We),We}else if(B.childNodes[0].name==="PrimaryExpression")if(B.childNodes[0].childNodes[0].name==="Identifier"){var We=[B.childNodes[0].childNodes[0].token.toString()];return E(We),We}else return null;else{if(B.childNodes[0].name==="]")return d(B.childNodes[3]),S(B.childNodes[1]),null;if(B.childNodes[0].name==="Arguments")return S(B.childNodes[0]),S(B.childNodes[1]),null;for(var Lt=0;Lt<B.childNodes.length;Lt++)S(B.childNodes[Lt])}}function E(B){for(var We=s,Lt=0;Lt<B.length-1;Lt++)We[B[Lt]]||(We[B[Lt]]=Object.create(null)),We=We[B[Lt]];p.paths.push(B),w[B.join(".")]=!1}}function ul(g){var s=g.childNodes.slice().reverse(),p=s.filter(B=>!B.token||!B.token.Punctuator);if(g.name==="UnaryExpression"&&s.length===2&&s[0].name==="-"&&p.length===1){var w=ul(p[0]);return w.value=-w.value,w}if(g.name==="Arguments"){for(var k=[],S=p[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(B=>ul(B))}}if(p&&p.length===1){var w=ul(p[0]);return w}if(g.token&&["NullLiteral","BooleanLiteral","NumericLiteral","StringLiteral","Identifier"].some(B=>g.token[B])){var d=Object.keys(g.token).filter(B=>B.match(/Literal/)||B.match(/Identifier/))[0],E={NullLiteral:null,BooleanLiteral:Boolean(g.token),NumericLiteral:Number(g.token),StringLiteral:g.token,Identifier:g.token}[d];return{type:d,value:E}}return g.name==="CallExpression"?{type:"CallExpression",children:[ul(s[0]),ul(s[1])]}:{type:s.filter(B=>B.token&&B.token.Punctuator)[0].name,children:s.filter(B=>!B.token||!B.token.Punctuator).map(B=>ul(B))}}function Iv(g){var s=new i1(g);return JSON.stringify(ul(s.tree),null)}function o1(g,s){return s==="bind"&&(g==="bindingx"||g==="binding")}function Nv(g){if(!g)return;try{g=JSON.parse(g)}catch(p){}let s={};if(gi(g)?s.origin=g:g&&(s.origin=g.origin,s.transformed=g.transformed),!(!s.transformed&&!s.origin))return s.transformed=s.transformed||Iv(s.origin),s}function a1(g){return g&&(g.exitExpression=Nv(g.exitExpression),g.props&&g.props.forEach(s=>{s.expression=Nv(s.expression)}),g)}function s1(g){return function(s={}){if($n(g))return g({state:s.state==="end"?"exit":s.state,t:s.t!==void 0?s.t:s.deltaT})}}function kv(g,s,p){return p&&(o1(g,s)?function(w,k=function(){}){if(!w)throw new Error("should pass options for binding");return a1(w),p(w,w&&w.eventType==="timing"?s1(k):k)}:p)}function l1(g,s){Object.defineProperty(g,"[[CurrentInstanceId]]",{value:s})}function Rv(g){return g["[[CurrentInstanceId]]"]}function c1(g,s,p){let w=Lr(g);return!w||!$n(w.send)?(console.error(`[JS Framework] Failed to find taskCenter (${g}).`),null):(...k)=>w.send("module",{module:s,method:p},k)}function u1(g,s,p,w){let k=Lr(g);return!k||!$n(k.send)?(console.error(`[JS Framework] Failed to find taskCenter (${g}).`),null):$n(w)?S=>k.send("module",{module:s,method:p},[S]):(console.error(`[JS Framework] ${s}.${p} must be assigned as a function.`),null)}var gu=class{constructor(s,p){l1(this,String(s)),this.config=p||{},this.document=new Go(s,this.config.bundleUrl),this.requireModule=this.requireModule.bind(this),this.importScript=this.importScript.bind(this),this.isRegisteredModule=uu,this.isRegisteredComponent=Tf}requireModule(s){let p=Rv(this);if(!(p&&this.document&&this.document.taskCenter)){console.error(`[JS Framework] Failed to requireModule("${s}"), instance (${p}) doesn't exist anymore.`);return}if(!uu(s)){console.warn(`[JS Framework] \u5F53\u524D\u8FD0\u884C\u7684\u57FA\u5EA7\u4E0D\u5305\u542B\u539F\u751F\u63D2\u4EF6[${s}]\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 w={},k=iv(s);for(let S in k)Object.defineProperty(w,S,{enumerable:!0,configurable:!0,get:()=>kv(s,S,c1(p,s,S)),set:d=>u1(p,s,S,d)});return w}supports(s){if(!gi(s))return null;let p=s.match(/^@(\w+)\/([\w-]+)(\.(\w+))?$/i);if(p){let w=p[1],k=p[2],S=p[4];switch(w){case"module":return uu(k,S);case"component":return Tf(k)}}return null}importScript(s,p={}){let w=Rv(this),k=Lr(w);return new Promise(function(S,d){if(!k||!$n(k.send))return d(new Error(`[JS Framework] Failed to import script "${s}", no taskCenter (${w}) matched.`));try{k.send("module",{module:"script",method:"importScript"},[s,p],{callback:[E=>S(E),E=>d(E)]})}catch(E){d(E)}})}};function f1(g,s){let p=Object.create(null);return p.service=Object.create(null),Rs.forEach(({name:w,options:k})=>{let S=k.create;if(S)try{let d=S(g,s);hi(p.service,d),hi(p,d.instance)}catch(d){console.error(`[JS Runtime] Failed to create service ${w}.`)}}),delete p.service.instance,Ta(p.service),p}var d1={uid:0},h1=Up(hc),g1=$p(hc);function xv(g,s,p){let w=new gu(g,s),k="Vue",S=f1(g,{weex:w,nvue:w,config:s,created:Date.now(),framework:k});Ta(S);let d=Object.create(null);return hi(d,y1(w)),hi(d,S,{SharedObject:d1,weex:w,nvue:w,requireModule:E=>w.requireModule(E),__WEEX_CALL_JAVASCRIPT__:Af,services:S}),d.plus=new d.WeexPlus(w),d.VueShared=hc,d.UniShared=h1,d.VueReactivity=g1,Ev(g,d),Ta(d),d}function p1(g,s,p={}){let w="Vue";p=hf(p),p.env=hf(global.WXEnvironment||{}),p.bundleType=w;let k=xv(g,p);v1(s,k)}function v1(g,s){let p=[],w=[];for(let d in s)p.push(d),w.push(s[d]);let S="(function (global) { "+`
global = (function () {
  var g
  // This works in non-strict mode
  g = (function () {
    return this
  })()
  try {
    // This works if eval is allowed (see CSP)
    g = g || new Function("return this")()
  } catch (e) {
    // This works if the window reference is available
    if (typeof window === "object") g = window
  }
  return g
})() || global;
`+g+" })(Object.create(this))";return new Function(...p,S)(...w)}function m1(g){let s=rs(g);try{if(s&&s.body)return s.body.toJSON()}catch(p){console.error("[JS Framework] Failed to get the virtual dom tree.");return}}function _1(g){kp(g),Rs.forEach(s=>{let p=s.options.destroy;p&&p(g)})}function b1(g){Rp(g),Rs.forEach(s=>{let p=s.options.refresh;p&&p(g)})}var E1={createInstance:p1,createInstanceContext:xv,getRoot:m1,getDocument:rs,registerService:fu,unregisterService:du,callJS(g,s){return Af(g,s)},registerComponents:ov,registerModules:rv,destroyInstance:_1,refreshInstance:b1};function Mf(){return nv(),E1}function y1(g){if(global.setTimeout&&global.setInterval)return{setTimeout:global.setTimeout,setInterval:global.setInterval,clearTimeout:global.clearTimeout,clearInterval:global.clearInterval};let s=g.requireModule("timer");return{setTimeout:(...w)=>{let k=function(){w[0](...w.slice(2))};return s.setTimeout(k,w[1]),g.document.taskCenter.callbackManager.lastCallbackId.toString()},setInterval:(...w)=>{let k=function(){w[0](...w.slice(2))};return s.setInterval(k,w[1]),g.document.taskCenter.callbackManager.lastCallbackId.toString()},clearTimeout:w=>{s.clearTimeout(w)},clearInterval:w=>{s.clearInterval(w)}}}var Bv={Document:Go,Element:Ki,Comment:cl,Listener:Vl,TaskCenter:Fl,sendTasks(...g){return $n(callNative)?callNative(...g):(global.callNative||(()=>{}))(...g)}};Go.handler=Bv.sendTasks;var fl=Bv;function S1(){Ta(fl.Comment),Ta(fl.Listener),Ta(fl.Document.prototype),Ta(fl.Comment.prototype),Ta(fl.Listener.prototype)}var pu={service:{register:fu,unregister:du,has:Pf},freezePrototype:S1,init:Mf,config:fl};var Df=class{constructor(s,p={}){this.type=s||"message",this.data=p.data||null,this.origin=p.origin||"",this.source=p.source||null,this.ports=p.ports||[],this.target=null,this.timeStamp=Date.now()}};var xs={},_c={};function Ff(){}Ff.prototype.postMessage=function(g){if(this._closed)throw new Error(`BroadcastChannel "${this.name}" is closed.`);let s=xs[this.name];if(s&&s.length)for(let p=0;p<s.length;++p){let w=s[p];w._closed||w===this||$n(w.onmessage)&&w.onmessage(new Df("message",{data:g}))}};Ff.prototype.close=function(){if(!this._closed&&(this._closed=!0,xs[this.name])){let g=xs[this.name].filter(s=>s!==this);g.length?xs[this.name]=g:delete xs[this.name]}};var Lv={create:g=>{if(_c[g]=[],$n(global.BroadcastChannel))return{};let s={BroadcastChannel:function(p){Object.defineProperty(this,"name",{configurable:!1,enumerable:!0,writable:!1,value:String(p)}),this._closed=!1,this.onmessage=null,xs[this.name]||(xs[this.name]=[]),xs[this.name].push(this),_c[g].push(this)}};return s.BroadcastChannel.prototype=Ff.prototype,{instance:s}},destroy:g=>{_c[g]&&(_c[g].forEach(s=>s.close()),delete _c[g])}};function Vf(){let{init:g}=pu;pu.service.register("BroadcastChannel",Lv),pu.freezePrototype();let s=g();for(let p in s)global[p]=(...w)=>{let k=s[p](...w);return k instanceof Error&&console.error(k.toString()),k}}var xx=global.console;function Mv(){if(jp(),global.WXEnvironment&&global.WXEnvironment.platform!=="Web")global.console={debug:(...g)=>{Kn("debug")&&global.nativeLog(...bc(g),"__DEBUG")},log:(...g)=>{Kn("log")&&global.nativeLog(...bc(g),"__LOG")},info:(...g)=>{Kn("info")&&global.nativeLog(...bc(g),"__INFO")},warn:(...g)=>{Kn("warn")&&global.nativeLog(...bc(g),"__WARN")},error:(...g)=>{Kn("error")&&global.nativeLog(...bc(g),"__ERROR")}};else{let{debug:g,log:s,info:p,warn:w,error:k}=console;console.__ori__={debug:g,log:s,info:p,warn:w,error:k},console.debug=(...S)=>{Kn("debug")&&console.__ori__.debug.apply(console,S)},console.log=(...S)=>{Kn("log")&&console.__ori__.log.apply(console,S)},console.info=(...S)=>{Kn("info")&&console.__ori__.info.apply(console,S)},console.warn=(...S)=>{Kn("warn")&&console.__ori__.warn.apply(console,S)},console.error=(...S)=>{Kn("error")&&console.__ori__.error.apply(console,S)}}}function bc(g){return g.map(s=>{if(Fa(s).toLowerCase()==="[object object]")try{s=JSON.stringify(s)}catch(w){s="[object object]"}else s=String(s);return s})}Mv();Vf();})();
