Skip to content

U
UniMPSDK-iOS

DCloud / UniMPSDK-iOS

通知 76
Star 5
Fork 4
U
UniMPSDK-iOS

体验新版 GitCode，发现更多精彩内容 >>

切换分支/标签
查找文件 普通视图历史永久链接Permalink
uni-jsframework-vue3.js 667.3 KB
Newer Older
DCloud_iOS_WZT's avatar
update unimpsdk  
DCloud_iOS_WZT 已提交
1 2 
//{"version":"3.99","encode":"base64"}
var __UniServiceStartTime__ = Date.now();var global=this; var process={env:{}}; var setTimeout=global.setTimeout;
(()=>{var Tp=Object.defineProperty;var Pp=Object.getOwnPropertySymbols;var wI=Object.prototype.hasOwnProperty,CI=Object.prototype.propertyIsEnumerable;var Ip=(f,s,p)=>s in f?Tp(f,s,{enumerable:!0,configurable:!0,writable:!0,value:p}):f[s]=p,Np=(f,s)=>{for(var p in s||(s={}))wI.call(s,p)&&Ip(f,p,s[p]);if(Pp)for(var p of Pp(s))CI.call(s,p)&&Ip(f,p,s[p]);return f};var AI=(f,s)=>{for(var p in s)Tp(f,p,{get:s[p],enumerable:!0})};var Oa=Object.freeze;function dc({getCurrentPages:f,uni:s,UniShared:p,Vue:w,VueShared:N}){var E=function(h,y,R,Fe){"use strict";function It(){let ze=f(),nt=ze.length;if(nt)return ze[nt-1]}function Vt(){let ze=It();if(ze)return ze.$vm}function Ot(ze,nt,At){if(R.isString(ze))At=nt,nt=ze,ze=Vt();else if(typeof ze=="number"){let Tn=f().find(sn=>sn.$page.id===ze);Tn?ze=Tn.$vm:ze=Vt()}if(!ze)return;if(ze.__call_hook)return ze.__call_hook(nt,At);let Qt=ze.$[nt];return Qt&&y.invokeArrayFns(Qt,At)}function P(ze,nt,At,Qt){R.isFunction(nt)&&Fe.injectHook(ze,nt.bind(At),Qt)}function wt(ze,nt,At){var Qt;let Tn=ze.mpType||At.$mpType;if(!(!Tn||Tn==="component")&&(Object.keys(ze).forEach(sn=>{if(y.isUniLifecycleHook(sn,ze[sn],!1)){let or=ze[sn];R.isArray(or)?or.forEach(Wn=>P(sn,Wn,At,nt)):P(sn,or,At,nt)}}),Tn==="page")){nt.__isVisible=!0;try{Ot(At,y.ON_LOAD,nt.attrs.__pageQuery),delete nt.attrs.__pageQuery,((Qt=At.$page)===null||Qt===void 0?void 0:Qt.openType)!=="preloadPage"&&Ot(At,y.ON_SHOW)}catch(sn){console.error(sn.message+y.LINEFEED+sn.stack)}}}function In(ze,nt){ot(nt,ze.$renderjs,ze["$"+y.RENDERJS_MODULES])}function ot(ze,nt,At={}){if(!R.isArray(nt))return;let Qt=ze.uid,Tn=ze.$wxsModules||(ze.$wxsModules=[]),sn=ze.ctx;nt.forEach(or=>{At[or]&&(sn[or]=z(Qt,At[or],or),Tn.push(or))})}function z(ze,nt,At){let Qt={};return new Proxy(Qt,{get(Tn,sn){return Qt[sn]||(Qt[sn]=J(ze,nt,At,sn))}})}function J(ze,nt,At,Qt){let Tn=()=>{},sn=()=>y.WXS_PROTOCOL+JSON.stringify([ze,nt,At+"."+Qt]);return new Proxy(Tn,{get(or,Wn){return Wn==="toJSON"?sn:Tn[Wn]||(Tn[Wn]=J(ze,nt,At+"."+Qt,Wn))},apply(or,Wn,An){return y.WXS_PROTOCOL+JSON.stringify([ze,nt,At+"."+Qt,[...An]])}})}function hn(ze,nt){ot(nt,ze.$wxs,ze["$"+y.WXS_MODULES])}function un(ze,nt,At){hn(ze,nt),In(ze,nt),wt(ze,nt,At)}function yn(ze,nt,At){return ze[nt]=At}function Jn(ze,...nt){let At=this[ze];return At?At(...nt):(console.error(`method ${ze} not found`),null)}function gi(ze){return function(At,Qt,Tn){if(!Qt)throw At;let sn=ze._instance;if(!sn||!sn.proxy)throw At;Ot(sn.proxy,y.ON_ERROR,At)}}function pi(ze,nt){return ze?[...new Set([].concat(ze,nt))]:nt}function qr(ze){y.UniLifecycleHooks.forEach(nt=>{ze[nt]=pi})}let gr,Sn="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",pr=/^(?:[A-Za-z\d+/]{4})*?(?:[A-Za-z\d+/]{2}(?:==)?|[A-Za-z\d+/]{3}=?)?$/;typeof atob!="function"?gr=function(ze){if(ze=String(ze).replace(/[\t\n\f\r ]+/g,""),!pr.test(ze))throw new Error("Failed to execute 'atob' on 'Window': The string to be decoded is not correctly encoded.");ze+="==".slice(2-(ze.length&3));for(var nt,At="",Qt,Tn,sn=0;sn<ze.length;)nt=Sn.indexOf(ze.charAt(sn++))<<18|Sn.indexOf(ze.charAt(sn++))<<12|(Qt=Sn.indexOf(ze.charAt(sn++)))<<6|(Tn=Sn.indexOf(ze.charAt(sn++))),At+=Qt===64?String.fromCharCode(nt>>16&255):Tn===64?String.fromCharCode(nt>>16&255,nt>>8&255):String.fromCharCode(nt>>16&255,nt>>8&255,nt&255);return At}:gr=atob;function Lr(ze){return decodeURIComponent(gr(ze).split("").map(function(nt){return"%"+("00"+nt.charCodeAt(0).toString(16)).slice(-2)}).join(""))}function Jr(){let ze=s.getStorageSync("uni_id_token")||"",nt=ze.split(".");if(!ze||nt.length!==3)return{uid:null,role:[],permission:[],tokenExpired:0};let At;try{At=JSON.parse(Lr(nt[1]))}catch(Qt){throw new Error("\u83B7\u53D6\u5F53\u524D\u7528\u6237\u4FE1\u606F\u51FA\u9519\uFF0C\u8BE6\u7EC6\u9519\u8BEF\u4FE1\u606F\u4E3A\uFF1A"+Qt.message)}return At.tokenExpired=At.exp*1e3,delete At.exp,delete At.iat,At}function vi(ze){ze.uniIDHasRole=function(nt){let{role:At}=Jr();return At.indexOf(nt)>-1},ze.uniIDHasPermission=function(nt){let{permission:At}=Jr();return this.uniIDHasRole("admin")||At.indexOf(nt)>-1},ze.uniIDTokenValid=function(){let{tokenExpired:nt}=Jr();return nt>Date.now()}}function Pn(ze){let nt=ze._context.config;nt.errorHandler=y.invokeCreateErrorHandler(ze,gi),qr(nt.optionMergeStrategies);let At=nt.globalProperties;vi(At),At.$set=yn,At.$applyOptions=un,At.$callMethod=Jn,y.invokeCreateVueAppHook(ze)}return h.initApp=Pn,Object.defineProperty(h,"__esModule",{value:!0}),h}({},p,N,w);return E}function eu(f,{nvue:s,UniShared:p,VueShared:w,VueReactivity:N}){let E={platform:s.config.env.platform,UniShared:p,VueShared:w,VueReactivity:N};return f(E,s.document)}function OI({setTimeout:f,clearTimeout:s,uni:p,getCurrentPages:w,Vue:N,weex:E,plus:h,BroadcastChannel:y,UniViewJSBridge:R,VueShared:Fe,UniShared:It,__uniConfig:Vt}){var Ot=function(P,wt,In){"use strict";let ot=["navigate","redirect","switchTab","reLaunch","navigateBack"],z=["slide-in-right","slide-in-left","slide-in-top","slide-in-bottom","fade-in","zoom-out","zoom-fade-out","pop-in","none"],J=["slide-out-right","slide-out-left","slide-out-top","slide-out-bottom","fade-out","zoom-in","zoom-fade-in","pop-out","none"],hn={hoverClass:{type:String,default:"navigator-hover"},url:{type:String,default:""},openType:{type:String,default:"navigate",validator(v){return Boolean(~ot.indexOf(v))}},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(v){return!v||z.concat(J).includes(v)}},animationDuration:{type:[String,Number],default:300}};function un(v){return()=>{if(v.openType!=="navigateBack"&&!v.url){console.error("<navigator/> should have url attribute when using navigateTo, redirectTo, reLaunch or switchTab");return}let x=parseInt(v.animationDuration);switch(v.openType){case"navigate":p.navigateTo({url:v.url,animationType:v.animationType||"pop-in",animationDuration:x});break;case"redirect":p.redirectTo({url:v.url,exists:v.exists});break;case"switchTab":p.switchTab({url:v.url});break;case"reLaunch":p.reLaunch({url:v.url});break;case"navigateBack":p.navigateBack({delta:v.delta,animationType:v.animationType||"pop-out",animationDuration:x});break}}}function yn(v){if(v.hoverClass&&v.hoverClass!=="none"){let x={hoverClass:v.hoverClass};return wt.hasOwn(v,"hoverStartTime")&&(x.hoverStartTime=v.hoverStartTime),wt.hasOwn(v,"hoverStayTime")&&(x.hoverStayTime=v.hoverStayTime),wt.hasOwn(v,"hoverStopPropagation")&&(x.hoverStopPropagation=v.hoverStopPropagation),x}return{}}function Jn(v,x){return P.createElementVNode("u-text",wt.extend({appendAsTree:!0},x),v)}let gi=[{"navigator-hover":{"":{backgroundColor:"rgba(0,0,0,0.1)",opacity:.7}}}],pi=P.defineComponent({name:"Navigator",props:hn,styles:gi,setup(v,{slots:x}){let $=un(v);return()=>P.createVNode("view",P.mergeProps(yn(v),{onClick:$}),[x.default&&x.default()])}});function qr(v){return Symbol(v)}function gr(){let v;try{v=P.getCurrentInstance().root.proxy.$page.id}catch(x){let $=h.webview.currentWebview().id;v=isNaN(Number($))?$:Number($)}return v}let Sn,pr,Lr;function Jr(){return typeof window=="object"&&typeof navigator=="object"&&typeof document=="object"?"webview":"v8"}function vi(){return Sn.webview.currentWebview().id}let Pn,ze,nt={};function At(v){let x=v.data&&v.data.__message;if(!x||!x.__page)return;let $=x.__page,U=nt[$];U&&U(x),x.keep||delete nt[$]}function Qt(v,x){Jr()==="v8"?Lr?(Pn&&Pn.close(),Pn=new Lr(vi()),Pn.onmessage=At):ze||(ze=pr.requireModule("globalEvent"),ze.addEventListener("plusMessage",At)):window.__plusMessage=At,nt[v]=x}class Tn{constructor(x){this.webview=x}sendMessage(x){let $=JSON.parse(JSON.stringify({__message:{data:x}})),U=this.webview.id;Lr?new Lr(U).postMessage($):Sn.webview.postMessageToUniNView&&Sn.webview.postMessageToUniNView($,U)}close(){this.webview.close()}}function sn({context:v={},url:x,data:$={},style:U={},onMessage:Z,onClose:q}){let te=Vt.darkmode;Sn=v.plus||h,pr=v.weex||(typeof E=="object"?E:null),Lr=v.BroadcastChannel||(typeof y=="object"?y:null);let ce={autoBackButton:!0,titleSize:"17px"},pe=`page${Date.now()}`;U=wt.extend({},U),U.titleNView!==!1&&U.titleNView!=="none"&&(U.titleNView=wt.extend(ce,U.titleNView));let Ie={top:0,bottom:0,usingComponents:{},popGesture:"close",scrollIndicator:"none",animationType:"pop-in",animationDuration:200,uniNView:{path:`/${x}.js`,defaultFontSize:16,viewport:Sn.screen.resolutionWidth}};U=wt.extend(Ie,U);let fe=Sn.webview.create("",pe,U,{extras:{from:vi(),runtime:Jr(),data:wt.extend({},$,{darkmode:te}),useGlobalEvent:!Lr}});return fe.addEventListener("close",q),Qt(pe,Ce=>{wt.isFunction(Z)&&Z(Ce.data),Ce.keep||fe.close("auto")}),fe.show(U.animationType,U.animationDuration),new Tn(fe)}let or={for:{type:String,default:""}},Wn=qr("ul");function An(){let v=[];return P.provide(Wn,{addHandler(x){v.push(x)},removeHandler(x){v.splice(v.indexOf(x),1)}}),v}let gn=P.defineComponent({name:"Label",props:or,styles:[],setup(v,{slots:x}){let $=gr(),U=An(),Z=q=>{v.for?R.emit(`uni-label-click-${$}-${v.for}`,q,!0):U.length&&U[0](q,!0)};return()=>P.createVNode("view",{onClick:Z},[x.default&&x.default()])}});function wr(v,x){Kr(v.id,x),P.watch(()=>v.id,($,U)=>{wo(U,x,!0),Kr($,x,!0)}),P.onUnmounted(()=>{wo(v.id,x)})}function Kr(v,x,$){let U=gr();$&&!v||!wt.isPlainObject(x)||Object.keys(x).forEach(Z=>{$?Z.indexOf("@")!==0&&Z.indexOf("uni-")!==0&&R.on(`uni-${Z}-${U}-${v}`,x[Z]):Z.indexOf("uni-")===0?R.on(Z,x[Z]):v&&R.on(`uni-${Z}-${U}-${v}`,x[Z])})}function wo(v,x,$){let U=gr();$&&!v||!wt.isPlainObject(x)||Object.keys(x).forEach(Z=>{$?Z.indexOf("@")!==0&&Z.indexOf("uni-")!==0&&R.off(`uni-${Z}-${U}-${v}`,x[Z]):Z.indexOf("uni-")===0?R.off(Z,x[Z]):v&&R.off(`uni-${Z}-${U}-${v}`,x[Z])})}function da(v){return Object.keys(v).map(x=>[x,v[x]])}let Ui=["class","style"],Zo=/^on[A-Z]+/,Xo=(v={})=>{let{excludeListeners:x=!1,excludeKeys:$=[]}=v,U=P.getCurrentInstance(),Z=P.shallowRef({}),q=P.shallowRef({}),te=P.shallowRef({}),ce=$.concat(Ui);return U.attrs=P.reactive(U.attrs),P.watchEffect(()=>{let pe=da(U.attrs).reduce((Ie,[fe,Ce])=>(ce.includes(fe)?Ie.exclude[fe]=Ce:Zo.test(fe)?(x||(Ie.attrs[fe]=Ce),Ie.listeners[fe]=Ce):Ie.attrs[fe]=Ce,Ie),{exclude:{},attrs:{},listeners:{}});Z.value=pe.attrs,q.value=pe.listeners,te.value=pe.exclude}),{$attrs:Z,$listeners:q,$excludeAttrs:te}},$i={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}},ri=qr("uf"),Co=[{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)"}}}],Ao={default:"d",primary:"p",warn:"w"},Oo=P.defineComponent({inheritAttrs:!1,name:"Button",props:wt.extend($i,{type:{type:String,default:"default"},size:{type:String,default:"default"}}),styles:Co,setup(v,{slots:x,attrs:$}){let{$attrs:U,$excludeAttrs:Z,$listeners:q}=Xo({excludeListeners:!0}),te=v.type,ce=P.ref(null),pe=P.inject(ri,!1),Ie=(yt,je)=>{let Mt=q.value.onClick||(()=>{});if(v.disabled)return;Mt(yt);let dn=v.formType;if(dn){if(!pe)return;dn==="submit"?pe.submit(yt):dn==="reset"&&pe.reset(yt)}},fe=yt=>{let je="ub-"+Ao[te]+yt;return v.disabled&&(je+="-d"),v.plain&&(je+="-plain"),v.size==="mini"&&yt==="-t"&&(je+=" ub-mini"),je},Ce=yt=>{if(v.disabled)return"";let je="ub-"+Ao[te]+yt+"-hover";return v.plain&&(je+="-plain"),je},ct=P.inject(Wn,!1);ct&&(ct.addHandler(Ie),P.onBeforeUnmount(()=>{ct.removeHandler(Ie)})),wr(v,{"label-click":Ie});let gt=P.computed(()=>{let yt={};for(let je in q.value){let Mt=q.value[je];je!=="onClick"&&(yt[je]=Mt)}return yt}),Ht=()=>{if(!x.default)return[];let yt=x.default();return yt.length===1&&yt[0].type===P.Text?[Jn(yt[0].children,{class:"ub-t "+fe("-t")})]:yt};return()=>{let yt=wt.extend({},yn(v),{hoverClass:Ce("")},U.value,Z.value,gt.value);return P.createVNode("view",P.mergeProps({ref:ce,class:["ub",fe("")],onClick:Ie},yt),[v.loading?P.createVNode("loading-indicator",P.mergeProps({class:["ub-loading",`ub-${Ao[te]}-loading`]},{arrow:"false",animating:"true"}),null):null,...Ht()])}}}),Xi={scaleArea:{type:Boolean,default:!1}};function mi(v){let x=[];return wt.isArray(v)&&v.forEach($=>{P.isVNode($)?$.type===P.Fragment?x.push(...mi($.children)):x.push($):wt.isArray($)&&x.push(...mi($))}),x}function To(v){let x=Object.create(null);return function(U){return x[U]||(x[U]=v(U))}}let uo=To(function(v){let x={},$=/;(?![^(]*\))/g,U=/:(.+)/;return v.split($).forEach(function(Z){if(Z){let q=Z.split(U);q.length>1&&(x[q[0].trim()]=q[1].trim())}}),x}),kn=v=>new Promise((x,$)=>{if(!v)return x({width:0,height:0,top:0,left:0});E.requireModule("dom").getComponentRect(v,({size:Z})=>{x(Z)})}),Cr=P.defineComponent({name:"MovableArea",props:Xi,styles:[{"uni-movable-area":{"":{overflow:"hidden",width:"10px",height:"10px"}}}],setup(v,{slots:x}){let $=P.ref(0),U=P.ref(0),Z=P.ref(0),q=P.ref(0),te=P.ref(!1),ce=P.ref(null),pe=[],Ie=null,fe=je=>{Ie=je},Ce=()=>kn(ce.value).then(({width:je,height:Mt,top:dn,left:Gt})=>{$.value=je,U.value=Mt,Z.value=dn,q.value=Gt}),ct=()=>{Ce().then(()=>{pe.forEach(function(je){je.setParent()})})};P.onMounted(()=>{f(()=>{te.value=!0,ct()},200)});let gt={onPanstart(je){Ie&&Ie.touchstart(je)},onPanmove(je){je.stopPropagation(),Ie&&Ie.touchmove(je)},onPanend(je){Ie&&Ie.touchend(je),Ie=null}},Ht=je=>{pe.push(je)},yt=je=>{let Mt=pe.indexOf(je);Mt>=0&&pe.splice(Mt,1)};return P.provide("_isMounted",te),P.provide("parentSize",{width:$,height:U,top:Z,left:q}),P.provide("addMovableViewContext",Ht),P.provide("removeMovableViewContext",yt),P.provide("setTouchMovableViewContext",fe),()=>{let je=x.default&&x.default(),Mt=mi(je);return P.createVNode("view",P.mergeProps({ref:ce,class:"uni-movable-area"},gt),[Mt])}}});function Qi(v){let x={};function $(fe,Ce){x[fe]&&x[fe](Ce)}function U(fe,Ce){x[fe]=function(ct){wt.isFunction(Ce)&&(ct.touches=ct.changedTouches,Ce(ct)===!1&&ct.stopPropagation())}}let Z=0,q=0,te=0,ce=0,pe=function(fe,Ce,ct,gt){if(v({target:fe.target,currentTarget:fe.currentTarget,stopPropagation:fe.stopPropagation.bind(fe),touches:fe.touches,changedTouches:fe.changedTouches,detail:{state:Ce,x:ct,y:gt,dx:ct-Z,dy:gt-q,ddx:ct-te,ddy:gt-ce,timeStamp:fe.timeStamp||Date.now()}})===!1)return!1},Ie=null;return U("touchstart",function(fe){if(!Ie)return Ie=fe,Z=te=fe.touches[0].pageX,q=ce=fe.touches[0].pageY,pe(fe,"start",Z,q)}),U("touchmove",function(fe){if(Ie){let Ce=pe(fe,"move",fe.touches[0].pageX,fe.touches[0].pageY);return te=fe.touches[0].pageX,ce=fe.touches[0].pageY,Ce}}),U("touchend",function(fe){if(Ie)return Ie=null,pe(fe,"end",fe.changedTouches[0].pageX,fe.changedTouches[0].pageY)}),{touchstart:function(fe){$("touchstart",fe)},touchmove:function(fe){$("touchmove",fe)},touchend:function(fe){$("touchend",fe)}}}function Kn(v,x){return($,U)=>{v.value&&x($,eo($,v.value,U||{}))}}function eo(v,x,$={}){return x=fo(x),{type:v,timeStamp:Date.now(),target:x,currentTarget:x,detail:$}}let Po=In.cacheStringFunction(v=>v.charAt(0).toLowerCase()+v.slice(1));function fo(v){let{offsetLeft:x,offsetTop:$}=v,U=v.attr,Z={};return Object.keys(U||{}).forEach(q=>{q.indexOf("data")===0&&(Z[Po(q.replace("data",""))]=U[q])}),{id:U&&U.id||"",dataset:Z,offsetLeft:x||0,offsetTop:$||0}}function ii(v,x,$){return v>x-$&&v<x+$}function ar(v,x){return ii(v,0,x)}function kr(){}kr.prototype.x=function(v){return Math.sqrt(v)};function Nn(v,x){this._m=v,this._f=1e3*x,this._startTime=0,this._v=0}Nn.prototype.setV=function(v,x){let $=Math.pow(Math.pow(v,2)+Math.pow(x,2),.5);this._x_v=v,this._y_v=x,this._x_a=-this._f*this._x_v/$,this._y_a=-this._f*this._y_v/$,this._t=Math.abs(v/this._x_a)||Math.abs(x/this._y_a),this._lastDt=null,this._startTime=new Date().getTime()},Nn.prototype.setS=function(v,x){this._x_s=v,this._y_s=x},Nn.prototype.s=function(v){v===void 0&&(v=(new Date().getTime()-this._startTime)/1e3),v>this._t&&(v=this._t,this._lastDt=v);let x=this._x_v*v+.5*this._x_a*Math.pow(v,2)+this._x_s,$=this._y_v*v+.5*this._y_a*Math.pow(v,2)+this._y_s;return(this._x_a>0&&x<this._endPositionX||this._x_a<0&&x>this._endPositionX)&&(x=this._endPositionX),(this._y_a>0&&$<this._endPositionY||this._y_a<0&&$>this._endPositionY)&&($=this._endPositionY),{x,y:$}},Nn.prototype.ds=function(v){return v===void 0&&(v=(new Date().getTime()-this._startTime)/1e3),v>this._t&&(v=this._t),{dx:this._x_v+this._x_a*v,dy:this._y_v+this._y_a*v}},Nn.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}},Nn.prototype.dt=function(){return-this._x_v/this._x_a},Nn.prototype.done=function(){let v=ii(this.s().x,this._endPositionX)||ii(this.s().y,this._endPositionY)||this._lastDt===this._t;return this._lastDt=null,v},Nn.prototype.setEnd=function(v,x){this._endPositionX=v,this._endPositionY=x},Nn.prototype.reconfigure=function(v,x){this._m=v,this._f=1e3*x};function Zn(v,x,$){this._m=v,this._k=x,this._c=$,this._solution=null,this._endPosition=0,this._startTime=0}Zn.prototype._solve=function(v,x){let $=this._c,U=this._m,Z=this._k,q=$*$-4*U*Z;if(q===0){let fe=-$/(2*U),Ce=v,ct=x/(fe*v);return{x:function(gt){return(Ce+ct*gt)*Math.pow(Math.E,fe*gt)},dx:function(gt){let Ht=Math.pow(Math.E,fe*gt);return fe*(Ce+ct*gt)*Ht+ct*Ht}}}if(q>0){let fe=(-$-Math.sqrt(q))/(2*U),Ce=(-$+Math.sqrt(q))/(2*U),ct=(x-fe*v)/(Ce-fe),gt=v-ct;return{x:function(Ht){let yt,je;return Ht===this._t&&(yt=this._powER1T,je=this._powER2T),this._t=Ht,yt||(yt=this._powER1T=Math.pow(Math.E,fe*Ht)),je||(je=this._powER2T=Math.pow(Math.E,Ce*Ht)),gt*yt+ct*je},dx:function(Ht){let yt,je;return Ht===this._t&&(yt=this._powER1T,je=this._powER2T),this._t=Ht,yt||(yt=this._powER1T=Math.pow(Math.E,fe*Ht)),je||(je=this._powER2T=Math.pow(Math.E,Ce*Ht)),gt*fe*yt+ct*Ce*je}}}let te=Math.sqrt(4*U*Z-$*$)/(2*U),ce=-$/2*U,pe=v,Ie=(x-ce*v)/te;return{x:function(fe){return Math.pow(Math.E,ce*fe)*(pe*Math.cos(te*fe)+Ie*Math.sin(te*fe))},dx:function(fe){let Ce=Math.pow(Math.E,ce*fe),ct=Math.cos(te*fe),gt=Math.sin(te*fe);return Ce*(Ie*te*ct-pe*te*gt)+ce*Ce*(Ie*gt+pe*ct)}}},Zn.prototype.x=function(v){return v===void 0&&(v=(new Date().getTime()-this._startTime)/1e3),this._solution?this._endPosition+this._solution.x(v):0},Zn.prototype.dx=function(v){return v===void 0&&(v=(new Date().getTime()-this._startTime)/1e3),this._solution?this._solution.dx(v):0},Zn.prototype.setEnd=function(v,x,$){if($||($=new Date().getTime()),v!==this._endPosition||!ar(x,.1)){x=x||0;let U=this._endPosition;this._solution&&(ar(x,.1)&&(x=this._solution.dx(($-this._startTime)/1e3)),U=this._solution.x(($-this._startTime)/1e3),ar(x,.1)&&(x=0),ar(U,.1)&&(U=0),U+=this._endPosition),this._solution&&ar(U-v,.1)&&ar(x,.1)||(this._endPosition=v,this._solution=this._solve(U-this._endPosition,x),this._startTime=$)}},Zn.prototype.snap=function(v){this._startTime=new Date().getTime(),this._endPosition=v,this._solution={x:function(){return 0},dx:function(){return 0}}},Zn.prototype.done=function(v){return v||(v=new Date().getTime()),ii(this.x(),this._endPosition,.1)&&ar(this.dx(),.1)},Zn.prototype.reconfigure=function(v,x,$){this._m=v,this._k=x,this._c=$,this.done()||(this._solution=this._solve(this.x()-this._endPosition,this.dx()),this._startTime=new Date().getTime())},Zn.prototype.springConstant=function(){return this._k},Zn.prototype.damping=function(){return this._c},Zn.prototype.configuration=function(){function v($,U){$.reconfigure(1,U,$.damping())}function x($,U){$.reconfigure(1,$.springConstant(),U)}return[{label:"Spring Constant",read:this.springConstant.bind(this),write:v.bind(this,this),min:100,max:1e3},{label:"Damping",read:this.damping.bind(this),write:x.bind(this,this),min:1,max:500}]};function Ni(v,x,$){this._springX=new Zn(v,x,$),this._springY=new Zn(v,x,$),this._springScale=new Zn(v,x,$),this._startTime=0}Ni.prototype.setEnd=function(v,x,$,U){let Z=new Date().getTime();this._springX.setEnd(v,U,Z),this._springY.setEnd(x,U,Z),this._springScale.setEnd($,U,Z),this._startTime=Z},Ni.prototype.x=function(){let v=(new Date().getTime()-this._startTime)/1e3;return{x:this._springX.x(v),y:this._springY.x(v),scale:this._springScale.x(v)}},Ni.prototype.done=function(){let v=new Date().getTime();return this._springX.done(v)&&this._springY.done(v)&&this._springScale.done(v)},Ni.prototype.reconfigure=function(v,x,$){this._springX.reconfigure(v,x,$),this._springY.reconfigure(v,x,$),this._springScale.reconfigure(v,x,$)};let Hi={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(v,x){return+((1e3*v-1e3*x)/1e3).toFixed(1)}function Fr(v,x,$){let U={id:0,cancelled:!1},Z=function(te){te&&te.id&&Vr(te.id),te&&(te.cancelled=!0)};function q(te,ce,pe,Ie){if(!te||!te.cancelled){pe(ce);let fe=ce.done();fe||te.cancelled||(te.id=Io(q.bind(null,te,ce,pe,Ie))),fe&&Ie&&Ie(ce)}}return q(U,v,x,$),{cancel:Z.bind(null,U),model:v}}let vr=!1;function ki(v){vr||(vr=!0,Io(function(){v(),vr=!1}))}function Io(v){return f(v,16)}function Vr(v){s(v)}let Zr=E.requireModule("animation"),Ar=P.defineComponent({name:"MovableView",props:Hi,emits:["change","scale"],styles:[{"uni-movable-view":{"":{position:"absolute",top:"0px",left:"0px",width:"10px",height:"10px"}}}],setup(v,{emit:x,slots:$}){let U=P.ref(null),Z=Kn(U,x),q=P.inject("setTouchMovableViewContext",()=>{}),te=pn(v,Z,U,q);return()=>{let ce={preventGesture:!0};return P.createVNode("view",P.mergeProps({ref:U,onTouchstart:te,class:"uni-movable-view",style:"transform-origin: center;"},ce),[$.default&&$.default()])}}});function pn(v,x,$,U){let Z=P.inject("_isMounted",P.ref(!1)),q=P.inject("parentSize",{width:P.ref(0),height:P.ref(0),top:P.ref(0),left:P.ref(0)}),te=P.inject("addMovableViewContext",()=>{}),ce=P.inject("removeMovableViewContext",()=>{}),pe={touchstart:()=>{},touchmove:()=>{},touchend:()=>{}};function Ie(xe){return Number(xe)||0}function fe(xe){return xe=Number(xe),isNaN(xe)?1:xe}let Ce=P.ref(Ie(v.x)),ct=P.ref(Ie(v.y)),gt=P.ref(fe(Number(v.scaleValue))),Ht=P.ref(0),yt=P.ref(0),je=P.ref(0),Mt=P.ref(0),dn=P.ref(0),Gt=P.ref(0),dt=null,en=null,Bn={x:0,y:0},Yt={x:0,y:0},jt=1,Ut=0,qt=0,ta=!1,ci,ei,qi=null,ja=null,Un={top:0,left:0,width:0,height:0},$n=new kr,Ir=new kr,Hn={historyX:[0,0],historyY:[0,0],historyT:[0,0]},yr=P.computed(()=>{let xe=Number(v.damping);return isNaN(xe)?20:xe}),zr=P.computed(()=>{let xe=Number(v.friction);return isNaN(xe)||xe<=0?2:xe}),na=P.computed(()=>{let xe=Number(v.scaleMin);return isNaN(xe)?.5:xe}),cs=P.computed(()=>{let xe=Number(v.scaleMax);return isNaN(xe)?10:xe}),on=P.computed(()=>v.direction==="all"||v.direction==="horizontal"),_n=P.computed(()=>v.direction==="all"||v.direction==="vertical"),jn=new Ni(1,9*Math.pow(yr.value,2)/40,yr.value),qn=new Nn(1,zr.value);P.watch(()=>v.x,xe=>{Ce.value=Ie(xe)}),P.watch(()=>v.y,xe=>{ct.value=Ie(xe)}),P.watch(()=>v.scaleValue,xe=>{gt.value=fe(Number(xe))}),P.watch(Ce,us),P.watch(ct,za),P.watch(gt,ra),P.watch(na,Ia),P.watch(cs,Ia);function Ai(){en&&en.cancel(),dt&&dt.cancel()}function us(xe){if(on.value){if(xe+Yt.x===Ut)return Ut;dt&&dt.cancel(),bo(xe+Yt.x,ct.value+Yt.y,jt)}return xe}function za(xe){if(_n.value){if(xe+Yt.y===qt)return qt;dt&&dt.cancel(),bo(Ce.value+Yt.x,xe+Yt.y,jt)}return xe}function Ia(){if(!v.scale)return!1;Di(jt,!0)}function ra(xe){return v.scale?(xe=_o(xe),Di(xe,!0),xe):!1}function so(){v.disabled||(Ai(),Hn.historyX=[0,0],Hn.historyY=[0,0],Hn.historyT=[0,0],on.value&&(ci=Ut),_n.value&&(ei=qt),qi=null,ja=null,ta=!0)}function Wa(xe){if(!v.disabled&&ta){let Nt=Ut,Pt=qt;if(ja===null&&(ja=Math.abs(xe.detail.dx/xe.detail.dy)>1?"htouchmove":"vtouchmove"),on.value&&(Nt=xe.detail.dx+ci,Hn.historyX.shift(),Hn.historyX.push(Nt),!_n.value&&qi===null&&(qi=Math.abs(xe.detail.dx/xe.detail.dy)<1)),_n.value&&(Pt=xe.detail.dy+ei,Hn.historyY.shift(),Hn.historyY.push(Pt),!on.value&&qi===null&&(qi=Math.abs(xe.detail.dy/xe.detail.dx)<1)),Hn.historyT.shift(),Hn.historyT.push(xe.detail.timeStamp),!qi){let wn="touch";Nt<je.value?v.outOfBounds?(wn="touch-out-of-bounds",Nt=je.value-$n.x(je.value-Nt)):Nt=je.value:Nt>dn.value&&(v.outOfBounds?(wn="touch-out-of-bounds",Nt=dn.value+$n.x(Nt-dn.value)):Nt=dn.value),Pt<Mt.value?v.outOfBounds?(wn="touch-out-of-bounds",Pt=Mt.value-Ir.x(Mt.value-Pt)):Pt=Mt.value:Pt>Gt.value&&(v.outOfBounds?(wn="touch-out-of-bounds",Pt=Gt.value+Ir.x(Pt-Gt.value)):Pt=Gt.value),ki(function(){Vo(Nt,Pt,jt,wn)})}}}function fs(){if(!v.disabled&&ta&&(ta=!1,!qi&&!ds("out-of-bounds")&&v.inertia)){let xe=1e3*(Hn.historyX[1]-Hn.historyX[0])/(Hn.historyT[1]-Hn.historyT[0]),Nt=1e3*(Hn.historyY[1]-Hn.historyY[0])/(Hn.historyT[1]-Hn.historyT[0]);qn.setV(xe,Nt),qn.setS(Ut,qt);let Pt=qn.delta().x,wn=qn.delta().y,Er=Pt+Ut,Oi=wn+qt;Er<je.value?(Er=je.value,Oi=qt+(je.value-Ut)*wn/Pt):Er>dn.value&&(Er=dn.value,Oi=qt+(dn.value-Ut)*wn/Pt),Oi<Mt.value?(Oi=Mt.value,Er=Ut+(Mt.value-qt)*Pt/wn):Oi>Gt.value&&(Oi=Gt.value,Er=Ut+(Gt.value-qt)*Pt/wn),qn.setEnd(Er,Oi),en=Fr(qn,function(){let Ji=qn.s(),Uo=Ji.x,Na=Ji.y;Vo(Uo,Na,jt,"friction")},function(){en.cancel()})}}function Wr(xe,Nt){let Pt=!1;return xe>dn.value?(xe=dn.value,Pt=!0):xe<je.value&&(xe=je.value,Pt=!0),Nt>Gt.value?(Nt=Gt.value,Pt=!0):Nt<Mt.value&&(Nt=Mt.value,Pt=!0),{x:xe,y:Nt,outOfBounds:Pt}}function Ga(){Bn.x=Un.left-q.left.value,Bn.y=Un.top-q.top.value}function Ya(xe){xe=xe||jt,xe=_o(xe),yt.value=Un.height/jt,Ht.value=Un.width/jt;let Nt=yt.value*xe,Pt=Ht.value*xe;Yt.x=(Pt-Ht.value)/2,Yt.y=(Nt-yt.value)/2}function Fo(){let xe=0-Bn.x+Yt.x,Nt=q.width.value-Ht.value-Bn.x-Yt.x;je.value=Math.min(xe,Nt),dn.value=Math.max(xe,Nt);let Pt=0-Bn.y+Yt.y,wn=q.height.value-yt.value-Bn.y-Yt.y;Mt.value=Math.min(Pt,wn),Gt.value=Math.max(Pt,wn)}function Di(xe,Nt){if(v.scale){xe=_o(xe),Ya(xe),Fo();let Pt=Wr(Ut,qt),wn=Pt.x,Er=Pt.y;Nt?bo(wn,Er,xe,"",!0,!0):ki(function(){Vo(wn,Er,xe,"",!0,!0)})}}function _o(xe){return xe=Math.max(.5,na.value,xe),xe=Math.min(10,cs.value,xe),xe}function bo(xe,Nt,Pt,wn,Er,Oi){Ai(),on.value||(xe=Ut),_n.value||(Nt=qt),v.scale||(Pt=jt);let Ji=Wr(xe,Nt);if(xe=Ji.x,Nt=Ji.y,!v.animation){Vo(xe,Nt,Pt,wn,Er,Oi);return}jn._springX._solution=null,jn._springY._solution=null,jn._springScale._solution=null,jn._springX._endPosition=Ut,jn._springY._endPosition=qt,jn._springScale._endPosition=jt,jn.setEnd(xe,Nt,Pt,1),dt=Fr(jn,function(){let Uo=jn.x(),Na=Uo.x,ia=Uo.y,gs=Uo.scale;Vo(Na,ia,gs,wn,Er,Oi)},function(){dt.cancel()})}function ds(xe){let Nt=Wr(Ut,qt),Pt=Nt.x,wn=Nt.y,Er=Nt.outOfBounds;return Er&&bo(Pt,wn,jt,xe),Er}function Vo(xe,Nt,Pt,wn="",Er,Oi){xe!==null&&xe.toString()!=="NaN"&&typeof xe=="number"||(xe=Ut||0),Nt!==null&&Nt.toString()!=="NaN"&&typeof Nt=="number"||(Nt=qt||0),xe=Number(xe.toFixed(1)),Nt=Number(Nt.toFixed(1)),Pt=Number(Pt.toFixed(1)),Ut===xe&&qt===Nt||Er||x("change",{x:oi(xe,Yt.x),y:oi(Nt,Yt.y),source:wn}),v.scale||(Pt=jt),Pt=_o(Pt),Pt=+Pt.toFixed(3),Oi&&Pt!==jt&&x("scale",{x:xe,y:Nt,scale:Pt});let Ji=`translate(${xe}px, ${Nt}px) scale(${Pt})`;Zr.transition($.value,{styles:{transform:Ji},duration:0,delay:0}),Ut=xe,qt=Nt,jt=Pt}function xs(){return kn($.value).then(xe=>{Un=xe})}function hs(){if(!Z.value)return;Ai();let xe=v.scale?gt.value:1;Ga(),Ya(xe),Fo(),Ut=Ce.value+Yt.x,qt=ct.value+Yt.y;let Nt=Wr(Ut,qt),Pt=Nt.x,wn=Nt.y;Vo(Pt,wn,xe,"",!0)}return P.onMounted(()=>{pe=Qi(Nt=>{switch(Nt.detail.state){case"start":so();break;case"move":Wa(Nt);break;case"end":fs()}}),f(()=>{xs().then(()=>{hs()})},100),qn.reconfigure(1,zr.value),jn.reconfigure(1,9*Math.pow(yr.value,2)/40,yr.value);let xe={setParent:hs};te(xe),P.onUnmounted(()=>{ce(xe)})}),P.onUnmounted(()=>{Ai()}),()=>{U(pe)}}let Xr=16,Ur={activeColor:In.PRIMARY_COLOR,backgroundColor:"#EBEBEB",activeMode:"backwards"},Dt={percent:{type:[Number,String],default:0,validator(v){return!isNaN(parseFloat(v))}},fontSize:{type:[String,Number],default:Xr},showInfo:{type:[Boolean,String],default:!1},strokeWidth:{type:[Number,String],default:6,validator(v){return!isNaN(parseFloat(v))}},color:{type:String,default:Ur.activeColor},activeColor:{type:String,default:Ur.activeColor},backgroundColor:{type:String,default:Ur.backgroundColor},active:{type:[Boolean,String],default:!1},activeMode:{type:String,default:Ur.activeMode},duration:{type:[Number,String],default:30,validator(v){return!isNaN(parseFloat(v))}},borderRadius:{type:[Number,String],default:0}},Te=[{"uni-progress":{"":{flex:1,flexDirection:"row",alignItems:"center"}},"uni-progress-bar":{"":{flex:1}},"uni-progress-inner-bar":{"":{position:"absolute"}},"uni-progress-info":{"":{marginLeft:"15px"}}}],_i=P.defineComponent({name:"Progress",props:Dt,styles:Te,emits:["activeend"],setup(v,{emit:x}){let $=P.ref(null),U=P.ref(null),Z=Kn($,x),q=bi(v);return P.watch(()=>q.realPercent,(te,ce)=>{q.lastPercent=ce||0,yi(q,v,Z)}),P.onMounted(()=>{f(()=>{kn(U.value).then(({width:te})=>{q.progressWidth=te||0,yi(q,v,Z)})},50)}),()=>{let{showInfo:te,fontSize:ce}=v,{outerBarStyle:pe,innerBarStyle:Ie,currentPercent:fe}=q;return P.createVNode("div",{ref:$,class:"uni-progress"},[P.createVNode("div",{ref:U,style:pe,class:"uni-progress-bar"},[P.createVNode("div",{style:Ie,class:"uni-progress-inner-bar"},null)]),te?Jn(fe+"%",{class:"uni-progress-info",style:{fontSize:ce}}):null])}}});function bi(v){let x=P.ref(0),$=P.ref(0),U=P.computed(()=>({backgroundColor:v.backgroundColor,borderRadius:v.borderRadius,height:v.strokeWidth})),Z=P.computed(()=>{let ce=v.color!==Ur.activeColor&&v.activeColor===Ur.activeColor?v.color:v.activeColor;return{width:x.value*$.value/100,height:v.strokeWidth,backgroundColor:ce,borderRadius:v.borderRadius}}),q=P.computed(()=>{let ce=parseFloat(v.percent);return ce<0&&(ce=0),ce>100&&(ce=100),ce});return P.reactive({outerBarStyle:U,innerBarStyle:Z,realPercent:q,currentPercent:x,strokeTimer:0,lastPercent:0,progressWidth:$})}function yi(v,x,$){v.strokeTimer&&clearInterval(v.strokeTimer),x.active?(v.currentPercent=x.activeMode===Ur.activeMode?0:v.lastPercent,v.strokeTimer=setInterval(()=>{v.currentPercent+1>v.realPercent?(v.currentPercent=v.realPercent,v.strokeTimer&&clearInterval(v.strokeTimer),$("activeend",{})):v.currentPercent+=1},parseFloat(x.duration))):v.currentPercent=v.realPercent}let Or={value:{type:Array,default(){return[]},validator:function(v){return wt.isArray(v)&&v.filter(x=>typeof x=="number").length===v.length}},indicatorStyle:{type:String,default:""},indicatorClass:{type:String,default:""},maskStyle:{type:String,default:""},maskClass:{type:String,default:""}},Ri=wt.extend({},Or,{height:{type:[Number,String],default:0},maskTopStyle:{type:String,default:""},maskBottomStyle:{type:String,default:""}}),Tr=P.defineComponent({name:"PickerView",props:Ri,emits:["change","update:value"],setup(v,{slots:x,emit:$}){let U=P.ref(null),Z=Rr(v),q=Kn(U,$),te=[],ce=Ie=>Array.prototype.indexOf.call(te.filter(fe=>fe.type!==P.Comment),Ie),pe=Ie=>P.computed({get(){let fe=ce(Ie.vnode);return Z.value[fe]||0},set(fe){if(!Ie.data._isMounted)return;let Ce=ce(Ie.vnode);if(Ce<0)return;if(Z.value[Ce]!==fe){Z.value[Ce]=fe;let gt=Z.value.map(Ht=>Ht);$("update:value",gt),q("change",{value:gt})}}});return P.provide("getPickerViewColumn",pe),P.provide("pickerViewProps",v),()=>{let Ie=x.default&&x.default();te=mi(Ie);let fe=v.height?{height:`${parseFloat(v.height)}px`}:{};return P.createVNode("view",P.mergeProps({ref:U,class:"uni-picker-view",style:fe},{preventGesture:!0}),[P.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 Rr(v){let x=P.reactive([...v.value]),$=P.reactive({value:x});return P.watch(()=>v.value,U=>{$.value.length=U.length,P.nextTick(()=>{U.forEach((Z,q)=>{Z!==$.value[q]&&$.value.splice(q,1,Z)})})}),$}let ai=E.requireModule("dom"),Pr=E.config.env.platform.toLowerCase()==="android";function Ei(v){return wt.extend({},wt.isString(v)?uo(v):v)}let fn={length:{type:[Number,String],default:0}},ji=P.defineComponent({name:"PickerViewColumn",props:fn,data:()=>({_isMounted:!1}),setup(v,{slots:x}){let $=P.getCurrentInstance(),U=P.ref(null),Z=P.ref(null),q=P.ref(null),te=P.ref(null),ce=P.inject("pickerViewProps"),Ie=P.inject("getPickerViewColumn")($),fe=P.computed(()=>Ei(ce.indicatorStyle)),Ce=P.computed(()=>Ei(ce.maskTopStyle)),ct=P.computed(()=>Ei(ce.maskBottomStyle)),gt=P.ref(0);gt.value=$r(fe.value);let Ht=P.ref(0);Ht.value=parseFloat(ce.height);let{setCurrent:yt,onScrollend:je}=to(v,Ie,Z,gt),Mt=()=>{let Gt,dt;f(()=>{Promise.all([kn(U.value).then(({height:en})=>{Gt=Ht.value=en}),Pr&&v.length?kn(q.value).then(({height:en})=>{dt=gt.value=en/parseFloat(v.length)}):kn(te.value).then(({height:en})=>{dt=gt.value=en})]).then(()=>{Gt&&dt?f(()=>{$.data._isMounted=!0,yt(Ie.value,!1,!0)},50):Mt()})},50)};P.onMounted(Mt);let dn=Gt=>Gt?Pr?P.createVNode("div",{ref:q,style:"flex-direction:column;"},[Gt]):Gt:null;return()=>{let Gt=x.default&&x.default(),dt=(Ht.value-gt.value)/2,en=`${Ht.value-dt}px`,Bn={showScrollbar:!1,scrollToBegin:!1,decelerationRate:.3,scrollY:!0};return Pr||(Bn.scrollTop=Ie.value*gt.value),P.createVNode("view",{ref:U,class:"uni-picker-view-column"},[P.createVNode("scroll-view",P.mergeProps({class:"uni-picker-view-group",style:"flex-direction:column;",onScrollend:je},Bn),[P.createVNode("view",{ref:Z,class:"uni-picker-view-content",style:{paddingTop:`${dt}px`,paddingBottom:`${dt}px`}},[dn(Gt)])]),P.createVNode("u-scalable",{class:"uni-picker-view-mask"},[P.createVNode("u-scalable",{class:"uni-picker-view-mask uni-picker-view-mask-top",style:wt.extend({},Ce.value,{bottom:en})},null),P.createVNode("u-scalable",{class:"uni-picker-view-mask uni-picker-view-mask-bottom",style:wt.extend({},ct.value,{top:en})},null)]),P.createVNode("u-scalable",{ref:te,class:"uni-picker-view-indicator",style:wt.extend({},fe.value,{top:`${dt}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 $r(v){let $=(v.height||v.lineHeight||"").match(/(-?[\d\.]+)px/),U=0;return $&&(U=parseFloat($[1])),U}function to(v,x,$,U){let Z;function q(pe,Ie=!0){ai.scrollToElement($.value,{offset:pe*U.value,animated:Ie}),Ie&&(Z=Date.now())}P.watch(()=>v.length,()=>{f(()=>{te(x.value,!0,!0)},150)}),P.watch(x,pe=>q(pe));let te=(pe,Ie=!0,fe)=>{x.value===pe&&!fe||(x.value=pe,Pr&&q(pe,Ie))};return{setCurrent:te,onScrollend:pe=>{if(Date.now()-Z<340)return;let Ie=pe.detail.contentOffset.y,fe=Math.round(Ie/U.value);Ie%U.value?te(fe,!0,!0):x.value=fe}}}let En={SELECTOR:"selector",MULTISELECTOR:"multiSelector",TIME:"time",DATE:"date"},Hr={YEAR:"year",MONTH:"month",DAY:"day"};function sr(v){return v>9?v:`0${v}`}function Si(v,x){v=String(v||"");let $=new Date;if(x===En.TIME){let U=v.split(":");U.length===2&&$.setHours(parseInt(U[0]),parseInt(U[1]))}else{let U=v.split("-");U.length===3&&$.setFullYear(parseInt(U[0]),parseInt(String(parseFloat(U[1])-1)),parseInt(U[2]))}return $}function xi(v){if(v.mode===En.TIME)return"00:00";if(v.mode===En.DATE){let x=new Date().getFullYear()-100;switch(v.fields){case Hr.YEAR:return x;case Hr.MONTH:return x+"-01";default:return x+"-01-01"}}return""}function mr(v){if(v.mode===En.TIME)return"23:59";if(v.mode===En.DATE){let x=new Date().getFullYear()+100;switch(v.fields){case Hr.YEAR:return x;case Hr.MONTH:return x+"-12";default:return x+"-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:En.SELECTOR,validator(v){return Object.values(En).indexOf(v)>=0}},fields:{type:String,default:""},start:{type:String,default:xi},end:{type:String,default:mr},disabled:{type:[Boolean,String],default:!1}},er=P.defineComponent({name:"Picker",props:Qr,emits:["change","cancel","columnchange"],setup(v,{slots:x,emit:$}){let U=P.ref(null),Z=Kn(U,$),q=P.ref(null),te=P.ref(null),ce=()=>{let yt=v.value;switch(v.mode){case En.MULTISELECTOR:{wt.isArray(yt)||(yt=[]),wt.isArray(q.value)||(q.value=[]);let je=q.value.length=Math.max(yt.length,v.range.length);for(let Mt=0;Mt<je;Mt++){let dn=Number(yt[Mt]),Gt=Number(q.value[Mt]),dt=isNaN(dn)?isNaN(Gt)?0:Gt:dn;q.value.splice(Mt,1,dt<0?0:dt)}}break;case En.TIME:case En.DATE:q.value=String(yt);break;default:{let je=Number(yt);q.value=je<0?0:je;break}}},pe=yt=>{te.value&&te.value.sendMessage(yt)},Ie=yt=>{let je={event:"cancel"};te.value=sn({url:"__uniapppicker",data:yt,style:{titleNView:!1,animationType:"none",animationDuration:0,background:"rgba(0,0,0,0)",popGesture:"none"},onMessage:Mt=>{let dn=Mt.event;if(dn==="created"){pe(yt);return}if(dn==="columnchange"){delete Mt.event,Z(dn,Mt);return}je=Mt},onClose:()=>{te.value=null;let Mt=je.event;delete je.event,Mt&&Z(Mt,je)}})},fe=yt=>{h.nativeUI[v.mode===En.TIME?"pickTime":"pickDate"](je=>{let Mt=je.date;Z("change",{value:v.mode===En.TIME?`${sr(Mt.getHours())}:${sr(Mt.getMinutes())}`:`${Mt.getFullYear()}-${sr(Mt.getMonth()+1)}-${sr(Mt.getDate())}`})},()=>{Z("cancel",{})},v.mode===En.TIME?{time:Si(v.value,En.TIME)}:{date:Si(v.value,En.DATE),minDate:Si(v.start,En.DATE),maxDate:Si(v.end,En.DATE)})},Ce=yt=>{(yt.mode===En.TIME||yt.mode===En.DATE)&&!yt.fields?fe():(yt.fields=Object.values(Hr).includes(yt.fields)?yt.fields:Hr.DAY,Ie(yt))},ct=yt=>{v.disabled||Ce(wt.extend({},v,{value:q.value,locale:p.getLocale()}))},gt=P.inject(ri,!1),Ht={submit:()=>[v.name,q.value],reset:()=>{switch(v.mode){case En.SELECTOR:q.value=0;break;case En.MULTISELECTOR:wt.isArray(v.value)&&(q.value=v.value.map(yt=>0));break;case En.DATE:case En.TIME:q.value="";break}}};return gt&&(gt.addField(Ht),P.onBeforeUnmount(()=>gt.removeField(Ht))),Object.keys(v).forEach(yt=>{P.watch(()=>v[yt],je=>{let Mt={};Mt[yt]=je,pe(Mt)},{deep:!0})}),P.watch(()=>v.value,ce,{deep:!0}),ce(),()=>P.createVNode("view",{ref:U,onClick:ct},[x.default&&x.default()])}}),tr={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}},Gn=[{"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"}}}],nr=P.defineComponent({name:"USlider",props:tr,styles:Gn,setup(v,{emit:x}){let $=P.ref(null),U=P.ref(null),Z=Kn($,x),q=cr(v),te=ho(v,q,Z);return go(v,q),P.watch(()=>v.value,ce=>{q.sliderValue=Number(ce)}),P.onMounted(()=>{f(()=>{kn(U.value).then(({width:ce,left:pe})=>{q.sliderLeft=pe,q.sliderWidth=ce||0,q.sliderValue=Number(v.value)})},100)}),()=>{let{showValue:ce}=v,{trackTapStyle:pe,trackStyle:Ie,trackActiveStyle:fe,thumbStyle:Ce,sliderValue:ct}=q;return P.createVNode("div",{class:"uni-slider",ref:$},[P.createVNode("div",{class:"uni-slider-wrapper"},[P.createVNode("div",P.mergeProps({class:"uni-slider-tap-area",style:pe},te),[P.createVNode("div",{class:"uni-slider-handle-wrapper",style:Ie,ref:U},[P.createVNode("div",{class:"uni-slider-track",style:fe},null)]),P.createVNode("div",{class:"uni-slider-thumb",style:Ce},null)]),ce?Jn(ct+"",{class:"uni-slider-value"}):null])])}}});function cr(v){let x=P.ref(0),$=P.ref(0),U=P.ref(0),Z=()=>v.backgroundColor!=="#e9e9e9"?v.backgroundColor:v.color!=="#007aff"?v.color:"#007aff",q=()=>v.activeColor!=="#007aff"?v.activeColor:v.selectedColor!=="#e9e9e9"?v.selectedColor:"#e9e9e9",te=()=>{let Ie=Number(v.max),fe=Number(v.min);return(U.value-fe)/(Ie-fe)*$.value},ce=Number(v.blockSize)/2;return P.reactive({sliderLeft:x,sliderWidth:$,sliderValue:U,sliderThumbOffset:ce,trackTapStyle:P.computed(()=>({paddingTop:ce,paddingBottom:ce})),trackStyle:P.computed(()=>({backgroundColor:Z(),marginLeft:ce,marginRight:ce})),trackActiveStyle:P.computed(()=>({backgroundColor:q(),width:te()})),thumbStyle:P.computed(()=>({width:v.blockSize,height:v.blockSize,backgroundColor:v.blockColor,left:te()}))})}function ho(v,x,$){let U=null;function Z(ce,pe){v.disabled||(ce==="move"?(q(pe),$("changing",{value:x.sliderValue})):ce==="end"&&(q(pe),$("change",{value:x.sliderValue})))}function q(ce){ce-=x.sliderThumbOffset,ce<0&&(ce=0),ce>x.sliderWidth&&(ce=x.sliderWidth);let pe=Number(v.max),Ie=Number(v.min),fe=Number(v.step),Ce=ce/x.sliderWidth*(pe-Ie);fe>0&&Ce>fe&&Ce%fe/fe!==0?Ce-=Ce%fe:Ce=parseInt(Ce+""),x.sliderValue=Ce+Ie}return{onTouchstart(ce){ce.changedTouches.length===1&&!U&&(U=ce,Z("start",ce.changedTouches[0].pageX))},onTouchmove(ce){ce.changedTouches.length===1&&U&&Z("move",ce.changedTouches[0].pageX)},onTouchend(ce){ce.changedTouches.length===1&&U&&(U=null,Z("end",ce.changedTouches[0].pageX))}}}function go(v,x){let $=P.inject(ri,!1),U={submit:()=>{let Z=["",null];return v.name&&(Z[0]=v.name,Z[1]=x.sliderValue),Z},reset:()=>{x.sliderValue=Number(v.value)}};$&&($.addField(U),P.onUnmounted(()=>{$.removeField(U)}))}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=P.defineComponent({name:"Switch",props:No,emits:["change"],setup(v,{emit:x}){let $=P.ref(null),U=P.ref(v.checked),Z=xr(v,U),q=Kn($,x);P.watch(()=>v.checked,ce=>{U.value=ce});let te=(ce,pe)=>{v.disabled||(U.value=ce.detail?ce.detail.value:!U.value,q("change",{value:U.value}))};return Z&&(Z.addHandler(te),P.onBeforeUnmount(()=>{Z.removeHandler(te)})),wr(v,{"label-click":te}),()=>{let{color:ce,type:pe,disabled:Ie}=v;return P.createVNode("div",{ref:$},[pe===no.switch?P.createVNode("dc-switch",P.mergeProps({dataUncType:"uni-switch"},{onChange:te},{checked:U.value,color:ce,disabled:Ie},{style:ko}),null):null,pe===no.checkbox?P.createVNode(P.resolveComponent("checkbox"),P.mergeProps({style:{color:ce}},{checked:U.value,disabled:Ie},{onClick:te}),null):null])}}});function xr(v,x){let $=P.inject(ri,!1),U=P.inject(Wn,!1),Z={submit:()=>{let q=["",null];return v.name&&(q[0]=v.name,q[1]=x.value),q},reset:()=>{x.value=!1}};return $&&($.addField(Z),P.onUnmounted(()=>{$.removeField(Z)})),U}let po={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:""}},Ro=qr("ucg"),ro={name:{type:String,default:""}},Bi=[{"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"}}}],vo=P.defineComponent({name:"Checkbox",props:po,styles:Bi,setup(v,{slots:x}){let $=P.ref(null),U=P.ref(v.checked),Z=P.ref(v.value),q=P.computed(()=>v.disabled?"#adadad":v.color),te=()=>{U.value=!1},ce=(Ce,ct)=>{v.disabled||(U.value=!U.value,pe&&pe.checkboxChange(Ce))},{uniCheckGroup:pe,uniLabel:Ie}=Mi(U,Z,te);Ie&&(Ie.addHandler(ce),P.onBeforeUnmount(()=>{Ie.removeHandler(ce)})),wr(v,{"label-click":ce}),P.watch([()=>v.checked,()=>v.value],([Ce,ct])=>{U.value=Ce,Z.value=ct});let fe=()=>{if(!x.default)return[];let Ce=x.default();return Ce.length===1&&Ce[0].type===Text?[Jn(Ce[0].children,{class:"uni-checkbox-slot"})]:Ce};return()=>P.createVNode("div",P.mergeProps({ref:$},{dataUncType:"uni-checkbox"},{onClick:ce,class:"uni-checkbox"}),[P.createVNode("div",{class:["uni-checkbox-input",{"uni-checkbox-input-disabled":v.disabled}]},[U.value?Jn("\uEA08",{class:"uni-icon",style:{color:q.value}}):null]),...fe()])}});function Mi(v,x,$){let U=P.computed(()=>({checkboxChecked:Boolean(v.value),value:x.value})),Z={reset:$},q=P.inject(Ro,!1);q&&q.addField(U);let te=P.inject(ri,!1);te&&te.addField(Z);let ce=P.inject(Wn,!1);return P.onBeforeUnmount(()=>{q&&q.removeField(U),te&&te.removeField(Z)}),{uniCheckGroup:q,uniForm:te,uniLabel:ce}}let zi=P.defineComponent({name:"CheckboxGroup",props:ro,emits:["change"],setup(v,{slots:x,emit:$}){let U=P.ref(null),Z=Kn(U,$);return Qo(v,Z),()=>P.createVNode("div",{ref:U,class:"uni-checkbox-group"},[x.default&&x.default()])}});function Qo(v,x){let $=[],U=()=>$.reduce((q,te)=>(te.value.checkboxChecked&&q.push(te.value.value),q),new Array);P.provide(Ro,{addField(q){$.push(q)},removeField(q){$.splice($.indexOf(q),1)},checkboxChange(q){x("change",{value:U()})}});let Z=P.inject(ri,!1);return Z&&Z.addField({submit:()=>{let q=["",null];return v.name!==""&&(q[0]=v.name,q[1]=U()),q}}),U}let B={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=qr("ucg"),he={name:{type:String,default:""}},ae=[{"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=P.defineComponent({name:"Radio",props:B,styles:ae,emits:["change"],setup(v,{slots:x}){let $=P.ref(null),U=P.ref(v.checked),Z=P.ref(v.value),q=P.computed(()=>{let ct=v.disabled?"#adadad":v.color;return U.value?{backgroundColor:ct,borderColor:ct}:{borderColor:"#d1d1d1"}}),te=()=>{U.value=!1},{uniCheckGroup:ce,uniLabel:pe,field:Ie}=vt(U,Z,te),fe=(ct,gt)=>{v.disabled||U.value||(U.value=!U.value,ce&&ce.radioChange(ct,Ie))};pe&&(pe.addHandler(fe),P.onBeforeUnmount(()=>{pe.removeHandler(fe)})),wr(v,{"label-click":fe}),P.watch([()=>v.checked,()=>v.value],([ct,gt])=>{U.value=ct,Z.value=gt});let Ce=()=>{if(!x.default)return[];let ct=x.default();return ct.length===1&&ct[0].type===Text?[Jn(ct[0].children,{class:"uni-radio-slot"})]:ct};return()=>{let{disabled:ct}=v;return P.createVNode("div",P.mergeProps({ref:$},{dataUncType:"uni-radio"},{onClick:fe,class:"uni-radio"}),[P.createVNode("div",{style:q.value,class:["uni-radio-input",{"uni-radio-input-disabled":ct}]},[U.value?Jn("\uEA08",{class:"uni-radio-input-icon"}):null]),...Ce()])}}});function vt(v,x,$){let U=P.computed({get:()=>({radioChecked:Boolean(v.value),value:x.value}),set:({radioChecked:pe})=>{v.value=pe}}),Z={reset:$},q=P.inject(Q,!1);q&&q.addField(U);let te=P.inject(ri,!1);te&&te.addField(Z);let ce=P.inject(Wn,!1);return P.onBeforeUnmount(()=>{q&&q.removeField(U),te&&te.removeField(Z)}),{uniCheckGroup:q,uniForm:te,uniLabel:ce,field:U}}let kt=P.defineComponent({name:"RadioGroup",props:he,emits:["change"],setup(v,{slots:x,emit:$}){let U=P.ref(null),Z=Kn(U,$);return X(v,Z),()=>P.createVNode("div",{ref:U},[x.default&&x.default()])}});function X(v,x){let $=[];P.onMounted(()=>{ce($.length-1)});let U=()=>{var pe;return(pe=$.find(Ie=>Ie.value.radioChecked))==null?void 0:pe.value.value};P.provide(Q,{addField(pe){$.push(pe)},removeField(pe){$.splice($.indexOf(pe),1)},radioChange(pe,Ie){let fe=$.indexOf(Ie);ce(fe,!0),x("change",{value:U()})}});let Z=P.inject(ri,!1),q={submit:()=>{let pe=["",null];return v.name!==""&&(pe[0]=v.name,pe[1]=U()),pe}};Z&&(Z.addField(q),P.onBeforeUnmount(()=>{Z.removeField(q)}));function te(pe,Ie){pe.value={radioChecked:Ie,value:pe.value.value}}function ce(pe,Ie){$.forEach((fe,Ce)=>{Ce!==pe&&Ie&&te($[Ce],!1)})}return $}let K=["u-input","u-textarea"],ie=P.defineComponent({name:"Form",emits:["submit","reset"],setup({},{slots:v,emit:x}){let $=P.ref(null),U=Kn($,x),Z=[],q;return P.provide(ri,{addField(te){Z.push(te)},removeField(te){Z.splice(Z.indexOf(te),1)},submit(te){let ce={};q&&q(ce);let pe=Z.reduce((Ie,fe)=>{if(fe.submit){let[Ce,ct]=fe.submit();Ce&&(Ie[Ce]=ct)}return Ie},Object.create(null));Object.assign(ce,pe),U("submit",{value:ce})},reset(te){q&&q(),Z.forEach(ce=>ce.reset&&ce.reset()),U("reset",te)}}),()=>{let te=v.default&&v.default();return q=Ne(te),P.createVNode("view",{ref:$},[te])}}});function Ne(v){let x=E.requireModule("plus"),$=(U,Z)=>{(Z||v||[]).forEach(function(q){K.indexOf(String(q.type))>=0&&q.el&&q.el.attr&&q.el.attr.name&&(U?U[q.el.attr.name]=x.getValue(q.el.nodeId):q.el.setValue("")),wt.isArray(q.children)&&q.children&&q.children.length&&$(U,q.children)})};return $}let st={type:{type:String,default:""},size:{type:[String,Number],default:23},color:{type:String,default:""}},Xt={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"},xn={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"},Dn=[{"uni-icon":{"":{fontFamily:"unincomponents"}}}],_r=P.defineComponent({name:"Icon",props:st,styles:Dn,setup(v,{}){return()=>Jn(xn[v.type],{class:"uni-icon",style:{color:v.color||Xt[v.type],fontSize:v.size}})}}),Br={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}},mo=E.config.env.platform.toLowerCase()==="android",xo=[{"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"}}}],Bo=P.defineComponent({name:"Swiper",props:Br,styles:xo,emits:["change","transition","animationfinish"],setup(v,{slots:x,emit:$}){let U=P.ref(null),Z=[],q=Kn(U,$),te=Ln(v),ce=Yn(te,v,Z,q);return P.watch([()=>v.current,()=>v.currentItemId],([pe,Ie])=>{Fn(te,v,Z)}),P.onMounted(()=>{f(()=>{kn(U.value).then(({width:pe,height:Ie})=>{te.swiperWidth=pe,te.swiperHeight=Ie})},50)}),()=>{let pe=x.default&&x.default(),{indicatorStyle:Ie,currentSync:fe}=te;return Z=mi(pe),P.createVNode("div",{ref:U,class:"uni-swiper"},[P.createVNode("slider",P.mergeProps({class:"uni-swiper-slider"},{autoPlay:v.autoplay,interval:v.interval,index:fe,keepIndex:!0,showIndicators:v.indicatorDots,infinite:v.circular,vertical:v.vertical,scrollable:!v.disableTouch},ce),[Z,P.createVNode("indicator",{class:"uni-swiper-dots",style:Ie},null)])])}}});function Ln(v){let x=P.ref(0),$=P.ref(0),U=P.ref(v.current),Z=P.ref("autoplay"),q=P.computed(()=>({itemColor:v.indicatorColor,itemSelectedColor:v.indicatorActiveColor,itemSize:8,opacity:v.indicatorDots?1:0}));return P.reactive({swiperWidth:x,swiperHeight:$,indicatorStyle:q,currentSync:U,currentChangeSource:Z})}function Yn(v,x,$,U){let Z=0,q=fe=>{let Ce=fe.detail,ct=x.vertical,gt=(ct?Ce.offsetYRatio:Ce.offsetXRatio)||0;if((fe.drag||fe.drag)&&(v.currentChangeSource="touch"),gt===0){let Ht=Math.abs(Z);if(Ht===1)return;Ht>.5&&(gt=1)}Z=gt,U("transition",{dx:ct?0:-v.swiperWidth*gt,dy:ct?-v.swiperHeight*gt:0})},te=fe=>{let Ce=()=>{U("animationfinish",pe()),v.currentChangeSource="autoplay"};mo?Ce():f(Ce,50)},ce=fe=>{wt.isString(fe.detail.source)&&(v.currentChangeSource=fe.detail.source),v.currentSync=fe.detail.index,Z=0};function pe(){let fe=Number(v.currentSync),Ce=$[fe]||{},ct=Ce.componentInstance&&Ce.componentInstance.itemId||"";return{current:fe,currentItemId:ct,source:v.currentChangeSource}}return P.watch(()=>v.currentSync,fe=>{U("change",pe())}),{onScroll:q,onScrollend:te,onChange:ce}}function Fn(v,x,$){let U=-1;if(x.currentItemId)for(let Z=0,q=$;Z<q.length;Z++){let te=q[Z].componentInstance;if(te&&te.itemId===x.currentItemId){U=Z;break}}U<0&&(U=Math.round(Number(x.current))||0),U=U<0?0:U,v.currentSync!==U&&(v.currentChangeSource="",v.currentSync=U)}let wi={itemId:{type:String,default:""}},is=P.defineComponent({name:"SwiperItem",props:wi,setup(v,{slots:x}){return()=>P.createVNode("div",{class:"uni-swiper-item",style:{position:"absolute",left:0,top:0,right:0,bottom:0,overflow:"hidden"}},[x.default&&x.default()])}});var ha=/^<([-A-Za-z0-9_]+)((?:\s+[a-zA-Z_:][-a-zA-Z0-9_:.]*(?:\s*=\s*(?:(?:"[^"]*")|(?:'[^']*')|[^>\s]+))?)*)\s*(\/?)>/,br=/^<\/([-A-Za-z0-9_]+)[^>]*>/,Ta=/([a-zA-Z_:][-a-zA-Z0-9_:.]*)(?:\s*=\s*(?:(?:"((?:\\.|[^"])*)")|(?:'((?:\\.|[^'])*)')|([^>\s]+)))?/g,La=Mo("area,base,basefont,br,col,frame,hr,img,input,link,meta,param,embed,command,keygen,source,track,wbr"),Fa=Mo("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"),Va=Mo("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"),Ua=Mo("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr"),ga=Mo("checked,compact,declare,defer,disabled,ismap,multiple,nohref,noresize,noshade,nowrap,readonly,selected"),Pa=Mo("script,style");function Vn(v,x){var $,U,Z,q=[],te=v;for(q.last=function(){return this[this.length-1]};v;){if(U=!0,!q.last()||!Pa[q.last()]){if(v.indexOf("<!--")==0?($=v.indexOf("-->"),$>=0&&(x.comment&&x.comment(v.substring(4,$)),v=v.substring($+3),U=!1)):v.indexOf("</")==0?(Z=v.match(br),Z&&(v=v.substring(Z[0].length),Z[0].replace(br,Ie),U=!1)):v.indexOf("<")==0&&(Z=v.match(ha),Z&&(v=v.substring(Z[0].length),Z[0].replace(ha,pe),U=!1)),U){$=v.indexOf("<");var ce=$<0?v:v.substring(0,$);v=$<0?"":v.substring($),x.chars&&x.chars(ce)}}else v=v.replace(new RegExp("([\\s\\S]*?)</"+q.last()+"[^>]*>"),function(fe,Ce){return Ce=Ce.replace(/<!--([\s\S]*?)-->|<!\[CDATA\[([\s\S]*?)]]>/g,"$1$2"),x.chars&&x.chars(Ce),""}),Ie("",q.last());if(v==te)throw"Parse Error: "+v;te=v}Ie();function pe(fe,Ce,ct,gt){if(Ce=Ce.toLowerCase(),Fa[Ce])for(;q.last()&&Va[q.last()];)Ie("",q.last());if(Ua[Ce]&&q.last()==Ce&&Ie("",Ce),gt=La[Ce]||!!gt,gt||q.push(Ce),x.start){var Ht=[];ct.replace(Ta,function(yt,je){var Mt=arguments[2]?arguments[2]:arguments[3]?arguments[3]:arguments[4]?arguments[4]:ga[je]?je:"";Ht.push({name:je,value:Mt,escaped:Mt.replace(/(^|[^\\])"/g,'$1\\"')})}),x.start&&x.start(Ce,Ht,gt)}}function Ie(fe,Ce){if(Ce)for(var ct=q.length-1;ct>=0&&q[ct]!=Ce;ct--);else var ct=0;if(ct>=0){for(var gt=q.length-1;gt>=ct;gt--)x.end&&x.end(q[gt]);q.length=ct}}}function Mo(v){for(var x={},$=v.split(","),U=0;U<$.length;U++)x[$[U]]=!0;return x}function ea(v){return v.replace(/<\?xml.*\?>\n/,"").replace(/<!doctype.*>\n/,"").replace(/<!DOCTYPE.*>\n/,"")}function Wi(v){return v.reduce(function(x,$){let U=$.value,Z=$.name;return U.match(/ /)&&["style","src"].indexOf(Z)===-1&&(U=U.split(" ")),x[Z]?Array.isArray(x[Z])?x[Z].push(U):x[Z]=[x[Z],U]:x[Z]=U,x},{})}function os(v){v=ea(v);let x=[],$={node:"root",children:[]};return Vn(v,{start:function(U,Z,q){let te={name:U};if(Z.length!==0&&(te.attrs=Wi(Z)),q){let ce=x[0]||$;ce.children||(ce.children=[]),ce.children.push(te)}else x.unshift(te)},end:function(U){let Z=x.shift();if(Z.name!==U&&console.error("invalid state: mismatch end tag"),x.length===0)$.children.push(Z);else{let q=x[0];q.children||(q.children=[]),q.children.push(Z)}},chars:function(U){let Z={type:"text",text:U};if(x.length===0)$.children.push(Z);else{let q=x[0];q.children||(q.children=[]),q.children.push(Z)}},comment:function(U){let Z={node:"comment",text:U},q=x[0];q.children||(q.children=[]),q.children.push(Z)}}),$.children}let as={nodes:{type:[Array,String],default:function(){return[]}}},Do=16,ss=P.defineComponent({name:"RichText",props:as,setup(v){let x=P.getCurrentInstance();return()=>{let $=v.nodes;return wt.isString($)&&($=os($)),P.createVNode("u-rich-text",{value:io($||[],x.root,{defaultFontSize:Do})},null)}}});function io(v,x,$){let U=["span","a","image","img"],Z={blockquote:Ce,br:yt,div:Ce,dl:Ce,h1:gt(2),h2:gt(1.5),h3:gt(1.17),h4:gt(1),h5:gt(.83),h6:gt(.67),hr:Ce,ol:Ce,p:Ce,strong:Ht,table:Ce,tbody:Ce,tfoot:Ce,thead:Ce,ul:Ce},q=/&(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:[]},Ie=null;function fe(dt){let en=Object.create(null);if(dt.attrs){let Bn=(dt.attrs.class||"").split(" ");Object.assign(en,P.parseClassList(Bn,x),uo(dt.attrs.style||""))}if(dt.name==="img"||dt.name==="image"){let Bn=dt.attrs;en.width=en.width||Bn.width,en.height=en.height||Bn.height}return en}function Ce(dt){return dt.__block=!0,dt}function ct(dt,en){return dt.style&&!dt.style.fontSize&&(dt.style.fontSize=$.defaultFontSize*en),Ce(Ht(dt))}function gt(dt){return function(en){return ct(en,dt)}}function Ht(dt){return dt.style&&!dt.style.fontWeight&&(dt.style.fontWeight="bold"),dt}function yt(dt){return dt.__value=" ",Ce(dt)}function je(dt){return dt.replace(q,function(en,Bn){return te[Bn]})}function Mt(dt){let en=(dt.name||"").toLowerCase(),Bn=en,Yt=Z[en];U.indexOf(en)===-1&&(en="span"),en==="img"&&(en="image");let jt={type:en,__type:Bn,attr:Object.create(null)};return(dt.type==="text"||dt.text)&&(jt.__value=jt.attr.value=je((dt.text||"").trim())),dt.attrs&&Object.keys(dt.attrs).forEach(Ut=>{Ut!=="class"&&Ut!=="style"&&(jt.attr[Ut]=dt.attrs[Ut])}),jt.style=fe(dt),Yt&&Yt(jt),(pe.__block||jt.__block)&&(Ie||(pe.children.push(ce),Ie=[pe,ce])),pe=jt,(pe.__value||pe.type==="image"&&pe.attr.src)&&(Ie=null),jt.children=dn(dt.children),pe=jt,pe.__block&&pe.style.height&&!/^0(px)?$/.test(pe.style.height)&&(Ie=null),jt}function dn(dt){return wt.isArray(dt)?dt.map(en=>Mt(en)):[]}let Gt=dn(v);if(Ie){let[dt,en]=Ie,Bn=dt.children,Yt=Bn.indexOf(en);Bn.splice(Yt,1)}return Gt}let si={};function Ci(v,x,$){let{adpid:U,width:Z}=v,q=U+"-"+Z,te=si[q];if(te&&te.length>0){x(te.splice(0,1)[0]);return}h.ad.getAds(v,ce=>{let pe=ce.ads;x(pe.splice(0,1)[0]),si[q]=te?te.concat(pe):pe},ce=>{$({errCode:ce.code,errMsg:ce.message})})}let Gi={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"},ur=P.defineComponent({name:"Ad",props:Gi,emits:[li.load,li.close,li.error,li.downloadchange],setup(v,{emit:x}){let $=P.ref(null),U=Kn($,x),Z=lr();P.watch(()=>v.adpid,te=>{$a(Z,v,U)}),P.watch(()=>v.data,te=>{Z.data=te}),P.onMounted(()=>{f(()=>{kn($.value).then(({width:te})=>{Z.width=te===0?-1:te,$a(Z,v,U)})},50)});let q={onDownloadchange(te){U(li.downloadchange,te)},onDislike(te){U(li.close,te)}};return()=>P.createVNode("u-ad",P.mergeProps({ref:$},{data:Z.data,rendering:!0},q),null)}});function lr(v){let x=P.ref("");return P.reactive({width:0,data:x})}function $a(v,x,$){Ci({adpid:x.adpid,width:v.width},U=>{v.data=U,$(li.load,{})},U=>{$(li.error,U)})}let Ha={};function Yi(v,x,$,U,Z){let q=v+"-"+x,te=Ha[q];if(te&&te.length>0){U(te.splice(0,1)[0]);return}h.ad.getDrawAds({adpid:String(v),count:3,width:x},ce=>{let pe=ce.ads;U(pe.splice(0,1)[0]),Ha[q]=te?te.concat(pe):pe},ce=>{Z({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=P.defineComponent({name:"AdDraw",props:oo,emits:[ao.load,ao.close,ao.error],setup(v,{emit:x}){let $=P.ref(null),U=Kn($,x),Z=pa();P.watch(()=>v.adpid,te=>{Lo(Z,v,U)}),P.watch(()=>v.data,te=>{Z.data=te});let q={onDislike(te){U(ao.close,te)}};return P.onMounted(()=>{f(()=>{kn($.value).then(({width:te,height:ce})=>{Z.width=te===0?-1:te,Z.height=ce===0?-1:ce,Lo(Z,v,U)})},50)}),()=>{let{data:te}=Z;return P.createVNode("u-ad-draw",P.mergeProps({ref:$},{data:te,rendering:!0},q),null)}}});function pa(v){let x=P.ref("");return P.reactive({width:0,height:0,data:x})}function Lo(v,x,$){Yi(x.adpid,v.width,v.height,U=>{v.data=U,$(ao.load,{})},U=>{$(ao.error,U)})}return{Navigator:pi,Label:gn,Button:Oo,MovableArea:Cr,MovableView:Ar,Progress:_i,PickerView:Tr,PickerViewColumn:ji,Picker:er,USlider:nr,Switch:jr,Checkbox:vo,CheckboxGroup:zi,Radio:de,RadioGroup:kt,Form:ie,Icon:_r,Swiper:Bo,SwiperItem:is,RichText:ss,Ad:ur,AdDraw:ls}}(N,Fe,It);return Ot}function TI(f,s){let{UniShared:p,Vue:w}=s;function N(h,y,R){let Fe=h.$[y];return Fe&&p.invokeArrayFns(Fe,R)}let E=f.setup;return f.inheritAttrs=!1,f.setup=(h,y)=>{let{attrs:{__pageId:R,__pagePath:Fe,__pageQuery:It}}=y,Vt=s.__uniRoutes.find(wt=>wt.meta.route===Fe),Ot=w.getCurrentInstance(),P=Ot.proxy;if(Vt&&(Vt.meta.isSubNVue||PI(P,s,{__pageId:R,__pagePath:Fe})),w.onMounted(()=>{w.nextTick(()=>{N(P,p.ON_READY)}),Ot.onPageScroll&&P.$el.addEvent("scroll",wt=>{wt.scrollTop=wt.detail.scrollTop,N(P,p.ON_PAGE_SCROLL,wt)}),Ot.onReachBottom&&P.$el.addEvent("scrolltolower",wt=>{N(P,p.ON_REACH_BOTTOM,wt)})}),w.onBeforeUnmount(()=>{N(P,p.ON_UNLOAD)}),E)return E(It,y)},f}function PI(f,s,{__pageId:p,__pagePath:w}){let N=s.getCurrentPages(),E=N[N.length-1];if(E&&E.__setup)E.__setup(f,E);else{let h="/"+w;return s.__registerPage({url:h,path:h,query:{},openType:"launch",webview:{id:p+""},nvuePageVm:f})}}var Ml={},kp;function Rp(f){kp=f}var tu;function II(f){if(tu)return tu;let s=new f.Emitter;return tu={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)}},tu}function NI(f){return(s,p,w)=>{let{nvue:N}=p,E=eu(f,p);p.Vue=E,Ml[s]={instanceId:s,config:N.config,document:N.document,data:w};let{createApp:h}=E;E.createVueApp=E.createApp=(y,R)=>(p.__uniConfig.styles=y.styles||[],h(y,R).use(kI,s,p)),E.createPageApp=(y,R)=>{TI(y,p);let Fe=R.$store;delete R.$store;let It=h(y,R);return Fe&&It.use(Fe),It.use(xI,E,s,p)}}}var kI={install(f,s,p){dc(p).initApp(f),RI(f,s,p)}};function RI(f,s,p){let{mount:w}=f,N=Ml[s];return f.mount=E=>{let h=E==="#app",y=N.app=w(xp(N.document,{isRoot:h}));return h&&p.__registerApp(y),y},f}var xI={install(f,s,p,w){let{weex:N,plus:E,BroadcastChannel:h,VueShared:y,UniShared:R,getCurrentPages:Fe,setTimeout:It,clearTimeout:Vt,__uniConfig:Ot}=w;f.config.globalProperties.$requireNativePlugin=N.requireModule;let P=OI({uni:kp,Vue:s,weex:N,plus:E,BroadcastChannel:h,UniViewJSBridge:II(R),VueShared:y,UniShared:R,getCurrentPages:Fe,setTimeout:It,clearTimeout:Vt,__uniConfig:Ot});Object.keys(P).forEach(wt=>{f.component(s.hyphenate(wt),P[wt])}),dc(w).initApp(f),BI(f,p,w)}};function BI(f,s,{nvue:p}){let{config:{compilerOptions:w},mount:N}=f;w.isCustomElement=h=>!!p.supports(`@component/${h}`);let E=Ml[s];return f.mount=h=>{let y=h==="#root",R=E.app=N(xp(E.document,{isRoot:y}));if(y)try{p.document.taskCenter.send("dom",{action:"createFinish"},[])}catch(Fe){}return R},f}function xp(f,{isRoot:s}){if(s)return f.documentElement;let p=f.createComment("root");return f.documentElement.appendChild(p),p}function Bp(f){let s=Ml[f];if(s&&s.app&&s.document){try{s.app.$.appContext.app.unmount(),s.document.destroy()}catch(p){}delete s.document,delete s.app}delete Ml[f]}function Mp(f){let s=Ml[f];if(!s||!s.app)return new Error(`refreshInstance: instance ${f} not found!`);s.document.taskCenter.send("dom",{action:"refreshFinish"},[])}function MI(f,s){let{UniShared:p,VueShared:w,VueReactivity:N}=f;var E=function(h,y,R,Fe){"use strict";function It(a){}function Vt(a,u){}function Ot(a,u,m,S){var I;try{I=S?a(...S):a()}catch(O){wt(O,u,m)}return I}function P(a,u,m,S){if(y.isFunction(a)){var I=Ot(a,u,m,S);return I&&y.isPromise(I)&&I.catch(W=>{wt(W,u,m)}),I}for(var O=[],F=0;F<a.length;F++)O.push(P(a[F],u,m,S));return O}function wt(a,u,m){if(u&&u.vnode,u){for(var S=u.parent,I=u.proxy,O=m;S;){var F=S.ec;if(F){for(var W=0;W<F.length;W++)if(F[W](a,I,O)===!1)return}S=S.parent}var G=u.appContext.config.errorHandler;if(G){Ot(G,null,10,[a,I,O]);return}}In(a)}function In(a,u,m){console.error(a)}var ot=!1,z=!1,J=[],hn=0,un=[],yn=null,Jn=0,gi=Promise.resolve(),pi=null;function qr(a){var u=pi||gi;return a?u.then(this?a.bind(this):a):u}function gr(a){for(var u=hn+1,m=J.length;u<m;){var S=u+m>>>1,I=ze(J[S]);I<a?u=S+1:m=S}return u}function Sn(a){(!J.length||!J.includes(a,ot&&a.allowRecurse?hn+1:hn))&&(a.id==null?J.push(a):J.splice(gr(a.id),0,a),pr())}function pr(){!ot&&!z&&(z=!0,pi=gi.then(At))}function Lr(a){var u=J.indexOf(a);u>hn&&J.splice(u,1)}function Jr(a){y.isArray(a)?un.push(...a):(!yn||!yn.includes(a,a.allowRecurse?Jn+1:Jn))&&un.push(a),pr()}function vi(a){for(var u=arguments.length>1&&arguments[1]!==void 0?arguments[1]:ot?hn+1:0;u<J.length;u++){var m=J[u];m&&m.pre&&(J.splice(u,1),u--,m())}}function Pn(a){if(un.length){var u=[...new Set(un)];if(un.length=0,yn){yn.push(...u);return}for(yn=u,yn.sort((m,S)=>ze(m)-ze(S)),Jn=0;Jn<yn.length;Jn++)yn[Jn]();yn=null,Jn=0}}var ze=a=>a.id==null?1/0:a.id,nt=(a,u)=>{var m=ze(a)-ze(u);if(m===0){if(a.pre&&!u.pre)return-1;if(u.pre&&!a.pre)return 1}return m};function At(a){z=!1,ot=!0,J.sort(nt);var u=y.NOOP;try{for(hn=0;hn<J.length;hn++){var m=J[hn];m&&m.active!==!1&&Ot(m,null,14)}}finally{hn=0,J.length=0,Pn(),ot=!1,pi=null,(J.length||un.length)&&At()}}h.devtools=void 0;var Qt=[];function Tn(a,u){var m,S;if(h.devtools=a,h.devtools)h.devtools.enabled=!0,Qt.forEach(O=>{var{event:F,args:W}=O;return h.devtools.emit(F,...W)}),Qt=[];else if(typeof window!="undefined"&&window.HTMLElement&&!((S=(m=window.navigator)===null||m===void 0?void 0:m.userAgent)===null||S===void 0?void 0:S.includes("jsdom"))){var I=u.__VUE_DEVTOOLS_HOOK_REPLAY__=u.__VUE_DEVTOOLS_HOOK_REPLAY__||[];I.push(O=>{Tn(O,u)}),setTimeout(()=>{h.devtools||(u.__VUE_DEVTOOLS_HOOK_REPLAY__=null,Qt=[])},3e3)}else Qt=[]}function sn(a,u){if(!a.isUnmounted){for(var m=a.vnode.props||y.EMPTY_OBJ,S=arguments.length,I=new Array(S>2?S-2:0),O=2;O<S;O++)I[O-2]=arguments[O];var F=I,W=u.startsWith("update:"),G=W&&u.slice(7);if(G&&G in m){var le="".concat(G==="modelValue"?"model":G,"Modifiers"),{number:We,trim:it}=m[le]||y.EMPTY_OBJ;it&&(F=I.map(mt=>y.isString(mt)?mt.trim():mt)),We&&(F=I.map(y.looseToNumber))}var ge,Ye=m[ge=y.toHandlerKey(u)]||m[ge=y.toHandlerKey(y.camelize(u))];!Ye&&W&&(Ye=m[ge=y.toHandlerKey(y.hyphenate(u))]),Ye&&P(Ye,a,6,F);var Je=m[ge+"Once"];if(Je){if(!a.emitted)a.emitted={};else if(a.emitted[ge])return;a.emitted[ge]=!0,P(Je,a,6,F)}}}function or(a,u){var m=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!1,S=u.emitsCache,I=S.get(a);if(I!==void 0)return I;var O=a.emits,F={},W=!1;if(!y.isFunction(a)){var G=le=>{var We=or(le,u,!0);We&&(W=!0,y.extend(F,We))};!m&&u.mixins.length&&u.mixins.forEach(G),a.extends&&G(a.extends),a.mixins&&a.mixins.forEach(G)}return!O&&!W?(y.isObject(a)&&S.set(a,null),null):(y.isArray(O)?O.forEach(le=>F[le]=null):y.extend(F,O),y.isObject(a)&&S.set(a,F),F)}function Wn(a,u){return!a||!y.isOn(u)?!1:(u=u.slice(2).replace(/Once$/,""),y.hasOwn(a,u[0].toLowerCase()+u.slice(1))||y.hasOwn(a,y.hyphenate(u))||y.hasOwn(a,u))}var An=null,gn=null;function wr(a){var u=An;return An=a,gn=a&&a.type.__scopeId||null,u}function Kr(a){gn=a}function wo(){gn=null}var da=a=>Ui;function Ui(a){var u=arguments.length>1&&arguments[1]!==void 0?arguments[1]:An;if(!u||a._n)return a;var m=function(){m._d&&Ht(-1);var S=wr(u),I;try{I=a(...arguments)}finally{wr(S),m._d&&Ht(1)}return I};return m._n=!0,m._c=!0,m._d=!0,m}function Zo(){}function Xo(a){var{type:u,vnode:m,proxy:S,withProxy:I,props:O,propsOptions:[F],slots:W,attrs:G,emit:le,render:We,renderCache:it,data:ge,setupState:Ye,ctx:Je,inheritAttrs:mt}=a,at,Se,Ee=wr(a);try{if(m.shapeFlag&4){var Ae=I||S;at=Un(We.call(Ae,Ae,it,O,Ye,ge,Je)),Se=G}else{var lt=u;at=Un(lt.length>1?lt(O,{attrs:G,slots:W,emit:le}):lt(O,null)),Se=u.props?G:ri(G)}}catch(l){Ie.length=0,wt(l,a,1),at=Ut(ce)}var Ve=at;if(Se&&mt!==!1){var Tt=Object.keys(Se),{shapeFlag:i}=Ve;Tt.length&&i&(1|6)&&(F&&Tt.some(y.isModelListener)&&(Se=Co(Se,F)),Ve=ci(Ve,Se))}return m.dirs&&(Ve=ci(Ve),Ve.dirs=Ve.dirs?Ve.dirs.concat(m.dirs):m.dirs),m.transition&&(Ve.transition=m.transition),at=Ve,wr(Ee),at}function $i(a){for(var u,m=0;m<a.length;m++){var S=a[m];if(dn(S)){if(S.type!==ce||S.children==="v-if"){if(u)return;u=S}}else return}return u}var ri=a=>{var u;for(var m in a)(m==="class"||m==="style"||y.isOn(m))&&((u||(u={}))[m]=a[m]);return u},Co=(a,u)=>{var m={};for(var S in a)(!y.isModelListener(S)||!(S.slice(9)in u))&&(m[S]=a[S]);return m};function Ao(a,u,m){var{props:S,children:I,component:O}=a,{props:F,children:W,patchFlag:G}=u,le=O.emitsOptions;if(u.dirs||u.transition)return!0;if(m&&G>=0){if(G&1024)return!0;if(G&16)return S?Oo(S,F,le):!!F;if(G&8)for(var We=u.dynamicProps,it=0;it<We.length;it++){var ge=We[it];if(F[ge]!==S[ge]&&!Wn(le,ge))return!0}}else return(I||W)&&(!W||!W.$stable)?!0:S===F?!1:S?F?Oo(S,F,le):!0:!!F;return!1}function Oo(a,u,m){var S=Object.keys(u);if(S.length!==Object.keys(a).length)return!0;for(var I=0;I<S.length;I++){var O=S[I];if(u[O]!==a[O]&&!Wn(m,O))return!0}return!1}function Xi(a,u){for(var{vnode:m,parent:S}=a;S&&S.subTree===m;)(m=S.vnode).el=u,S=S.parent}var mi=a=>a.__isSuspense,To={name:"Suspense",__isSuspense:!0,process(a,u,m,S,I,O,F,W,G,le){a==null?Cr(u,m,S,I,O,F,W,G,le):Qi(a,u,m,S,I,F,W,G,le)},hydrate:eo,create:Kn,normalize:Po},uo=To;function kn(a,u){var m=a.props&&a.props[u];y.isFunction(m)&&m()}function Cr(a,u,m,S,I,O,F,W,G){var{p:le,o:{createElement:We}}=G,it=We("div"),ge=a.suspense=Kn(a,I,S,u,it,m,O,F,W,G);le(null,ge.pendingBranch=a.ssContent,it,null,S,ge,O,F),ge.deps>0?(kn(a,"onPending"),kn(a,"onFallback"),le(null,a.ssFallback,u,m,S,null,O,F),ar(ge,a.ssFallback)):ge.resolve()}function Qi(a,u,m,S,I,O,F,W,G){var{p:le,um:We,o:{createElement:it}}=G,ge=u.suspense=a.suspense;ge.vnode=u,u.el=a.el;var Ye=u.ssContent,Je=u.ssFallback,{activeBranch:mt,pendingBranch:at,isInFallback:Se,isHydrating:Ee}=ge;if(at)ge.pendingBranch=Ye,Gt(Ye,at)?(le(at,Ye,ge.hiddenContainer,null,I,ge,O,F,W),ge.deps<=0?ge.resolve():Se&&(le(mt,Je,m,S,I,null,O,F,W),ar(ge,Je))):(ge.pendingId++,Ee?(ge.isHydrating=!1,ge.activeBranch=at):We(at,I,ge),ge.deps=0,ge.effects.length=0,ge.hiddenContainer=it("div"),Se?(le(null,Ye,ge.hiddenContainer,null,I,ge,O,F,W),ge.deps<=0?ge.resolve():(le(mt,Je,m,S,I,null,O,F,W),ar(ge,Je))):mt&&Gt(Ye,mt)?(le(mt,Ye,m,S,I,ge,O,F,W),ge.resolve(!0)):(le(null,Ye,ge.hiddenContainer,null,I,ge,O,F,W),ge.deps<=0&&ge.resolve()));else if(mt&&Gt(Ye,mt))le(mt,Ye,m,S,I,ge,O,F,W),ar(ge,Ye);else if(kn(u,"onPending"),ge.pendingBranch=Ye,ge.pendingId++,le(null,Ye,ge.hiddenContainer,null,I,ge,O,F,W),ge.deps<=0)ge.resolve();else{var{timeout:Ae,pendingId:lt}=ge;Ae>0?setTimeout(()=>{ge.pendingId===lt&&ge.fallback(Je)},Ae):Ae===0&&ge.fallback(Je)}}function Kn(a,u,m,S,I,O,F,W,G,le){var We=arguments.length>10&&arguments[10]!==void 0?arguments[10]:!1,{p:it,m:ge,um:Ye,n:Je,o:{parentNode:mt,remove:at}}=le,Se=a.props?y.toNumber(a.props.timeout):void 0,Ee={vnode:a,parent:u,parentComponent:m,isSVG:F,container:S,hiddenContainer:I,anchor:O,deps:0,pendingId:0,timeout:typeof Se=="number"?Se:-1,activeBranch:null,pendingBranch:null,isInFallback:!0,isHydrating:We,isUnmounted:!1,effects:[],resolve(){var Ae=arguments.length>0&&arguments[0]!==void 0?arguments[0]:!1,{vnode:lt,activeBranch:Ve,pendingBranch:Tt,pendingId:i,effects:l,parentComponent:d,container:_}=Ee;if(Ee.isHydrating)Ee.isHydrating=!1;else if(!Ae){var A=Ve&&Tt.transition&&Tt.transition.mode==="out-in";A&&(Ve.transition.afterLeave=()=>{i===Ee.pendingId&&ge(Tt,_,C,0)});var{anchor:C}=Ee;Ve&&(C=Je(Ve),Ye(Ve,d,Ee,!0)),A||ge(Tt,_,C,0)}ar(Ee,Tt),Ee.pendingBranch=null,Ee.isInFallback=!1;for(var k=Ee.parent,D=!1;k;){if(k.pendingBranch){k.effects.push(...l),D=!0;break}k=k.parent}D||Jr(l),Ee.effects=[],kn(lt,"onResolve")},fallback(Ae){if(!!Ee.pendingBranch){var{vnode:lt,activeBranch:Ve,parentComponent:Tt,container:i,isSVG:l}=Ee;kn(lt,"onFallback");var d=Je(Ve),_=()=>{!Ee.isInFallback||(it(null,Ae,i,d,Tt,null,l,W,G),ar(Ee,Ae))},A=Ae.transition&&Ae.transition.mode==="out-in";A&&(Ve.transition.afterLeave=_),Ee.isInFallback=!0,Ye(Ve,Tt,null,!0),A||_()}},move(Ae,lt,Ve){Ee.activeBranch&&ge(Ee.activeBranch,Ae,lt,Ve),Ee.container=Ae},next(){return Ee.activeBranch&&Je(Ee.activeBranch)},registerDep(Ae,lt){var Ve=!!Ee.pendingBranch;Ve&&Ee.deps++;var Tt=Ae.vnode.el;Ae.asyncDep.catch(i=>{wt(i,Ae,0)}).then(i=>{if(!(Ae.isUnmounted||Ee.isUnmounted||Ee.pendingId!==Ae.suspenseId)){Ae.asyncResolved=!0;var{vnode:l}=Ae;Ia(Ae,i,!1),Tt&&(l.el=Tt);var d=!Tt&&Ae.subTree.el;lt(Ae,l,mt(Tt||Ae.subTree.el),Tt?null:Je(Ae.subTree),Ee,F,G),d&&at(d),Xi(Ae,l.el),Ve&&--Ee.deps===0&&Ee.resolve()}})},unmount(Ae,lt){Ee.isUnmounted=!0,Ee.activeBranch&&Ye(Ee.activeBranch,m,Ae,lt),Ee.pendingBranch&&Ye(Ee.pendingBranch,m,Ae,lt)}};return Ee}function eo(a,u,m,S,I,O,F,W,G){var le=u.suspense=Kn(u,S,m,a.parentNode,s.createElement("div"),null,I,O,F,W,!0),We=G(a,le.pendingBranch=u.ssContent,m,le,O,F);return le.deps===0&&le.resolve(),We}function Po(a){var{shapeFlag:u,children:m}=a,S=u&32;a.ssContent=fo(S?m.default:m),a.ssFallback=S?fo(m.fallback):Ut(ce)}function fo(a){var u;if(y.isFunction(a)){var m=gt&&a._c;m&&(a._d=!1,Ce()),a=a(),m&&(a._d=!0,u=fe,ct())}if(y.isArray(a)){var S=$i(a);a=S}return a=Un(a),u&&!a.dynamicChildren&&(a.dynamicChildren=u.filter(I=>I!==a)),a}function ii(a,u){u&&u.pendingBranch?y.isArray(a)?u.effects.push(...a):u.effects.push(a):Jr(a)}function ar(a,u){a.activeBranch=u;var{vnode:m,parentComponent:S}=a,I=m.el=u.el;S&&S.subTree===m&&(S.vnode.el=I,Xi(S,I))}function kr(a,u){if(on){var m=on.provides,S=on.parent&&on.parent.provides;S===m&&(m=on.provides=Object.create(S)),m[a]=u,on.type.mpType==="app"&&on.appContext.app.provide(a,u)}}function Nn(a,u){var m=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!1,S=on||An;if(S){var I=S.parent==null?S.vnode.appContext&&S.vnode.appContext.provides:S.parent.provides;if(I&&a in I)return I[a];if(arguments.length>1)return m&&y.isFunction(u)?u.call(S.proxy):u}}function Zn(a,u){return vr(a,null,u)}function Ni(a,u){return vr(a,null,{flush:"post"})}function Hi(a,u){return vr(a,null,{flush:"sync"})}var oi={};function Fr(a,u,m){return vr(a,u,m)}function vr(a,u){var{immediate:m,deep:S,flush:I,onTrack:O,onTrigger:F}=arguments.length>2&&arguments[2]!==void 0?arguments[2]:y.EMPTY_OBJ,W=R.getCurrentScope()===(on==null?void 0:on.scope)?on:null,G,le=!1,We=!1;if(R.isRef(a)?(G=()=>a.value,le=R.isShallow(a)):R.isReactive(a)?(G=()=>a,S=!0):y.isArray(a)?(We=!0,le=a.some(Ae=>R.isReactive(Ae)||R.isShallow(Ae)),G=()=>a.map(Ae=>{if(R.isRef(Ae))return Ae.value;if(R.isReactive(Ae))return Vr(Ae);if(y.isFunction(Ae))return Ot(Ae,W,2)})):y.isFunction(a)?u?G=()=>Ot(a,W,2):G=()=>{if(!(W&&W.isUnmounted))return ge&&ge(),P(a,W,3,[Ye])}:G=y.NOOP,u&&S){var it=G;G=()=>Vr(it())}var ge,Ye=Ae=>{ge=Se.onStop=()=>{Ot(Ae,W,4)}},Je=We?new Array(a.length).fill(oi):oi,mt=()=>{if(!!Se.active)if(u){var Ae=Se.run();(S||le||(We?Ae.some((lt,Ve)=>y.hasChanged(lt,Je[Ve])):y.hasChanged(Ae,Je)))&&(ge&&ge(),P(u,W,3,[Ae,Je===oi?void 0:We&&Je[0]===oi?[]:Je,Ye]),Je=Ae)}else Se.run()};mt.allowRecurse=!!u;var at;I==="sync"?at=mt:I==="post"?at=()=>ur(mt,W&&W.suspense):(mt.pre=!0,W&&(mt.id=W.uid),at=()=>Sn(mt));var Se=new R.ReactiveEffect(G,at);u?m?mt():Je=Se.run():I==="post"?ur(Se.run.bind(Se),W&&W.suspense):Se.run();var Ee=()=>{Se.stop(),W&&W.scope&&y.remove(W.scope.effects,Se)};return Ee}function ki(a,u,m){var S=this.proxy,I=y.isString(a)?a.includes(".")?Io(S,a):()=>S[a]:a.bind(S,S),O;y.isFunction(u)?O=u:(O=u.handler,m=u);var F=on;jn(this);var W=vr(I,O.bind(S),m);return F?jn(F):qn(),W}function Io(a,u){var m=u.split(".");return()=>{for(var S=a,I=0;I<m.length&&S;I++)S=S[m[I]];return S}}function Vr(a,u){if(!y.isObject(a)||a.__v_skip||(u=u||new Set,u.has(a)))return a;if(u.add(a),R.isRef(a))Vr(a.value,u);else if(y.isArray(a))for(var m=0;m<a.length;m++)Vr(a[m],u);else if(y.isSet(a)||y.isMap(a))a.forEach(I=>{Vr(I,u)});else if(y.isPlainObject(a))for(var S in a)Vr(a[S],u);return a}function Zr(){var a={isMounted:!1,isLeaving:!1,isUnmounting:!1,leavingVNodes:new Map};return er(()=>{a.isMounted=!0}),nr(()=>{a.isUnmounting=!0}),a}var Ar=[Function,Array],pn={mode:String,appear:Boolean,persisted:Boolean,onBeforeEnter:Ar,onEnter:Ar,onAfterEnter:Ar,onEnterCancelled:Ar,onBeforeLeave:Ar,onLeave:Ar,onAfterLeave:Ar,onLeaveCancelled:Ar,onBeforeAppear:Ar,onAppear:Ar,onAfterAppear:Ar,onAppearCancelled:Ar},Xr={name:"BaseTransition",props:pn,setup(a,u){var{slots:m}=u,S=_n(),I=Zr(),O;return()=>{var F=m.default&&Or(m.default(),!0);if(!(!F||!F.length)){var W=F[0];if(F.length>1){for(var G of F)if(G.type!==ce){W=G;break}}var le=R.toRaw(a),{mode:We}=le;if(I.isLeaving)return _i(W);var it=bi(W);if(!it)return _i(W);var ge=Te(it,le,I,S);yi(it,ge);var Ye=S.subTree,Je=Ye&&bi(Ye),mt=!1,{getTransitionKey:at}=it.type;if(at){var Se=at();O===void 0?O=Se:Se!==O&&(O=Se,mt=!0)}if(Je&&Je.type!==ce&&(!Gt(it,Je)||mt)){var Ee=Te(Je,le,I,S);if(yi(Je,Ee),We==="out-in")return I.isLeaving=!0,Ee.afterLeave=()=>{I.isLeaving=!1,S.update.active!==!1&&S.update()},_i(W);We==="in-out"&&it.type!==ce&&(Ee.delayLeave=(Ae,lt,Ve)=>{var Tt=Dt(I,Je);Tt[String(Je.key)]=Je,Ae._leaveCb=()=>{lt(),Ae._leaveCb=void 0,delete ge.delayedLeave},ge.delayedLeave=Ve})}return W}}}},Ur=Xr;function Dt(a,u){var{leavingVNodes:m}=a,S=m.get(u.type);return S||(S=Object.create(null),m.set(u.type,S)),S}function Te(a,u,m,S){var{appear:I,mode:O,persisted:F=!1,onBeforeEnter:W,onEnter:G,onAfterEnter:le,onEnterCancelled:We,onBeforeLeave:it,onLeave:ge,onAfterLeave:Ye,onLeaveCancelled:Je,onBeforeAppear:mt,onAppear:at,onAfterAppear:Se,onAppearCancelled:Ee}=u,Ae=String(a.key),lt=Dt(m,a),Ve=(l,d)=>{l&&P(l,S,9,d)},Tt=(l,d)=>{var _=d[1];Ve(l,d),y.isArray(l)?l.every(A=>A.length<=1)&&_():l.length<=1&&_()},i={mode:O,persisted:F,beforeEnter(l){var d=W;if(!m.isMounted)if(I)d=mt||W;else return;l._leaveCb&&l._leaveCb(!0);var _=lt[Ae];_&&Gt(a,_)&&_.el._leaveCb&&_.el._leaveCb(),Ve(d,[l])},enter(l){var d=G,_=le,A=We;if(!m.isMounted)if(I)d=at||G,_=Se||le,A=Ee||We;else return;var C=!1,k=l._enterCb=D=>{C||(C=!0,D?Ve(A,[l]):Ve(_,[l]),i.delayedLeave&&i.delayedLeave(),l._enterCb=void 0)};d?Tt(d,[l,k]):k()},leave(l,d){var _=String(a.key);if(l._enterCb&&l._enterCb(!0),m.isUnmounting)return d();Ve(it,[l]);var A=!1,C=l._leaveCb=k=>{A||(A=!0,d(),k?Ve(Je,[l]):Ve(Ye,[l]),l._leaveCb=void 0,lt[_]===a&&delete lt[_])};lt[_]=a,ge?Tt(ge,[l,C]):C()},clone(l){return Te(l,u,m,S)}};return i}function _i(a){if(Pr(a))return a=ci(a),a.children=null,a}function bi(a){return Pr(a)?a.children?a.children[0]:void 0:a}function yi(a,u){a.shapeFlag&6&&a.component?yi(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 Or(a){for(var u=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!1,m=arguments.length>2?arguments[2]:void 0,S=[],I=0,O=0;O<a.length;O++){var F=a[O],W=m==null?F.key:String(m)+String(F.key!=null?F.key:O);F.type===q?(F.patchFlag&128&&I++,S=S.concat(Or(F.children,u,W))):(u||F.type!==ce)&&S.push(W!=null?ci(F,{key:W}):F)}if(I>1)for(var G=0;G<S.length;G++)S[G].patchFlag=-2;return S}function Ri(a){return y.isFunction(a)?{setup:a,name:a.name}:a}var Tr=a=>!!a.type.__asyncLoader;function Rr(a){y.isFunction(a)&&(a={loader:a});var{loader:u,loadingComponent:m,errorComponent:S,delay:I=200,timeout:O,suspensible:F=!0,onError:W}=a,G=null,le,We=0,it=()=>(We++,G=null,ge()),ge=()=>{var Ye;return G||(Ye=G=u().catch(Je=>{if(Je=Je instanceof Error?Je:new Error(String(Je)),W)return new Promise((mt,at)=>{var Se=()=>mt(it()),Ee=()=>at(Je);W(Je,Se,Ee,We+1)});throw Je}).then(Je=>Ye!==G&&G?G:(Je&&(Je.__esModule||Je[Symbol.toStringTag]==="Module")&&(Je=Je.default),le=Je,Je)))};return Ri({name:"AsyncComponentWrapper",__asyncLoader:ge,get __asyncResolved(){return le},setup(){var Ye=on;if(le)return()=>ai(le,Ye);var Je=Ee=>{G=null,wt(Ee,Ye,13)};if(F&&Ye.suspense)return ge().then(Ee=>()=>ai(Ee,Ye)).catch(Ee=>(Je(Ee),()=>S?Ut(S,{error:Ee}):null));var mt=R.ref(!1),at=R.ref(),Se=R.ref(!!I);return I&&setTimeout(()=>{Se.value=!1},I),O!=null&&setTimeout(()=>{if(!mt.value&&!at.value){var Ee=new Error("Async component timed out after ".concat(O,"ms."));Je(Ee),at.value=Ee}},O),ge().then(()=>{mt.value=!0,Ye.parent&&Pr(Ye.parent.vnode)&&Sn(Ye.parent.update)}).catch(Ee=>{Je(Ee),at.value=Ee}),()=>{if(mt.value&&le)return ai(le,Ye);if(at.value&&S)return Ut(S,{error:at.value});if(m&&!Se.value)return Ut(m)}}})}function ai(a,u){var{ref:m,props:S,children:I,ce:O}=u.vnode,F=Ut(a,S,I);return F.ref=m,F.ce=O,delete u.vnode.ce,F}var Pr=a=>a.type.__isKeepAlive,Ei={name:"KeepAlive",__isKeepAlive:!0,props:{include:[String,RegExp,Array],exclude:[String,RegExp,Array],max:[String,Number]},setup(a,u){var{slots:m}=u,S=_n(),I=S.ctx,O=new Map,F=new Set,W=null,G=S.suspense,{renderer:{p:le,m:We,um:it,o:{createElement:ge}}}=I,Ye=ge("div");I.activate=(Ae,lt,Ve,Tt,i)=>{var l=Ae.component;We(Ae,lt,Ve,0,G),le(l.vnode,Ae,lt,Ve,l,G,Tt,Ae.slotScopeIds,i),ur(()=>{l.isDeactivated=!1,l.a&&y.invokeArrayFns(l.a);var d=Ae.props&&Ae.props.onVnodeMounted;d&&yr(d,l.parent,Ae)},G)},I.deactivate=Ae=>{var lt=Ae.component;We(Ae,Ye,null,1,G),ur(()=>{lt.da&&y.invokeArrayFns(lt.da);var Ve=Ae.props&&Ae.props.onVnodeUnmounted;Ve&&yr(Ve,lt.parent,Ae),lt.isDeactivated=!0},G)};function Je(Ae){sr(Ae),it(Ae,S,G,!0)}function mt(Ae){O.forEach((lt,Ve)=>{var Tt=Di(lt.type);Tt&&(!Ae||!Ae(Tt))&&at(Ve)})}function at(Ae){var lt=O.get(Ae);!W||!Gt(lt,W)?Je(lt):W&&sr(W),O.delete(Ae),F.delete(Ae)}Fr(()=>[a.include,a.exclude],Ae=>{var[lt,Ve]=Ae;lt&&mt(Tt=>ji(lt,Tt)),Ve&&mt(Tt=>!ji(Ve,Tt))},{flush:"post",deep:!0});var Se=null,Ee=()=>{Se!=null&&O.set(Se,Si(S.subTree))};return er(Ee),Gn(Ee),nr(()=>{O.forEach(Ae=>{var{subTree:lt,suspense:Ve}=S,Tt=Si(lt);if(Ae.type===Tt.type&&Ae.key===Tt.key){sr(Tt);var i=Tt.component.da;i&&ur(i,Ve);return}Je(Ae)})}),()=>{if(Se=null,!m.default)return null;var Ae=m.default(),lt=Ae[0];if(Ae.length>1)return W=null,Ae;if(!dn(lt)||!(lt.shapeFlag&4)&&!(lt.shapeFlag&128))return W=null,lt;var Ve=Si(lt),Tt=Ve.type,i=Di(Tr(Ve)?Ve.type.__asyncResolved||{}:Tt),{include:l,exclude:d,max:_}=a;if(l&&(!i||!ji(l,i))||d&&i&&ji(d,i))return W=Ve,lt;var A=Ve.key==null?Tt:Ve.key,C=O.get(A);return Ve.el&&(Ve=ci(Ve),lt.shapeFlag&128&&(lt.ssContent=Ve)),Se=A,C?(Ve.el=C.el,Ve.component=C.component,Ve.transition&&yi(Ve,Ve.transition),Ve.shapeFlag|=512,F.delete(A),F.add(A)):(F.add(A),_&&F.size>parseInt(_,10)&&at(F.values().next().value)),Ve.shapeFlag|=256,W=Ve,mi(lt.type)?lt:Ve}}},fn=Ei;function ji(a,u){return y.isArray(a)?a.some(m=>ji(m,u)):y.isString(a)?a.split(",").includes(u):y.isRegExp(a)?a.test(u):!1}function $r(a,u){En(a,"a",u)}function to(a,u){En(a,"da",u)}function En(a,u){var m=arguments.length>2&&arguments[2]!==void 0?arguments[2]:on,S=a.__wdc||(a.__wdc=()=>{for(var O=m;O;){if(O.isDeactivated)return;O=O.parent}return a()});if(xi(u,S,m),m)for(var I=m.parent;I&&I.parent;)Pr(I.parent.vnode)&&Hr(S,u,m,I),I=I.parent}function Hr(a,u,m,S){var I=xi(u,a,S,!0);cr(()=>{y.remove(S[u],I)},m)}function sr(a){a.shapeFlag&=~256,a.shapeFlag&=~512}function Si(a){return a.shapeFlag&128?a.ssContent:a}function xi(a,u){var m=arguments.length>2&&arguments[2]!==void 0?arguments[2]:on,S=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1;if(m){if(Fe.isRootHook(a)&&m!==m.root&&(m=m.root,Fe.isRootImmediateHook(a))){var I=m.proxy;P(u.bind(I),m,a,Fe.ON_LOAD===a?[I.$page.options]:[])}var O=m[a]||(m[a]=[]),F=u.__weh||(u.__weh=function(){if(!m.isUnmounted){R.pauseTracking(),jn(m);for(var W=arguments.length,G=new Array(W),le=0;le<W;le++)G[le]=arguments[le];var We=P(u,m,a,G);return qn(),R.resetTracking(),We}});return S?O.unshift(F):O.push(F),F}}var mr=a=>function(u){var m=arguments.length>1&&arguments[1]!==void 0?arguments[1]:on;return(!h.isInSSRComponentSetup||a==="sp")&&xi(a,function(){return u(...arguments)},m)},Qr=mr("bm"),er=mr("m"),tr=mr("bu"),Gn=mr("u"),nr=mr("bum"),cr=mr("um"),ho=mr("sp"),go=mr("rtg"),No=mr("rtc");function no(a){var u=arguments.length>1&&arguments[1]!==void 0?arguments[1]:on;xi("ec",a,u)}function ko(a,u){var m=An;if(m===null)return a;for(var S=Fo(m)||m.proxy,I=a.dirs||(a.dirs=[]),O=0;O<u.length;O++){var[F,W,G,le=y.EMPTY_OBJ]=u[O];F&&(y.isFunction(F)&&(F={mounted:F,updated:F}),F.deep&&Vr(W),I.push({dir:F,instance:S,value:W,oldValue:void 0,arg:G,modifiers:le}))}return a}function jr(a,u,m,S){for(var I=a.dirs,O=u&&u.dirs,F=0;F<I.length;F++){var W=I[F];O&&(W.oldValue=O[F].value);var G=W.dir[S];G&&(R.pauseTracking(),P(G,m,8,[a.el,W,a,u]),R.resetTracking())}}var xr="components",po="directives";function Ro(a,u){return Mi(xr,a,!0,u)||a}var ro=Symbol();function Bi(a){return y.isString(a)?Mi(xr,a,!1)||a:a||ro}function vo(a){return Mi(po,a)}function Mi(a,u){var m=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1,S=An||on;if(S){var I=S.type;if(a===xr){var O=Di(I,!1);if(O&&(O===u||O===y.camelize(u)||O===y.capitalize(y.camelize(u))))return I}var F=zi(S[a]||I[a],u)||zi(S.appContext[a],u);return!F&&m?I:F}}function zi(a,u){return a&&(a[u]||a[y.camelize(u)]||a[y.capitalize(y.camelize(u))])}function Qo(a,u,m,S){var I,O=m&&m[S];if(y.isArray(a)||y.isString(a)){I=new Array(a.length);for(var F=0,W=a.length;F<W;F++)I[F]=u(a[F],F,void 0,O&&O[F])}else if(typeof a=="number"){I=new Array(a);for(var G=0;G<a;G++)I[G]=u(G+1,G,void 0,O&&O[G])}else if(y.isObject(a))if(a[Symbol.iterator])I=Array.from(a,(Ye,Je)=>u(Ye,Je,void 0,O&&O[Je]));else{var le=Object.keys(a);I=new Array(le.length);for(var We=0,it=le.length;We<it;We++){var ge=le[We];I[We]=u(a[ge],ge,We,O&&O[We])}}else I=[];return m&&(m[S]=I),I}function B(a,u){for(var m=function(I){var O=u[I];if(y.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 W=O.fn(...arguments);return W&&(W.key=O.key),W}:O.fn)},S=0;S<u.length;S++)m(S);return a}function Q(a,u){var m=arguments.length>2&&arguments[2]!==void 0?arguments[2]:{},S=arguments.length>3?arguments[3]:void 0,I=arguments.length>4?arguments[4]:void 0;if(An.isCE||An.parent&&Tr(An.parent)&&An.parent.isCE)return u!=="default"&&(m.name=u),Ut("slot",m,S&&S());var O=a[u];O&&O._c&&(O._d=!1),Ce();var F=O&&he(O(m)),W=Mt(q,{key:m.key||F&&F.key||"_".concat(u)},F||(S?S():[]),F&&a._===1?64:-2);return!I&&W.scopeId&&(W.slotScopeIds=[W.scopeId+"-s"]),O&&O._c&&(O._d=!0),W}function he(a){return a.some(u=>dn(u)?!(u.type===ce||u.type===q&&!he(u.children)):!0)?a:null}function ae(a,u){var m={};for(var S in a)m[u&&/[A-Z]/.test(S)?"on:".concat(S):y.toHandlerKey(S)]=a[S];return m}var de=a=>a?Ai(a)?Fo(a)||a.proxy:de(a.parent):null,vt=y.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=>Dn(a),$forceUpdate:a=>a.f||(a.f=()=>Sn(a.update)),$nextTick:a=>a.n||(a.n=qr.bind(a.proxy)),$watch:a=>ki.bind(a)}),kt=(a,u)=>a!==y.EMPTY_OBJ&&!a.__isScriptSetup&&y.hasOwn(a,u),X={get(a,u){var{_:m}=a,{ctx:S,setupState:I,data:O,props:F,accessCache:W,type:G,appContext:le}=m,We;if(u[0]!=="$"){var it=W[u];if(it!==void 0)switch(it){case 1:return I[u];case 2:return O[u];case 4:return S[u];case 3:return F[u]}else{if(kt(I,u))return W[u]=1,I[u];if(O!==y.EMPTY_OBJ&&y.hasOwn(O,u))return W[u]=2,O[u];if((We=m.propsOptions[0])&&y.hasOwn(We,u))return W[u]=3,F[u];if(S!==y.EMPTY_OBJ&&y.hasOwn(S,u))return W[u]=4,S[u];ie&&(W[u]=0)}}var ge=vt[u],Ye,Je;if(ge)return u==="$attrs"&&R.track(m,"get",u),ge(m);if((Ye=G.__cssModules)&&(Ye=Ye[u]))return Ye;if(S!==y.EMPTY_OBJ&&y.hasOwn(S,u))return W[u]=4,S[u];if(Je=le.config.globalProperties,y.hasOwn(Je,u))return Je[u]},set(a,u,m){var{_:S}=a,{data:I,setupState:O,ctx:F}=S;return kt(O,u)?(O[u]=m,!0):I!==y.EMPTY_OBJ&&y.hasOwn(I,u)?(I[u]=m,!0):y.hasOwn(S.props,u)||u[0]==="$"&&u.slice(1)in S?!1:(F[u]=m,!0)},has(a,u){var{_:{data:m,setupState:S,accessCache:I,ctx:O,appContext:F,propsOptions:W}}=a,G;return!!I[u]||m!==y.EMPTY_OBJ&&y.hasOwn(m,u)||kt(S,u)||(G=W[0])&&y.hasOwn(G,u)||y.hasOwn(O,u)||y.hasOwn(vt,u)||y.hasOwn(F.config.globalProperties,u)},defineProperty(a,u,m){return m.get!=null?a._.accessCache[u]=0:y.hasOwn(m,"value")&&this.set(a,u,m.value,null),Reflect.defineProperty(a,u,m)}},K=y.extend({},X,{get(a,u){if(u!==Symbol.unscopables)return X.get(a,u,a)},has(a,u){var m=u[0]!=="_"&&!y.isGloballyWhitelisted(u);return m}}),ie=!0;function Ne(a){var u=Dn(a),m=a.proxy,S=a.ctx;ie=!1,u.beforeCreate&&Xt(u.beforeCreate,a,"bc");var{data:I,computed:O,methods:F,watch:W,provide:G,inject:le,created:We,beforeMount:it,mounted:ge,beforeUpdate:Ye,updated:Je,activated:mt,deactivated:at,beforeDestroy:Se,beforeUnmount:Ee,destroyed:Ae,unmounted:lt,render:Ve,renderTracked:Tt,renderTriggered:i,errorCaptured:l,serverPrefetch:d,expose:_,inheritAttrs:A,components:C,directives:k,filters:D}=u,H=null;if(le&&st(le,S,H,a.appContext.config.unwrapInjectedRef),F)for(var ne in F){var ve=F[ne];y.isFunction(ve)&&(S[ne]=ve.bind(m))}if(I){var Be=I.call(m,m);y.isObject(Be)&&(a.data=R.reactive(Be))}if(ie=!0,O){var ue=function(ye){var Le=O[ye],Oe=y.isFunction(Le)?Le.bind(m,m):y.isFunction(Le.get)?Le.get.bind(m,m):y.NOOP,bt=!y.isFunction(Le)&&y.isFunction(Le.set)?Le.set.bind(m):y.NOOP,Ct=bo({get:Oe,set:bt});Object.defineProperty(S,ye,{enumerable:!0,configurable:!0,get:()=>Ct.value,set:Ke=>Ct.value=Ke})};for(var ke in O)ue(ke)}if(W)for(var Ge in W)xn(W[Ge],S,m,Ge);if(G){var ut=y.isFunction(G)?G.call(m):G;Reflect.ownKeys(ut).forEach(ye=>{kr(ye,ut[ye])})}We&&Xt(We,a,"c");function Qe(ye,Le){y.isArray(Le)?Le.forEach(Oe=>ye(Oe.bind(m))):Le&&ye(Le.bind(m))}if(Qe(Qr,it),Qe(er,ge),Qe(tr,Ye),Qe(Gn,Je),Qe($r,mt),Qe(to,at),Qe(no,l),Qe(No,Tt),Qe(go,i),Qe(nr,Ee),Qe(cr,lt),Qe(ho,d),y.isArray(_))if(_.length){var Re=a.exposed||(a.exposed={});_.forEach(ye=>{Object.defineProperty(Re,ye,{get:()=>m[ye],set:Le=>m[ye]=Le})})}else a.exposed||(a.exposed={});Ve&&a.render===y.NOOP&&(a.render=Ve),A!=null&&(a.inheritAttrs=A),C&&(a.components=C),k&&(a.directives=k);var me=a.appContext.config.globalProperties.$applyOptions;me&&me(u,a,m)}function st(a,u){var m=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1;y.isArray(a)&&(a=Bo(a));var S=function(O){var F=a[O],W=void 0;y.isObject(F)?"default"in F?W=Nn(F.from||O,F.default,!0):W=Nn(F.from||O):W=Nn(F),R.isRef(W)&&m?Object.defineProperty(u,O,{enumerable:!0,configurable:!0,get:()=>W.value,set:G=>W.value=G}):u[O]=W};for(var I in a)S(I)}function Xt(a,u,m){P(y.isArray(a)?a.map(S=>S.bind(u.proxy)):a.bind(u.proxy),u,m)}function xn(a,u,m,S){var I=S.includes(".")?Io(m,S):()=>m[S];if(y.isString(a)){var O=u[a];y.isFunction(O)&&Fr(I,O)}else if(y.isFunction(a))Fr(I,a.bind(m));else if(y.isObject(a))if(y.isArray(a))a.forEach(W=>xn(W,u,m,S));else{var F=y.isFunction(a.handler)?a.handler.bind(m):u[a.handler];y.isFunction(F)&&Fr(I,F,a)}}function Dn(a){var u=a.type,{mixins:m,extends:S}=u,{mixins:I,optionsCache:O,config:{optionMergeStrategies:F}}=a.appContext,W=O.get(u),G;return W?G=W:!I.length&&!m&&!S?G=u:(G={},I.length&&I.forEach(le=>_r(G,le,F,!0)),_r(G,u,F)),y.isObject(u)&&O.set(u,G),G}function _r(a,u,m){var S=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1,{mixins:I,extends:O}=u;O&&_r(a,O,m,!0),I&&I.forEach(G=>_r(a,G,m,!0));for(var F in u)if(!(S&&F==="expose")){var W=Br[F]||m&&m[F];a[F]=W?W(a[F],u[F]):u[F]}return a}var Br={data:mo,props:Yn,emits:Yn,methods:Yn,computed:Yn,beforeCreate:Ln,created:Ln,beforeMount:Ln,mounted:Ln,beforeUpdate:Ln,updated:Ln,beforeDestroy:Ln,beforeUnmount:Ln,destroyed:Ln,unmounted:Ln,activated:Ln,deactivated:Ln,errorCaptured:Ln,serverPrefetch:Ln,components:Yn,directives:Yn,watch:Fn,provide:mo,inject:xo};function mo(a,u){return u?a?function(){return y.extend(y.isFunction(a)?a.call(this,this):a,y.isFunction(u)?u.call(this,this):u)}:u:a}function xo(a,u){return Yn(Bo(a),Bo(u))}function Bo(a){if(y.isArray(a)){for(var u={},m=0;m<a.length;m++)u[a[m]]=a[m];return u}return a}function Ln(a,u){return a?[...new Set([].concat(a,u))]:u}function Yn(a,u){return a?y.extend(y.extend(Object.create(null),a),u):u}function Fn(a,u){if(!a)return u;if(!u)return a;var m=y.extend(Object.create(null),a);for(var S in u)m[S]=Ln(a[S],u[S]);return m}function wi(a,u,m){var S=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1,I={},O={};y.def(O,en,1),a.propsDefaults=Object.create(null),ha(a,u,I,O);for(var F in a.propsOptions[0])F in I||(I[F]=void 0);m?a.props=S?I:R.shallowReactive(I):a.type.props?a.props=I:a.props=O,a.attrs=O}function is(a,u,m,S){var{props:I,attrs:O,vnode:{patchFlag:F}}=a,W=R.toRaw(I),[G]=a.propsOptions,le=!1;if((S||F>0)&&!(F&16)){if(F&8)for(var We=a.vnode.dynamicProps,it=0;it<We.length;it++){var ge=We[it];if(!Wn(a.emitsOptions,ge)){var Ye=u[ge];if(G)if(y.hasOwn(O,ge))Ye!==O[ge]&&(O[ge]=Ye,le=!0);else{var Je=y.camelize(ge);I[Je]=br(G,W,Je,Ye,a,!1)}else Ye!==O[ge]&&(O[ge]=Ye,le=!0)}}}else{ha(a,u,I,O)&&(le=!0);var mt;for(var at in W)(!u||!y.hasOwn(u,at)&&((mt=y.hyphenate(at))===at||!y.hasOwn(u,mt)))&&(G?m&&(m[at]!==void 0||m[mt]!==void 0)&&(I[at]=br(G,W,at,void 0,a,!0)):delete I[at]);if(O!==W)for(var Se in O)(!u||!y.hasOwn(u,Se)&&!0)&&(delete O[Se],le=!0)}le&&R.trigger(a,"set","$attrs")}function ha(a,u,m,S){var[I,O]=a.propsOptions,F=!1,W;if(u){for(var G in u)if(!y.isReservedProp(G)){var le=u[G],We=void 0;I&&y.hasOwn(I,We=y.camelize(G))?!O||!O.includes(We)?m[We]=le:(W||(W={}))[We]=le:Wn(a.emitsOptions,G)||(!(G in S)||le!==S[G])&&(S[G]=le,F=!0)}}if(O)for(var it=R.toRaw(m),ge=W||y.EMPTY_OBJ,Ye=0;Ye<O.length;Ye++){var Je=O[Ye];m[Je]=br(I,it,Je,ge[Je],a,!y.hasOwn(ge,Je))}return F}function br(a,u,m,S,I,O){var F=a[m];if(F!=null){var W=y.hasOwn(F,"default");if(W&&S===void 0){var G=F.default;if(F.type!==Function&&y.isFunction(G)){var{propsDefaults:le}=I;m in le?S=le[m]:(jn(I),S=le[m]=G.call(null,u),qn())}else S=G}F[0]&&(O&&!W?S=!1:F[1]&&(S===""||S===y.hyphenate(m))&&(S=!0))}return S}function Ta(a,u){var m=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!1,S=u.propsCache,I=S.get(a);if(I)return I;var O=a.props,F={},W=[],G=!1;if(!y.isFunction(a)){var le=Ae=>{G=!0;var[lt,Ve]=Ta(Ae,u,!0);y.extend(F,lt),Ve&&W.push(...Ve)};!m&&u.mixins.length&&u.mixins.forEach(le),a.extends&&le(a.extends),a.mixins&&a.mixins.forEach(le)}if(!O&&!G)return y.isObject(a)&&S.set(a,y.EMPTY_ARR),y.EMPTY_ARR;if(y.isArray(O))for(var We=0;We<O.length;We++){var it=y.camelize(O[We]);La(it)&&(F[it]=y.EMPTY_OBJ)}else if(O)for(var ge in O){var Ye=y.camelize(ge);if(La(Ye)){var Je=O[ge],mt=F[Ye]=y.isArray(Je)||y.isFunction(Je)?{type:Je}:Object.assign({},Je);if(mt){var at=Ua(Boolean,mt.type),Se=Ua(String,mt.type);mt[0]=at>-1,mt[1]=Se<0||at<Se,(at>-1||y.hasOwn(mt,"default"))&&W.push(Ye)}}}var Ee=[F,W];return y.isObject(a)&&S.set(a,Ee),Ee}function La(a){return a[0]!=="$"}function Fa(a){var u=a&&a.toString().match(/^\s*(function|class) (\w+)/);return u?u[2]:a===null?"null":""}function Va(a,u){return Fa(a)===Fa(u)}function Ua(a,u){return y.isArray(u)?u.findIndex(m=>Va(m,a)):y.isFunction(u)&&Va(u,a)?0:-1}var ga=a=>a[0]==="_"||a==="$stable",Pa=a=>y.isArray(a)?a.map(Un):[Un(a)],Vn=(a,u,m)=>{if(u._n)return u;var S=Ui(function(){return Pa(u(...arguments))},m);return S._c=!1,S},Mo=(a,u,m)=>{var S=a._ctx;for(var I in a)if(!ga(I)){var O=a[I];y.isFunction(O)?u[I]=Vn(I,O,S):O!=null&&function(){var F=Pa(O);u[I]=()=>F}()}},ea=(a,u)=>{var m=Pa(u);a.slots.default=()=>m},Wi=(a,u)=>{if(a.vnode.shapeFlag&32){var m=u._;m?(a.slots=R.toRaw(u),y.def(u,"_",m)):Mo(u,a.slots={})}else a.slots={},u&&ea(a,u);y.def(a.slots,en,1)},os=(a,u,m)=>{var{vnode:S,slots:I}=a,O=!0,F=y.EMPTY_OBJ;if(S.shapeFlag&32){var W=u._;W?m&&W===1?O=!1:(y.extend(I,u),!m&&W===1&&delete I._):(O=!u.$stable,Mo(u,I)),F=u}else u&&(ea(a,u),F={default:1});if(O)for(var G in I)!ga(G)&&!(G in F)&&delete I[G]};function as(){return{app:null,config:{isNativeTag:y.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 Do=0;function ss(a,u){return function(S){var I=arguments.length>1&&arguments[1]!==void 0?arguments[1]:null;y.isFunction(S)||(S=Object.assign({},S)),I!=null&&!y.isObject(I)&&(I=null);var O=as(),F=new Set,W=!1,G=O.app={_uid:Do++,_component:S,_props:I,_container:null,_context:O,_instance:null,version:ps,get config(){return O.config},set config(le){},use(le){for(var We=arguments.length,it=new Array(We>1?We-1:0),ge=1;ge<We;ge++)it[ge-1]=arguments[ge];return F.has(le)||(le&&y.isFunction(le.install)?(F.add(le),le.install(G,...it)):y.isFunction(le)&&(F.add(le),le(G,...it))),G},mixin(le){return O.mixins.includes(le)||O.mixins.push(le),G},component(le,We){return We?(O.components[le]=We,G):O.components[le]},directive(le,We){return We?(O.directives[le]=We,G):O.directives[le]},mount(le,We,it){if(!W){var ge=Ut(S,I);return ge.appContext=O,We&&u?u(ge,le):a(ge,le,it),W=!0,G._container=le,le.__vue_app__=G,G._instance=ge.component,Fo(ge.component)||ge.component.proxy}},unmount(){W&&(a(null,G._container),delete G._container.__vue_app__)},provide(le,We){return O.provides[le]=We,G}};return G}}function io(a,u,m,S){var I=arguments.length>4&&arguments[4]!==void 0?arguments[4]:!1;if(y.isArray(a)){a.forEach((mt,at)=>io(mt,u&&(y.isArray(u)?u[at]:u),m,S,I));return}if(!(Tr(S)&&!I)){var O=S.shapeFlag&4?Fo(S.component)||S.component.proxy:S.el,F=I?null:O,{i:W,r:G}=a,le=u&&u.r,We=W.refs===y.EMPTY_OBJ?W.refs={}:W.refs,it=W.setupState;if(le!=null&&le!==G&&(y.isString(le)?(We[le]=null,y.hasOwn(it,le)&&(it[le]=null)):R.isRef(le)&&(le.value=null)),y.isFunction(G))Ot(G,W,12,[F,We]);else{var ge=y.isString(G),Ye=R.isRef(G);if(ge||Ye){var Je=()=>{if(a.f){var mt=ge?y.hasOwn(it,G)?it[G]:We[G]:G.value;I?y.isArray(mt)&&y.remove(mt,O):y.isArray(mt)?mt.includes(O)||mt.push(O):ge?(We[G]=[O],y.hasOwn(it,G)&&(it[G]=We[G])):(G.value=[O],a.k&&(We[a.k]=G.value))}else ge?(We[G]=F,y.hasOwn(it,G)&&(it[G]=F)):Ye&&(G.value=F,a.k&&(We[a.k]=F))};F?(Je.id=-1,ur(Je,m)):Je()}}}}var si=!1,Ci=a=>/svg/.test(a.namespaceURI)&&a.tagName!=="foreignObject",Gi=a=>a.nodeType===8;function li(a){var{mt:u,p:m,o:{patchProp:S,createText:I,nextSibling:O,parentNode:F,remove:W,insert:G,createComment:le}}=a,We=(Se,Ee)=>{if(!Ee.hasChildNodes()){m(null,Se,Ee),Pn(),Ee._vnode=Se;return}si=!1,it(Ee.firstChild,Se,null,null,null),Pn(),Ee._vnode=Se,si&&console.error("Hydration completed but contains mismatches.")},it=function(Se,Ee,Ae,lt,Ve){var Tt=arguments.length>5&&arguments[5]!==void 0?arguments[5]:!1,i=Gi(Se)&&Se.data==="[",l=()=>mt(Se,Ee,Ae,lt,Ve,i),{type:d,ref:_,shapeFlag:A,patchFlag:C}=Ee,k=Se.nodeType;Ee.el=Se,C===-2&&(Tt=!1,Ee.dynamicChildren=null);var D=null;switch(d){case te:k!==3?Ee.children===""?(G(Ee.el=I(""),F(Se),Se),D=Se):D=l():(Se.data!==Ee.children&&(si=!0,Se.data=Ee.children),D=O(Se));break;case ce:k!==8||i?D=l():D=O(Se);break;case pe:if(i&&(Se=O(Se),k=Se.nodeType),k===1||k===3){D=Se;for(var H=!Ee.children.length,ne=0;ne<Ee.staticCount;ne++)H&&(Ee.children+=D.nodeType===1?D.outerHTML:D.data),ne===Ee.staticCount-1&&(Ee.anchor=D),D=O(D);return i?O(D):D}else l();break;case q:i?D=Je(Se,Ee,Ae,lt,Ve,Tt):D=l();break;default:if(A&1)k!==1||Ee.type.toLowerCase()!==Se.tagName.toLowerCase()?D=l():D=ge(Se,Ee,Ae,lt,Ve,Tt);else if(A&6){Ee.slotScopeIds=Ve;var ve=F(Se);if(u(Ee,ve,null,Ae,lt,Ci(ve),Tt),D=i?at(Se):O(Se),D&&Gi(D)&&D.data==="teleport end"&&(D=O(D)),Tr(Ee)){var Be;i?(Be=Ut(q),Be.anchor=D?D.previousSibling:ve.lastChild):Be=Se.nodeType===3?ei(""):Ut("div"),Be.el=Se,Ee.component.subTree=Be}}else A&64?k!==8?D=l():D=Ee.type.hydrate(Se,Ee,Ae,lt,Ve,Tt,a,Ye):A&128&&(D=Ee.type.hydrate(Se,Ee,Ae,lt,Ci(F(Se)),Ve,Tt,a,it))}return _!=null&&io(_,null,lt,Ee),D},ge=(Se,Ee,Ae,lt,Ve,Tt)=>{Tt=Tt||!!Ee.dynamicChildren;var{type:i,props:l,patchFlag:d,shapeFlag:_,dirs:A}=Ee,C=i==="input"&&A||i==="option";if(C||d!==-1){if(A&&jr(Ee,null,Ae,"created"),l)if(C||!Tt||d&(16|32))for(var k in l)(C&&k.endsWith("value")||y.isOn(k)&&!y.isReservedProp(k))&&S(Se,k,null,l[k],!1,void 0,Ae);else l.onClick&&S(Se,"onClick",null,l.onClick,!1,void 0,Ae);var D;if((D=l&&l.onVnodeBeforeMount)&&yr(D,Ae,Ee),A&&jr(Ee,null,Ae,"beforeMount"),((D=l&&l.onVnodeMounted)||A)&&ii(()=>{D&&yr(D,Ae,Ee),A&&jr(Ee,null,Ae,"mounted")},lt),_&16&&!(l&&(l.innerHTML||l.textContent)))for(var H=Ye(Se.firstChild,Ee,Se,Ae,lt,Ve,Tt);H;){si=!0;var ne=H;H=H.nextSibling,W(ne)}else _&8&&Se.textContent!==Ee.children&&(si=!0,Se.textContent=Ee.children)}return Se.nextSibling},Ye=(Se,Ee,Ae,lt,Ve,Tt,i)=>{i=i||!!Ee.dynamicChildren;for(var l=Ee.children,d=l.length,_=0;_<d;_++){var A=i?l[_]:l[_]=Un(l[_]);if(Se)Se=it(Se,A,lt,Ve,Tt,i);else{if(A.type===te&&!A.children)continue;si=!0,m(null,A,Ae,null,lt,Ve,Ci(Ae),Tt)}}return Se},Je=(Se,Ee,Ae,lt,Ve,Tt)=>{var{slotScopeIds:i}=Ee;i&&(Ve=Ve?Ve.concat(i):i);var l=F(Se),d=Ye(O(Se),Ee,l,Ae,lt,Ve,Tt);return d&&Gi(d)&&d.data==="]"?O(Ee.anchor=d):(si=!0,G(Ee.anchor=le("]"),l,d),d)},mt=(Se,Ee,Ae,lt,Ve,Tt)=>{if(si=!0,Ee.el=null,Tt)for(var i=at(Se);;){var l=O(Se);if(l&&l!==i)W(l);else break}var d=O(Se),_=F(Se);return W(Se),m(null,Ee,_,d,Ae,lt,Ci(_),Ve),d},at=Se=>{for(var Ee=0;Se;)if(Se=O(Se),Se&&Gi(Se)&&(Se.data==="["&&Ee++,Se.data==="]")){if(Ee===0)return O(Se);Ee--}return Se};return[We,it]}var ur=ii;function lr(a){return Ha(a)}function $a(a){return Ha(a,li)}function Ha(a,u){var m=y.getGlobalThis();m.__VUE__=!0;var{insert:S,remove:I,patchProp:O,forcePatchProp:F,createElement:W,createText:G,createComment:le,setText:We,setElementText:it,parentNode:ge,nextSibling:Ye,setScopeId:Je=y.NOOP,insertStaticContent:mt}=a,at=function(M,j,se){var re=arguments.length>3&&arguments[3]!==void 0?arguments[3]:null,oe=arguments.length>4&&arguments[4]!==void 0?arguments[4]:null,Ue=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,Ze=arguments.length>8&&arguments[8]!==void 0?arguments[8]:!!j.dynamicChildren;if(M!==j){M&&!Gt(M,j)&&(re=Oe(M),Qe(M,oe,Ue,!0),M=null),j.patchFlag===-2&&(Ze=!1,j.dynamicChildren=null);var{type:$e,ref:$t,shapeFlag:pt}=j;switch($e){case te:Se(M,j,se,re);break;case ce:Ee(M,j,se,re);break;case pe:M==null&&Ae(j,se,re,rt);break;case q:k(M,j,se,re,oe,Ue,rt,qe,Ze);break;default:pt&1?Tt(M,j,se,re,oe,Ue,rt,qe,Ze):pt&6?D(M,j,se,re,oe,Ue,rt,qe,Ze):(pt&64||pt&128)&&$e.process(M,j,se,re,oe,Ue,rt,qe,Ze,Ct)}$t!=null&&oe&&io($t,M&&M.ref,Ue,j||M,!j)}},Se=(M,j,se,re)=>{if(M==null)S(j.el=G(j.children),se,re);else{var oe=j.el=M.el;j.children!==M.children&&We(oe,j.children)}},Ee=(M,j,se,re)=>{M==null?S(j.el=le(j.children||""),se,re):j.el=M.el},Ae=(M,j,se,re)=>{[M.el,M.anchor]=mt(M.children,j,se,re,M.el,M.anchor)},lt=(M,j,se)=>{for(var{el:re,anchor:oe}=M,Ue;re&&re!==oe;)Ue=Ye(re),S(re,j,se),re=Ue;S(oe,j,se)},Ve=M=>{for(var{el:j,anchor:se}=M,re;j&&j!==se;)re=Ye(j),I(j),j=re;I(se)},Tt=(M,j,se,re,oe,Ue,rt,qe,Ze)=>{rt=rt||j.type==="svg",M==null?i(j,se,re,oe,Ue,rt,qe,Ze):_(M,j,oe,Ue,rt,qe,Ze)},i=(M,j,se,re,oe,Ue,rt,qe)=>{var Ze,$e,{type:$t,props:pt,shapeFlag:xt,transition:Bt,dirs:Mn}=M;if(Ze=M.el=W(M.type,Ue,pt&&pt.is,pt),xt&8?it(Ze,M.children):xt&16&&d(M.children,Ze,null,re,oe,Ue&&$t!=="foreignObject",rt,qe),Mn&&jr(M,null,re,"created"),l(Ze,M,M.scopeId,rt,re),pt){for(var Rn in pt)Rn!=="value"&&!y.isReservedProp(Rn)&&O(Ze,Rn,null,pt[Rn],Ue,M.children,re,oe,Le,M.hostInstance);"value"in pt&&O(Ze,"value",null,pt.value,!1,[],re,null,void 0,M.hostInstance),($e=pt.onVnodeBeforeMount)&&yr($e,re,M)}Mn&&jr(M,null,re,"beforeMount");var vn=(!oe||oe&&!oe.pendingBranch)&&Bt&&!Bt.persisted;vn&&Bt.beforeEnter(Ze),S(Ze,j,se),(($e=pt&&pt.onVnodeMounted)||vn||Mn)&&ur(()=>{$e&&yr($e,re,M),vn&&Bt.enter(Ze),Mn&&jr(M,null,re,"mounted")},oe)},l=(M,j,se,re,oe)=>{if(se&&Je(M,se),re)for(var Ue=0;Ue<re.length;Ue++)Je(M,re[Ue]);if(oe){var rt=oe.subTree;if(j===rt){var qe=oe.vnode;l(M,qe,qe.scopeId,qe.slotScopeIds,oe.parent)}}},d=function(M,j,se,re,oe,Ue,rt,qe){for(var Ze=arguments.length>8&&arguments[8]!==void 0?arguments[8]:0,$e=Ze;$e<M.length;$e++){var $t=M[$e]=qe?$n(M[$e]):Un(M[$e]);at(null,$t,j,se,re,oe,Ue,rt,qe)}},_=(M,j,se,re,oe,Ue,rt)=>{var qe=j.el=M.el,{patchFlag:Ze,dynamicChildren:$e,dirs:$t}=j;Ze|=M.patchFlag&16;var pt=M.props||y.EMPTY_OBJ,xt=j.props||y.EMPTY_OBJ,Bt;se&&Yi(se,!1),(Bt=xt.onVnodeBeforeUpdate)&&yr(Bt,se,j,M),$t&&jr(j,M,se,"beforeUpdate"),se&&Yi(se,!0);var Mn=oe&&j.type!=="foreignObject";if($e?A(M.dynamicChildren,$e,qe,se,re,Mn,Ue):rt||ue(M,j,qe,null,se,re,Mn,Ue,!1),Ze>0){if(Ze&16)C(qe,j,pt,xt,se,re,oe);else if(Ze&2&&pt.class!==xt.class&&O(qe,"class",null,xt.class,oe,[],se,null,void 0,j.hostInstance),Ze&4&&O(qe,"style",pt.style,xt.style,oe,[],se,null,void 0,j.hostInstance),Ze&8)for(var Rn=j.dynamicProps,vn=0;vn<Rn.length;vn++){var bn=Rn[vn],fr=pt[bn],ni=xt[bn];(ni!==fr||bn==="value"||F&&F(qe,bn))&&O(qe,bn,fr,ni,oe,M.children,se,re,Le,j.hostInstance)}Ze&1&&M.children!==j.children&&it(qe,j.children)}else!rt&&$e==null&&C(qe,j,pt,xt,se,re,oe);((Bt=xt.onVnodeUpdated)||$t)&&ur(()=>{Bt&&yr(Bt,se,j,M),$t&&jr(j,M,se,"updated")},re)},A=(M,j,se,re,oe,Ue,rt)=>{for(var qe=0;qe<j.length;qe++){var Ze=M[qe],$e=j[qe],$t=Ze.el&&(Ze.type===q||!Gt(Ze,$e)||Ze.shapeFlag&(6|64))?ge(Ze.el):se;at(Ze,$e,$t,null,re,oe,Ue,rt,!0)}},C=(M,j,se,re,oe,Ue,rt)=>{if(se!==re){if(se!==y.EMPTY_OBJ)for(var qe in se)!y.isReservedProp(qe)&&!(qe in re)&&O(M,qe,se[qe],null,rt,j.children,oe,Ue,Le,j.hostInstance);for(var Ze in re)if(!y.isReservedProp(Ze)){var $e=re[Ze],$t=se[Ze];($e!==$t&&Ze!=="value"||F&&F(M,Ze))&&O(M,Ze,$t,$e,rt,j.children,oe,Ue,Le,j.hostInstance)}"value"in re&&O(M,"value",se.value,re.value,!1,[],oe,null,void 0,j.hostInstance)}},k=(M,j,se,re,oe,Ue,rt,qe,Ze)=>{var $e=j.el=M?M.el:G(""),$t=j.anchor=M?M.anchor:G(""),{patchFlag:pt,dynamicChildren:xt,slotScopeIds:Bt}=j;Bt&&(qe=qe?qe.concat(Bt):Bt),M==null?(S($e,se,re),S($t,se,re),d(j.children,se,$t,oe,Ue,rt,qe,Ze)):pt>0&&pt&64&&xt&&M.dynamicChildren?(A(M.dynamicChildren,xt,se,oe,Ue,rt,qe),(j.key!=null||oe&&j===oe.subTree)&&oo(M,j,!0)):ue(M,j,se,$t,oe,Ue,rt,qe,Ze)},D=(M,j,se,re,oe,Ue,rt,qe,Ze)=>{j.slotScopeIds=qe,M==null?j.shapeFlag&512?oe.ctx.activate(j,se,re,rt,Ze):H(j,se,re,oe,Ue,rt,Ze):ne(M,j,Ze)},H=(M,j,se,re,oe,Ue,rt)=>{var qe=M.component=cs(M,re,oe);if(Pr(M)&&(qe.ctx.renderer=Ct),us(qe),qe.asyncDep){if(oe&&oe.registerDep(qe,ve),!M.el){var Ze=qe.subTree=Ut(ce);Ee(null,Ze,j,se)}return}ve(qe,M,j,se,oe,Ue,rt)},ne=(M,j,se)=>{var re=j.component=M.component;if(Ao(M,j,se))if(re.asyncDep&&!re.asyncResolved){Be(re,j,se);return}else re.next=j,Lr(re.update),re.update();else j.el=M.el,re.vnode=j},ve=(M,j,se,re,oe,Ue,rt)=>{var qe=()=>{if(M.isMounted){var{next:Jt,bu:an,u:lo,parent:Y,vnode:ee}=M,be=Jt,Me;Yi(M,!1),Jt?(Jt.el=ee.el,Be(M,Jt,rt)):Jt=ee,an&&y.invokeArrayFns(an),(Me=Jt.props&&Jt.props.onVnodeBeforeUpdate)&&yr(Me,Y,Jt,ee),Yi(M,!0);var De=Xo(M),Xe=M.subTree;M.subTree=De,at(Xe,De,ge(Xe.el),Oe(Xe),M,oe,Ue),Jt.el=De.el,be===null&&Xi(M,De.el),lo&&ur(lo,oe),(Me=Jt.props&&Jt.props.onVnodeUpdated)&&ur(()=>yr(Me,Y,Jt,ee),oe)}else{var $t,{el:pt,props:xt}=j,{bm:Bt,m:Mn,parent:Rn}=M,vn=Tr(j);if(Yi(M,!1),Bt&&y.invokeArrayFns(Bt),!vn&&($t=xt&&xt.onVnodeBeforeMount)&&yr($t,Rn,j),Yi(M,!0),pt&&Rt){var bn=()=>{M.subTree=Xo(M),Rt(pt,M.subTree,M,oe,null)};vn?j.type.__asyncLoader().then(()=>!M.isUnmounted&&bn()):bn()}else{var fr=M.subTree=Xo(M);at(null,fr,se,re,M,oe,Ue),j.el=fr.el}if(Mn&&ur(Mn,oe),!vn&&($t=xt&&xt.onVnodeMounted)){var ni=j;ur(()=>yr($t,Rn,ni),oe)}(j.shapeFlag&256||Rn&&Tr(Rn.vnode)&&Rn.vnode.shapeFlag&256)&&M.a&&ur(M.a,oe),M.isMounted=!0,j=se=re=null}},Ze=M.effect=new R.ReactiveEffect(qe,()=>Sn($e),M.scope),$e=M.update=()=>Ze.run();$e.id=M.uid,Yi(M,!0),$e()},Be=(M,j,se)=>{j.component=M;var re=M.vnode.props;M.vnode=j,M.next=null,is(M,j.props,re,se),os(M,j.children,se),R.pauseTracking(),vi(),R.resetTracking()},ue=function(M,j,se,re,oe,Ue,rt,qe){var Ze=arguments.length>8&&arguments[8]!==void 0?arguments[8]:!1,$e=M&&M.children,$t=M?M.shapeFlag:0,pt=j.children,{patchFlag:xt,shapeFlag:Bt}=j;if(xt>0){if(xt&128){Ge($e,pt,se,re,oe,Ue,rt,qe,Ze);return}else if(xt&256){ke($e,pt,se,re,oe,Ue,rt,qe,Ze);return}}Bt&8?($t&16&&Le($e,oe,Ue),pt!==$e&&it(se,pt)):$t&16?Bt&16?Ge($e,pt,se,re,oe,Ue,rt,qe,Ze):Le($e,oe,Ue,!0):($t&8&&it(se,""),Bt&16&&d(pt,se,re,oe,Ue,rt,qe,Ze))},ke=(M,j,se,re,oe,Ue,rt,qe,Ze)=>{M=M||y.EMPTY_ARR,j=j||y.EMPTY_ARR;var $e=M.length,$t=j.length,pt=Math.min($e,$t),xt;for(xt=0;xt<pt;xt++){var Bt=j[xt]=Ze?$n(j[xt]):Un(j[xt]);at(M[xt],Bt,se,null,oe,Ue,rt,qe,Ze)}$e>$t?Le(M,oe,Ue,!0,!1,pt):d(j,se,re,oe,Ue,rt,qe,Ze,pt)},Ge=(M,j,se,re,oe,Ue,rt,qe,Ze)=>{for(var $e=0,$t=j.length,pt=M.length-1,xt=$t-1;$e<=pt&&$e<=xt;){var Bt=M[$e],Mn=j[$e]=Ze?$n(j[$e]):Un(j[$e]);if(Gt(Bt,Mn))at(Bt,Mn,se,null,oe,Ue,rt,qe,Ze);else break;$e++}for(;$e<=pt&&$e<=xt;){var Rn=M[pt],vn=j[xt]=Ze?$n(j[xt]):Un(j[xt]);if(Gt(Rn,vn))at(Rn,vn,se,null,oe,Ue,rt,qe,Ze);else break;pt--,xt--}if($e>pt){if($e<=xt)for(var bn=xt+1,fr=bn<$t?j[bn].el:re;$e<=xt;)at(null,j[$e]=Ze?$n(j[$e]):Un(j[$e]),se,fr,oe,Ue,rt,qe,Ze),$e++}else if($e>xt)for(;$e<=pt;)Qe(M[$e],oe,Ue,!0),$e++;else{var ni=$e,Jt=$e,an=new Map;for($e=Jt;$e<=xt;$e++){var lo=j[$e]=Ze?$n(j[$e]):Un(j[$e]);lo.key!=null&&an.set(lo.key,$e)}var Y,ee=0,be=xt-Jt+1,Me=!1,De=0,Xe=new Array(be);for($e=0;$e<be;$e++)Xe[$e]=0;for($e=ni;$e<=pt;$e++){var _t=M[$e];if(ee>=be){Qe(_t,oe,Ue,!0);continue}var et=void 0;if(_t.key!=null)et=an.get(_t.key);else for(Y=Jt;Y<=xt;Y++)if(Xe[Y-Jt]===0&&Gt(_t,j[Y])){et=Y;break}et===void 0?Qe(_t,oe,Ue,!0):(Xe[et-Jt]=$e+1,et>=De?De=et:Me=!0,at(_t,j[et],se,null,oe,Ue,rt,qe,Ze),ee++)}var tt=Me?ao(Xe):y.EMPTY_ARR;for(Y=tt.length-1,$e=be-1;$e>=0;$e--){var He=Jt+$e,zt=j[He],Lt=He+1<$t?j[He+1].el:re;Xe[$e]===0?at(null,zt,se,Lt,oe,Ue,rt,qe,Ze):Me&&(Y<0||$e!==tt[Y]?ut(zt,se,Lt,2):Y--)}}},ut=function(M,j,se,re){var oe=arguments.length>4&&arguments[4]!==void 0?arguments[4]:null,{el:Ue,type:rt,transition:qe,children:Ze,shapeFlag:$e}=M;if($e&6){ut(M.component.subTree,j,se,re);return}if($e&128){M.suspense.move(j,se,re);return}if($e&64){rt.move(M,j,se,Ct);return}if(rt===q){S(Ue,j,se);for(var $t=0;$t<Ze.length;$t++)ut(Ze[$t],j,se,re);S(M.anchor,j,se);return}if(rt===pe){lt(M,j,se);return}var pt=re!==2&&$e&1&&qe;if(pt)if(re===0)qe.beforeEnter(Ue),S(Ue,j,se),ur(()=>qe.enter(Ue),oe);else{var{leave:xt,delayLeave:Bt,afterLeave:Mn}=qe,Rn=()=>S(Ue,j,se),vn=()=>{xt(Ue,()=>{Rn(),Mn&&Mn()})};Bt?Bt(Ue,Rn,vn):vn()}else S(Ue,j,se)},Qe=function(M,j,se){var re=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1,oe=arguments.length>4&&arguments[4]!==void 0?arguments[4]:!1,{type:Ue,props:rt,ref:qe,children:Ze,dynamicChildren:$e,shapeFlag:$t,patchFlag:pt,dirs:xt}=M;if(qe!=null&&io(qe,null,se,M,!0),$t&256){j.ctx.deactivate(M);return}var Bt=$t&1&&xt,Mn=!Tr(M),Rn;if(Mn&&(Rn=rt&&rt.onVnodeBeforeUnmount)&&yr(Rn,j,M),$t&6)ye(M.component,se,re);else{if($t&128){M.suspense.unmount(se,re);return}Bt&&jr(M,null,j,"beforeUnmount"),$t&64?M.type.remove(M,j,se,oe,Ct,re):$e&&(Ue!==q||pt>0&&pt&64)?Le($e,j,se,!1,!0):(Ue===q&&pt&(128|256)||!oe&&$t&16)&&Le(Ze,j,se),re&&Re(M)}(Mn&&(Rn=rt&&rt.onVnodeUnmounted)||Bt)&&ur(()=>{Rn&&yr(Rn,j,M),Bt&&jr(M,null,j,"unmounted")},se)},Re=M=>{var{type:j,el:se,anchor:re,transition:oe}=M;if(j===q){me(se,re);return}if(j===pe){Ve(M);return}var Ue=()=>{I(se),oe&&!oe.persisted&&oe.afterLeave&&oe.afterLeave()};if(M.shapeFlag&1&&oe&&!oe.persisted){var{leave:rt,delayLeave:qe}=oe,Ze=()=>rt(se,Ue);qe?qe(M.el,Ue,Ze):Ze()}else Ue()},me=(M,j)=>{for(var se;M!==j;)se=Ye(M),I(M),M=se;I(j)},ye=(M,j,se)=>{var{bum:re,scope:oe,update:Ue,subTree:rt,um:qe}=M;re&&y.invokeArrayFns(re),oe.stop(),Ue&&(Ue.active=!1,Qe(rt,M,j,se)),qe&&ur(qe,j),ur(()=>{M.isUnmounted=!0},j),j&&j.pendingBranch&&!j.isUnmounted&&M.asyncDep&&!M.asyncResolved&&M.suspenseId===j.pendingId&&(j.deps--,j.deps===0&&j.resolve())},Le=function(M,j,se){for(var re=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1,oe=arguments.length>4&&arguments[4]!==void 0?arguments[4]:!1,Ue=arguments.length>5&&arguments[5]!==void 0?arguments[5]:0,rt=Ue;rt<M.length;rt++)Qe(M[rt],j,se,re,oe)},Oe=M=>M.shapeFlag&6?Oe(M.component.subTree):M.shapeFlag&128?M.suspense.next():Ye(M.anchor||M.el),bt=(M,j,se)=>{M==null?j._vnode&&Qe(j._vnode,null,null,!0):at(j._vnode||null,M,j,null,null,null,se),vi(),Pn(),j._vnode=M},Ct={p:at,um:Qe,m:ut,r:Re,mt:H,mc:d,pc:ue,pbc:A,n:Oe,o:a},Ke,Rt;return u&&([Ke,Rt]=u(Ct)),{render:bt,hydrate:Ke,createApp:ss(bt,Ke)}}function Yi(a,u){var{effect:m,update:S}=a;m.allowRecurse=S.allowRecurse=u}function oo(a,u){var m=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!1,S=a.children,I=u.children;if(y.isArray(S)&&y.isArray(I))for(var O=0;O<S.length;O++){var F=S[O],W=I[O];W.shapeFlag&1&&!W.dynamicChildren&&((W.patchFlag<=0||W.patchFlag===32)&&(W=I[O]=$n(I[O]),W.el=F.el),m||oo(F,W)),W.type===te&&(W.el=F.el)}}function ao(a){var u=a.slice(),m=[0],S,I,O,F,W,G=a.length;for(S=0;S<G;S++){var le=a[S];if(le!==0){if(I=m[m.length-1],a[I]<le){u[S]=I,m.push(S);continue}for(O=0,F=m.length-1;O<F;)W=O+F>>1,a[m[W]]<le?O=W+1:F=W;le<a[m[O]]&&(O>0&&(u[S]=m[O-1]),m[O]=S)}}for(O=m.length,F=m[O-1];O-- >0;)m[O]=F,F=u[F];return m}var ls=a=>a.__isTeleport,pa=a=>a&&(a.disabled||a.disabled===""),Lo=a=>typeof SVGElement!="undefined"&&a instanceof SVGElement,va=(a,u)=>{var m=a&&a.to;if(y.isString(m))if(u){var S=u(m);return S}else return null;else return m},v={__isTeleport:!0,process(a,u,m,S,I,O,F,W,G,le){var{mc:We,pc:it,pbc:ge,o:{insert:Ye,querySelector:Je,createText:mt,createComment:at}}=le,Se=pa(u.props),{shapeFlag:Ee,children:Ae,dynamicChildren:lt}=u;if(a==null){var Ve=u.el=mt(""),Tt=u.anchor=mt("");Ye(Ve,m,S),Ye(Tt,m,S);var i=u.target=va(u.props,Je),l=u.targetAnchor=mt("");i&&(Ye(l,i),F=F||Lo(i));var d=(ve,Be)=>{Ee&16&&We(Ae,ve,Be,I,O,F,W,G)};Se?d(m,Tt):i&&d(i,l)}else{u.el=a.el;var _=u.anchor=a.anchor,A=u.target=a.target,C=u.targetAnchor=a.targetAnchor,k=pa(a.props),D=k?m:A,H=k?_:C;if(F=F||Lo(A),lt?(ge(a.dynamicChildren,lt,D,I,O,F,W),oo(a,u,!0)):G||it(a,u,D,H,I,O,F,W,!1),Se)k||x(u,m,_,le,1);else if((u.props&&u.props.to)!==(a.props&&a.props.to)){var ne=u.target=va(u.props,Je);ne&&x(u,ne,null,le,0)}else k&&x(u,A,C,le,1)}Z(u)},remove(a,u,m,S,I,O){var{um:F,o:{remove:W}}=I,{shapeFlag:G,children:le,anchor:We,targetAnchor:it,target:ge,props:Ye}=a;if(ge&&W(it),(O||!pa(Ye))&&(W(We),G&16))for(var Je=0;Je<le.length;Je++){var mt=le[Je];F(mt,u,m,!0,!!mt.dynamicChildren)}},move:x,hydrate:$};function x(a,u,m,S){var{o:{insert:I},m:O}=S,F=arguments.length>4&&arguments[4]!==void 0?arguments[4]:2;F===0&&I(a.targetAnchor,u,m);var{el:W,anchor:G,shapeFlag:le,children:We,props:it}=a,ge=F===2;if(ge&&I(W,u,m),(!ge||pa(it))&&le&16)for(var Ye=0;Ye<We.length;Ye++)O(We[Ye],u,m,2);ge&&I(G,u,m)}function $(a,u,m,S,I,O,F,W){var{o:{nextSibling:G,parentNode:le,querySelector:We}}=F,it=u.target=va(u.props,We);if(it){var ge=it._lpa||it.firstChild;if(u.shapeFlag&16)if(pa(u.props))u.anchor=W(G(a),u,le(a),m,S,I,O),u.targetAnchor=ge;else{u.anchor=G(a);for(var Ye=ge;Ye;)if(Ye=G(Ye),Ye&&Ye.nodeType===8&&Ye.data==="teleport anchor"){u.targetAnchor=Ye,it._lpa=u.targetAnchor&&G(u.targetAnchor);break}W(ge,u,it,m,S,I,O)}Z(u)}return u.anchor&&G(u.anchor)}var U=v;function Z(a){var u=a.ctx;if(u&&u.ut){for(var m=a.children[0].el;m!==a.targetAnchor;)m.nodeType===1&&m.setAttribute("data-v-owner",u.uid),m=m.nextSibling;u.ut()}}var q=Symbol(void 0),te=Symbol(void 0),ce=Symbol(void 0),pe=Symbol(void 0),Ie=[],fe=null;function Ce(){var a=arguments.length>0&&arguments[0]!==void 0?arguments[0]:!1;Ie.push(fe=a?null:[])}function ct(){Ie.pop(),fe=Ie[Ie.length-1]||null}var gt=1;function Ht(a){gt+=a}function yt(a){return a.dynamicChildren=gt>0?fe||y.EMPTY_ARR:null,ct(),gt>0&&fe&&fe.push(a),a}function je(a,u,m,S,I,O){return yt(jt(a,u,m,S,I,O,!0))}function Mt(a,u,m,S,I){return yt(Ut(a,u,m,S,I,!0))}function dn(a){return a?a.__v_isVNode===!0:!1}function Gt(a,u){return a.type===u.type&&a.key===u.key}function dt(a){}var en="__vInternal",Bn=a=>{var{key:u}=a;return u!=null?u:null},Yt=a=>{var{ref:u,ref_key:m,ref_for:S}=a;return u!=null?y.isString(u)||R.isRef(u)||y.isFunction(u)?{i:An,r:u,k:m,f:!!S}:u:null};function jt(a){var u=arguments.length>1&&arguments[1]!==void 0?arguments[1]:null,m=arguments.length>2&&arguments[2]!==void 0?arguments[2]:null,S=arguments.length>3&&arguments[3]!==void 0?arguments[3]:0,I=arguments.length>4&&arguments[4]!==void 0?arguments[4]:null,O=arguments.length>5&&arguments[5]!==void 0?arguments[5]:a===q?0:1,F=arguments.length>6&&arguments[6]!==void 0?arguments[6]:!1,W=arguments.length>7&&arguments[7]!==void 0?arguments[7]:!1,G={__v_isVNode:!0,__v_skip:!0,type:a,props:u,key:u&&Bn(u),ref:u&&Yt(u),scopeId:gn,slotScopeIds:null,children:m,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:S,dynamicProps:I,dynamicChildren:null,appContext:null,hostInstance:An,ctx:An};return W?(Ir(G,m),O&128&&a.normalize(G)):m&&(G.shapeFlag|=y.isString(m)?8:16),gt>0&&!F&&fe&&(G.patchFlag>0||O&6)&&G.patchFlag!==32&&fe.push(G),G}var Ut=qt;function qt(a){var u=arguments.length>1&&arguments[1]!==void 0?arguments[1]:null,m=arguments.length>2&&arguments[2]!==void 0?arguments[2]:null,S=arguments.length>3&&arguments[3]!==void 0?arguments[3]:0,I=arguments.length>4&&arguments[4]!==void 0?arguments[4]:null,O=arguments.length>5&&arguments[5]!==void 0?arguments[5]:!1;if((!a||a===ro)&&(a=ce),dn(a)){var F=ci(a,u,!0);return m&&Ir(F,m),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=ta(u);var{class:W,style:G}=u;W&&!y.isString(W)&&(u.class=y.normalizeClass(W)),y.isObject(G)&&(R.isProxy(G)&&!y.isArray(G)&&(G=y.extend({},G)),u.style=y.normalizeStyle(G))}var le=y.isString(a)?1:mi(a)?128:ls(a)?64:y.isObject(a)?4:y.isFunction(a)?2:0;return jt(a,u,m,S,I,le,O,!0)}function ta(a){return a?R.isProxy(a)||en in a?y.extend({},a):a:null}function ci(a,u){var m=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!1,{props:S,ref:I,patchFlag:O,children:F}=a,W=u?Hn(S||{},u):S,G={__v_isVNode:!0,__v_skip:!0,type:a.type,props:W,key:W&&Bn(W),ref:u&&u.ref?m&&I?y.isArray(I)?I.concat(Yt(u)):[I,Yt(u)]:Yt(u):I,scopeId:a.scopeId,slotScopeIds:a.slotScopeIds,children:F,target:a.target,targetAnchor:a.targetAnchor,staticCount:a.staticCount,shapeFlag:a.shapeFlag,patchFlag:u&&a.type!==q?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 G}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 Ut(te,null,a,u)}function qi(a,u){var m=Ut(pe,null,a);return m.staticCount=u,m}function ja(){var a=arguments.length>0&&arguments[0]!==void 0?arguments[0]:"",u=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!1;return u?(Ce(),Mt(ce,null,a)):Ut(ce,null,a)}function Un(a){return a==null||typeof a=="boolean"?Ut(ce):y.isArray(a)?Ut(q,null,a.slice()):typeof a=="object"?$n(a):Ut(te,null,String(a))}function $n(a){return a.el===null&&a.patchFlag!==-1||a.memo?a:ci(a)}function Ir(a,u){var m=0,{shapeFlag:S}=a;if(u==null)u=null;else if(y.isArray(u))m=16;else if(typeof u=="object")if(S&(1|64)){var I=u.default;I&&(I._c&&(I._d=!1),Ir(a,I()),I._c&&(I._d=!0));return}else{m=32;var O=u._;!O&&!(en in u)?u._ctx=An:O===3&&An&&(An.slots._===1?u._=1:(u._=2,a.patchFlag|=1024))}else y.isFunction(u)?(u={default:u,_ctx:An},m=32):(u=String(u),S&64?(m=16,u=[ei(u)]):m=8);a.children=u,a.shapeFlag|=m}function Hn(){for(var a={},u=0;u<arguments.length;u++){var m=u<0||arguments.length<=u?void 0:arguments[u];for(var S in m)if(S==="class")a.class!==m.class&&(a.class=y.normalizeClass([a.class,m.class]));else if(S==="style")a.style=y.normalizeStyle([a.style,m.style]);else if(y.isOn(S)){var I=a[S],O=m[S];O&&I!==O&&!(y.isArray(I)&&I.includes(O))&&(a[S]=I?[].concat(I,O):O)}else S!==""&&(a[S]=m[S])}return a}function yr(a,u,m){var S=arguments.length>3&&arguments[3]!==void 0?arguments[3]:null;P(a,u,7,[m,S])}var zr=as(),na=0;function cs(a,u,m){var S=a.type,I=(u?u.appContext:a.appContext)||zr,O={uid:na++,vnode:a,type:S,parent:u,appContext:I,root:null,next:null,subTree:null,effect:null,update:null,scope:new R.EffectScope(!0),render:null,proxy:null,exposed:null,exposeProxy:null,withProxy:null,provides:u?u.provides:Object.create(I.provides),accessCache:null,renderCache:[],components:null,directives:null,propsOptions:Ta(S,I),emitsOptions:or(S,I),emit:null,emitted:null,propsDefaults:y.EMPTY_OBJ,inheritAttrs:S.inheritAttrs,ctx:y.EMPTY_OBJ,data:y.EMPTY_OBJ,props:y.EMPTY_OBJ,attrs:y.EMPTY_OBJ,slots:y.EMPTY_OBJ,refs:y.EMPTY_OBJ,setupState:y.EMPTY_OBJ,setupContext:null,suspense:m,suspenseId:m?m.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=sn.bind(null,O),a.ce&&a.ce(O),O}var on=null,_n=()=>on||An,jn=a=>{on=a,a.scope.on()},qn=()=>{on&&on.scope.off(),on=null};function Ai(a){return a.vnode.shapeFlag&4}h.isInSSRComponentSetup=!1;function us(a){var u=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!1;h.isInSSRComponentSetup=u;var{props:m,children:S}=a.vnode,I=Ai(a);wi(a,m,I,u),Wi(a,S);var O=I?za(a,u):void 0;return h.isInSSRComponentSetup=!1,O}function za(a,u){var m=a.type;a.accessCache=Object.create(null),a.proxy=R.markRaw(new Proxy(a.ctx,X));var{setup:S}=m;if(S){var I=a.setupContext=S.length>1?Ya(a):null;jn(a),R.pauseTracking();var O=Ot(S,a,0,[a.props,I]);if(R.resetTracking(),qn(),y.isPromise(O)){if(O.then(qn,qn),u)return O.then(F=>{Ia(a,F,u)}).catch(F=>{wt(F,a,0)});a.asyncDep=O}else Ia(a,O,u)}else Wr(a,u)}function Ia(a,u,m){y.isFunction(u)?a.render=u:y.isObject(u)&&(a.setupState=R.proxyRefs(u)),Wr(a,m)}var ra,so;function Wa(a){ra=a,so=u=>{u.render._rc&&(u.withProxy=new Proxy(u.ctx,K))}}var fs=()=>!ra;function Wr(a,u,m){var S=a.type;if(!a.render){if(!u&&ra&&!S.render){var I=S.template||Dn(a).template;if(I){var{isCustomElement:O,compilerOptions:F}=a.appContext.config,{delimiters:W,compilerOptions:G}=S,le=y.extend(y.extend({isCustomElement:O,delimiters:W},F),G);S.render=ra(I,le)}}a.render=S.render||y.NOOP,so&&so(a)}jn(a),R.pauseTracking(),Ne(a),R.resetTracking(),qn()}function Ga(a){return new Proxy(a.attrs,{get(u,m){return R.track(a,"get","$attrs"),u[m]}})}function Ya(a){var u=S=>{a.exposed=S||{}},m;return{get attrs(){return m||(m=Ga(a))},slots:a.slots,emit:a.emit,expose:u}}function Fo(a){if(a.exposed)return a.exposeProxy||(a.exposeProxy=new Proxy(R.proxyRefs(R.markRaw(a.exposed)),{get(u,m){if(m in u)return u[m];if(m in vt)return vt[m](a)},has(u,m){return m in u||m in vt}}))}function Di(a){var u=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!0;return y.isFunction(a)?a.displayName||a.name:a.name||u&&a.__name}function _o(a){return y.isFunction(a)&&"__vccOpts"in a}var bo=(a,u)=>R.computed(a,u,h.isInSSRComponentSetup);function ds(){return null}function Vo(){return null}function xs(a){}function hs(a,u){return null}function Bs(){return Nt().slots}function xe(){return Nt().attrs}function Nt(){var a=_n();return a.setupContext||(a.setupContext=Ya(a))}function Pt(a,u){var m=y.isArray(a)?a.reduce((O,F)=>(O[F]={},O),{}):a;for(var S in u){var I=m[S];I?y.isArray(I)||y.isFunction(I)?m[S]={type:I,default:u[S]}:I.default=u[S]:I===null&&(m[S]={default:u[S]})}return m}function wn(a,u){var m={},S=function(O){u.includes(O)||Object.defineProperty(m,O,{enumerable:!0,get:()=>a[O]})};for(var I in a)S(I);return m}function Er(a){var u=_n(),m=a();return qn(),y.isPromise(m)&&(m=m.catch(S=>{throw jn(u),S})),[m,()=>jn(u)]}function Oi(a,u,m){var S=arguments.length;return S===2?y.isObject(u)&&!y.isArray(u)?dn(u)?Ut(a,null,[u]):Ut(a,u):Ut(a,null,u):(S>3?m=Array.prototype.slice.call(arguments,2):S===3&&dn(m)&&(m=[m]),Ut(a,u,m))}var Ji=Symbol(""),Uo=()=>{{var a=Nn(Ji);return a}};function Na(){}function ia(a,u,m,S){var I=m[S];if(I&&gs(I,a))return I;var O=u();return O.memo=a.slice(),m[S]=O}function gs(a,u){var m=a.memo;if(m.length!=u.length)return!1;for(var S=0;S<m.length;S++)if(y.hasChanged(m[S],u[S]))return!1;return gt>0&&fe&&fe.push(a),!0}var ps="3.2.47",dl=null,$l=null,Hl=null,Ms={insert:(a,u,m)=>m?u.insertBefore(a,m):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 $o(a){return Object.keys(a)}function Ho(a){var u={};return y.isArray(a)&&a.forEach(m=>{$o(m).forEach(S=>{var I=m[S],O=u[S]||(u[S]={});$o(I).forEach(F=>{var W=I[F],G=O[F]||(O[F]={});$o(W).forEach(le=>{le[0]==="!"?(G[le]=W[le],delete G[le.slice(1)]):y.hasOwn(G,"!"+le)||(G[le]=W[le])})})})}),u}function oa(a,u){var m=u&&u.classList;return m&&m.includes(a)}var qa=/[+~> ]$/,vs="parentNode",jo="previousSibling";function Ds(a,u){for(var m=a.split("."),S=m.length-1;S>0;S--){var I=m[S],O=I[I.length-1],F=I.replace(qa,"");if(O==="~"||O===" "){for(var W=O==="~"?jo:vs;u&&(u=u[W],!oa(F,u)););if(!u)return!1}else if(O===">"?u=u&&u[vs]:O==="+"&&(u=u&&u[jo]),!oa(F,u))return!1}return!0}var jl=1e3;function Ls(a,u,m){var{styles:S,weights:I}=a;$o(u).forEach(O=>{if(!(O&&m&&!Ds(O,m))){var F=O.split(".").length,W=u[O];$o(W).forEach(G=>{var le=W[G],We=G[0]==="!";We&&(G=G.slice(1));var it=I[G]||0,ge=F+(We?jl:0);ge>=it&&(I[G]=ge,S[G]=le)})}})}function ms(a,u){var m=arguments.length>2&&arguments[2]!==void 0?arguments[2]:null,S={styles:{},weights:{}};return a.forEach(I=>{var O=u[I];O&&Ls(S,O,m)}),S.styles}function hl(a){return ms(a.classList,a.styleSheet,a)}function Fs(a,u){var m=arguments.length>2&&arguments[2]!==void 0?arguments[2]:null;return ms(a,Ja(u),m)}function Ja(a){var{type:u,appContext:m}=a,S=u;if(!S.__styles)if(m&&y.isArray(m.provides.__globalStyles)&&(m.provides.__globalStyles=Ho(m.provides.__globalStyles)),S.mpType==="page"&&m)S.__styles=m.provides.__globalStyles;else{var I=[];m&&I.push(m.provides.__globalStyles),y.isArray(S.styles)&&S.styles.forEach(O=>I.push(O)),S.__styles=Ho(I)}return S.__styles}function _s(a,u,m){var S=arguments.length>3&&arguments[3]!==void 0?arguments[3]:null;S&&([u,m]=aa(a,u,m,S)),a.setAttr(u,m)}var Vs="hoverClass",Us="placeholderClass",gl="placeholderStyle",zo="indicatorClass",Ka="indicatorStyle",ma="maskClass",ka="maskStyle",yo={view:{class:[Vs],style:[]},button:{class:[Vs],style:[]},navigator:{class:[Vs],style:[]},"u-input":{class:[Us],style:[gl]},"u-textarea":{class:[Us],style:[gl]},"picker-view":{class:[zo,ma],style:[Ka,ka]}};function aa(a,u,m,S){if(!m)return[u,m];var I=yo[a.type];if(I){var O=y.camelize(u);if(I.class.indexOf(O)>-1)return[O,Fs([m],S,a)];if(I.style.indexOf(u)>-1)return y.isString(m)?[O,y.parseStringStyle(m)]:[O,y.normalizeStyle(m)]}return[u,m]}function Za(a,u,m){var S=arguments.length>3&&arguments[3]!==void 0?arguments[3]:null;if(!!S){var I=m?m.split(" "):[];a.setClassList(I),a.setStyleSheet(Ja(S))}}function $s(a,u,m,S){a.addEvent(u,m)}function pl(a,u){a.removeEvent(u)}function sa(a,u,m,S){var I=arguments.length>4&&arguments[4]!==void 0?arguments[4]:null,O=a._vei||(a._vei={}),F=O[u];if(S&&F)F.value=S;else{var[W,G]=Qa(u);if(S){var le=O[u]=ti(S,I);$s(a,W,le)}else F&&(pl(a,W),O[u]=void 0)}}var Xa=/(?:Once|Passive|Capture)$/;function Hs(a){return a==="on-post-message"?"onPostMessage":a}function Qa(a){var u;if(Xa.test(a)){u={};for(var m;m=a.match(Xa);)a=a.slice(0,a.length-m[0].length),u[m[0].toLowerCase()]=!0}var S=a[2]===":"?a.slice(3):a.slice(2);return[Hs(y.hyphenate(S)),u]}function ti(a,u){var m=I=>{P(m.value,u,5,[I])};m.value=a;var S=new Set;return y.isArray(m.value)?m.value.forEach(I=>{I.modifiers&&I.modifiers.forEach(O=>{S.add(O)})}):m.value.modifiers&&m.value.modifiers.forEach(I=>{S.add(I)}),m.modifiers=[...S],m}function Mr(a,u,m){if(!!m){y.isString(m)&&(m=y.parseStringStyle(m));var S={},I=u&&!y.isString(u);if(I){for(var O in u)m[O]==null&&(S[y.camelize(O)]="");for(var F in m){var W=m[F];W!==u[F]&&(S[y.camelize(F)]=W)}}else for(var G in m)S[y.camelize(G)]=m[G];a.setStyles(S)}}var la=["u-input","u-textarea"],vl=function(a,u,m,S){var I=arguments.length>6?arguments[6]:void 0,O=arguments.length>9?arguments[9]:void 0;u==="class"?Za(a,m,S,O||I):u==="style"?Mr(a,m,S):y.isOn(u)?y.isModelListener(u)||sa(a,u,m,S,I):u==="modelValue"&&la.includes(a.type)?a.setAttrs({modelValue:S,value:S}):_s(a,u,S,I)};function zl(){var a=arguments.length>0&&arguments[0]!==void 0?arguments[0]:"$style";{var u=_n();if(!u)return y.EMPTY_OBJ;var m=u.type.__cssModules;if(!m)return y.EMPTY_OBJ;var S=m[a];return S||y.EMPTY_OBJ}}function js(a){var u=_n();if(!!u){var m=()=>bs(u.subTree,a(u.proxy));er(()=>Zn(m,{flush:"post"})),Gn(m)}}function bs(a,u){if(a.shapeFlag&128){var m=a.suspense;a=m.activeBranch,m.pendingBranch&&!m.isHydrating&&m.effects.push(()=>{bs(m.activeBranch,u)})}for(;a.component;)a=a.component.subTree;if(a.shapeFlag&1&&a.el){var S=a.el.style;for(var I in u)S.setProperty("--".concat(I),u[I])}else a.type===q&&a.children.forEach(O=>bs(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(m=>a["".concat(m,"Key")]&&!u.includes(m))},ml=(a,u)=>function(m){for(var S=0;S<u.length;S++){var I=Ws[u[S]];if(I&&I(m,u))return}for(var O=arguments.length,F=new Array(O>1?O-1:0),W=1;W<O;W++)F[W-1]=arguments[W];return a(m,...F)},Gs=(a,u)=>m=>{if("key"in m){var S=y.hyphenate(m.key);if(u.some(I=>I===S))return a(m)}},ys=y.extend({patchProp:vl},Ms),Es;function Ss(){return Es||(Es=lr(ys))}var _l=function(){Ss().render(...arguments)},bl=function(){var a=Ss().createApp(...arguments),{mount:u}=a;return a.mount=m=>u(m),a};return Object.defineProperty(h,"camelize",{enumerable:!0,get:function(){return y.camelize}}),Object.defineProperty(h,"capitalize",{enumerable:!0,get:function(){return y.capitalize}}),Object.defineProperty(h,"hyphenate",{enumerable:!0,get:function(){return y.hyphenate}}),Object.defineProperty(h,"normalizeClass",{enumerable:!0,get:function(){return y.normalizeClass}}),Object.defineProperty(h,"normalizeProps",{enumerable:!0,get:function(){return y.normalizeProps}}),Object.defineProperty(h,"normalizeStyle",{enumerable:!0,get:function(){return y.normalizeStyle}}),Object.defineProperty(h,"toDisplayString",{enumerable:!0,get:function(){return y.toDisplayString}}),Object.defineProperty(h,"toHandlerKey",{enumerable:!0,get:function(){return y.toHandlerKey}}),Object.defineProperty(h,"EffectScope",{enumerable:!0,get:function(){return R.EffectScope}}),Object.defineProperty(h,"ReactiveEffect",{enumerable:!0,get:function(){return R.ReactiveEffect}}),Object.defineProperty(h,"customRef",{enumerable:!0,get:function(){return R.customRef}}),Object.defineProperty(h,"effect",{enumerable:!0,get:function(){return R.effect}}),Object.defineProperty(h,"effectScope",{enumerable:!0,get:function(){return R.effectScope}}),Object.defineProperty(h,"getCurrentScope",{enumerable:!0,get:function(){return R.getCurrentScope}}),Object.defineProperty(h,"isProxy",{enumerable:!0,get:function(){return R.isProxy}}),Object.defineProperty(h,"isReactive",{enumerable:!0,get:function(){return R.isReactive}}),Object.defineProperty(h,"isReadonly",{enumerable:!0,get:function(){return R.isReadonly}}),Object.defineProperty(h,"isRef",{enumerable:!0,get:function(){return R.isRef}}),Object.defineProperty(h,"isShallow",{enumerable:!0,get:function(){return R.isShallow}}),Object.defineProperty(h,"markRaw",{enumerable:!0,get:function(){return R.markRaw}}),Object.defineProperty(h,"onScopeDispose",{enumerable:!0,get:function(){return R.onScopeDispose}}),Object.defineProperty(h,"proxyRefs",{enumerable:!0,get:function(){return R.proxyRefs}}),Object.defineProperty(h,"reactive",{enumerable:!0,get:function(){return R.reactive}}),Object.defineProperty(h,"readonly",{enumerable:!0,get:function(){return R.readonly}}),Object.defineProperty(h,"ref",{enumerable:!0,get:function(){return R.ref}}),Object.defineProperty(h,"shallowReactive",{enumerable:!0,get:function(){return R.shallowReactive}}),Object.defineProperty(h,"shallowReadonly",{enumerable:!0,get:function(){return R.shallowReadonly}}),Object.defineProperty(h,"shallowRef",{enumerable:!0,get:function(){return R.shallowRef}}),Object.defineProperty(h,"stop",{enumerable:!0,get:function(){return R.stop}}),Object.defineProperty(h,"toRaw",{enumerable:!0,get:function(){return R.toRaw}}),Object.defineProperty(h,"toRef",{enumerable:!0,get:function(){return R.toRef}}),Object.defineProperty(h,"toRefs",{enumerable:!0,get:function(){return R.toRefs}}),Object.defineProperty(h,"triggerRef",{enumerable:!0,get:function(){return R.triggerRef}}),Object.defineProperty(h,"unref",{enumerable:!0,get:function(){return R.unref}}),h.BaseTransition=Ur,h.BaseTransitionPropsValidators=pn,h.Comment=ce,h.Fragment=q,h.KeepAlive=fn,h.Static=pe,h.Suspense=uo,h.Teleport=U,h.Text=te,h.assertNumber=Vt,h.callWithAsyncErrorHandling=P,h.callWithErrorHandling=Ot,h.cloneVNode=ci,h.compatUtils=Hl,h.computed=bo,h.createApp=bl,h.createBlock=Mt,h.createCommentVNode=ja,h.createElementBlock=je,h.createElementVNode=jt,h.createHydrationRenderer=$a,h.createPropsRestProxy=wn,h.createRenderer=lr,h.createSlots=B,h.createStaticVNode=qi,h.createTextVNode=ei,h.createVNode=Ut,h.defineAsyncComponent=Rr,h.defineComponent=Ri,h.defineEmits=Vo,h.defineExpose=xs,h.defineProps=ds,h.getCurrentInstance=_n,h.getTransitionRawChildren=Or,h.guardReactiveProps=ta,h.h=Oi,h.handleError=wt,h.initCustomFormatter=Na,h.inject=Nn,h.injectHook=xi,h.isMemoSame=gs,h.isRuntimeOnly=fs,h.isVNode=dn,h.mergeDefaults=Pt,h.mergeProps=Hn,h.nextTick=qr,h.onActivated=$r,h.onBeforeMount=Qr,h.onBeforeUnmount=nr,h.onBeforeUpdate=tr,h.onDeactivated=to,h.onErrorCaptured=no,h.onMounted=er,h.onRenderTracked=No,h.onRenderTriggered=go,h.onServerPrefetch=ho,h.onUnmounted=cr,h.onUpdated=Gn,h.openBlock=Ce,h.parseClassList=Fs,h.parseClassStyles=hl,h.popScopeId=wo,h.provide=kr,h.pushScopeId=Kr,h.queuePostFlushCb=Jr,h.registerRuntimeCompiler=Wa,h.render=_l,h.renderList=Qo,h.renderSlot=Q,h.resolveComponent=Ro,h.resolveDirective=vo,h.resolveDynamicComponent=Bi,h.resolveFilter=$l,h.resolveTransitionHooks=Te,h.setBlockTracking=Ht,h.setDevtoolsHook=Tn,h.setTransitionHooks=yi,h.ssrContextKey=Ji,h.ssrUtils=dl,h.toHandlers=ae,h.transformVNodeArgs=dt,h.useAttrs=xe,h.useCssModule=zl,h.useCssStyles=Ho,h.useCssVars=js,h.useSSRContext=Uo,h.useSlots=Bs,h.useTransitionState=Zr,h.version=ps,h.warn=It,h.watch=Fr,h.watchEffect=Zn,h.watchPostEffect=Ni,h.watchSyncEffect=Hi,h.withAsyncContext=Er,h.withCtx=Ui,h.withDefaults=hs,h.withDirectives=ko,h.withKeys=Gs,h.withMemo=ia,h.withModifiers=ml,h.withScopeId=da,Object.defineProperty(h,"__esModule",{value:!0}),h}({},w,N,p);return E.__TYPE__="nvue",E}var Dp=NI(MI);var hc={};AI(hc,{EMPTY_ARR:()=>JI,EMPTY_OBJ:()=>qI,NO:()=>ZI,NOOP:()=>KI,camelize:()=>fN,capitalize:()=>ru,def:()=>vN,extend:()=>Fi,getGlobalThis:()=>bN,hasChanged:()=>gN,hasOwn:()=>il,hyphenate:()=>ff,invokeArrayFns:()=>pN,isArray:()=>Ii,isBuiltInDirective:()=>cN,isFunction:()=>zn,isGloballyWhitelisted:()=>FI,isHTMLTag:()=>WI,isIntegerKey:()=>sN,isMap:()=>Vp,isModelListener:()=>eN,isObject:()=>Ll,isOn:()=>QI,isPlainObject:()=>Fl,isPromise:()=>oN,isRegExp:()=>rN,isReservedProp:()=>lN,isSVGTag:()=>GI,isSet:()=>Up,isString:()=>hi,isSymbol:()=>iN,looseToNumber:()=>mN,makeMap:()=>Dl,normalizeClass:()=>uf,normalizeProps:()=>HI,normalizeStyle:()=>cf,parseStringStyle:()=>Lp,remove:()=>tN,toDisplayString:()=>YI,toHandlerKey:()=>hN,toNumber:()=>_N,toRawType:()=>aN,toTypeString:()=>Ma});function Dl(f,s){let p=Object.create(null),w=f.split(",");for(let N=0;N<w.length;N++)p[w[N]]=!0;return s?N=>!!p[N.toLowerCase()]:N=>!!p[N]}var LI="Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt",FI=Dl(LI);function cf(f){if(Ii(f)){let s={};for(let p=0;p<f.length;p++){let w=f[p],N=hi(w)?Lp(w):cf(w);if(N)for(let E in N)s[E]=N[E]}return s}else{if(hi(f))return f;if(Ll(f))return f}}var VI=/;(?![^(]*\))/g,UI=/:([^]+)/,$I=/\/\*.*?\*\//gs;function Lp(f){let s={};return f.replace($I,"").split(VI).forEach(p=>{if(p){let w=p.split(UI);w.length>1&&(s[w[0].trim()]=w[1].trim())}}),s}function uf(f){let s="";if(hi(f))s=f;else if(Ii(f))for(let p=0;p<f.length;p++){let w=uf(f[p]);w&&(s+=w+" ")}else if(Ll(f))for(let p in f)f[p]&&(s+=p+" ");return s.trim()}function HI(f){if(!f)return null;let{class:s,style:p}=f;return s&&!hi(s)&&(f.class=uf(s)),p&&(f.style=cf(p)),f}var jI="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",zI="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",WI=Dl(jI),GI=Dl(zI),YI=f=>hi(f)?f:f==null?"":Ii(f)||Ll(f)&&(f.toString===$p||!zn(f.toString))?JSON.stringify(f,Fp,2):String(f),Fp=(f,s)=>s&&s.__v_isRef?Fp(f,s.value):Vp(s)?{[`Map(${s.size})`]:[...s.entries()].reduce((p,[w,N])=>(p[`${w} =>`]=N,p),{})}:Up(s)?{[`Set(${s.size})`]:[...s.values()]}:Ll(s)&&!Ii(s)&&!Fl(s)?String(s):s,qI={},JI=[],KI=()=>{},ZI=()=>!1,XI=/^on[^a-z]/,QI=f=>XI.test(f),eN=f=>f.startsWith("onUpdate:"),Fi=Object.assign,tN=(f,s)=>{let p=f.indexOf(s);p>-1&&f.splice(p,1)},nN=Object.prototype.hasOwnProperty,il=(f,s)=>nN.call(f,s),Ii=Array.isArray,Vp=f=>Ma(f)==="[object Map]",Up=f=>Ma(f)==="[object Set]",rN=f=>Ma(f)==="[object RegExp]",zn=f=>typeof f=="function",hi=f=>typeof f=="string",iN=f=>typeof f=="symbol",Ll=f=>f!==null&&typeof f=="object",oN=f=>Ll(f)&&zn(f.then)&&zn(f.catch),$p=Object.prototype.toString,Ma=f=>$p.call(f),aN=f=>Ma(f).slice(8,-1),Fl=f=>Ma(f)==="[object Object]",sN=f=>hi(f)&&f!=="NaN"&&f[0]!=="-"&&""+parseInt(f,10)===f,lN=Dl(",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted"),cN=Dl("bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text,memo"),nu=f=>{let s=Object.create(null);return p=>s[p]||(s[p]=f(p))},uN=/-(\w)/g,fN=nu(f=>f.replace(uN,(s,p)=>p?p.toUpperCase():"")),dN=/\B([A-Z])/g,ff=nu(f=>f.replace(dN,"-$1").toLowerCase()),ru=nu(f=>f.charAt(0).toUpperCase()+f.slice(1)),hN=nu(f=>f?`on${ru(f)}`:""),gN=(f,s)=>!Object.is(f,s),pN=(f,s)=>{for(let p=0;p<f.length;p++)f[p](s)},vN=(f,s,p)=>{Object.defineProperty(f,s,{configurable:!0,enumerable:!1,value:p})},mN=f=>{let s=parseFloat(f);return isNaN(s)?f:s},_N=f=>{let s=hi(f)?Number(f):NaN;return isNaN(s)?f:s},Hp,bN=()=>Hp||(Hp=typeof globalThis!="undefined"?globalThis:typeof self!="undefined"?self:typeof window!="undefined"?window:typeof global!="undefined"?global:{});function jp(f){var s=function(p,w){"use strict";function N(B,...Q){console.warn(`[Vue warn] ${B}`,...Q)}let E;class h{constructor(Q=!1){this.detached=Q,this._active=!0,this.effects=[],this.cleanups=[],this.parent=E,!Q&&E&&(this.index=(E.scopes||(E.scopes=[])).push(this)-1)}get active(){return this._active}run(Q){if(this._active){let he=E;try{return E=this,Q()}finally{E=he}}}on(){E=this}off(){E=this.parent}stop(Q){if(this._active){let he,ae;for(he=0,ae=this.effects.length;he<ae;he++)this.effects[he].stop();for(he=0,ae=this.cleanups.length;he<ae;he++)this.cleanups[he]();if(this.scopes)for(he=0,ae=this.scopes.length;he<ae;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 y(B){return new h(B)}function R(B,Q=E){Q&&Q.active&&Q.effects.push(B)}function Fe(){return E}function It(B){E&&E.cleanups.push(B)}let Vt=B=>{let Q=new Set(B);return Q.w=0,Q.n=0,Q},Ot=B=>(B.w&J)>0,P=B=>(B.n&J)>0,wt=({deps:B})=>{if(B.length)for(let Q=0;Q<B.length;Q++)B[Q].w|=J},In=B=>{let{deps:Q}=B;if(Q.length){let he=0;for(let ae=0;ae<Q.length;ae++){let de=Q[ae];Ot(de)&&!P(de)?de.delete(B):Q[he++]=de,de.w&=~J,de.n&=~J}Q.length=he}},ot=new WeakMap,z=0,J=1,hn=30,un,yn=Symbol(""),Jn=Symbol("");class gi{constructor(Q,he=null,ae){this.fn=Q,this.scheduler=he,this.active=!0,this.deps=[],this.parent=void 0,R(this,ae)}run(){if(!this.active)return this.fn();let Q=un,he=Sn;for(;Q;){if(Q===this)return;Q=Q.parent}try{return this.parent=un,un=this,Sn=!0,J=1<<++z,z<=hn?wt(this):pi(this),this.fn()}finally{z<=hn&&In(this),J=1<<--z,un=this.parent,Sn=he,this.parent=void 0,this.deferStop&&this.stop()}}stop(){un===this?this.deferStop=!0:this.active&&(pi(this),this.onStop&&this.onStop(),this.active=!1)}}function pi(B){let{deps:Q}=B;if(Q.length){for(let he=0;he<Q.length;he++)Q[he].delete(B);Q.length=0}}function qr(B,Q){B.effect&&(B=B.effect.fn);let he=new gi(B);Q&&(w.extend(he,Q),Q.scope&&R(he,Q.scope)),(!Q||!Q.lazy)&&he.run();let ae=he.run.bind(he);return ae.effect=he,ae}function gr(B){B.effect.stop()}let Sn=!0,pr=[];function Lr(){pr.push(Sn),Sn=!1}function Jr(){pr.push(Sn),Sn=!0}function vi(){let B=pr.pop();Sn=B===void 0?!0:B}function Pn(B,Q,he){if(Sn&&un){let ae=ot.get(B);ae||ot.set(B,ae=new Map);let de=ae.get(he);de||ae.set(he,de=Vt()),ze(de,void 0)}}function ze(B,Q){let he=!1;z<=hn?P(B)||(B.n|=J,he=!Ot(B)):he=!B.has(un),he&&(B.add(un),un.deps.push(B))}function nt(B,Q,he,ae,de,vt){let kt=ot.get(B);if(!kt)return;let X=[];if(Q==="clear")X=[...kt.values()];else if(he==="length"&&w.isArray(B)){let ie=Number(ae);kt.forEach((Ne,st)=>{(st==="length"||st>=ie)&&X.push(Ne)})}else switch(he!==void 0&&X.push(kt.get(he)),Q){case"add":w.isArray(B)?w.isIntegerKey(he)&&X.push(kt.get("length")):(X.push(kt.get(yn)),w.isMap(B)&&X.push(kt.get(Jn)));break;case"delete":w.isArray(B)||(X.push(kt.get(yn)),w.isMap(B)&&X.push(kt.get(Jn)));break;case"set":w.isMap(B)&&X.push(kt.get(yn));break}let K=void 0;if(X.length===1)X[0]&&At(X[0]);else{let ie=[];for(let Ne of X)Ne&&ie.push(...Ne);At(Vt(ie))}}function At(B,Q){let he=w.isArray(B)?B:[...B];for(let ae of he)ae.computed&&Qt(ae,Q);for(let ae of he)ae.computed||Qt(ae,Q)}function Qt(B,Q){(B!==un||B.allowRecurse)&&(B.scheduler?B.scheduler():B.run())}function Tn(B,Q){var he;return(he=ot.get(B))===null||he===void 0?void 0:he.get(Q)}let sn=w.makeMap("__proto__,__v_isRef,__isVue"),or=new Set(Object.getOwnPropertyNames(Symbol).filter(B=>B!=="arguments"&&B!=="caller").map(B=>Symbol[B]).filter(w.isSymbol)),Wn=Ui(),An=Ui(!1,!0),gn=Ui(!0),wr=Ui(!0,!0),Kr=wo();function wo(){let B={};return["includes","indexOf","lastIndexOf"].forEach(Q=>{B[Q]=function(...he){let ae=fn(this);for(let vt=0,kt=this.length;vt<kt;vt++)Pn(ae,"get",vt+"");let de=ae[Q](...he);return de===-1||de===!1?ae[Q](...he.map(fn)):de}}),["push","pop","shift","unshift","splice"].forEach(Q=>{B[Q]=function(...he){Lr();let ae=fn(this)[Q].apply(this,he);return vi(),ae}}),B}function da(B){let Q=fn(this);return Pn(Q,"has",B),Q.hasOwnProperty(B)}function Ui(B=!1,Q=!1){return function(ae,de,vt){if(de==="__v_isReactive")return!B;if(de==="__v_isReadonly")return B;if(de==="__v_isShallow")return Q;if(de==="__v_raw"&&vt===(B?Q?Dt:Ur:Q?Xr:pn).get(ae))return ae;let kt=w.isArray(ae);if(!B){if(kt&&w.hasOwn(Kr,de))return Reflect.get(Kr,de,vt);if(de==="hasOwnProperty")return da}let X=Reflect.get(ae,de,vt);return(w.isSymbol(de)?or.has(de):sn(de))||(B||Pn(ae,"get",de),Q)?X:sr(X)?kt&&w.isIntegerKey(de)?X:X.value:w.isObject(X)?B?Or(X):bi(X):X}}let Zo=$i(),Xo=$i(!0);function $i(B=!1){return function(he,ae,de,vt){let kt=he[ae];if(ai(kt)&&sr(kt)&&!sr(de))return!1;if(!B&&(!Pr(de)&&!ai(de)&&(kt=fn(kt),de=fn(de)),!w.isArray(he)&&sr(kt)&&!sr(de)))return kt.value=de,!0;let X=w.isArray(he)&&w.isIntegerKey(ae)?Number(ae)<he.length:w.hasOwn(he,ae),K=Reflect.set(he,ae,de,vt);return he===fn(vt)&&(X?w.hasChanged(de,kt)&&nt(he,"set",ae,de,kt):nt(he,"add",ae,de)),K}}function ri(B,Q){let he=w.hasOwn(B,Q),ae=B[Q],de=Reflect.deleteProperty(B,Q);return de&&he&&nt(B,"delete",Q,void 0,ae),de}function Co(B,Q){let he=Reflect.has(B,Q);return(!w.isSymbol(Q)||!or.has(Q))&&Pn(B,"has",Q),he}function Ao(B){return Pn(B,"iterate",w.isArray(B)?"length":yn),Reflect.ownKeys(B)}let Oo={get:Wn,set:Zo,deleteProperty:ri,has:Co,ownKeys:Ao},Xi={get:gn,set(B,Q){return!0},deleteProperty(B,Q){return!0}},mi=w.extend({},Oo,{get:An,set:Xo}),To=w.extend({},Xi,{get:wr}),uo=B=>B,kn=B=>Reflect.getPrototypeOf(B);function Cr(B,Q,he=!1,ae=!1){B=B.__v_raw;let de=fn(B),vt=fn(Q);he||(Q!==vt&&Pn(de,"get",Q),Pn(de,"get",vt));let{has:kt}=kn(de),X=ae?uo:he?to:$r;if(kt.call(de,Q))return X(B.get(Q));if(kt.call(de,vt))return X(B.get(vt));B!==de&&B.get(Q)}function Qi(B,Q=!1){let he=this.__v_raw,ae=fn(he),de=fn(B);return Q||(B!==de&&Pn(ae,"has",B),Pn(ae,"has",de)),B===de?he.has(B):he.has(B)||he.has(de)}function Kn(B,Q=!1){return B=B.__v_raw,!Q&&Pn(fn(B),"iterate",yn),Reflect.get(B,"size",B)}function eo(B){B=fn(B);let Q=fn(this);return kn(Q).has.call(Q,B)||(Q.add(B),nt(Q,"add",B,B)),this}function Po(B,Q){Q=fn(Q);let he=fn(this),{has:ae,get:de}=kn(he),vt=ae.call(he,B);vt||(B=fn(B),vt=ae.call(he,B));let kt=de.call(he,B);return he.set(B,Q),vt?w.hasChanged(Q,kt)&&nt(he,"set",B,Q,kt):nt(he,"add",B,Q),this}function fo(B){let Q=fn(this),{has:he,get:ae}=kn(Q),de=he.call(Q,B);de||(B=fn(B),de=he.call(Q,B));let vt=ae?ae.call(Q,B):void 0,kt=Q.delete(B);return de&&nt(Q,"delete",B,void 0,vt),kt}function ii(){let B=fn(this),Q=B.size!==0,he=void 0,ae=B.clear();return Q&&nt(B,"clear",void 0,void 0,he),ae}function ar(B,Q){return function(ae,de){let vt=this,kt=vt.__v_raw,X=fn(kt),K=Q?uo:B?to:$r;return!B&&Pn(X,"iterate",yn),kt.forEach((ie,Ne)=>ae.call(de,K(ie),K(Ne),vt))}}function kr(B,Q,he){return function(...ae){let de=this.__v_raw,vt=fn(de),kt=w.isMap(vt),X=B==="entries"||B===Symbol.iterator&&kt,K=B==="keys"&&kt,ie=de[B](...ae),Ne=he?uo:Q?to:$r;return!Q&&Pn(vt,"iterate",K?Jn:yn),{next(){let{value:st,done:Xt}=ie.next();return Xt?{value:st,done:Xt}:{value:X?[Ne(st[0]),Ne(st[1])]:Ne(st),done:Xt}},[Symbol.iterator](){return this}}}}function Nn(B){return function(...Q){return B==="delete"?!1:this}}function Zn(){let B={get(vt){return Cr(this,vt)},get size(){return Kn(this)},has:Qi,add:eo,set:Po,delete:fo,clear:ii,forEach:ar(!1,!1)},Q={get(vt){return Cr(this,vt,!1,!0)},get size(){return Kn(this)},has:Qi,add:eo,set:Po,delete:fo,clear:ii,forEach:ar(!1,!0)},he={get(vt){return Cr(this,vt,!0)},get size(){return Kn(this,!0)},has(vt){return Qi.call(this,vt,!0)},add:Nn("add"),set:Nn("set"),delete:Nn("delete"),clear:Nn("clear"),forEach:ar(!0,!1)},ae={get(vt){return Cr(this,vt,!0,!0)},get size(){return Kn(this,!0)},has(vt){return Qi.call(this,vt,!0)},add:Nn("add"),set:Nn("set"),delete:Nn("delete"),clear:Nn("clear"),forEach:ar(!0,!0)};return["keys","values","entries",Symbol.iterator].forEach(vt=>{B[vt]=kr(vt,!1,!1),he[vt]=kr(vt,!0,!1),Q[vt]=kr(vt,!1,!0),ae[vt]=kr(vt,!0,!0)}),[B,he,Q,ae]}let[Ni,Hi,oi,Fr]=Zn();function vr(B,Q){let he=Q?B?Fr:oi:B?Hi:Ni;return(ae,de,vt)=>de==="__v_isReactive"?!B:de==="__v_isReadonly"?B:de==="__v_raw"?ae:Reflect.get(w.hasOwn(he,de)&&de in ae?he:ae,de,vt)}let ki={get:vr(!1,!1)},Io={get:vr(!1,!0)},Vr={get:vr(!0,!1)},Zr={get:vr(!0,!0)};function Ar(B,Q,he){let ae=fn(he);if(ae!==he&&Q.call(B,ae)){let de=w.toRawType(B);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 pn=new WeakMap,Xr=new WeakMap,Ur=new WeakMap,Dt=new WeakMap;function Te(B){switch(B){case"Object":case"Array":return 1;case"Map":case"Set":case"WeakMap":case"WeakSet":return 2;default:return 0}}function _i(B){return B.__v_skip||!Object.isExtensible(B)?0:Te(w.toRawType(B))}function bi(B){return ai(B)?B:Tr(B,!1,Oo,ki,pn)}function yi(B){return Tr(B,!1,mi,Io,Xr)}function Or(B){return Tr(B,!0,Xi,Vr,Ur)}function Ri(B){return Tr(B,!0,To,Zr,Dt)}function Tr(B,Q,he,ae,de){if(!w.isObject(B)||B.__v_raw&&!(Q&&B.__v_isReactive))return B;let vt=de.get(B);if(vt)return vt;let kt=_i(B);if(kt===0)return B;let X=new Proxy(B,kt===2?ae:he);return de.set(B,X),X}function Rr(B){return ai(B)?Rr(B.__v_raw):!!(B&&B.__v_isReactive)}function ai(B){return!!(B&&B.__v_isReadonly)}function Pr(B){return!!(B&&B.__v_isShallow)}function Ei(B){return Rr(B)||ai(B)}function fn(B){let Q=B&&B.__v_raw;return Q?fn(Q):B}function ji(B){return w.def(B,"__v_skip",!0),B}let $r=B=>w.isObject(B)?bi(B):B,to=B=>w.isObject(B)?Or(B):B;function En(B){Sn&&un&&(B=fn(B),ze(B.dep||(B.dep=Vt())))}function Hr(B,Q){B=fn(B);let he=B.dep;he&&At(he)}function sr(B){return!!(B&&B.__v_isRef===!0)}function Si(B){return mr(B,!1)}function xi(B){return mr(B,!0)}function mr(B,Q){return sr(B)?B:new Qr(B,Q)}class Qr{constructor(Q,he){this.__v_isShallow=he,this.dep=void 0,this.__v_isRef=!0,this._rawValue=he?Q:fn(Q),this._value=he?Q:$r(Q)}get value(){return En(this),this._value}set value(Q){let he=this.__v_isShallow||Pr(Q)||ai(Q);Q=he?Q:fn(Q),w.hasChanged(Q,this._rawValue)&&(this._rawValue=Q,this._value=he?Q:$r(Q),Hr(this,Q))}}function er(B){Hr(B,void 0)}function tr(B){return sr(B)?B.value:B}let Gn={get:(B,Q,he)=>tr(Reflect.get(B,Q,he)),set:(B,Q,he,ae)=>{let de=B[Q];return sr(de)&&!sr(he)?(de.value=he,!0):Reflect.set(B,Q,he,ae)}};function nr(B){return Rr(B)?B:new Proxy(B,Gn)}class cr{constructor(Q){this.dep=void 0,this.__v_isRef=!0;let{get:he,set:ae}=Q(()=>En(this),()=>Hr(this));this._get=he,this._set=ae}get value(){return this._get()}set value(Q){this._set(Q)}}function ho(B){return new cr(B)}function go(B){let Q=w.isArray(B)?new Array(B.length):{};for(let he in B)Q[he]=no(B,he);return Q}class No{constructor(Q,he,ae){this._object=Q,this._key=he,this._defaultValue=ae,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 Tn(fn(this._object),this._key)}}function no(B,Q,he){let ae=B[Q];return sr(ae)?ae:new No(B,Q,he)}var ko;class jr{constructor(Q,he,ae,de){this._setter=he,this.dep=void 0,this.__v_isRef=!0,this[ko]=!1,this._dirty=!0,this.effect=new gi(Q,()=>{this._dirty||(this._dirty=!0,Hr(this))}),this.effect.computed=this,this.effect.active=this._cacheable=!de,this.__v_isReadonly=ae}get value(){let Q=fn(this);return En(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 xr(B,Q,he=!1){let ae,de,vt=w.isFunction(B);return vt?(ae=B,de=w.NOOP):(ae=B.get,de=B.set),new jr(ae,de,vt||!de,he)}var po;let Ro=Promise.resolve(),ro=[],Bi=!1,vo=B=>{ro.push(B),Bi||(Bi=!0,Ro.then(Mi))},Mi=()=>{for(let B=0;B<ro.length;B++)ro[B]();ro.length=0,Bi=!1};class zi{constructor(Q){this.dep=void 0,this._dirty=!0,this.__v_isRef=!0,this[po]=!0;let he,ae=!1,de=!1;this.effect=new gi(Q,vt=>{if(this.dep){if(vt)he=this._value,ae=!0;else if(!de){let kt=ae?he:this._value;de=!0,ae=!1,vo(()=>{this.effect.active&&this._get()!==kt&&Hr(this),de=!1})}for(let kt of this.dep)kt.computed instanceof zi&&kt.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 En(this),fn(this)._get()}}po="__v_isReadonly";function Qo(B){return new zi(B)}return p.EffectScope=h,p.ITERATE_KEY=yn,p.ReactiveEffect=gi,p.computed=xr,p.customRef=ho,p.deferredComputed=Qo,p.effect=qr,p.effectScope=y,p.enableTracking=Jr,p.getCurrentScope=Fe,p.isProxy=Ei,p.isReactive=Rr,p.isReadonly=ai,p.isRef=sr,p.isShallow=Pr,p.markRaw=ji,p.onScopeDispose=It,p.pauseTracking=Lr,p.proxyRefs=nr,p.reactive=bi,p.readonly=Or,p.ref=Si,p.resetTracking=vi,p.shallowReactive=yi,p.shallowReadonly=Ri,p.shallowRef=xi,p.stop=gr,p.toRaw=fn,p.toRef=no,p.toRefs=go,p.track=Pn,p.trigger=nt,p.triggerRef=er,p.unref=tr,Object.defineProperty(p,"__esModule",{value:!0}),p}({},f);return s}function zp(f){var s=function(p){"use strict";let w=`
`,N=44,E=50,h=50,y=["%","%"],R="#007aff",Fe=/^([a-z-]+:)?\/\//i,It=/^data:.*,.*/,Vt="WEB_INVOKE_APPSERVICE",Ot="wxs://",P="json://",wt="wxsModules",In="renderjsModules",ot="onShow",z="onHide",J="onLaunch",hn="onError",un="onThemeChange",yn="offThemeChange",Jn="onKeyboardHeightChange",gi="onPageNotFound",pi="onUnhandledRejection",qr="onExit",gr="onLoad",Sn="onReady",pr="onUnload",Lr="onInit",Jr="onSaveExitState",vi="onResize",Pn="onBackPress",ze="onPageScroll",nt="onTabItemTap",At="onReachBottom",Qt="onPullDownRefresh",Tn="onShareTimeline",sn="onAddToFavorites",or="onShareAppMessage",Wn="onNavigationBarButtonTap",An="onNavigationBarSearchInputClicked",gn="onNavigationBarSearchInputChanged",wr="onNavigationBarSearchInputConfirmed",Kr="onNavigationBarSearchInputFocusChanged",wo="onAppEnterForeground",da="onAppEnterBackground",Ui="onWxsInvokeCallMethod";function Zo(X){return!!X.appContext}function Xo(X){return X&&(Zo(X)?X.proxy:X)}function $i(X){return X.nodeType===1}function ri(X,K=!1){let{vnode:ie}=X;if($i(ie.el))return K?ie.el?[ie.el]:[]:ie.el;let{subTree:Ne}=X;if(Ne.shapeFlag&16){let st=Ne.children.filter(Xt=>Xt.el&&$i(Xt.el));if(st.length>0)return K?st.map(Xt=>Xt.el):st[0].el}return K?ie.el?[ie.el]:[]:ie.el}let Co=0;function Ao(X,...K){let ie=Date.now(),Ne=Co?ie-Co:0;return Co=ie,`[${ie}][${Ne}ms][${X}]\uFF1A${K.map(st=>JSON.stringify(st)).join(" ")}`}function Oo(X){let K=Object.create(null);return ie=>K[ie]||(K[ie]=X(ie))}function Xi(X){return Oo(X)}function mi(X=""){return(""+X).replace(/[^\x00-\xff]/g,"**").length}function To(X){return X.indexOf("/")===0}function uo(X){return To(X)?X:"/"+X}function kn(X){return To(X)?X.slice(1):X}let Cr=(X,K)=>{let ie;for(let Ne=0;Ne<X.length;Ne++)ie=X[Ne](K);return ie};function Qi(X,K=null){let ie;return(...Ne)=>(X&&(ie=X.apply(K,Ne),X=null),ie)}function Kn(X,K){X=X||{},p.isString(K)&&(K={errMsg:K}),/:ok$/.test(K.errMsg)?p.isFunction(X.success)&&X.success(K):p.isFunction(X.fail)&&X.fail(K),p.isFunction(X.complete)&&X.complete(K)}function eo(X){let K={};return p.isPlainObject(X)&&Object.keys(X).sort().forEach(ie=>{let Ne=ie;K[Ne]=X[Ne]}),Object.keys(K)?K:X}let Po=encodeURIComponent;function fo(X,K=Po){let ie=X?Object.keys(X).map(Ne=>{let st=X[Ne];return typeof st===void 0||st===null?st="":p.isPlainObject(st)&&(st=JSON.stringify(st)),K(Ne)+"="+K(st)}).filter(Ne=>Ne.length>0).join("&"):null;return ie?`?${ie}`:""}function ii(X){try{return decodeURIComponent(""+X)}catch(K){}return""+X}let ar=/\+/g;function kr(X){let K={};if(X===""||X==="?")return K;let Ne=(X[0]==="?"?X.slice(1):X).split("&");for(let st=0;st<Ne.length;++st){let Xt=Ne[st].replace(ar," "),xn=Xt.indexOf("="),Dn=ii(xn<0?Xt:Xt.slice(0,xn)),_r=xn<0?null:ii(Xt.slice(xn+1));if(Dn in K){let Br=K[Dn];p.isArray(Br)||(Br=K[Dn]=[Br]),Br.push(_r)}else K[Dn]=_r}return K}function Nn(X){let[K,ie]=X.split("?",2);return{path:K,query:kr(ie||"")}}function Zn(X){let K={};return X&&Object.keys(X).forEach(ie=>{ie.indexOf("data-")===0&&(K[ie.replace("data-","")]=X[ie])}),K}class Ni extends Error{constructor(K){super(K);this.name="DOMException"}}function Hi(X,K){return K&&(K.capture&&(X+="Capture"),K.once&&(X+="Once"),K.passive&&(X+="Passive")),`on${p.capitalize(p.camelize(X))}`}class oi{constructor(K,ie){this.defaultPrevented=!1,this.timeStamp=Date.now(),this._stop=!1,this._end=!1,this.type=K,this.bubbles=!!ie.bubbles,this.cancelable=!!ie.cancelable}preventDefault(){this.defaultPrevented=!0}stopImmediatePropagation(){this._end=this._stop=!0}stopPropagation(){this._stop=!0}}function Fr(X){if(X instanceof oi)return X;let[K]=Io(X.type),ie=new oi(K,{bubbles:!1,cancelable:!1});return p.extend(ie,X),ie}class vr{constructor(){this.listeners=Object.create(null)}dispatchEvent(K){let ie=this.listeners[K.type];if(!ie)return!1;let Ne=Fr(K),st=ie.length;for(let Xt=0;Xt<st&&(ie[Xt].call(this,Ne),!Ne._end);Xt++);return Ne.cancelable&&Ne.defaultPrevented}addEventListener(K,ie,Ne){K=Hi(K,Ne),(this.listeners[K]||(this.listeners[K]=[])).push(ie)}removeEventListener(K,ie,Ne){K=Hi(K,Ne);let st=this.listeners[K];if(!st)return;let Xt=st.indexOf(ie);Xt>-1&&st.splice(Xt,1)}}let ki=/(?:Once|Passive|Capture)$/;function Io(X){let K;if(ki.test(X)){K={};let ie;for(;ie=X.match(ki);)X=X.slice(0,X.length-ie[0].length),K[ie[0].toLowerCase()]=!0}return[p.hyphenate(X.slice(2)),K]}let Vr=(()=>({stop:1,prevent:1<<1,self:1<<2}))();function Zr(X){let K=0;return X.includes("stop")&&(K|=Vr.stop),X.includes("prevent")&&(K|=Vr.prevent),X.includes("self")&&(K|=Vr.self),K}let Ar=0,pn=1,Xr=3,Ur=8;function Dt(X,K){let{parentNode:ie}=X;if(!ie)return null;let{childNodes:Ne}=ie;return Ne[Ne.indexOf(X)+(K==="n"?1:-1)]||null}function Te(X){let{parentNode:K}=X;if(K){let{childNodes:ie}=K,Ne=ie.indexOf(X);Ne>-1&&(X.parentNode=null,ie.splice(Ne,1))}}function _i(X){!X.nodeId&&X.pageNode&&(X.nodeId=X.pageNode.genId())}class bi extends vr{constructor(K,ie,Ne){super();if(this.pageNode=null,this.parentNode=null,this._text=null,Ne){let{pageNode:st}=Ne;st&&(this.pageNode=st,this.nodeId=st.genId(),!st.isUnmounted&&st.onCreate(this,ie))}this.nodeType=K,this.nodeName=ie,this.childNodes=[]}get firstChild(){return this.childNodes[0]||null}get lastChild(){let{childNodes:K}=this,ie=K.length;return ie?K[ie-1]:null}get nextSibling(){return Dt(this,"n")}get nodeValue(){return null}set nodeValue(K){}get textContent(){return this._text||""}set textContent(K){this._text=K,this.pageNode&&!this.pageNode.isUnmounted&&this.pageNode.onTextContent(this,K)}get parentElement(){let{parentNode:K}=this;return K&&K.nodeType===pn?K:null}get previousSibling(){return Dt(this,"p")}appendChild(K){return this.insertBefore(K,null)}cloneNode(K){let ie=p.extend(Object.create(Object.getPrototypeOf(this)),this),{attributes:Ne}=ie;return Ne&&(ie.attributes=p.extend({},Ne)),K&&(ie.childNodes=ie.childNodes.map(st=>st.cloneNode(!0))),ie}insertBefore(K,ie){Te(K),K.pageNode=this.pageNode,K.parentNode=this,_i(K);let{childNodes:Ne}=this;if(ie){let st=Ne.indexOf(ie);if(st===-1)throw new Ni("Failed to execute 'insertBefore' on 'Node': The node before which the new node is to be inserted is not a child of this node.");Ne.splice(st,0,K)}else Ne.push(K);return this.pageNode&&!this.pageNode.isUnmounted?this.pageNode.onInsertBefore(this,K,ie):K}removeChild(K){let{childNodes:ie}=this,Ne=ie.indexOf(K);if(Ne===-1)throw new Ni("Failed to execute 'removeChild' on 'Node': The node to be removed is not a child of this node.");return K.parentNode=null,ie.splice(Ne,1),this.pageNode&&!this.pageNode.isUnmounted?this.pageNode.onRemoveChild(K):K}}let yi="class",Or="style",Ri=".vOwnerId",Tr=".vRenderjs";class Rr extends bi{constructor(K,ie,Ne){super(K,ie,Ne);this.attributes=Object.create(null),this.style=null,this.vShow=null,this._html=null}get className(){return this.attributes[yi]||""}set className(K){this.setAttribute(yi,K)}get innerHTML(){return""}set innerHTML(K){this._html=K}addEventListener(K,ie,Ne){super.addEventListener(K,ie,Ne),this.pageNode&&!this.pageNode.isUnmounted&&(ie.wxsEvent?this.pageNode.onAddWxsEvent(this,Hi(K,Ne),ie.wxsEvent,Zr(ie.modifiers||[])):this.pageNode.onAddEvent(this,Hi(K,Ne),Zr(ie.modifiers||[])))}removeEventListener(K,ie,Ne){super.removeEventListener(K,ie,Ne),this.pageNode&&!this.pageNode.isUnmounted&&this.pageNode.onRemoveEvent(this,Hi(K,Ne))}getAttribute(K){return K===Or?this.style:this.attributes[K]}removeAttribute(K){K==Or?this.style=null:delete this.attributes[K],this.pageNode&&!this.pageNode.isUnmounted&&this.pageNode.onRemoveAttribute(this,K)}setAttribute(K,ie){K===Or?this.style=ie:this.attributes[K]=ie,this.pageNode&&!this.pageNode.isUnmounted&&this.pageNode.onSetAttribute(this,K,ie)}toJSON({attr:K,normalize:ie}={}){let{attributes:Ne,style:st,listeners:Xt,_text:xn}=this,Dn={};Object.keys(Ne).length&&(Dn.a=ie?ie(Ne):Ne);let _r=Object.keys(Xt);if(_r.length){let Br,mo={};_r.forEach(xo=>{let Bo=Xt[xo];if(Bo.length){let{wxsEvent:Ln,modifiers:Yn}=Bo[0],Fn=Zr(Yn||[]);Ln?(Br||(Br={}),Br[xo]=[ie?ie(Ln):Ln,Fn]):mo[xo]=Fn}}),Dn.e=ie?ie(mo,!1):mo,Br&&(Dn.w=ie?ie(Br,!1):Br)}return st!==null&&(Dn.s=ie?ie(st):st),K||(Dn.i=this.nodeId,Dn.n=this.nodeName),xn!==null&&(Dn.t=ie?ie(xn):xn),Dn}}class ai extends bi{constructor(K,ie){super(Ur,"#comment",ie);this._text=""}toJSON(K={}){return K.attr?{}:{i:this.nodeId}}}class Pr extends Rr{constructor(K,ie){super(pn,K.toUpperCase(),ie);this.tagName=this.nodeName}}class Ei extends Pr{get value(){return this.getAttribute("value")}set value(K){this.setAttribute("value",K)}}class fn extends Ei{}class ji extends Rr{constructor(K,ie){super(Xr,"#text",ie);this._text=K}get nodeValue(){return this._text||""}set nodeValue(K){this._text=K,this.pageNode&&!this.pageNode.isUnmounted&&this.pageNode.onNodeValue(this,K)}}let $r={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"]},to=["animation"],En=(X,K)=>{if(to.indexOf(K)>-1)return!0;let ie=$r[X.nodeName];return!!(ie&&ie.indexOf(K)>-1)},Hr=1,sr=2,Si=3,xi=4,mr=5,Qr=6,er=7,tr=8,Gn=9,nr=10,cr=12,ho=15,go=20;function No(X,K,{clearTimeout:ie,setTimeout:Ne}){let st,Xt=function(){ie(st),st=Ne(()=>X.apply(this,arguments),K)};return Xt.cancel=function(){ie(st)},Xt}class no{constructor(K,ie){this.id=K,this.listener={},this.emitCache=[],ie&&Object.keys(ie).forEach(Ne=>{this.on(Ne,ie[Ne])})}emit(K,...ie){let Ne=this.listener[K];if(!Ne)return this.emitCache.push({eventName:K,args:ie});Ne.forEach(st=>{st.fn.apply(st.fn,ie)}),this.listener[K]=Ne.filter(st=>st.type!=="once")}on(K,ie){this._addListener(K,"on",ie),this._clearCache(K)}once(K,ie){this._addListener(K,"once",ie),this._clearCache(K)}off(K,ie){let Ne=this.listener[K];if(!!Ne)if(ie)for(let st=0;st<Ne.length;)Ne[st].fn===ie&&(Ne.splice(st,1),st--),st++;else delete this.listener[K]}_clearCache(K){for(let ie=0;ie<this.emitCache.length;ie++){let Ne=this.emitCache[ie],st=K?Ne.eventName===K?K:null:Ne.eventName;if(!st)continue;if(typeof this.emit.apply(this,[st,...Ne.args])=="number"){this.emitCache.pop();continue}this.emitCache.splice(ie,1),ie--}}_addListener(K,ie,Ne){(this.listener[K]||(this.listener[K]=[])).push({fn:Ne,type:ie})}}let ko=[Lr,gr,ot,z,pr,Pn,ze,nt,At,Qt,Tn,or,sn,Jr,Wn,An,gn,wr,Kr],jr=[gr,ot];function xr(X){return jr.indexOf(X)>-1}function po(X){return ko.indexOf(X)>-1}let Ro=[ot,z,J,hn,un,gi,pi,qr,Lr,gr,Sn,pr,vi,Pn,ze,nt,At,Qt,Tn,sn,or,Jr,Wn,An,gn,wr,Kr];function ro(X,K,ie=!0){return ie&&!p.isFunction(K)?!1:Ro.indexOf(X)>-1?!0:X.indexOf("on")===0}let Bi,vo=[];function Mi(X){if(Bi)return X(Bi);vo.push(X)}function zi(X){Bi=X,vo.forEach(K=>K(X))}let Qo=Qi((X,K)=>{if(p.isFunction(X._component.onError))return K(X)}),B=function(){};B.prototype={on:function(X,K,ie){var Ne=this.e||(this.e={});return(Ne[X]||(Ne[X]=[])).push({fn:K,ctx:ie}),this},once:function(X,K,ie){var Ne=this;function st(){Ne.off(X,st),K.apply(ie,arguments)}return st._=K,this.on(X,st,ie)},emit:function(X){var K=[].slice.call(arguments,1),ie=((this.e||(this.e={}))[X]||[]).slice(),Ne=0,st=ie.length;for(Ne;Ne<st;Ne++)ie[Ne].fn.apply(ie[Ne].ctx,K);return this},off:function(X,K){var ie=this.e||(this.e={}),Ne=ie[X],st=[];if(Ne&&K)for(var Xt=0,xn=Ne.length;Xt<xn;Xt++)Ne[Xt].fn!==K&&Ne[Xt].fn._!==K&&st.push(Ne[Xt]);return st.length?ie[X]=st:delete ie[X],this}};var Q=B;let he={black:"rgba(0,0,0,0.4)",white:"rgba(255,255,255,0.4)"};function ae(X){return X&&X in he?he[X]:X}function de(X){return X==="black"?"#000000":"#ffffff"}function vt(X,K={},ie="light"){let Ne=K[ie],st={};return Ne?(Object.keys(X).forEach(Xt=>{let xn=X[Xt];st[Xt]=(()=>{if(p.isPlainObject(xn))return vt(xn,K,ie);if(p.isArray(xn))return xn.map(Dn=>p.isPlainObject(Dn)?vt(Dn,K,ie):Dn);if(p.isString(xn)&&xn.startsWith("@")){let Dn=xn.replace("@",""),_r=Ne[Dn]||xn;switch(Xt){case"titleColor":_r=de(_r);break;case"borderStyle":_r=ae(_r);break}return _r}return xn})()}),st):X}var kt={invokeArrayFns:Cr,isUniLifecycleHook:ro,ON_LOAD:gr,ON_SHOW:ot,LINEFEED:w,RENDERJS_MODULES:In,formatLog:Ao,WXS_PROTOCOL:Ot,WXS_MODULES:wt,UniLifecycleHooks:Ro,ON_ERROR:hn,invokeCreateErrorHandler:Qo,invokeCreateVueAppHook:zi,parseNVueDataset:Zn,once:Qi,I18N_JSON_DELIMITERS:y,Emitter:Q,normalizeStyles:vt,addLeadingSlash:uo,resolveComponentInstance:Xo,removeLeadingSlash:kn,ON_RESIZE:vi,ON_APP_ENTER_FOREGROUND:wo,ON_APP_ENTER_BACKGROUND:da,ON_HIDE:z,ON_PAGE_SCROLL:ze,ON_REACH_BOTTOM:At,SCHEME_RE:Fe,DATA_RE:It,cacheStringFunction:Xi,parseQuery:kr,callOptions:Kn,ON_UNHANDLE_REJECTION:pi,ON_PAGE_NOT_FOUND:gi,PRIMARY_COLOR:R,getLen:mi,ON_THEME_CHANGE:un,TABBAR_HEIGHT:E,NAVBAR_HEIGHT:N,sortObject:eo,OFF_THEME_CHANGE:yn,ON_KEYBOARD_HEIGHT_CHANGE:Jn,normalizeTabBarStyles:ae,ON_NAVIGATION_BAR_BUTTON_TAP:Wn,stringifyQuery:fo,debounce:No,ON_PULL_DOWN_REFRESH:Qt,ON_NAVIGATION_BAR_SEARCH_INPUT_CHANGED:gn,ON_NAVIGATION_BAR_SEARCH_INPUT_CONFIRMED:wr,ON_NAVIGATION_BAR_SEARCH_INPUT_CLICKED:An,ON_NAVIGATION_BAR_SEARCH_INPUT_FOCUS_CHANGED:Kr,ON_BACK_PRESS:Pn,UniNode:bi,NODE_TYPE_PAGE:Ar,ACTION_TYPE_PAGE_CREATE:Hr,ACTION_TYPE_PAGE_CREATED:sr,ACTION_TYPE_PAGE_SCROLL:ho,ACTION_TYPE_INSERT:xi,ACTION_TYPE_CREATE:Si,ACTION_TYPE_REMOVE:mr,ACTION_TYPE_ADD_EVENT:tr,ACTION_TYPE_ADD_WXS_EVENT:cr,ACTION_TYPE_REMOVE_EVENT:Gn,ACTION_TYPE_SET_ATTRIBUTE:Qr,ACTION_TYPE_REMOVE_ATTRIBUTE:er,ACTION_TYPE_SET_TEXT:nr,ON_READY:Sn,ON_UNLOAD:pr,EventChannel:no,ON_REACH_BOTTOM_DISTANCE:h,parseUrl:Nn,onCreateVueApp:Mi,ON_TAB_ITEM_TAP:nt,ON_LAUNCH:J,ACTION_TYPE_EVENT:go,createUniEvent:Fr,ON_WXS_INVOKE_CALL_METHOD:Ui,WEB_INVOKE_APPSERVICE:Vt,isRootHook:po,isRootImmediateHook:xr,UniInputElement:Ei,UniTextAreaElement:fn,UniElement:Pr,UniTextNode:ji,UniCommentNode:ai,forcePatchProp:En,JSON_PROTOCOL:P,resolveOwnerEl:ri,ATTR_V_OWNER_ID:Ri,ATTR_V_RENDERJS:Tr};return kt}(f);return s}var yN=1;function Wp(){return(yN++).toString()}var df=f=>f&&JSON.parse(JSON.stringify(f))||f;function gc(f){let s=Ma(f);return s.substring(8,s.length-1)}function hf(f){if(!zn(btoa))return"";let s=Array.prototype.map.call(new Uint8Array(f),p=>String.fromCharCode(p)).join("");return btoa(s)}function pc(f){if(!f||typeof f!="object")return!0;for(let s in f)if(il(f,s))return!1;return!0}var iu=["off","error","warn","info","log","debug"],ou={};function Gp(){iu.forEach(f=>{let s=iu.indexOf(f);ou[f]={},iu.forEach(p=>{iu.indexOf(p)<=s&&(ou[f][p]=!0)})})}function Qn(f){let s=global.WXEnvironment&&global.WXEnvironment.logLevel||"log";return ou[s]&&ou[s][f]}function Vi(f){global.nativeLog("wxInteractionAnalyzer: [jsfm]"+f,"__DEBUG")}function Yp(f,s,p){return`${s}@${p}#${f}`}var au=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,N){let E=Yp(s,p,w);this.hooks[E]&&console.warn(`[JS Framework] Override an existing component hook "${E}".`),this.hooks[E]=N}triggerHook(s,p,w,N){let E=Yp(s,p,w),h=this.hooks[E];if(!zn(h))return console.error(`[JS Framework] Invalid hook function type (${typeof h}) on "${E}".`),null;let y=null;try{y=h.apply(null,N||[])}catch(R){throw console.error(`[JS Framework] Failed to execute the hook function on "${E}".`),R}return y}consume(s,p,w){let N=this.callbacks[s];if((typeof w=="undefined"||w===!1)&&delete this.callbacks[s],zn(N))try{return N.call(null,p,w)}catch(E){throw console.error(`[JS Framework] Failed to execute the callback function:
 ${E.toString()}`),E}return new Error(`invalid callback id "${s}"`)}close(){this.callbacks={},this.hooks={}}};var su={};function qp(f,s){f&&(su[f]=s)}function rs(f){return su[f]}function Jp(f){delete su[f]}function Dr(f){if(f){let s=su[f];if(s&&s.taskCenter)return s.taskCenter}return null}function EN(f){f.calcClassList&&f.calcClassList()}function gf(f,s,p){let{documentElement:w}=f;if(w.pureChildren.length>0||s.parentNode)return;let N=w.children,E=p?N.indexOf(p):-1;E<0?N.push(s):N.splice(E,0,s),s.nodeType===1?(s.role==="body"?(s.docId=f.id,s.ownerDocument=f,s.parentNode=w,ol(s,w)):(s.children.forEach(h=>{h.parentNode=s}),pf(f,s),ol(s,w),delete f.nodeMap[s.nodeId]),w.pureChildren.push(s),SN(f,s)):(s.parentNode=w,f.nodeMap[s.ref]=s)}function SN(f,s){let p=s.toJSON();f&&f.taskCenter&&zn(f.taskCenter.send)&&f.taskCenter.send("dom",{action:"createBody"},[p])}function pf(f,s){s.role="body",s.depth=1,delete f.nodeMap[s.nodeId],s.ref="_root",f.nodeMap._root=s,f.body=s}function ol(f,s){f.parentNode=s,EN(f),s.docId&&(f.docId=s.docId,f.ownerDocument=s.ownerDocument,f.ownerDocument.nodeMap[f.nodeId]=f,f.depth=s.depth+1),f.children.forEach(p=>{ol(p,f)})}function vf(f){for(;f;){if(f.nodeType===1)return f;f=f.nextSibling}}function mf(f){for(;f;){if(f.nodeType===1)return f;f=f.previousSibling}}function al(f,s,p,w=!1){p<0&&(p=0);let N=s[p-1],E=s[p];return s.splice(p,0,f),w&&(N&&(N.nextSibling=f),f.previousSibling=N,f.nextSibling=E,E&&(E.previousSibling=f)),p}function sl(f,s,p,w=!1){let N=s.indexOf(f);if(N<0)return-1;if(w){let R=s[N-1],Fe=s[N+1];R&&(R.nextSibling=Fe),Fe&&(Fe.previousSibling=R)}s.splice(N,1);let E=p;N<=p&&(E=p-1);let h=s[E-1],y=s[E];return s.splice(E,0,f),w&&(h&&(h.nextSibling=f),f.previousSibling=h,f.nextSibling=y,y&&(y.previousSibling=f)),N===E?-1:p}function _f(f,s,p=!1){let w=s.indexOf(f);if(!(w<0)){if(p){let N=s[w-1],E=s[w+1];N&&(N.nextSibling=E),E&&(E.previousSibling=N)}s.splice(w,1)}}var ll=class{constructor(){this.depth=0;this.nodeId=Wp(),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 Kp={};function bf(f,s){if(!Ii(s)||!s.length)return;class p extends Zi{}s.forEach(w=>{p.prototype[w]=function(...N){let E=Dr(this.docId);if(E)return E.send("component",{ref:this.ref,component:f,method:w},N)}}),Kp[f]=p}function Zp(f){return Kp[f]}function Nr(f,s,p,w,N){let E={type:"decl",prop:f,value:s.toString(),raws:w,source:N};return p&&(E.important=!0),E}var wN="backgroundColor",CN="backgroundImage",AN=f=>{let{value:s,important:p,raws:w,source:N}=f;return/^#?\S+$/.test(s)||/^rgba?(.+)$/.test(s)?[Nr(wN,s,p,w,N)]:/^linear-gradient(.+)$/.test(s)?[Nr(CN,s,p,w,N)]:[f]},ON="Width",TN="Style",PN="Color";function IN(f){return s=>{let{prop:p,value:w,important:N,raws:E,source:h}=s,y=w.replace(/\s*,\s*/g,",").split(/\s+/),R=[/^[\d\.]+\S*|^(thin|medium|thick)$/,/^(solid|dashed|dotted|none)$/,/\S+/].map(Fe=>{let It=y.findIndex(Vt=>Fe.test(Vt));return It<0?null:y.splice(It,1)[0]});return y.length?[s]:[Nr(p+ON,(R[0]||(f.type==="uvue"?"thin":"0")).trim(),N,E,h),Nr(p+TN,(R[1]||(f.type==="uvue"?"none":"solid")).trim(),N,E,h),Nr(p+PN,(R[2]||"#000000").trim(),N,E,h)]}}var NN="borderTop",kN="borderRight",RN="borderBottom",xN="borderLeft",yf=f=>{let{prop:s,value:p,important:w,raws:N,source:E}=f,h=ff(s).split("-")[1];h=ru(h);let y=p.replace(/\s*,\s*/g,",").split(/\s+/);switch(y.length){case 1:return[f];case 2:y.push(y[0],y[1]);break;case 3:y.push(y[1]);break}return[Nr(NN+h,y[0],w,N,E),Nr(kN+h,y[1],w,N,E),Nr(RN+h,y[2],w,N,E),Nr(xN+h,y[3],w,N,E)]},BN="borderTopLeftRadius",MN="borderTopRightRadius",DN="borderBottomRightRadius",LN="borderBottomLeftRadius",FN=f=>{let{value:s,important:p,raws:w,source:N}=f,E=s.split(/\s+/);if(s.includes("/"))return[f];switch(E.length){case 1:return[f];case 2:E.push(E[0],E[1]);break;case 3:E.push(E[1]);break}return[Nr(BN,E[0],p,w,N),Nr(MN,E[1],p,w,N),Nr(DN,E[2],p,w,N),Nr(LN,E[3],p,w,N)]},VN=yf,UN=yf,$N="flexDirection",HN="flexWrap",jN=f=>{let{value:s,important:p,raws:w,source:N}=f,E=s.split(/\s+/),h=[/^(column|column-reverse|row|row-reverse)$/,/^(nowrap|wrap|wrap-reverse)$/].map(y=>{let R=E.findIndex(Fe=>y.test(Fe));return R<0?null:E.splice(R,1)[0]});return E.length?[f]:[Nr($N,h[0]||"column",p,w,N),Nr(HN,h[1]||"nowrap",p,w,N)]},zN="Top",WN="Right",GN="Bottom",YN="Left",Xp=f=>s=>{let{value:p,important:w,raws:N,source:E}=s,h=p.split(/\s+/);switch(h.length){case 1:h.push(h[0],h[0],h[0]);break;case 2:h.push(h[0],h[1]);break;case 3:h.push(h[1]);break}return[Nr(f+zN,h[0],w,N,E),Nr(f+WN,h[1],w,N,E),Nr(f+GN,h[2],w,N,E),Nr(f+YN,h[3],w,N,E)]},qN=Xp("margin"),JN=Xp("padding"),KN="transitionProperty",ZN="transitionDuration",XN="transitionTimingFunction",QN="transitionDelay",ek=f=>{let s=/^(\S*)?\s*(\d*\.?\d+(?:ms|s)?)?\s*(\S*)?\s*(\d*\.?\d+(?:ms|s)?)?$/,{value:p,important:w,raws:N,source:E}=f,h=[],y=p.match(s);return y&&(y[1]&&h.push(Nr(KN,y[1],w,N,E)),y[2]&&h.push(Nr(ZN,y[2],w,N,E)),y[3]&&h.push(Nr(XN,y[3],w,N,E)),y[4]&&h.push(Nr(QN,y[4],w,N,E))),h};function tk(f){let s=IN(f),p=Np({transition:ek,border:s,background:AN,borderTop:s,borderRight:s,borderBottom:s,borderLeft:s,borderStyle:VN,borderWidth:UN,borderColor:yf,borderRadius:FN},f.type!=="uvue"?{margin:qN,padding:JN,flexFlow:jN}:{}),w={};return w=p,w}var Ef,Qp=Symbol("expanded");function ev(f){return{postcssPlugin:"nvue:expand",Declaration(p){if(p[Qp])return;Ef||(Ef=tk(f));let w=Ef[p.prop];if(w){let N=w(p);N.length===1&&N[0]===p||p.replaceWith(N)}p[Qp]=!0}}}var nk=ev({type:"nvue"}).Declaration;function Sf(f,s){let p=Fi({replaceWith(N){w=N}},rk(f,s)),w=[p];return nk(p),w}function rk(f,s){let p=s+"";return p.includes("!important")?{prop:f,value:p.replace(/\s*!important/,""),important:!0}:{prop:f,value:p,important:!1}}var ik="view",ok=["click","longpress","touchstart","touchmove","touchend","panstart","panmove","panend","horizontalpan","verticalpan","swipe"];function wf(f,s){let p=rs(f);p.nodeMap[s.nodeId]=s}var Cf;function tv(f){Cf||(Cf=f)}var Zi=class extends ll{constructor(s=ik,p={},w){super();let N=Zp(s);if(N&&!w)return new N(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(Qn("debug")&&Vi(`[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=Dr(this.docId);if(w&&p>=0)return w.send("dom",{action:"moveElement"},[s.ref,this.ref,p])}}else if(Qn("debug")&&Vi(`[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=Dr(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=vf(p),N=sl(s,this.pureChildren,w?this.pureChildren.indexOf(w):this.pureChildren.length),E=Dr(this.docId);if(E&&N>=0)return E.send("dom",{action:"moveElement"},[s.ref,this.ref,N])}}else if(Qn("debug")&&Vi(`[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=vf(p),N=al(s,this.pureChildren,w?this.pureChildren.indexOf(w):this.pureChildren.length),E=Dr(this.docId);if(E)return E.send("dom",{action:"addElement"},[this.ref,s.toJSON(),N])}}}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(mf(p))+1),N=Dr(this.docId);if(N&&w>=0)return N.send("dom",{action:"moveElement"},[s.ref,this.ref,w])}}else if(Qn("debug")&&Vi(`[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(mf(p))+1),N=Dr(this.docId);if(N)return N.send("dom",{action:"addElement"},[this.ref,s.toJSON(),w])}}}removeChild(s,p){if(s.parentNode&&(_f(s,this.children,!0),s.nodeType===1)){Qn("debug")&&Vi(`[removeChild](${this.docId},${s.type},${s.ref}) Remove <${s.type}> from <${this.type}> (${this.ref}).`),_f(s,this.pureChildren);let w=Dr(this.docId);w&&w.send("dom",{action:"removeElement"},[s.ref])}p||s.destroy()}clear(){let s=Dr(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 N=Dr(this.docId);!w&&N&&N.send("dom",{action:"updateAttrs"},[this.ref,{[s]:p}])}setAttrs(s,p){if(pc(s))return;let w={};for(let N in s)this.attr[N]!==s[N]&&(this.attr[N]=s[N],w[N]=s[N]);if(!pc(w)){let N=Dr(this.docId);!p&&N&&N.send("dom",{action:"updateAttrs"},[this.ref,w])}}setStyle(s,p,w){Sf(s,p).forEach(({prop:N,value:E})=>{if(this.style[N]===E&&w!==!1)return;this.style[N]=E;let h=Dr(this.docId);!w&&h&&h.send("dom",{action:"updateStyle"},[this.ref,{[N]:E===""&&N in this.classStyle?this.classStyle[N]:E}])})}setStyles(s,p){if(pc(s))return;let w={};for(let N in s)Sf(N,s[N]).forEach(({prop:E,value:h})=>{this.style[E]!==h&&(this.style[E]=h,w[E]=h===""&&E in this.classStyle?this.classStyle[E]:h)});if(!pc(w)){let N=Dr(this.docId);!p&&N&&N.send("dom",{action:"updateStyle"},[this.ref,w])}}setClassStyle(s){for(let w in this.classStyle)this.classStyle[w]="";Fi(this.classStyle,s);let p=Dr(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]){Qn("debug")&&Vi(`[addEvent](${this.docId},${this.type},${this.ref}) Add "${s}" event on <${this.type}> (${this.ref}).`),this.event[s]={handler:p,params:w};let N=Dr(this.docId);N&&N.send("dom",{action:"addEvent"},[this.ref,s])}}removeEvent(s){if(this.event&&this.event[s]){Qn("debug")&&Vi(`[removeEvent](${this.docId},${this.type},${this.ref}) Remove "${s}" event on <${this.type}> (${this.ref}).`),delete this.event[s];let p=Dr(this.docId);p&&p.send("dom",{action:"removeEvent"},[this.ref,s])}}fireEvent(s,p,w,N){let E=null,h=!1,y=this.event[s];if(y&&p){Qn("debug")&&Vi(`[fireEvent](${this.docId},${this.type},${this.ref}) Fire "${s}" event on <${this.type}> (${this.ref}).`);let R=y.handler;p.stopPropagation=()=>{h=!0},p.preventDefault=()=>{};try{N&&N.params?E=R.call(this,...N.params,p):E=R.call(this,p)}catch(Fe){throw console.error(`[JS Framework] Failed to invoke the event handler of "${s}" on ${this.type} (${this.ref}):
 ${Fe.toString()}`),Fe}}return!h&&w&&ok.indexOf(s)!==-1&&this.parentNode&&this.parentNode.fireEvent&&(p.currentTarget=this.parentNode,this.parentNode.fireEvent(s,p,w)),E}toStyle(){let s=Object.assign({},this.classStyle),p=this.style;for(let w in p){let N=p[w];s[w]=N===""&&w in this.classStyle?this.classStyle[w]:N}return s}toJSON(s=!1){let p={ref:this.ref.toString(),type:this.type,attr:this.attr,style:this.toStyle()},w=[];for(let N in this.event){let{params:E}=this.event[N];E?w.push({type:N,params:E}):w.push(N)}return w.length&&(p.event=w),!s&&this.pureChildren.length&&(p.children=this.pureChildren.map(N=>N.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 nv(f){let s=f&&f.__v_raw;return s?nv(s):f}function rv(f){let s=gc(f);switch(s){case"Undefined":case"Null":return"";case"RegExp":return f.toString();case"Date":return f.toISOString();case"Number":case"String":case"Boolean":case"Array":case"Object":return nv(f);case"ArrayBuffer":return{"@type":"binary",dataType:s,base64:hf(f)};case"Int8Array":case"Uint8Array":case"Uint8ClampedArray":case"Int16Array":case"Uint16Array":case"Int32Array":case"Uint32Array":case"Float32Array":case"Float64Array":return{"@type":"binary",dataType:s,base64:hf(f.buffer)};default:return JSON.stringify(f)}}var lu=function(){},Vl=class{constructor(s,p){Object.defineProperty(this,"instanceId",{enumerable:!0,value:String(s)}),Object.defineProperty(this,"callbackManager",{enumerable:!0,value:new au(s)}),lu=p||function(){}}callback(s,p,w){return this.callbackManager.consume(s,p,w)}registerHook(s,p,w,N){return this.callbackManager.registerHook(s,p,w,N)}triggerHook(s,p,w,N){return this.callbackManager.triggerHook(s,p,w,N)}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 Zi)return s.ref;if(s&&s.$el instanceof Zi)return s.$el.ref;if(w==="Function")return this.callbackManager.add(s).toString();if(p){if(w==="Object"){let N={};for(let E in s)N[E]=this.normalize(s[E],!0);return N}if(w==="Array")return s.map(N=>this.normalize(N,!0))}return s&&s.ref&&s["[[VirtualElement]]"]?s.ref:rv(s)}send(s,p,w,N){let{action:E,component:h,ref:y,module:R,method:Fe}=p;switch(w=w.map(It=>this.normalize(It,s!=="module")),gc(N)==="Object"&&(N=this.normalize(N,!0)),s){case"dom":return Qn("debug")&&Vi(`[task](${this.instanceId},${s},${E}) ${JSON.stringify(w)}`),this[E](this.instanceId,w);case"component":return this.componentHandler(this.instanceId,y,Fe,w,Fi({component:h},N));default:return Qn("debug")&&Vi(`[task](${this.instanceId},${R},${Fe}) ${JSON.stringify(w)}`),this.moduleHandler(this.instanceId,R,Fe,w,N)}}callDOM(s,p){return this[s](this.instanceId,p)}callComponent(s,p,w,N){return this.componentHandler(this.instanceId,s,p,w,N)}callModule(s,p,w,N){return this.moduleHandler(this.instanceId,s,p,w,N)}};function iv(){let f={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=Vl.prototype;for(let p in f){let w=f[p];s[p]=w?(N,E)=>w(N,...E):(N,E)=>lu(N,[{module:"dom",method:p,args:E}],"-1")}s.componentHandler=global.callNativeComponent||((p,w,N,E,h)=>lu(p,[{component:h.component,ref:w,method:N,args:E}])),s.moduleHandler=global.callNativeModule||((p,w,N,E)=>lu(p,[{module:w,method:N,args:E}]))}function ak(f,s,p,w,N,E){let h=f.getRef(s);if(h)return f.fireEvent(h,p,w,N,E);if(w)return w._nodeId=s,f.fireEvent(f.getRef("_documentElement"),p,w,N,E)}function sk(f,s,p,w){return f.taskCenter.callback(s,p,w)}function lk(f,s,p,w,N){if(!f||!f.taskCenter)return console.error(`[JS Framework] Can't find "document" or "taskCenter".`),null;let E=null;try{E=f.taskCenter.triggerHook(s,p,w,N)}catch(h){throw console.error(`[JS Framework] Failed to trigger the "${p}@${w}" hook on ${s}.`),h}return E}function Af(f,s){let p=rs(f);if(!p)return new Error(`[JS Framework] Failed to receiveTasks, instance (${f}) is not available.`);if(Ii(s))return s.map(w=>{switch(w.method){case"callback":return sk(p,...w.args);case"fireEventSync":case"fireEvent":return ak(p,...w.args);case"componentHook":return lk(p,...w.args)}})}var Ns={};function ov(f={}){for(let s in f)il(Ns,s)||(Ns[s]={}),!!Ii(f[s])&&f[s].forEach(p=>{hi(p)?Ns[s][p]=!0:Fl(p)&&hi(p.name)&&(Ns[s][p.name]=p.args||[])})}function cu(f,s){return hi(s)?!!(Ns[f]&&Ns[f][s]):!!Ns[f]}function av(f){return Ns[f]}var Of={};function sv(f){!Ii(f)||f.forEach(s=>{!s||(hi(s)?Of[s]=!0:Fl(s)&&hi(s.type)&&(Of[s.type]=s,bf(s.type,s.methods)))})}function Tf(f){return!!Of[f]}var ks=[];function uu(f,s){Pf(f)?console.warn(`Service "${f}" has been registered already!`):(s=Fi({},s),ks.push({name:f,options:s}))}function fu(f){ks.some((s,p)=>{if(s.name===f)return ks.splice(p,1),!0})}function Pf(f){return ck(f)>=0}function ck(f){return ks.map(s=>s.name).indexOf(f)}function uk(f){return s=>{let p=eu(f,s),{createApp:w}=p;p.createVueApp=p.createApp=(N,E)=>w(N,E).use(fk,s),s.Vue=p}}var fk={install(f,s){dk(f,s),dc(s).initApp(f)}};function dk(f,s){let{mount:p}=f;f.mount=w=>{let N=p(w);return w==="#app"&&s.__registerApp(N),N}}function hk(f){let{UniShared:s,VueShared:p,VueReactivity:w}=f;var N=function(E,h,y,R){"use strict";function Fe(i){}function It(i,l){}function Vt(i,l,d,_){var A;try{A=_?i(..._):i()}catch(C){P(C,l,d)}return A}function Ot(i,l,d,_){if(h.isFunction(i)){var A=Vt(i,l,d,_);return A&&h.isPromise(A)&&A.catch(D=>{P(D,l,d)}),A}for(var C=[],k=0;k<i.length;k++)C.push(Ot(i[k],l,d,_));return C}function P(i,l,d){if(l&&l.vnode,l){for(var _=l.parent,A=l.proxy,C=d;_;){var k=_.ec;if(k){for(var D=0;D<k.length;D++)if(k[D](i,A,C)===!1)return}_=_.parent}var H=l.appContext.config.errorHandler;if(H){Vt(H,null,10,[i,A,C]);return}}wt(i)}function wt(i,l,d){console.error(i)}var In=!1,ot=!1,z=[],J=0,hn=[],un=null,yn=0,Jn={then(i){setTimeout(()=>i(),0)}},gi=E.platform==="iOS",pi=gi?Jn:Promise.resolve(),qr=null;function gr(i){var l=qr||pi;return i?l.then(this?i.bind(this):i):l}function Sn(i){for(var l=J+1,d=z.length;l<d;){var _=l+d>>>1,A=nt(z[_]);A<i?l=_+1:d=_}return l}function pr(i){(!z.length||!z.includes(i,In&&i.allowRecurse?J+1:J))&&(i.id==null?z.push(i):z.splice(Sn(i.id),0,i),Lr())}function Lr(){!In&&!ot&&(ot=!0,qr=pi.then(Qt))}function Jr(i){var l=z.indexOf(i);l>J&&z.splice(l,1)}function vi(i){h.isArray(i)?hn.push(...i):(!un||!un.includes(i,i.allowRecurse?yn+1:yn))&&hn.push(i),Lr()}function Pn(i){for(var l=arguments.length>1&&arguments[1]!==void 0?arguments[1]:In?J+1:0;l<z.length;l++){var d=z[l];d&&d.pre&&(z.splice(l,1),l--,d())}}function ze(i){if(hn.length){var l=[...new Set(hn)];if(hn.length=0,un){un.push(...l);return}for(un=l,un.sort((d,_)=>nt(d)-nt(_)),yn=0;yn<un.length;yn++)un[yn]();un=null,yn=0}}var nt=i=>i.id==null?1/0:i.id,At=(i,l)=>{var d=nt(i)-nt(l);if(d===0){if(i.pre&&!l.pre)return-1;if(l.pre&&!i.pre)return 1}return d};function Qt(i){ot=!1,In=!0,z.sort(At);var l=h.NOOP;try{for(J=0;J<z.length;J++){var d=z[J];d&&d.active!==!1&&Vt(d,null,14)}}finally{J=0,z.length=0,ze(),In=!1,qr=null,(z.length||hn.length)&&Qt()}}E.devtools=void 0;var Tn=[];function sn(i,l){var d,_;if(E.devtools=i,E.devtools)E.devtools.enabled=!0,Tn.forEach(C=>{var{event:k,args:D}=C;return E.devtools.emit(k,...D)}),Tn=[];else if(typeof window!="undefined"&&window.HTMLElement&&!((_=(d=window.navigator)===null||d===void 0?void 0:d.userAgent)===null||_===void 0?void 0:_.includes("jsdom"))){var A=l.__VUE_DEVTOOLS_HOOK_REPLAY__=l.__VUE_DEVTOOLS_HOOK_REPLAY__||[];A.push(C=>{sn(C,l)}),setTimeout(()=>{E.devtools||(l.__VUE_DEVTOOLS_HOOK_REPLAY__=null,Tn=[])},3e3)}else Tn=[]}function or(i,l){if(!i.isUnmounted){for(var d=i.vnode.props||h.EMPTY_OBJ,_=arguments.length,A=new Array(_>2?_-2:0),C=2;C<_;C++)A[C-2]=arguments[C];var k=A,D=l.startsWith("update:"),H=D&&l.slice(7);if(H&&H in d){var ne="".concat(H==="modelValue"?"model":H,"Modifiers"),{number:ve,trim:Be}=d[ne]||h.EMPTY_OBJ;Be&&(k=A.map(ut=>h.isString(ut)?ut.trim():ut)),ve&&(k=A.map(h.looseToNumber))}var ue,ke=d[ue=h.toHandlerKey(l)]||d[ue=h.toHandlerKey(h.camelize(l))];!ke&&D&&(ke=d[ue=h.toHandlerKey(h.hyphenate(l))]),ke&&Ot(ke,i,6,k);var Ge=d[ue+"Once"];if(Ge){if(!i.emitted)i.emitted={};else if(i.emitted[ue])return;i.emitted[ue]=!0,Ot(Ge,i,6,k)}}}function Wn(i,l){var d=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,k={},D=!1;if(!h.isFunction(i)){var H=ne=>{var ve=Wn(ne,l,!0);ve&&(D=!0,h.extend(k,ve))};!d&&l.mixins.length&&l.mixins.forEach(H),i.extends&&H(i.extends),i.mixins&&i.mixins.forEach(H)}return!C&&!D?(h.isObject(i)&&_.set(i,null),null):(h.isArray(C)?C.forEach(ne=>k[ne]=null):h.extend(k,C),h.isObject(i)&&_.set(i,k),k)}function An(i,l){return!i||!h.isOn(l)?!1:(l=l.slice(2).replace(/Once$/,""),h.hasOwn(i,l[0].toLowerCase()+l.slice(1))||h.hasOwn(i,h.hyphenate(l))||h.hasOwn(i,l))}var gn=null,wr=null;function Kr(i){var l=gn;return gn=i,wr=i&&i.type.__scopeId||null,l}function wo(i){wr=i}function da(){wr=null}var Ui=i=>Zo;function Zo(i){var l=arguments.length>1&&arguments[1]!==void 0?arguments[1]:gn;if(!l||i._n)return i;var d=function(){d._d&&yt(-1);var _=Kr(l),A;try{A=i(...arguments)}finally{Kr(_),d._d&&yt(1)}return A};return d._n=!0,d._c=!0,d._d=!0,d}function Xo(){}function $i(i){var{type:l,vnode:d,proxy:_,withProxy:A,props:C,propsOptions:[k],slots:D,attrs:H,emit:ne,render:ve,renderCache:Be,data:ue,setupState:ke,ctx:Ge,inheritAttrs:ut}=i,Qe,Re,me=Kr(i);try{if(d.shapeFlag&4){var ye=A||_;Qe=$n(ve.call(ye,ye,Be,C,ke,ue,Ge)),Re=H}else{var Le=l;Qe=$n(Le.length>1?Le(C,{attrs:H,slots:D,emit:ne}):Le(C,null)),Re=l.props?H:Co(H)}}catch(Ke){fe.length=0,P(Ke,i,1),Qe=qt(pe)}var Oe=Qe;if(Re&&ut!==!1){var bt=Object.keys(Re),{shapeFlag:Ct}=Oe;bt.length&&Ct&(1|6)&&(k&&bt.some(h.isModelListener)&&(Re=Ao(Re,k)),Oe=ei(Oe,Re))}return d.dirs&&(Oe=ei(Oe),Oe.dirs=Oe.dirs?Oe.dirs.concat(d.dirs):d.dirs),d.transition&&(Oe.transition=d.transition),Qe=Oe,Kr(me),Qe}function ri(i){for(var l,d=0;d<i.length;d++){var _=i[d];if(Gt(_)){if(_.type!==pe||_.children==="v-if"){if(l)return;l=_}}else return}return l}var Co=i=>{var l;for(var d in i)(d==="class"||d==="style"||h.isOn(d))&&((l||(l={}))[d]=i[d]);return l},Ao=(i,l)=>{var d={};for(var _ in i)(!h.isModelListener(_)||!(_.slice(9)in l))&&(d[_]=i[_]);return d};function Oo(i,l,d){var{props:_,children:A,component:C}=i,{props:k,children:D,patchFlag:H}=l,ne=C.emitsOptions;if(l.dirs||l.transition)return!0;if(d&&H>=0){if(H&1024)return!0;if(H&16)return _?Xi(_,k,ne):!!k;if(H&8)for(var ve=l.dynamicProps,Be=0;Be<ve.length;Be++){var ue=ve[Be];if(k[ue]!==_[ue]&&!An(ne,ue))return!0}}else return(A||D)&&(!D||!D.$stable)?!0:_===k?!1:_?k?Xi(_,k,ne):!0:!!k;return!1}function Xi(i,l,d){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]&&!An(d,C))return!0}return!1}function mi(i,l){for(var{vnode:d,parent:_}=i;_&&_.subTree===d;)(d=_.vnode).el=l,_=_.parent}var To=i=>i.__isSuspense,uo={name:"Suspense",__isSuspense:!0,process(i,l,d,_,A,C,k,D,H,ne){i==null?Qi(l,d,_,A,C,k,D,H,ne):Kn(i,l,d,_,A,k,D,H,ne)},hydrate:Po,create:eo,normalize:fo},kn=uo;function Cr(i,l){var d=i.props&&i.props[l];h.isFunction(d)&&d()}function Qi(i,l,d,_,A,C,k,D,H){var{p:ne,o:{createElement:ve}}=H,Be=ve("div",l),ue=i.suspense=eo(i,A,_,l,Be,d,C,k,D,H);ne(null,ue.pendingBranch=i.ssContent,Be,null,_,ue,C,k),ue.deps>0?(Cr(i,"onPending"),Cr(i,"onFallback"),ne(null,i.ssFallback,l,d,_,null,C,k),kr(ue,i.ssFallback)):ue.resolve()}function Kn(i,l,d,_,A,C,k,D,H){var{p:ne,um:ve,o:{createElement:Be}}=H,ue=l.suspense=i.suspense;ue.vnode=l,l.el=i.el;var ke=l.ssContent,Ge=l.ssFallback,{activeBranch:ut,pendingBranch:Qe,isInFallback:Re,isHydrating:me}=ue;if(Qe)ue.pendingBranch=ke,dt(ke,Qe)?(ne(Qe,ke,ue.hiddenContainer,null,A,ue,C,k,D),ue.deps<=0?ue.resolve():Re&&(ne(ut,Ge,d,_,A,null,C,k,D),kr(ue,Ge))):(ue.pendingId++,me?(ue.isHydrating=!1,ue.activeBranch=Qe):ve(Qe,A,ue),ue.deps=0,ue.effects.length=0,ue.hiddenContainer=Be("div",d),Re?(ne(null,ke,ue.hiddenContainer,null,A,ue,C,k,D),ue.deps<=0?ue.resolve():(ne(ut,Ge,d,_,A,null,C,k,D),kr(ue,Ge))):ut&&dt(ke,ut)?(ne(ut,ke,d,_,A,ue,C,k,D),ue.resolve(!0)):(ne(null,ke,ue.hiddenContainer,null,A,ue,C,k,D),ue.deps<=0&&ue.resolve()));else if(ut&&dt(ke,ut))ne(ut,ke,d,_,A,ue,C,k,D),kr(ue,ke);else if(Cr(l,"onPending"),ue.pendingBranch=ke,ue.pendingId++,ne(null,ke,ue.hiddenContainer,null,A,ue,C,k,D),ue.deps<=0)ue.resolve();else{var{timeout:ye,pendingId:Le}=ue;ye>0?setTimeout(()=>{ue.pendingId===Le&&ue.fallback(Ge)},ye):ye===0&&ue.fallback(Ge)}}function eo(i,l,d,_,A,C,k,D,H,ne){var ve=arguments.length>10&&arguments[10]!==void 0?arguments[10]:!1,{p:Be,m:ue,um:ke,n:Ge,o:{parentNode:ut,remove:Qe}}=ne,Re=i.props?h.toNumber(i.props.timeout):void 0,me={vnode:i,parent:l,parentComponent:d,isSVG:k,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:Le,activeBranch:Oe,pendingBranch:bt,pendingId:Ct,effects:Ke,parentComponent:Rt,container:M}=me;if(me.isHydrating)me.isHydrating=!1;else if(!ye){var j=Oe&&bt.transition&&bt.transition.mode==="out-in";j&&(Oe.transition.afterLeave=()=>{Ct===me.pendingId&&ue(bt,M,se,0)});var{anchor:se}=me;Oe&&(se=Ge(Oe),ke(Oe,Rt,me,!0)),j||ue(bt,M,se,0)}kr(me,bt),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||vi(Ke),me.effects=[],Cr(Le,"onResolve")},fallback(ye){if(!!me.pendingBranch){var{vnode:Le,activeBranch:Oe,parentComponent:bt,container:Ct,isSVG:Ke}=me;Cr(Le,"onFallback");var Rt=Ge(Oe),M=()=>{!me.isInFallback||(Be(null,ye,Ct,Rt,bt,null,Ke,D,H),kr(me,ye))},j=ye.transition&&ye.transition.mode==="out-in";j&&(Oe.transition.afterLeave=M),me.isInFallback=!0,ke(Oe,bt,null,!0),j||M()}},move(ye,Le,Oe){me.activeBranch&&ue(me.activeBranch,ye,Le,Oe),me.container=ye},next(){return me.activeBranch&&Ge(me.activeBranch)},registerDep(ye,Le){var Oe=!!me.pendingBranch;Oe&&me.deps++;var bt=ye.vnode.el;ye.asyncDep.catch(Ct=>{P(Ct,ye,0)}).then(Ct=>{if(!(ye.isUnmounted||me.isUnmounted||me.pendingId!==ye.suspenseId)){ye.asyncResolved=!0;var{vnode:Ke}=ye;ra(ye,Ct,!1),bt&&(Ke.el=bt);var Rt=!bt&&ye.subTree.el;Le(ye,Ke,ut(bt||ye.subTree.el),bt?null:Ge(ye.subTree),me,k,H),Rt&&Qe(Rt),mi(ye,Ke.el),Oe&&--me.deps===0&&me.resolve()}})},unmount(ye,Le){me.isUnmounted=!0,me.activeBranch&&ke(me.activeBranch,d,ye,Le),me.pendingBranch&&ke(me.pendingBranch,d,ye,Le)}};return me}function Po(i,l,d,_,A,C,k,D,H){var ne=l.suspense=eo(l,_,d,i.parentNode,document.createElement("div"),null,A,C,k,D,!0),ve=H(i,ne.pendingBranch=l.ssContent,d,ne,C,k);return ne.deps===0&&ne.resolve(),ve}function fo(i){var{shapeFlag:l,children:d}=i,_=l&32;i.ssContent=ii(_?d.default:d),i.ssFallback=_?ii(d.fallback):qt(pe)}function ii(i){var l;if(h.isFunction(i)){var d=Ht&&i._c;d&&(i._d=!1,ct()),i=i(),d&&(i._d=!0,l=Ce,gt())}if(h.isArray(i)){var _=ri(i);i=_}return i=$n(i),l&&!i.dynamicChildren&&(i.dynamicChildren=l.filter(A=>A!==i)),i}function ar(i,l){l&&l.pendingBranch?h.isArray(i)?l.effects.push(...i):l.effects.push(i):vi(i)}function kr(i,l){i.activeBranch=l;var{vnode:d,parentComponent:_}=i,A=d.el=l.el;_&&_.subTree===d&&(_.vnode.el=A,mi(_,A))}function Nn(i,l){if(_n){var d=_n.provides,_=_n.parent&&_n.parent.provides;_===d&&(d=_n.provides=Object.create(_)),d[i]=l,_n.type.mpType==="app"&&_n.appContext.app.provide(i,l)}}function Zn(i,l){var d=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!1,_=_n||gn;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 d&&h.isFunction(l)?l.call(_.proxy):l}}function Ni(i,l){return ki(i,null,l)}function Hi(i,l){return ki(i,null,{flush:"post"})}function oi(i,l){return ki(i,null,{flush:"sync"})}var Fr={};function vr(i,l,d){return ki(i,l,d)}function ki(i,l){var{immediate:d,deep:_,flush:A,onTrack:C,onTrigger:k}=arguments.length>2&&arguments[2]!==void 0?arguments[2]:h.EMPTY_OBJ,D=y.getCurrentScope()===(_n==null?void 0:_n.scope)?_n:null,H,ne=!1,ve=!1;if(y.isRef(i)?(H=()=>i.value,ne=y.isShallow(i)):y.isReactive(i)?(H=()=>i,_=!0):h.isArray(i)?(ve=!0,ne=i.some(Oe=>y.isReactive(Oe)||y.isShallow(Oe)),H=()=>i.map(Oe=>{if(y.isRef(Oe))return Oe.value;if(y.isReactive(Oe))return Zr(Oe);if(h.isFunction(Oe))return Vt(Oe,D,2)})):h.isFunction(i)?l?H=()=>Vt(i,D,2):H=()=>{if(!(D&&D.isUnmounted))return ue&&ue(),Ot(i,D,3,[ke])}:H=h.NOOP,l&&_){var Be=H;H=()=>Zr(Be())}var ue,ke=Oe=>{ue=ye.onStop=()=>{Vt(Oe,D,4)}},Ge;if(E.isInSSRComponentSetup)if(ke=h.NOOP,l?d&&Ot(l,D,3,[H(),ve?[]:void 0,ke]):H(),A==="sync"){var ut=Na();Ge=ut.__watcherHandles||(ut.__watcherHandles=[])}else return h.NOOP;var Qe=ve?new Array(i.length).fill(Fr):Fr,Re=()=>{if(!!ye.active)if(l){var Oe=ye.run();(_||ne||(ve?Oe.some((bt,Ct)=>h.hasChanged(bt,Qe[Ct])):h.hasChanged(Oe,Qe)))&&(ue&&ue(),Ot(l,D,3,[Oe,Qe===Fr?void 0:ve&&Qe[0]===Fr?[]:Qe,ke]),Qe=Oe)}else ye.run()};Re.allowRecurse=!!l;var me;A==="sync"?me=Re:A==="post"?me=()=>lr(Re,D&&D.suspense):(Re.pre=!0,D&&(Re.id=D.uid),me=()=>pr(Re));var ye=new y.ReactiveEffect(H,me);l?d?Re():Qe=ye.run():A==="post"?lr(ye.run.bind(ye),D&&D.suspense):ye.run();var Le=()=>{ye.stop(),D&&D.scope&&h.remove(D.scope.effects,ye)};return Ge&&Ge.push(Le),Le}function Io(i,l,d){var _=this.proxy,A=h.isString(i)?i.includes(".")?Vr(_,i):()=>_[i]:i.bind(_,_),C;h.isFunction(l)?C=l:(C=l.handler,d=l);var k=_n;qn(this);var D=ki(A,C.bind(_),d);return k?qn(k):Ai(),D}function Vr(i,l){var d=l.split(".");return()=>{for(var _=i,A=0;A<d.length&&_;A++)_=_[d[A]];return _}}function Zr(i,l){if(!h.isObject(i)||i.__v_skip||(l=l||new Set,l.has(i)))return i;if(l.add(i),y.isRef(i))Zr(i.value,l);else if(h.isArray(i))for(var d=0;d<i.length;d++)Zr(i[d],l);else if(h.isSet(i)||h.isMap(i))i.forEach(A=>{Zr(A,l)});else if(h.isPlainObject(i))for(var _ in i)Zr(i[_],l);return i}function Ar(){var i={isMounted:!1,isLeaving:!1,isUnmounting:!1,leavingVNodes:new Map};return tr(()=>{i.isMounted=!0}),cr(()=>{i.isUnmounting=!0}),i}var pn=[Function,Array],Xr={mode:String,appear:Boolean,persisted:Boolean,onBeforeEnter:pn,onEnter:pn,onAfterEnter:pn,onEnterCancelled:pn,onBeforeLeave:pn,onLeave:pn,onAfterLeave:pn,onLeaveCancelled:pn,onBeforeAppear:pn,onAppear:pn,onAfterAppear:pn,onAppearCancelled:pn},Ur={name:"BaseTransition",props:Xr,setup(i,l){var{slots:d}=l,_=jn(),A=Ar(),C;return()=>{var k=d.default&&Ri(d.default(),!0);if(!(!k||!k.length)){var D=k[0];if(k.length>1){for(var H of k)if(H.type!==pe){D=H;break}}var ne=y.toRaw(i),{mode:ve}=ne;if(A.isLeaving)return bi(D);var Be=yi(D);if(!Be)return bi(D);var ue=_i(Be,ne,A,_);Or(Be,ue);var ke=_.subTree,Ge=ke&&yi(ke),ut=!1,{getTransitionKey:Qe}=Be.type;if(Qe){var Re=Qe();C===void 0?C=Re:Re!==C&&(C=Re,ut=!0)}if(Ge&&Ge.type!==pe&&(!dt(Be,Ge)||ut)){var me=_i(Ge,ne,A,_);if(Or(Ge,me),ve==="out-in")return A.isLeaving=!0,me.afterLeave=()=>{A.isLeaving=!1,_.update.active!==!1&&_.update()},bi(D);ve==="in-out"&&Be.type!==pe&&(me.delayLeave=(ye,Le,Oe)=>{var bt=Te(A,Ge);bt[String(Ge.key)]=Ge,ye._leaveCb=()=>{Le(),ye._leaveCb=void 0,delete ue.delayedLeave},ue.delayedLeave=Oe})}return D}}}},Dt=Ur;function Te(i,l){var{leavingVNodes:d}=i,_=d.get(l.type);return _||(_=Object.create(null),d.set(l.type,_)),_}function _i(i,l,d,_){var{appear:A,mode:C,persisted:k=!1,onBeforeEnter:D,onEnter:H,onAfterEnter:ne,onEnterCancelled:ve,onBeforeLeave:Be,onLeave:ue,onAfterLeave:ke,onLeaveCancelled:Ge,onBeforeAppear:ut,onAppear:Qe,onAfterAppear:Re,onAppearCancelled:me}=l,ye=String(i.key),Le=Te(d,i),Oe=(Ke,Rt)=>{Ke&&Ot(Ke,_,9,Rt)},bt=(Ke,Rt)=>{var M=Rt[1];Oe(Ke,Rt),h.isArray(Ke)?Ke.every(j=>j.length<=1)&&M():Ke.length<=1&&M()},Ct={mode:C,persisted:k,beforeEnter(Ke){var Rt=D;if(!d.isMounted)if(A)Rt=ut||D;else return;Ke._leaveCb&&Ke._leaveCb(!0);var M=Le[ye];M&&dt(i,M)&&M.el._leaveCb&&M.el._leaveCb(),Oe(Rt,[Ke])},enter(Ke){var Rt=H,M=ne,j=ve;if(!d.isMounted)if(A)Rt=Qe||H,M=Re||ne,j=me||ve;else return;var se=!1,re=Ke._enterCb=oe=>{se||(se=!0,oe?Oe(j,[Ke]):Oe(M,[Ke]),Ct.delayedLeave&&Ct.delayedLeave(),Ke._enterCb=void 0)};Rt?bt(Rt,[Ke,re]):re()},leave(Ke,Rt){var M=String(i.key);if(Ke._enterCb&&Ke._enterCb(!0),d.isUnmounting)return Rt();Oe(Be,[Ke]);var j=!1,se=Ke._leaveCb=re=>{j||(j=!0,Rt(),re?Oe(Ge,[Ke]):Oe(ke,[Ke]),Ke._leaveCb=void 0,Le[M]===i&&delete Le[M])};Le[M]=i,ue?bt(ue,[Ke,se]):se()},clone(Ke){return _i(Ke,l,d,_)}};return Ct}function bi(i){if(Ei(i))return i=ei(i),i.children=null,i}function yi(i){return Ei(i)?i.children?i.children[0]:void 0:i}function Or(i,l){i.shapeFlag&6&&i.component?Or(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 Ri(i){for(var l=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!1,d=arguments.length>2?arguments[2]:void 0,_=[],A=0,C=0;C<i.length;C++){var k=i[C],D=d==null?k.key:String(d)+String(k.key!=null?k.key:C);k.type===te?(k.patchFlag&128&&A++,_=_.concat(Ri(k.children,l,D))):(l||k.type!==pe)&&_.push(D!=null?ei(k,{key:D}):k)}if(A>1)for(var H=0;H<_.length;H++)_[H].patchFlag=-2;return _}function Tr(i){return h.isFunction(i)?{setup:i,name:i.name}:i}var Rr=i=>!!i.type.__asyncLoader;function ai(i){h.isFunction(i)&&(i={loader:i});var{loader:l,loadingComponent:d,errorComponent:_,delay:A=200,timeout:C,suspensible:k=!0,onError:D}=i,H=null,ne,ve=0,Be=()=>(ve++,H=null,ue()),ue=()=>{var ke;return H||(ke=H=l().catch(Ge=>{if(Ge=Ge instanceof Error?Ge:new Error(String(Ge)),D)return new Promise((ut,Qe)=>{var Re=()=>ut(Be()),me=()=>Qe(Ge);D(Ge,Re,me,ve+1)});throw Ge}).then(Ge=>ke!==H&&H?H:(Ge&&(Ge.__esModule||Ge[Symbol.toStringTag]==="Module")&&(Ge=Ge.default),ne=Ge,Ge)))};return Tr({name:"AsyncComponentWrapper",__asyncLoader:ue,get __asyncResolved(){return ne},setup(){var ke=_n;if(ne)return()=>Pr(ne,ke);var Ge=me=>{H=null,P(me,ke,13)};if(k&&ke.suspense||E.isInSSRComponentSetup)return ue().then(me=>()=>Pr(me,ke)).catch(me=>(Ge(me),()=>_?qt(_,{error:me}):null));var ut=y.ref(!1),Qe=y.ref(),Re=y.ref(!!A);return A&&setTimeout(()=>{Re.value=!1},A),C!=null&&setTimeout(()=>{if(!ut.value&&!Qe.value){var me=new Error("Async component timed out after ".concat(C,"ms."));Ge(me),Qe.value=me}},C),ue().then(()=>{ut.value=!0,ke.parent&&Ei(ke.parent.vnode)&&pr(ke.parent.update)}).catch(me=>{Ge(me),Qe.value=me}),()=>{if(ut.value&&ne)return Pr(ne,ke);if(Qe.value&&_)return qt(_,{error:Qe.value});if(d&&!Re.value)return qt(d)}}})}function Pr(i,l){var{ref:d,props:_,children:A,ce:C}=l.vnode,k=qt(i,_,A);return k.ref=d,k.ce=C,delete l.vnode.ce,k}var Ei=i=>i.type.__isKeepAlive,fn={name:"KeepAlive",__isKeepAlive:!0,props:{include:[String,RegExp,Array],exclude:[String,RegExp,Array],max:[String,Number]},setup(i,l){var{slots:d}=l,_=jn(),A=_.ctx;if(!A.renderer)return()=>{var ye=d.default&&d.default();return ye&&ye.length===1?ye[0]:ye};var C=new Map,k=new Set,D=null,H=_.suspense,{renderer:{p:ne,m:ve,um:Be,o:{createElement:ue}}}=A,ke=ue("div",null);A.activate=(ye,Le,Oe,bt,Ct)=>{var Ke=ye.component;ve(ye,Le,Oe,0,H),ne(Ke.vnode,ye,Le,Oe,Ke,H,bt,ye.slotScopeIds,Ct),lr(()=>{Ke.isDeactivated=!1,Ke.a&&h.invokeArrayFns(Ke.a);var Rt=ye.props&&ye.props.onVnodeMounted;Rt&&zr(Rt,Ke.parent,ye)},H)},A.deactivate=ye=>{var Le=ye.component;ve(ye,ke,null,1,H),lr(()=>{Le.da&&h.invokeArrayFns(Le.da);var Oe=ye.props&&ye.props.onVnodeUnmounted;Oe&&zr(Oe,Le.parent,ye),Le.isDeactivated=!0},H)};function Ge(ye){Si(ye),Be(ye,_,H,!0)}function ut(ye){C.forEach((Le,Oe)=>{var bt=_o(Le.type);bt&&(!ye||!ye(bt))&&Qe(Oe)})}function Qe(ye){var Le=C.get(ye);!D||!dt(Le,D)?Ge(Le):D&&Si(D),C.delete(ye),k.delete(ye)}vr(()=>[i.include,i.exclude],ye=>{var[Le,Oe]=ye;Le&&ut(bt=>$r(Le,bt)),Oe&&ut(bt=>!$r(Oe,bt))},{flush:"post",deep:!0});var Re=null,me=()=>{Re!=null&&C.set(Re,xi(_.subTree))};return tr(me),nr(me),cr(()=>{C.forEach(ye=>{var{subTree:Le,suspense:Oe}=_,bt=xi(Le);if(ye.type===bt.type&&ye.key===bt.key){Si(bt);var Ct=bt.component.da;Ct&&lr(Ct,Oe);return}Ge(ye)})}),()=>{if(Re=null,!d.default)return null;var ye=d.default(),Le=ye[0];if(ye.length>1)return D=null,ye;if(!Gt(Le)||!(Le.shapeFlag&4)&&!(Le.shapeFlag&128))return D=null,Le;var Oe=xi(Le),bt=Oe.type,Ct=_o(Rr(Oe)?Oe.type.__asyncResolved||{}:bt),{include:Ke,exclude:Rt,max:M}=i;if(Ke&&(!Ct||!$r(Ke,Ct))||Rt&&Ct&&$r(Rt,Ct))return D=Oe,Le;var j=Oe.key==null?bt:Oe.key,se=C.get(j);return Oe.el&&(Oe=ei(Oe),Le.shapeFlag&128&&(Le.ssContent=Oe)),Re=j,se?(Oe.el=se.el,Oe.component=se.component,Oe.transition&&Or(Oe,Oe.transition),Oe.shapeFlag|=512,k.delete(j),k.add(j)):(k.add(j),M&&k.size>parseInt(M,10)&&Qe(k.values().next().value)),Oe.shapeFlag|=256,D=Oe,To(Le.type)?Le:Oe}}},ji=fn;function $r(i,l){return h.isArray(i)?i.some(d=>$r(d,l)):h.isString(i)?i.split(",").includes(l):h.isRegExp(i)?i.test(l):!1}function to(i,l){Hr(i,"a",l)}function En(i,l){Hr(i,"da",l)}function Hr(i,l){var d=arguments.length>2&&arguments[2]!==void 0?arguments[2]:_n,_=i.__wdc||(i.__wdc=()=>{for(var C=d;C;){if(C.isDeactivated)return;C=C.parent}return i()});if(mr(l,_,d),d)for(var A=d.parent;A&&A.parent;)Ei(A.parent.vnode)&&sr(_,l,d,A),A=A.parent}function sr(i,l,d,_){var A=mr(l,i,_,!0);ho(()=>{h.remove(_[l],A)},d)}function Si(i){i.shapeFlag&=~256,i.shapeFlag&=~512}function xi(i){return i.shapeFlag&128?i.ssContent:i}function mr(i,l){var d=arguments.length>2&&arguments[2]!==void 0?arguments[2]:_n,_=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1;if(d){if(R.isRootHook(i)&&d!==d.root&&(d=d.root,R.isRootImmediateHook(i))){var A=d.proxy;Ot(l.bind(A),d,i,R.ON_LOAD===i?[A.$page.options]:[])}var{__page_container__:C}=d.root.vnode;C&&C.onInjectHook(i);var k=d[i]||(d[i]=[]),D=l.__weh||(l.__weh=function(){if(!d.isUnmounted){y.pauseTracking(),qn(d);for(var H=arguments.length,ne=new Array(H),ve=0;ve<H;ve++)ne[ve]=arguments[ve];var Be=Ot(l,d,i,ne);return Ai(),y.resetTracking(),Be}});return _?k.unshift(D):k.push(D),D}}var Qr=i=>function(l){var d=arguments.length>1&&arguments[1]!==void 0?arguments[1]:_n;return(!E.isInSSRComponentSetup||i==="sp")&&mr(i,function(){return l(...arguments)},d)},er=Qr("bm"),tr=Qr("m"),Gn=Qr("bu"),nr=Qr("u"),cr=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]:_n;mr("ec",i,l)}function jr(i,l){var d=gn;if(d===null)return i;for(var _=Di(d)||d.proxy,A=i.dirs||(i.dirs=[]),C=0;C<l.length;C++){var[k,D,H,ne=h.EMPTY_OBJ]=l[C];k&&(h.isFunction(k)&&(k={mounted:k,updated:k}),k.deep&&Zr(D),A.push({dir:k,instance:_,value:D,oldValue:void 0,arg:H,modifiers:ne}))}return i}function xr(i,l,d,_){for(var A=i.dirs,C=l&&l.dirs,k=0;k<A.length;k++){var D=A[k];C&&(D.oldValue=C[k].value);var H=D.dir[_];H&&(y.pauseTracking(),Ot(H,d,8,[i.el,D,i,l]),y.resetTracking())}}var po="components",Ro="directives";function ro(i,l){return zi(po,i,!0,l)||i}var Bi=Symbol();function vo(i){return h.isString(i)?zi(po,i,!1)||i:i||Bi}function Mi(i){return zi(Ro,i)}function zi(i,l){var d=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1,_=gn||_n;if(_){var A=_.type;if(i===po){var C=_o(A,!1);if(C&&(C===l||C===h.camelize(l)||C===h.capitalize(h.camelize(l))))return A}var k=Qo(_[i]||A[i],l)||Qo(_.appContext[i],l);return!k&&d?A:k}}function Qo(i,l){return i&&(i[l]||i[h.camelize(l)]||i[h.capitalize(h.camelize(l))])}function B(i,l,d,_){var A,C=d&&d[_];if(h.isArray(i)||h.isString(i)){A=new Array(i.length);for(var k=0,D=i.length;k<D;k++)A[k]=l(i[k],k,void 0,C&&C[k])}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(h.isObject(i))if(i[Symbol.iterator])A=Array.from(i,(ke,Ge)=>l(ke,Ge,void 0,C&&C[Ge]));else{var ne=Object.keys(i);A=new Array(ne.length);for(var ve=0,Be=ne.length;ve<Be;ve++){var ue=ne[ve];A[ve]=l(i[ue],ue,ve,C&&C[ve])}}else A=[];return d&&(d[_]=A),A}function Q(i,l){for(var d=function(A){var C=l[A];if(h.isArray(C))for(var k=0;k<C.length;k++)i[C[k].name]=C[k].fn;else C&&(i[C.name]=C.key?function(){var D=C.fn(...arguments);return D&&(D.key=C.key),D}:C.fn)},_=0;_<l.length;_++)d(_);return i}function he(i,l){var d=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(gn.isCE||gn.parent&&Rr(gn.parent)&&gn.parent.isCE)return l!=="default"&&(d.name=l),qt("slot",d,_&&_());var C=i[l];C&&C._c&&(C._d=!1),ct();var k=C&&ae(C(d)),D=dn(te,{key:d.key||k&&k.key||"_".concat(l)},k||(_?_():[]),k&&i._===1?64:-2);return!A&&D.scopeId&&(D.slotScopeIds=[D.scopeId+"-s"]),C&&C._c&&(C._d=!0),D}function ae(i){return i.some(l=>Gt(l)?!(l.type===pe||l.type===te&&!ae(l.children)):!0)?i:null}function de(i,l){var d={};for(var _ in i)d[l&&/[A-Z]/.test(_)?"on:".concat(_):h.toHandlerKey(_)]=i[_];return d}var vt=i=>i?us(i)?Di(i)||i.proxy:vt(i.parent):null,kt=h.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=>vt(i.parent),$root:i=>vt(i.root),$emit:i=>i.emit,$options:i=>_r(i),$forceUpdate:i=>i.f||(i.f=()=>pr(i.update)),$nextTick:i=>i.n||(i.n=gr.bind(i.proxy)),$watch:i=>Io.bind(i)}),X=(i,l)=>i!==h.EMPTY_OBJ&&!i.__isScriptSetup&&h.hasOwn(i,l),K={get(i,l){var{_:d}=i,{ctx:_,setupState:A,data:C,props:k,accessCache:D,type:H,appContext:ne}=d,ve;if(l[0]!=="$"){var Be=D[l];if(Be!==void 0)switch(Be){case 1:return A[l];case 2:return C[l];case 4:return _[l];case 3:return k[l]}else{if(X(A,l))return D[l]=1,A[l];if(C!==h.EMPTY_OBJ&&h.hasOwn(C,l))return D[l]=2,C[l];if((ve=d.propsOptions[0])&&h.hasOwn(ve,l))return D[l]=3,k[l];if(_!==h.EMPTY_OBJ&&h.hasOwn(_,l))return D[l]=4,_[l];Ne&&(D[l]=0)}}var ue=kt[l],ke,Ge;if(ue)return l==="$attrs"&&y.track(d,"get",l),ue(d);if((ke=H.__cssModules)&&(ke=ke[l]))return ke;if(_!==h.EMPTY_OBJ&&h.hasOwn(_,l))return D[l]=4,_[l];if(Ge=ne.config.globalProperties,h.hasOwn(Ge,l))return Ge[l]},set(i,l,d){var{_}=i,{data:A,setupState:C,ctx:k}=_;return X(C,l)?(C[l]=d,!0):A!==h.EMPTY_OBJ&&h.hasOwn(A,l)?(A[l]=d,!0):h.hasOwn(_.props,l)||l[0]==="$"&&l.slice(1)in _?!1:(k[l]=d,!0)},has(i,l){var{_:{data:d,setupState:_,accessCache:A,ctx:C,appContext:k,propsOptions:D}}=i,H;return!!A[l]||d!==h.EMPTY_OBJ&&h.hasOwn(d,l)||X(_,l)||(H=D[0])&&h.hasOwn(H,l)||h.hasOwn(C,l)||h.hasOwn(kt,l)||h.hasOwn(k.config.globalProperties,l)},defineProperty(i,l,d){return d.get!=null?i._.accessCache[l]=0:h.hasOwn(d,"value")&&this.set(i,l,d.value,null),Reflect.defineProperty(i,l,d)}},ie=h.extend({},K,{get(i,l){if(l!==Symbol.unscopables)return K.get(i,l,i)},has(i,l){var d=l[0]!=="_"&&!h.isGloballyWhitelisted(l);return d}}),Ne=!0;function st(i){var l=_r(i),d=i.proxy,_=i.ctx;Ne=!1,l.beforeCreate&&xn(l.beforeCreate,i,"bc");var{data:A,computed:C,methods:k,watch:D,provide:H,inject:ne,created:ve,beforeMount:Be,mounted:ue,beforeUpdate:ke,updated:Ge,activated:ut,deactivated:Qe,beforeDestroy:Re,beforeUnmount:me,destroyed:ye,unmounted:Le,render:Oe,renderTracked:bt,renderTriggered:Ct,errorCaptured:Ke,serverPrefetch:Rt,expose:M,inheritAttrs:j,components:se,directives:re,filters:oe}=l,Ue=null;if(ne&&Xt(ne,_,Ue,i.appContext.config.unwrapInjectedRef),k)for(var rt in k){var qe=k[rt];h.isFunction(qe)&&(_[rt]=qe.bind(d))}if(A){var Ze=A.call(d,d);h.isObject(Ze)&&(i.data=y.reactive(Ze))}if(Ne=!0,C){var $e=function(vn){var bn=C[vn],fr=h.isFunction(bn)?bn.bind(d,d):h.isFunction(bn.get)?bn.get.bind(d,d):h.NOOP,ni=!h.isFunction(bn)&&h.isFunction(bn.set)?bn.set.bind(d):h.NOOP,Jt=ds({get:fr,set:ni});Object.defineProperty(_,vn,{enumerable:!0,configurable:!0,get:()=>Jt.value,set:an=>Jt.value=an})};for(var $t in C)$e($t)}if(D)for(var pt in D)Dn(D[pt],_,d,pt);if(H){var xt=h.isFunction(H)?H.call(d):H;Reflect.ownKeys(xt).forEach(vn=>{Nn(vn,xt[vn])})}ve&&xn(ve,i,"c");function Bt(vn,bn){h.isArray(bn)?bn.forEach(fr=>vn(fr.bind(d))):bn&&vn(bn.bind(d))}if(Bt(er,Be),Bt(tr,ue),Bt(Gn,ke),Bt(nr,Ge),Bt(to,ut),Bt(En,Qe),Bt(ko,Ke),Bt(no,bt),Bt(No,Ct),Bt(cr,me),Bt(ho,Le),Bt(go,Rt),h.isArray(M))if(M.length){var Mn=i.exposed||(i.exposed={});M.forEach(vn=>{Object.defineProperty(Mn,vn,{get:()=>d[vn],set:bn=>d[vn]=bn})})}else i.exposed||(i.exposed={});Oe&&i.render===h.NOOP&&(i.render=Oe),j!=null&&(i.inheritAttrs=j),se&&(i.components=se),re&&(i.directives=re);var Rn=i.appContext.config.globalProperties.$applyOptions;Rn&&Rn(l,i,d)}function Xt(i,l){var d=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1;h.isArray(i)&&(i=Ln(i));var _=function(C){var k=i[C],D=void 0;h.isObject(k)?"default"in k?D=Zn(k.from||C,k.default,!0):D=Zn(k.from||C):D=Zn(k),y.isRef(D)&&d?Object.defineProperty(l,C,{enumerable:!0,configurable:!0,get:()=>D.value,set:H=>D.value=H}):l[C]=D};for(var A in i)_(A)}function xn(i,l,d){Ot(h.isArray(i)?i.map(_=>_.bind(l.proxy)):i.bind(l.proxy),l,d)}function Dn(i,l,d,_){var A=_.includes(".")?Vr(d,_):()=>d[_];if(h.isString(i)){var C=l[i];h.isFunction(C)&&vr(A,C)}else if(h.isFunction(i))vr(A,i.bind(d));else if(h.isObject(i))if(h.isArray(i))i.forEach(D=>Dn(D,l,d,_));else{var k=h.isFunction(i.handler)?i.handler.bind(d):l[i.handler];h.isFunction(k)&&vr(A,k,i)}}function _r(i){var l=i.type,{mixins:d,extends:_}=l,{mixins:A,optionsCache:C,config:{optionMergeStrategies:k}}=i.appContext,D=C.get(l),H;return D?H=D:!A.length&&!d&&!_?H=l:(H={},A.length&&A.forEach(ne=>Br(H,ne,k,!0)),Br(H,l,k)),h.isObject(l)&&C.set(l,H),H}function Br(i,l,d){var _=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1,{mixins:A,extends:C}=l;C&&Br(i,C,d,!0),A&&A.forEach(H=>Br(i,H,d,!0));for(var k in l)if(!(_&&k==="expose")){var D=mo[k]||d&&d[k];i[k]=D?D(i[k],l[k]):l[k]}return i}var mo={data:xo,props:Fn,emits:Fn,methods:Fn,computed:Fn,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:Fn,directives:Fn,watch:wi,provide:xo,inject:Bo};function xo(i,l){return l?i?function(){return h.extend(h.isFunction(i)?i.call(this,this):i,h.isFunction(l)?l.call(this,this):l)}:l:i}function Bo(i,l){return Fn(Ln(i),Ln(l))}function Ln(i){if(h.isArray(i)){for(var l={},d=0;d<i.length;d++)l[i[d]]=i[d];return l}return i}function Yn(i,l){return i?[...new Set([].concat(i,l))]:l}function Fn(i,l){return i?h.extend(h.extend(Object.create(null),i),l):l}function wi(i,l){if(!i)return l;if(!l)return i;var d=h.extend(Object.create(null),i);for(var _ in l)d[_]=Yn(i[_],l[_]);return d}function is(i,l,d){var _=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1,A={},C={};h.def(C,Bn,1),i.propsDefaults=Object.create(null),br(i,l,A,C);for(var k in i.propsOptions[0])k in A||(A[k]=void 0);d?i.props=_?A:y.shallowReactive(A):i.type.props?i.props=A:i.props=C,i.attrs=C}function ha(i,l,d,_){var{props:A,attrs:C,vnode:{patchFlag:k}}=i,D=y.toRaw(A),[H]=i.propsOptions,ne=!1;if((_||k>0)&&!(k&16)){if(k&8)for(var ve=i.vnode.dynamicProps,Be=0;Be<ve.length;Be++){var ue=ve[Be];if(!An(i.emitsOptions,ue)){var ke=l[ue];if(H)if(h.hasOwn(C,ue))ke!==C[ue]&&(C[ue]=ke,ne=!0);else{var Ge=h.camelize(ue);A[Ge]=Ta(H,D,Ge,ke,i,!1)}else ke!==C[ue]&&(C[ue]=ke,ne=!0)}}}else{br(i,l,A,C)&&(ne=!0);var ut;for(var Qe in D)(!l||!h.hasOwn(l,Qe)&&((ut=h.hyphenate(Qe))===Qe||!h.hasOwn(l,ut)))&&(H?d&&(d[Qe]!==void 0||d[ut]!==void 0)&&(A[Qe]=Ta(H,D,Qe,void 0,i,!0)):delete A[Qe]);if(C!==D)for(var Re in C)(!l||!h.hasOwn(l,Re)&&!0)&&(delete C[Re],ne=!0)}ne&&y.trigger(i,"set","$attrs")}function br(i,l,d,_){var[A,C]=i.propsOptions,k=!1,D;if(l){for(var H in l)if(!h.isReservedProp(H)){var ne=l[H],ve=void 0;A&&h.hasOwn(A,ve=h.camelize(H))?!C||!C.includes(ve)?d[ve]=ne:(D||(D={}))[ve]=ne:An(i.emitsOptions,H)||(!(H in _)||ne!==_[H])&&(_[H]=ne,k=!0)}}if(C)for(var Be=y.toRaw(d),ue=D||h.EMPTY_OBJ,ke=0;ke<C.length;ke++){var Ge=C[ke];d[Ge]=Ta(A,Be,Ge,ue[Ge],i,!h.hasOwn(ue,Ge))}return k}function Ta(i,l,d,_,A,C){var k=i[d];if(k!=null){var D=h.hasOwn(k,"default");if(D&&_===void 0){var H=k.default;if(k.type!==Function&&h.isFunction(H)){var{propsDefaults:ne}=A;d in ne?_=ne[d]:(qn(A),_=ne[d]=H.call(null,l),Ai())}else _=H}k[0]&&(C&&!D?_=!1:k[1]&&(_===""||_===h.hyphenate(d))&&(_=!0))}return _}function La(i,l){var d=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!1,_=l.propsCache,A=_.get(i);if(A)return A;var C=i.props,k={},D=[],H=!1;if(!h.isFunction(i)){var ne=ye=>{H=!0;var[Le,Oe]=La(ye,l,!0);h.extend(k,Le),Oe&&D.push(...Oe)};!d&&l.mixins.length&&l.mixins.forEach(ne),i.extends&&ne(i.extends),i.mixins&&i.mixins.forEach(ne)}if(!C&&!H)return h.isObject(i)&&_.set(i,h.EMPTY_ARR),h.EMPTY_ARR;if(h.isArray(C))for(var ve=0;ve<C.length;ve++){var Be=h.camelize(C[ve]);Fa(Be)&&(k[Be]=h.EMPTY_OBJ)}else if(C)for(var ue in C){var ke=h.camelize(ue);if(Fa(ke)){var Ge=C[ue],ut=k[ke]=h.isArray(Ge)||h.isFunction(Ge)?{type:Ge}:Object.assign({},Ge);if(ut){var Qe=ga(Boolean,ut.type),Re=ga(String,ut.type);ut[0]=Qe>-1,ut[1]=Re<0||Qe<Re,(Qe>-1||h.hasOwn(ut,"default"))&&D.push(ke)}}}var me=[k,D];return h.isObject(i)&&_.set(i,me),me}function Fa(i){return i[0]!=="$"}function Va(i){var l=i&&i.toString().match(/^\s*(function|class) (\w+)/);return l?l[2]:i===null?"null":""}function Ua(i,l){return Va(i)===Va(l)}function ga(i,l){return h.isArray(l)?l.findIndex(d=>Ua(d,i)):h.isFunction(l)&&Ua(l,i)?0:-1}var Pa=i=>i[0]==="_"||i==="$stable",Vn=i=>h.isArray(i)?i.map($n):[$n(i)],Mo=(i,l,d)=>{if(l._n)return l;var _=Zo(function(){return Vn(l(...arguments))},d);return _._c=!1,_},ea=(i,l,d)=>{var _=i._ctx;for(var A in i)if(!Pa(A)){var C=i[A];h.isFunction(C)?l[A]=Mo(A,C,_):C!=null&&function(){var k=Vn(C);l[A]=()=>k}()}},Wi=(i,l)=>{var d=Vn(l);i.slots.default=()=>d},os=(i,l)=>{if(i.vnode.shapeFlag&32){var d=l._;d?(i.slots=y.toRaw(l),h.def(l,"_",d)):ea(l,i.slots={})}else i.slots={},l&&Wi(i,l);h.def(i.slots,Bn,1)},as=(i,l,d)=>{var{vnode:_,slots:A}=i,C=!0,k=h.EMPTY_OBJ;if(_.shapeFlag&32){var D=l._;D?d&&D===1?C=!1:(h.extend(A,l),!d&&D===1&&delete A._):(C=!l.$stable,ea(l,A)),k=l}else l&&(Wi(i,l),k={default:1});if(C)for(var H in A)!Pa(H)&&!(H in k)&&delete A[H]};function Do(){return{app:null,config:{isNativeTag:h.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;h.isFunction(_)||(_=Object.assign({},_)),A!=null&&!h.isObject(A)&&(A=null);var C=Do(),k=new Set,D=!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,Be=new Array(ve>1?ve-1:0),ue=1;ue<ve;ue++)Be[ue-1]=arguments[ue];return k.has(ne)||(ne&&h.isFunction(ne.install)?(k.add(ne),ne.install(H,...Be)):h.isFunction(ne)&&(k.add(ne),ne(H,...Be))),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,Be){if(!D){var ue=qt(_,A);return ue.appContext=C,ve&&l?l(ue,ne):i(ue,ne,Be),D=!0,H._container=ne,ne.__vue_app__=H,H._instance=ue.component,Di(ue.component)||ue.component.proxy}},unmount(){D&&(i(null,H._container),delete H._container.__vue_app__)},provide(ne,ve){return C.provides[ne]=ve,H}};return H}}function si(i,l,d,_){var A=arguments.length>4&&arguments[4]!==void 0?arguments[4]:!1;if(h.isArray(i)){i.forEach((ut,Qe)=>si(ut,l&&(h.isArray(l)?l[Qe]:l),d,_,A));return}if(!(Rr(_)&&!A)){var C=_.shapeFlag&4?Di(_.component)||_.component.proxy:_.el,k=A?null:C,{i:D,r:H}=i,ne=l&&l.r,ve=D.refs===h.EMPTY_OBJ?D.refs={}:D.refs,Be=D.setupState;if(ne!=null&&ne!==H&&(h.isString(ne)?(ve[ne]=null,h.hasOwn(Be,ne)&&(Be[ne]=null)):y.isRef(ne)&&(ne.value=null)),h.isFunction(H))Vt(H,D,12,[k,ve]);else{var ue=h.isString(H),ke=y.isRef(H);if(ue||ke){var Ge=()=>{if(i.f){var ut=ue?h.hasOwn(Be,H)?Be[H]:ve[H]:H.value;A?h.isArray(ut)&&h.remove(ut,C):h.isArray(ut)?ut.includes(C)||ut.push(C):ue?(ve[H]=[C],h.hasOwn(Be,H)&&(Be[H]=ve[H])):(H.value=[C],i.k&&(ve[i.k]=H.value))}else ue?(ve[H]=k,h.hasOwn(Be,H)&&(Be[H]=k)):ke&&(H.value=k,i.k&&(ve[i.k]=k))};k?(Ge.id=-1,lr(Ge,d)):Ge()}}}}var Ci=!1,Gi=i=>/svg/.test(i.namespaceURI)&&i.tagName!=="foreignObject",li=i=>i.nodeType===8;function ur(i){var{mt:l,p:d,o:{patchProp:_,createText:A,nextSibling:C,parentNode:k,remove:D,insert:H,createComment:ne}}=i,ve=(Re,me)=>{if(!me.hasChildNodes()){d(null,Re,me),ze(),me._vnode=Re;return}Ci=!1,Be(me.firstChild,Re,null,null,null),ze(),me._vnode=Re,Ci&&console.error("Hydration completed but contains mismatches.")},Be=function(Re,me,ye,Le,Oe){var bt=arguments.length>5&&arguments[5]!==void 0?arguments[5]:!1,Ct=li(Re)&&Re.data==="[",Ke=()=>ut(Re,me,ye,Le,Oe,Ct),{type:Rt,ref:M,shapeFlag:j,patchFlag:se}=me,re=Re.nodeType;me.el=Re,se===-2&&(bt=!1,me.dynamicChildren=null);var oe=null;switch(Rt){case ce:re!==3?me.children===""?(H(me.el=A("",Re.parentNode),k(Re),Re),oe=Re):oe=Ke():(Re.data!==me.children&&(Ci=!0,Re.data=me.children),oe=C(Re));break;case pe:re!==8||Ct?oe=Ke():oe=C(Re);break;case Ie:if(Ct&&(Re=C(Re),re=Re.nodeType),re===1||re===3){oe=Re;for(var Ue=!me.children.length,rt=0;rt<me.staticCount;rt++)Ue&&(me.children+=oe.nodeType===1?oe.outerHTML:oe.data),rt===me.staticCount-1&&(me.anchor=oe),oe=C(oe);return Ct?C(oe):oe}else Ke();break;case te:Ct?oe=Ge(Re,me,ye,Le,Oe,bt):oe=Ke();break;default:if(j&1)re!==1||me.type.toLowerCase()!==Re.tagName.toLowerCase()?oe=Ke():oe=ue(Re,me,ye,Le,Oe,bt);else if(j&6){me.slotScopeIds=Oe;var qe=k(Re);if(l(me,qe,null,ye,Le,Gi(qe),bt),oe=Ct?Qe(Re):C(Re),oe&&li(oe)&&oe.data==="teleport end"&&(oe=C(oe)),Rr(me)){var Ze;Ct?(Ze=qt(te),Ze.anchor=oe?oe.previousSibling:qe.lastChild):Ze=Re.nodeType===3?qi(""):qt("div"),Ze.el=Re,me.component.subTree=Ze}}else j&64?re!==8?oe=Ke():oe=me.type.hydrate(Re,me,ye,Le,Oe,bt,i,ke):j&128&&(oe=me.type.hydrate(Re,me,ye,Le,Gi(k(Re)),Oe,bt,i,Be))}return M!=null&&si(M,null,Le,me),oe},ue=(Re,me,ye,Le,Oe,bt)=>{bt=bt||!!me.dynamicChildren;var{type:Ct,props:Ke,patchFlag:Rt,shapeFlag:M,dirs:j}=me,se=Ct==="input"&&j||Ct==="option";if(se||Rt!==-1){if(j&&xr(me,null,ye,"created"),Ke)if(se||!bt||Rt&(16|32))for(var re in Ke)(se&&re.endsWith("value")||h.isOn(re)&&!h.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&&xr(me,null,ye,"beforeMount"),((oe=Ke&&Ke.onVnodeMounted)||j)&&ar(()=>{oe&&zr(oe,ye,me),j&&xr(me,null,ye,"mounted")},Le),M&16&&!(Ke&&(Ke.innerHTML||Ke.textContent)))for(var Ue=ke(Re.firstChild,me,Re,ye,Le,Oe,bt);Ue;){Ci=!0;var rt=Ue;Ue=Ue.nextSibling,D(rt)}else M&8&&Re.textContent!==me.children&&(Ci=!0,Re.textContent=me.children)}return Re.nextSibling},ke=(Re,me,ye,Le,Oe,bt,Ct)=>{Ct=Ct||!!me.dynamicChildren;for(var Ke=me.children,Rt=Ke.length,M=0;M<Rt;M++){var j=Ct?Ke[M]:Ke[M]=$n(Ke[M]);if(Re)Re=Be(Re,j,Le,Oe,bt,Ct);else{if(j.type===ce&&!j.children)continue;Ci=!0,d(null,j,ye,null,Le,Oe,Gi(ye),bt)}}return Re},Ge=(Re,me,ye,Le,Oe,bt)=>{var{slotScopeIds:Ct}=me;Ct&&(Oe=Oe?Oe.concat(Ct):Ct);var Ke=k(Re),Rt=ke(C(Re),me,Ke,ye,Le,Oe,bt);return Rt&&li(Rt)&&Rt.data==="]"?C(me.anchor=Rt):(Ci=!0,H(me.anchor=ne("]",Ke),Ke,Rt),Rt)},ut=(Re,me,ye,Le,Oe,bt)=>{if(Ci=!0,me.el=null,bt)for(var Ct=Qe(Re);;){var Ke=C(Re);if(Ke&&Ke!==Ct)D(Ke);else break}var Rt=C(Re),M=k(Re);return D(Re),d(null,me,M,Rt,ye,Le,Gi(M),Oe),Rt},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,Be]}var lr=ar;function $a(i){return Yi(i)}function Ha(i){return Yi(i,ur)}function Yi(i,l){var d=h.getGlobalThis();d.__VUE__=!0;var{insert:_,remove:A,patchProp:C,forcePatchProp:k,createElement:D,createText:H,createComment:ne,setText:ve,setElementText:Be,parentNode:ue,nextSibling:ke,setScopeId:Ge=h.NOOP,insertStaticContent:ut}=i,Qe=function(Y,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,Xe=arguments.length>5&&arguments[5]!==void 0?arguments[5]:null,_t=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(Y!==ee){Y&&!dt(Y,ee)&&(Me=fr(Y),Bt(Y,De,Xe,!0),Y=null),ee.patchFlag===-2&&(tt=!1,ee.dynamicChildren=null);var{type:He,ref:zt,shapeFlag:Lt}=ee;switch(He){case ce:Re(Y,ee,be,Me);break;case pe:me(Y,ee,be,Me);break;case Ie:Y==null&&ye(ee,be,Me,_t);break;case te:re(Y,ee,be,Me,De,Xe,_t,et,tt);break;default:Lt&1?bt(Y,ee,be,Me,De,Xe,_t,et,tt):Lt&6?oe(Y,ee,be,Me,De,Xe,_t,et,tt):(Lt&64||Lt&128)&&He.process(Y,ee,be,Me,De,Xe,_t,et,tt,Jt)}zt!=null&&De&&si(zt,Y&&Y.ref,Xe,ee||Y,!ee)}},Re=(Y,ee,be,Me)=>{if(Y==null)_(ee.el=H(ee.children,be),be,Me);else{var De=ee.el=Y.el;ee.children!==Y.children&&ve(De,ee.children)}},me=(Y,ee,be,Me)=>{Y==null?_(ee.el=ne(ee.children||"",be),be,Me):ee.el=Y.el},ye=(Y,ee,be,Me)=>{[Y.el,Y.anchor]=ut(Y.children,ee,be,Me,Y.el,Y.anchor)},Le=(Y,ee,be)=>{for(var{el:Me,anchor:De}=Y,Xe;Me&&Me!==De;)Xe=ke(Me),_(Me,ee,be),Me=Xe;_(De,ee,be)},Oe=Y=>{for(var{el:ee,anchor:be}=Y,Me;ee&&ee!==be;)Me=ke(ee),A(ee),ee=Me;A(be)},bt=(Y,ee,be,Me,De,Xe,_t,et,tt)=>{_t=_t||ee.type==="svg",Y==null?Ct(ee,be,Me,De,Xe,_t,et,tt):M(Y,ee,De,Xe,_t,et,tt)},Ct=(Y,ee,be,Me,De,Xe,_t,et)=>{var tt,He,{type:zt,props:Lt,shapeFlag:Wt,transition:On,dirs:Gr}=Y;if(tt=Y.el=D(Y.type,ee),Wt&8?Be(tt,Y.children):Wt&16&&Rt(Y.children,tt,null,Me,De,Xe&&zt!=="foreignObject",_t,et),Gr&&xr(Y,null,Me,"created"),Ke(tt,Y,Y.scopeId,_t,Me),Lt){for(var Xn in Lt)Xn!=="value"&&!h.isReservedProp(Xn)&&C(tt,Xn,null,Lt[Xn],Xe,Y.children,Me,De,bn);"value"in Lt&&C(tt,"value",null,Lt.value),(He=Lt.onVnodeBeforeMount)&&zr(He,Me,Y)}Object.defineProperty(tt,"__vueParentComponent",{value:Me,enumerable:!1}),Gr&&xr(Y,null,Me,"beforeMount");var ui=(!De||De&&!De.pendingBranch)&&On&&!On.persisted;ui&&On.beforeEnter(tt),_(tt,ee,be),((He=Lt&&Lt.onVnodeMounted)||ui||Gr)&&lr(()=>{He&&zr(He,Me,Y),ui&&On.enter(tt),Gr&&xr(Y,null,Me,"mounted")},De)},Ke=(Y,ee,be,Me,De)=>{if(be&&Ge(Y,be),Me)for(var Xe=0;Xe<Me.length;Xe++)Ge(Y,Me[Xe]);if(De){var _t=De.subTree;if(ee===_t){var et=De.vnode;Ke(Y,et,et.scopeId,et.slotScopeIds,De.parent)}}},Rt=function(Y,ee,be,Me,De,Xe,_t,et){for(var tt=arguments.length>8&&arguments[8]!==void 0?arguments[8]:0,He=tt;He<Y.length;He++){var zt=Y[He]=et?Ir(Y[He]):$n(Y[He]);Qe(null,zt,ee,be,Me,De,Xe,_t,et)}},M=(Y,ee,be,Me,De,Xe,_t)=>{var et=ee.el=Y.el,{patchFlag:tt,dynamicChildren:He,dirs:zt}=ee;tt|=Y.patchFlag&16;var Lt=Y.props||h.EMPTY_OBJ,Wt=ee.props||h.EMPTY_OBJ,On;be&&oo(be,!1),(On=Wt.onVnodeBeforeUpdate)&&zr(On,be,ee,Y),zt&&xr(ee,Y,be,"beforeUpdate"),be&&oo(be,!0);var Gr=De&&ee.type!=="foreignObject";if(He?j(Y.dynamicChildren,He,et,be,Me,Gr,Xe):_t||$e(Y,ee,et,null,be,Me,Gr,Xe,!1),tt>0){if(tt&16)se(et,ee,Lt,Wt,be,Me,De);else if(tt&2&&Lt.class!==Wt.class&&C(et,"class",null,Wt.class,De),tt&4&&C(et,"style",Lt.style,Wt.style,De),tt&8)for(var Xn=ee.dynamicProps,ui=0;ui<Xn.length;ui++){var Wo=Xn[ui],es=Lt[Wo],ws=Wt[Wo];(ws!==es||Wo==="value"||k&&k(et,Wo))&&C(et,Wo,es,ws,De,Y.children,be,Me,bn)}tt&1&&Y.children!==ee.children&&Be(et,ee.children)}else!_t&&He==null&&se(et,ee,Lt,Wt,be,Me,De);((On=Wt.onVnodeUpdated)||zt)&&lr(()=>{On&&zr(On,be,ee,Y),zt&&xr(ee,Y,be,"updated")},Me)},j=(Y,ee,be,Me,De,Xe,_t)=>{for(var et=0;et<ee.length;et++){var tt=Y[et],He=ee[et],zt=tt.el&&(tt.type===te||!dt(tt,He)||tt.shapeFlag&(6|64))?ue(tt.el):be;Qe(tt,He,zt,null,Me,De,Xe,_t,!0)}},se=(Y,ee,be,Me,De,Xe,_t)=>{if(be!==Me){if(be!==h.EMPTY_OBJ)for(var et in be)!h.isReservedProp(et)&&!(et in Me)&&C(Y,et,be[et],null,_t,ee.children,De,Xe,bn);for(var tt in Me)if(!h.isReservedProp(tt)){var He=Me[tt],zt=be[tt];(He!==zt&&tt!=="value"||k&&k(Y,tt))&&C(Y,tt,zt,He,_t,ee.children,De,Xe,bn)}"value"in Me&&C(Y,"value",be.value,Me.value)}},re=(Y,ee,be,Me,De,Xe,_t,et,tt)=>{var He=ee.el=Y?Y.el:H("",be),zt=ee.anchor=Y?Y.anchor:H("",be),{patchFlag:Lt,dynamicChildren:Wt,slotScopeIds:On}=ee;On&&(et=et?et.concat(On):On),Y==null?(_(He,be,Me),_(zt,be,Me),Rt(ee.children,be,zt,De,Xe,_t,et,tt)):Lt>0&&Lt&64&&Wt&&Y.dynamicChildren?(j(Y.dynamicChildren,Wt,be,De,Xe,_t,et),(ee.key!=null||De&&ee===De.subTree)&&ao(Y,ee,!0)):$e(Y,ee,be,zt,De,Xe,_t,et,tt)},oe=(Y,ee,be,Me,De,Xe,_t,et,tt)=>{ee.slotScopeIds=et,Y==null?ee.shapeFlag&512?De.ctx.activate(ee,be,Me,_t,tt):Ue(ee,be,Me,De,Xe,_t,tt):rt(Y,ee,tt)},Ue=(Y,ee,be,Me,De,Xe,_t)=>{var et=Y.component=on(Y,Me,De);if(Ei(Y)&&(et.ctx.renderer=Jt),za(et),et.asyncDep){if(De&&De.registerDep(et,qe),!Y.el){var tt=et.subTree=qt(pe);me(null,tt,ee,be)}return}if(qe(et,Y,ee,be,De,Xe,_t),et.$wxsModules){var He=R.resolveOwnerEl(et,!0);He.length&&He.forEach(zt=>{zt.setAttribute(R.ATTR_V_OWNER_ID,et.uid);var{$renderjsModules:Lt}=et.type;Lt&&zt.setAttribute(R.ATTR_V_RENDERJS,Lt)})}},rt=(Y,ee,be)=>{var Me=ee.component=Y.component;if(Oo(Y,ee,be))if(Me.asyncDep&&!Me.asyncResolved){Ze(Me,ee,be);return}else Me.next=ee,Jr(Me.update),Me.update();else ee.el=Y.el,Me.vnode=ee},qe=(Y,ee,be,Me,De,Xe,_t)=>{var et=()=>{if(Y.isMounted){var{next:rr,bu:Ra,u:Cs,parent:Ki,vnode:Go}=Y,co=rr,_a;oo(Y,!1),rr?(rr.el=Go.el,Ze(Y,rr,_t)):rr=Go,Ra&&h.invokeArrayFns(Ra),(_a=rr.props&&rr.props.onVnodeBeforeUpdate)&&zr(_a,Ki,rr,Go),oo(Y,!0);var ts=$i(Y),ca=Y.subTree;Y.subTree=ts,Qe(ca,ts,ue(ca.el),fr(ca),Y,De,Xe),rr.el=ts.el,co===null&&mi(Y,ts.el),Cs&&lr(Cs,De),(_a=rr.props&&rr.props.onVnodeUpdated)&&lr(()=>zr(_a,Ki,rr,Go),De)}else{var zt,{el:Lt,props:Wt}=ee,{bm:On,m:Gr,parent:Xn}=Y,ui=Rr(ee);if(oo(Y,!1),On&&h.invokeArrayFns(On),!ui&&(zt=Wt&&Wt.onVnodeBeforeMount)&&zr(zt,Xn,ee),oo(Y,!0),Lt&&lo){var Wo=()=>{Y.subTree=$i(Y),lo(Lt,Y.subTree,Y,De,null)};ui?ee.type.__asyncLoader().then(()=>!Y.isUnmounted&&Wo()):Wo()}else{var es=Y.subTree=$i(Y);Qe(null,es,be,Me,Y,De,Xe),ee.el=es.el}if(Gr&&lr(Gr,De),!ui&&(zt=Wt&&Wt.onVnodeMounted)){var ws=ee;lr(()=>zr(zt,Xn,ws),De)}(ee.shapeFlag&256||Xn&&Rr(Xn.vnode)&&Xn.vnode.shapeFlag&256)&&Y.a&&lr(Y.a,De),Y.isMounted=!0,ee=be=Me=null}},tt=Y.effect=new y.ReactiveEffect(et,()=>pr(He),Y.scope),He=Y.update=()=>tt.run();He.id=Y.uid,oo(Y,!0),He()},Ze=(Y,ee,be)=>{ee.component=Y;var Me=Y.vnode.props;Y.vnode=ee,Y.next=null,ha(Y,ee.props,Me,be),as(Y,ee.children,be),y.pauseTracking(),Pn(),y.resetTracking()},$e=function(Y,ee,be,Me,De,Xe,_t,et){var tt=arguments.length>8&&arguments[8]!==void 0?arguments[8]:!1,He=Y&&Y.children,zt=Y?Y.shapeFlag:0,Lt=ee.children,{patchFlag:Wt,shapeFlag:On}=ee;if(Wt>0){if(Wt&128){pt(He,Lt,be,Me,De,Xe,_t,et,tt);return}else if(Wt&256){$t(He,Lt,be,Me,De,Xe,_t,et,tt);return}}On&8?(zt&16&&bn(He,De,Xe),Lt!==He&&Be(be,Lt)):zt&16?On&16?pt(He,Lt,be,Me,De,Xe,_t,et,tt):bn(He,De,Xe,!0):(zt&8&&Be(be,""),On&16&&Rt(Lt,be,Me,De,Xe,_t,et,tt))},$t=(Y,ee,be,Me,De,Xe,_t,et,tt)=>{Y=Y||h.EMPTY_ARR,ee=ee||h.EMPTY_ARR;var He=Y.length,zt=ee.length,Lt=Math.min(He,zt),Wt;for(Wt=0;Wt<Lt;Wt++){var On=ee[Wt]=tt?Ir(ee[Wt]):$n(ee[Wt]);Qe(Y[Wt],On,be,null,De,Xe,_t,et,tt)}He>zt?bn(Y,De,Xe,!0,!1,Lt):Rt(ee,be,Me,De,Xe,_t,et,tt,Lt)},pt=(Y,ee,be,Me,De,Xe,_t,et,tt)=>{for(var He=0,zt=ee.length,Lt=Y.length-1,Wt=zt-1;He<=Lt&&He<=Wt;){var On=Y[He],Gr=ee[He]=tt?Ir(ee[He]):$n(ee[He]);if(dt(On,Gr))Qe(On,Gr,be,null,De,Xe,_t,et,tt);else break;He++}for(;He<=Lt&&He<=Wt;){var Xn=Y[Lt],ui=ee[Wt]=tt?Ir(ee[Wt]):$n(ee[Wt]);if(dt(Xn,ui))Qe(Xn,ui,be,null,De,Xe,_t,et,tt);else break;Lt--,Wt--}if(He>Lt){if(He<=Wt)for(var Wo=Wt+1,es=Wo<zt?ee[Wo].el:Me;He<=Wt;)Qe(null,ee[He]=tt?Ir(ee[He]):$n(ee[He]),be,es,De,Xe,_t,et,tt),He++}else if(He>Wt)for(;He<=Lt;)Bt(Y[He],De,Xe,!0),He++;else{var ws=He,rr=He,Ra=new Map;for(He=rr;He<=Wt;He++){var Cs=ee[He]=tt?Ir(ee[He]):$n(ee[He]);Cs.key!=null&&Ra.set(Cs.key,He)}var Ki,Go=0,co=Wt-rr+1,_a=!1,ts=0,ca=new Array(co);for(He=0;He<co;He++)ca[He]=0;for(He=ws;He<=Lt;He++){var ua=Y[He];if(Go>=co){Bt(ua,De,Xe,!0);continue}var Yo=void 0;if(ua.key!=null)Yo=Ra.get(ua.key);else for(Ki=rr;Ki<=Wt;Ki++)if(ca[Ki-rr]===0&&dt(ua,ee[Ki])){Yo=Ki;break}Yo===void 0?Bt(ua,De,Xe,!0):(ca[Yo-rr]=He+1,Yo>=ts?ts=Yo:_a=!0,Qe(ua,ee[Yo],be,null,De,Xe,_t,et,tt),Go++)}var yl=_a?ls(ca):h.EMPTY_ARR;for(Ki=yl.length-1,He=co-1;He>=0;He--){var Ys=rr+He,bc=ee[Ys],Wl=Ys+1<zt?ee[Ys+1].el:Me;ca[He]===0?Qe(null,bc,be,Wl,De,Xe,_t,et,tt):_a&&(Ki<0||He!==yl[Ki]?xt(bc,be,Wl,2):Ki--)}}},xt=function(Y,ee,be,Me){var De=arguments.length>4&&arguments[4]!==void 0?arguments[4]:null,{el:Xe,type:_t,transition:et,children:tt,shapeFlag:He}=Y;if(He&6){xt(Y.component.subTree,ee,be,Me);return}if(He&128){Y.suspense.move(ee,be,Me);return}if(He&64){_t.move(Y,ee,be,Jt);return}if(_t===te){_(Xe,ee,be);for(var zt=0;zt<tt.length;zt++)xt(tt[zt],ee,be,Me);_(Y.anchor,ee,be);return}if(_t===Ie){Le(Y,ee,be);return}var Lt=Me!==2&&He&1&&et;if(Lt)if(Me===0)et.beforeEnter(Xe),_(Xe,ee,be),lr(()=>et.enter(Xe),De);else{var{leave:Wt,delayLeave:On,afterLeave:Gr}=et,Xn=()=>_(Xe,ee,be),ui=()=>{Wt(Xe,()=>{Xn(),Gr&&Gr()})};On?On(Xe,Xn,ui):ui()}else _(Xe,ee,be)},Bt=function(Y,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:Xe,props:_t,ref:et,children:tt,dynamicChildren:He,shapeFlag:zt,patchFlag:Lt,dirs:Wt}=Y;if(et!=null&&si(et,null,be,Y,!0),zt&256){ee.ctx.deactivate(Y);return}var On=zt&1&&Wt,Gr=!Rr(Y),Xn;if(Gr&&(Xn=_t&&_t.onVnodeBeforeUnmount)&&zr(Xn,ee,Y),zt&6)vn(Y.component,be,Me);else{if(zt&128){Y.suspense.unmount(be,Me);return}On&&xr(Y,null,ee,"beforeUnmount"),zt&64?Y.type.remove(Y,ee,be,De,Jt,Me):He&&(Xe!==te||Lt>0&&Lt&64)?bn(He,ee,be,!1,!0):(Xe===te&&Lt&(128|256)||!De&&zt&16)&&bn(tt,ee,be),Me&&Mn(Y)}(Gr&&(Xn=_t&&_t.onVnodeUnmounted)||On)&&lr(()=>{Xn&&zr(Xn,ee,Y),On&&xr(Y,null,ee,"unmounted")},be)},Mn=Y=>{var{type:ee,el:be,anchor:Me,transition:De}=Y;if(ee===te){Rn(be,Me);return}if(ee===Ie){Oe(Y);return}var Xe=()=>{A(be),De&&!De.persisted&&De.afterLeave&&De.afterLeave()};if(Y.shapeFlag&1&&De&&!De.persisted){var{leave:_t,delayLeave:et}=De,tt=()=>_t(be,Xe);et?et(Y.el,Xe,tt):tt()}else Xe()},Rn=(Y,ee)=>{for(var be;Y!==ee;)be=ke(Y),A(Y),Y=be;A(ee)},vn=(Y,ee,be)=>{var{bum:Me,scope:De,update:Xe,subTree:_t,um:et}=Y;Me&&h.invokeArrayFns(Me),De.stop(),Xe&&(Xe.active=!1,Bt(_t,Y,ee,be)),et&&lr(et,ee),lr(()=>{Y.isUnmounted=!0},ee),ee&&ee.pendingBranch&&!ee.isUnmounted&&Y.asyncDep&&!Y.asyncResolved&&Y.suspenseId===ee.pendingId&&(ee.deps--,ee.deps===0&&ee.resolve())},bn=function(Y,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,Xe=arguments.length>5&&arguments[5]!==void 0?arguments[5]:0,_t=Xe;_t<Y.length;_t++)Bt(Y[_t],ee,be,Me,De)},fr=Y=>Y.shapeFlag&6?fr(Y.component.subTree):Y.shapeFlag&128?Y.suspense.next():ke(Y.anchor||Y.el),ni=(Y,ee,be)=>{Y==null?ee._vnode&&Bt(ee._vnode,null,null,!0):Qe(ee._vnode||null,Y,ee,null,null,null,be),Pn(),ze(),ee._vnode=Y},Jt={p:Qe,um:Bt,m:xt,r:Mn,mt:Ue,mc:Rt,pc:$e,pbc:j,n:fr,o:i},an,lo;return l&&([an,lo]=l(Jt)),{render:ni,hydrate:an,createApp:io(ni,an)}}function oo(i,l){var{effect:d,update:_}=i;d.allowRecurse=_.allowRecurse=l}function ao(i,l){var d=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!1,_=i.children,A=l.children;if(h.isArray(_)&&h.isArray(A))for(var C=0;C<_.length;C++){var k=_[C],D=A[C];D.shapeFlag&1&&!D.dynamicChildren&&((D.patchFlag<=0||D.patchFlag===32)&&(D=A[C]=Ir(A[C]),D.el=k.el),d||ao(k,D)),D.type===ce&&(D.el=k.el)}}function ls(i){var l=i.slice(),d=[0],_,A,C,k,D,H=i.length;for(_=0;_<H;_++){var ne=i[_];if(ne!==0){if(A=d[d.length-1],i[A]<ne){l[_]=A,d.push(_);continue}for(C=0,k=d.length-1;C<k;)D=C+k>>1,i[d[D]]<ne?C=D+1:k=D;ne<i[d[C]]&&(C>0&&(l[_]=d[C-1]),d[C]=_)}}for(C=d.length,k=d[C-1];C-- >0;)d[C]=k,k=l[k];return d}var pa=i=>i.__isTeleport,Lo=i=>i&&(i.disabled||i.disabled===""),va=i=>typeof SVGElement!="undefined"&&i instanceof SVGElement,v=(i,l)=>{var d=i&&i.to;if(h.isString(d))if(l){var _=l(d);return _}else return null;else return d},x={__isTeleport:!0,process(i,l,d,_,A,C,k,D,H,ne){var{mc:ve,pc:Be,pbc:ue,o:{insert:ke,querySelector:Ge,createText:ut,createComment:Qe}}=ne,Re=Lo(l.props),{shapeFlag:me,children:ye,dynamicChildren:Le}=l;if(i==null){var Oe=l.el=ut("",d),bt=l.anchor=ut("",d);ke(Oe,d,_),ke(bt,d,_);var Ct=l.target=v(l.props,Ge),Ke=l.targetAnchor=ut("",d);Ct&&(ke(Ke,Ct),k=k||va(Ct));var Rt=(qe,Ze)=>{me&16&&ve(ye,qe,Ze,A,C,k,D,H)};Re?Rt(d,bt):Ct&&Rt(Ct,Ke)}else{l.el=i.el;var M=l.anchor=i.anchor,j=l.target=i.target,se=l.targetAnchor=i.targetAnchor,re=Lo(i.props),oe=re?d:j,Ue=re?M:se;if(k=k||va(j),Le?(ue(i.dynamicChildren,Le,oe,A,C,k,D),ao(i,l,!0)):H||Be(i,l,oe,Ue,A,C,k,D,!1),Re)re||$(l,d,M,ne,1);else if((l.props&&l.props.to)!==(i.props&&i.props.to)){var rt=l.target=v(l.props,Ge);rt&&$(l,rt,null,ne,0)}else re&&$(l,j,se,ne,1)}q(l)},remove(i,l,d,_,A,C){var{um:k,o:{remove:D}}=A,{shapeFlag:H,children:ne,anchor:ve,targetAnchor:Be,target:ue,props:ke}=i;if(ue&&D(Be),(C||!Lo(ke))&&(D(ve),H&16))for(var Ge=0;Ge<ne.length;Ge++){var ut=ne[Ge];k(ut,l,d,!0,!!ut.dynamicChildren)}},move:$,hydrate:U};function $(i,l,d,_){var{o:{insert:A},m:C}=_,k=arguments.length>4&&arguments[4]!==void 0?arguments[4]:2;k===0&&A(i.targetAnchor,l,d);var{el:D,anchor:H,shapeFlag:ne,children:ve,props:Be}=i,ue=k===2;if(ue&&A(D,l,d),(!ue||Lo(Be))&&ne&16)for(var ke=0;ke<ve.length;ke++)C(ve[ke],l,d,2);ue&&A(H,l,d)}function U(i,l,d,_,A,C,k,D){var{o:{nextSibling:H,parentNode:ne,querySelector:ve}}=k,Be=l.target=v(l.props,ve);if(Be){var ue=Be._lpa||Be.firstChild;if(l.shapeFlag&16)if(Lo(l.props))l.anchor=D(H(i),l,ne(i),d,_,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,Be._lpa=l.targetAnchor&&H(l.targetAnchor);break}D(ue,l,Be,d,_,A,C)}q(l)}return l.anchor&&H(l.anchor)}var Z=x;function q(i){var l=i.ctx;if(l&&l.ut){for(var d=i.children[0].el;d!==i.targetAnchor;)d.nodeType===1&&d.setAttribute("data-v-owner",l.uid),d=d.nextSibling;l.ut()}}var te=Symbol(void 0),ce=Symbol(void 0),pe=Symbol(void 0),Ie=Symbol(void 0),fe=[],Ce=null;function ct(){var i=arguments.length>0&&arguments[0]!==void 0?arguments[0]:!1;fe.push(Ce=i?null:[])}function gt(){fe.pop(),Ce=fe[fe.length-1]||null}var Ht=1;function yt(i){Ht+=i}function je(i){return i.dynamicChildren=Ht>0?Ce||h.EMPTY_ARR:null,gt(),Ht>0&&Ce&&Ce.push(i),i}function Mt(i,l,d,_,A,C){return je(Ut(i,l,d,_,A,C,!0))}function dn(i,l,d,_,A){return je(qt(i,l,d,_,A,!0))}function Gt(i){return i?i.__v_isVNode===!0:!1}function dt(i,l){return i.type===l.type&&i.key===l.key}function en(i){}var Bn="__vInternal",Yt=i=>{var{key:l}=i;return l!=null?l:null},jt=i=>{var{ref:l,ref_key:d,ref_for:_}=i;return l!=null?h.isString(l)||y.isRef(l)||h.isFunction(l)?{i:gn,r:l,k:d,f:!!_}:l:null};function Ut(i){var l=arguments.length>1&&arguments[1]!==void 0?arguments[1]:null,d=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,k=arguments.length>6&&arguments[6]!==void 0?arguments[6]:!1,D=arguments.length>7&&arguments[7]!==void 0?arguments[7]:!1,H={__v_isVNode:!0,__v_skip:!0,type:i,props:l,key:l&&Yt(l),ref:l&&jt(l),scopeId:wr,slotScopeIds:null,children:d,component:null,suspense:null,ssContent:null,ssFallback:null,dirs:null,transition:null,el:null,anchor:null,target:null,targetAnchor:null,staticCount:0,shapeFlag:C,patchFlag:_,dynamicProps:A,dynamicChildren:null,appContext:null,ctx:gn};return D?(Hn(H,d),C&128&&i.normalize(H)):d&&(H.shapeFlag|=h.isString(d)?8:16),Ht>0&&!k&&Ce&&(H.patchFlag>0||C&6)&&H.patchFlag!==32&&Ce.push(H),H}var qt=ta;function ta(i){var l=arguments.length>1&&arguments[1]!==void 0?arguments[1]:null,d=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===Bi)&&(i=pe),Gt(i)){var k=ei(i,l,!0);return d&&Hn(k,d),Ht>0&&!C&&Ce&&(k.shapeFlag&6?Ce[Ce.indexOf(i)]=k:Ce.push(k)),k.patchFlag|=-2,k}if(bo(i)&&(i=i.__vccOpts),l){l=ci(l);var{class:D,style:H}=l;D&&!h.isString(D)&&(l.class=h.normalizeClass(D)),h.isObject(H)&&(y.isProxy(H)&&!h.isArray(H)&&(H=h.extend({},H)),l.style=h.normalizeStyle(H))}var ne=h.isString(i)?1:To(i)?128:pa(i)?64:h.isObject(i)?4:h.isFunction(i)?2:0;return Ut(i,l,d,_,A,ne,C,!0)}function ci(i){return i?y.isProxy(i)||Bn in i?h.extend({},i):i:null}function ei(i,l){var d=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!1,{props:_,ref:A,patchFlag:C,children:k}=i,D=l?yr(_||{},l):_,H={__v_isVNode:!0,__v_skip:!0,type:i.type,props:D,key:D&&Yt(D),ref:l&&l.ref?d&&A?h.isArray(A)?A.concat(jt(l)):[A,jt(l)]:jt(l):A,scopeId:i.scopeId,slotScopeIds:i.slotScopeIds,children:k,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 qi(){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 ja(i,l){var d=qt(Ie,null,i);return d.staticCount=l,d}function Un(){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(),dn(pe,null,i)):qt(pe,null,i)}function $n(i){return i==null||typeof i=="boolean"?qt(pe):h.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 Hn(i,l){var d=0,{shapeFlag:_}=i;if(l==null)l=null;else if(h.isArray(l))d=16;else if(typeof l=="object")if(_&(1|64)){var A=l.default;A&&(A._c&&(A._d=!1),Hn(i,A()),A._c&&(A._d=!0));return}else{d=32;var C=l._;!C&&!(Bn in l)?l._ctx=gn:C===3&&gn&&(gn.slots._===1?l._=1:(l._=2,i.patchFlag|=1024))}else h.isFunction(l)?(l={default:l,_ctx:gn},d=32):(l=String(l),_&64?(d=16,l=[qi(l)]):d=8);i.children=l,i.shapeFlag|=d}function yr(){for(var i={},l=0;l<arguments.length;l++){var d=l<0||arguments.length<=l?void 0:arguments[l];for(var _ in d)if(_==="class")i.class!==d.class&&(i.class=h.normalizeClass([i.class,d.class]));else if(_==="style")i.style=h.normalizeStyle([i.style,d.style]);else if(h.isOn(_)){var A=i[_],C=d[_];C&&A!==C&&!(h.isArray(A)&&A.includes(C))&&(i[_]=A?[].concat(A,C):C)}else _!==""&&(i[_]=d[_])}return i}function zr(i,l,d){var _=arguments.length>3&&arguments[3]!==void 0?arguments[3]:null;Ot(i,l,7,[d,_])}var na=Do(),cs=0;function on(i,l,d){var _=i.type,A=(l?l.appContext:i.appContext)||na,C={uid:cs++,vnode:i,type:_,parent:l,appContext:A,root:null,next:null,subTree:null,effect:null,update:null,scope:new y.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:La(_,A),emitsOptions:Wn(_,A),emit:null,emitted:null,propsDefaults:h.EMPTY_OBJ,inheritAttrs:_.inheritAttrs,ctx:h.EMPTY_OBJ,data:h.EMPTY_OBJ,props:h.EMPTY_OBJ,attrs:h.EMPTY_OBJ,slots:h.EMPTY_OBJ,refs:h.EMPTY_OBJ,setupState:h.EMPTY_OBJ,setupContext:null,suspense:d,suspenseId:d?d.pendingId:0,asyncDep:null,asyncResolved:!1,isMounted:!1,isUnmounted:!1,isDeactivated:!1,bc:null,c:null,bm:null,m:null,bu:null,u:null,um:null,bum:null,da:null,a:null,rtg:null,rtc:null,ec:null,sp:null};return C.ctx={_:C},C.root=l?l.root:C,C.emit=or.bind(null,C),i.ce&&i.ce(C),C}var _n=null,jn=()=>_n||gn,qn=i=>{_n=i,i.scope.on()},Ai=()=>{_n&&_n.scope.off(),_n=null};function us(i){return i.vnode.shapeFlag&4}E.isInSSRComponentSetup=!1;function za(i){var l=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!1;E.isInSSRComponentSetup=l;var{props:d,children:_}=i.vnode,A=us(i);is(i,d,A,l),os(i,_);var C=A?Ia(i,l):void 0;return E.isInSSRComponentSetup=!1,C}function Ia(i,l){var d=i.type;i.accessCache=Object.create(null),i.proxy=y.markRaw(new Proxy(i.ctx,K));var{setup:_}=d;if(_){var A=i.setupContext=_.length>1?Fo(i):null;qn(i),y.pauseTracking();var C=Vt(_,i,0,[i.props,A]);if(y.resetTracking(),Ai(),h.isPromise(C)){if(C.then(Ai,Ai),l)return C.then(k=>{ra(i,k,l)}).catch(k=>{P(k,i,0)});i.asyncDep=C}else ra(i,C,l)}else Ga(i,l)}function ra(i,l,d){h.isFunction(l)?i.type.__ssrInlineRender?i.ssrRender=l:i.render=l:h.isObject(l)&&(i.setupState=y.proxyRefs(l)),Ga(i,d)}var so,Wa;function fs(i){so=i,Wa=l=>{l.render._rc&&(l.withProxy=new Proxy(l.ctx,ie))}}var Wr=()=>!so;function Ga(i,l,d){var _=i.type;if(!i.render){if(!l&&so&&!_.render){var A=_.template||_r(i).template;if(A){var{isCustomElement:C,compilerOptions:k}=i.appContext.config,{delimiters:D,compilerOptions:H}=_,ne=h.extend(h.extend({isCustomElement:C,delimiters:D},k),H);_.render=so(A,ne)}}i.render=_.render||h.NOOP,Wa&&Wa(i)}qn(i),y.pauseTracking(),st(i),y.resetTracking(),Ai()}function Ya(i){return new Proxy(i.attrs,{get(l,d){return y.track(i,"get","$attrs"),l[d]}})}function Fo(i){var l=_=>{i.exposed=_||{}},d;return{get attrs(){return d||(d=Ya(i))},slots:i.slots,emit:i.emit,expose:l}}function Di(i){if(i.exposed)return i.exposeProxy||(i.exposeProxy=new Proxy(y.proxyRefs(y.markRaw(i.exposed)),{get(l,d){if(d in l)return l[d];if(d in kt)return kt[d](i)},has(l,d){return d in l||d in kt}}))}function _o(i){var l=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!0;return h.isFunction(i)?i.displayName||i.name:i.name||l&&i.__name}function bo(i){return h.isFunction(i)&&"__vccOpts"in i}var ds=(i,l)=>y.computed(i,l,E.isInSSRComponentSetup);function Vo(){return null}function xs(){return null}function hs(i){}function Bs(i,l){return null}function xe(){return Pt().slots}function Nt(){return Pt().attrs}function Pt(){var i=jn();return i.setupContext||(i.setupContext=Fo(i))}function wn(i,l){var d=h.isArray(i)?i.reduce((C,k)=>(C[k]={},C),{}):i;for(var _ in l){var A=d[_];A?h.isArray(A)||h.isFunction(A)?d[_]={type:A,default:l[_]}:A.default=l[_]:A===null&&(d[_]={default:l[_]})}return d}function Er(i,l){var d={},_=function(C){l.includes(C)||Object.defineProperty(d,C,{enumerable:!0,get:()=>i[C]})};for(var A in i)_(A);return d}function Oi(i){var l=jn(),d=i();return Ai(),h.isPromise(d)&&(d=d.catch(_=>{throw qn(l),_})),[d,()=>qn(l)]}function Ji(i,l,d){var _=arguments.length;return _===2?h.isObject(l)&&!h.isArray(l)?Gt(l)?qt(i,null,[l]):qt(i,l):qt(i,null,l):(_>3?d=Array.prototype.slice.call(arguments,2):_===3&&Gt(d)&&(d=[d]),qt(i,l,d))}var Uo=Symbol(""),Na=()=>{{var i=Zn(Uo);return i}};function ia(){}function gs(i,l,d,_){var A=d[_];if(A&&ps(A,i))return A;var C=l();return C.memo=i.slice(),d[_]=C}function ps(i,l){var d=i.memo;if(d.length!=l.length)return!1;for(var _=0;_<d.length;_++)if(h.hasChanged(d[_],l[_]))return!1;return Ht>0&&Ce&&Ce.push(i),!0}var dl="3.2.47",$l={createComponentInstance:on,setupComponent:za,renderComponentRoot:$i,setCurrentRenderingInstance:Kr,isVNode:Gt,normalizeVNode:$n},Hl=$l,Ms=null,$o=null;function Ho(i,l){return i==="input"?new R.UniInputElement(i,l):i==="textarea"?new R.UniTextAreaElement(i,l):new R.UniElement(i,l)}function oa(i,l){return new R.UniTextNode(i,l)}function qa(i,l){return new R.UniCommentNode(i,l)}var vs,jo={insert:(i,l,d)=>{l.insertBefore(i,d||null)},remove:i=>{var l=i.parentNode;l&&l.removeChild(i)},createElement:(i,l)=>Ho(i,l),createText:(i,l)=>oa(i,l),createComment:(i,l)=>qa(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,d){var _=vs||(vs=Ho("div"));_.innerHTML=i;for(var A=_.firstChild,C=A,k=C;C;)k=C,jo.insert(C,l,d),C=_.firstChild;return[A,k]}};function Ds(i,l){l==null&&(l=""),i.setAttribute("class",l)}function jl(i,l,d){if(!d)i.removeAttribute("style");else if(h.isString(d))l!==d&&i.setAttribute("style",d);else{var _={},A=l&&!h.isString(l);if(A){for(var C in l)d[C]==null&&(_[C]="");for(var k in d){var D=d[k];D!==l[k]&&(_[k]=D)}}else for(var H in d)_[H]=d[H];Object.keys(_).length&&i.setAttribute("style",_)}}function Ls(i,l,d){d==null?i.removeAttribute(l):i.setAttribute(l,d)}function ms(i,l,d,_){i.addEventListener(l,d,_)}function hl(i,l,d,_){i.removeEventListener(l,d,_)}function Fs(i,l,d,_){var A=arguments.length>4&&arguments[4]!==void 0?arguments[4]:null,C=i._vei||(i._vei={}),k=C[l];if(_&&k)k.value=_;else{var[D,H]=_s(l);if(_){var ne=C[l]=Vs(_,A);ms(i,D,ne,H)}else k&&(hl(i,D,k,H),C[l]=void 0)}}var Ja=/(?:Once|Passive|Capture)$/;function _s(i){var l;if(Ja.test(i)){l={};for(var d;d=i.match(Ja);)i=i.slice(0,i.length-d[0].length),l[d[0].toLowerCase()]=!0}return[h.hyphenate(i.slice(2)),l]}function Vs(i,l){var d=A=>{Ot(d.value,l,5,[A])};d.value=i;var _=new Set;return h.isArray(d.value)?d.value.forEach(A=>{A.modifiers&&A.modifiers.forEach(C=>{_.add(C)})}):(d.value.modifiers&&d.value.modifiers.forEach(A=>{_.add(A)}),Us(d,l)),d.modifiers=[..._],d}function Us(i,l){if(!!l){var{$wxsModules:d}=l;if(!!d){var _=i.value.toString();!d.find(A=>_.indexOf("."+A+".")>-1)||(i.wxsEvent=i.value())}}}var gl=function(i,l,d,_){var A=arguments.length>6?arguments[6]:void 0;switch(l){case"class":Ds(i,_);break;case"style":jl(i,d,_);break;default:if(h.isOn(l))h.isModelListener(l)||Fs(i,l,d,_,A);else{if(h.isObject(_)){var C=d===_;if(_=R.JSON_PROTOCOL+JSON.stringify(_),C&&i.getAttribute(l)===_)return}else if(d===_)return;Ls(i,l,_)}break}};function zo(){var i=arguments.length>0&&arguments[0]!==void 0?arguments[0]:"$style";{var l=jn();if(!l)return h.EMPTY_OBJ;var d=l.type.__cssModules;if(!d)return h.EMPTY_OBJ;var _=d[i];return _||h.EMPTY_OBJ}}function Ka(i){var l=jn();if(!!l){var d=()=>ma(l.subTree,i(l.proxy));tr(()=>Ni(d,{flush:"post"})),nr(d)}}function ma(i,l){if(i.shapeFlag&128){var d=i.suspense;i=d.activeBranch,d.pendingBranch&&!d.isHydrating&&d.effects.push(()=>{ma(d.activeBranch,l)})}for(;i.component;)i=i.component.subTree;if(i.shapeFlag&1&&i.el)ka(i.el,l);else if(i.type===te)i.children.forEach(C=>ma(C,l));else if(i.type===Ie)for(var{el:_,anchor:A}=i;_&&(ka(_,l),_!==A);)_=_.nextSibling}function ka(i,l){if(i.nodeType===1)for(var d in l)i.setAttribute("--".concat(d),l[d])}var yo="transition",aa="animation",Za=(i,l)=>{var{slots:d}=l;return Ji(Dt,Hs(i),d)};Za.displayName="Transition";var $s={name:String,type:String,css:{type:Boolean,default:!0},duration:[String,Number,Object],enterFromClass:String,enterActiveClass:String,enterToClass:String,appearFromClass:String,appearActiveClass:String,appearToClass:String,leaveFromClass:String,leaveActiveClass:String,leaveToClass:String},pl=Za.props=h.extend({},Dt.props,$s),sa=function(i){var l=arguments.length>1&&arguments[1]!==void 0?arguments[1]:[];h.isArray(i)?i.forEach(d=>d(...l)):i&&i(...l)},Xa=i=>i?h.isArray(i)?i.some(l=>l.length>1):i.length>1:!1;function Hs(i){var l={};for(var d in i)d in $s||(l[d]=i[d]);if(i.css===!1)return l;var{name:_="v",type:A,duration:C,enterFromClass:k="".concat(_,"-enter-from"),enterActiveClass:D="".concat(_,"-enter-active"),enterToClass:H="".concat(_,"-enter-to"),appearFromClass:ne=k,appearActiveClass:ve=D,appearToClass:Be=H,leaveFromClass:ue="".concat(_,"-leave-from"),leaveActiveClass:ke="".concat(_,"-leave-active"),leaveToClass:Ge="".concat(_,"-leave-to")}=i,ut=Qa(C),Qe=ut&&ut[0],Re=ut&&ut[1],{onBeforeEnter:me,onEnter:ye,onEnterCancelled:Le,onLeave:Oe,onLeaveCancelled:bt,onBeforeAppear:Ct=me,onAppear:Ke=ye,onAppearCancelled:Rt=Le}=l,M=(re,oe,Ue)=>{la(re,oe?Be:H),la(re,oe?ve:D),Ue&&Ue()},j=(re,oe)=>{la(re,Ge),la(re,ke),oe&&oe()},se=re=>(oe,Ue)=>{var rt=re?Ke:ye,qe=()=>M(oe,re,Ue);sa(rt,[oe,qe]),vl(()=>{la(oe,re?ne:k),Mr(oe,re?Be:H),Xa(rt)||js(oe,A,Qe,qe)})};return h.extend(l,{onBeforeEnter(re){sa(me,[re]),Mr(re,k),Mr(re,D)},onBeforeAppear(re){sa(Ct,[re]),Mr(re,ne),Mr(re,ve)},onEnter:se(!1),onAppear:se(!0),onLeave(re,oe){var Ue=()=>j(re,oe);Mr(re,ue),ml(),Mr(re,ke),vl(()=>{la(re,ue),Mr(re,Ge),Xa(Oe)||js(re,A,Re,Ue)}),sa(Oe,[re,Ue])},onEnterCancelled(re){M(re,!1),sa(Le,[re])},onAppearCancelled(re){M(re,!0),sa(Rt,[re])},onLeaveCancelled(re){j(re),sa(bt,[re])}})}function Qa(i){if(i==null)return null;if(h.isObject(i))return[ti(i.enter),ti(i.leave)];var l=ti(i);return[l,l]}function ti(i){var l=h.toNumber(i);return l}function Mr(i,l){l.split(/\s+/).forEach(d=>d&&i.classList.add(d)),(i._vtc||(i._vtc=new Set)).add(l)}function la(i,l){l.split(/\s+/).forEach(_=>_&&i.classList.remove(_));var{_vtc:d}=i;d&&(d.delete(l),d.size||(i._vtc=void 0))}function vl(i){requestAnimationFrame(()=>{requestAnimationFrame(i)})}var zl=0;function js(i,l,d,_){var A=i._endId=++zl,C=()=>{A===i._endId&&_()};if(d)return setTimeout(C,d);var{type:k,timeout:D,propCount:H}=bs(i,l);if(!k)return _();var ne=k+"end",ve=0,Be=()=>{i.removeEventListener(ne,ue),C()},ue=ke=>{ke.target===i&&++ve>=H&&Be()};setTimeout(()=>{ve<H&&Be()},D+1),i.addEventListener(ne,ue)}function bs(i,l){var d=window.getComputedStyle(i),_=Ge=>(d[Ge]||"").split(", "),A=_(yo+"Delay"),C=_(yo+"Duration"),k=zs(A,C),D=_(aa+"Delay"),H=_(aa+"Duration"),ne=zs(D,H),ve=null,Be=0,ue=0;l===yo?k>0&&(ve=yo,Be=k,ue=C.length):l===aa?ne>0&&(ve=aa,Be=ne,ue=H.length):(Be=Math.max(k,ne),ve=Be>0?k>ne?yo:aa:null,ue=ve?ve===yo?C.length:H.length:0);var ke=ve===yo&&/\b(transform|all)(,|$)/.test(d[yo+"Property"]);return{type:ve,timeout:Be,propCount:ue,hasTransform:ke}}function zs(i,l){for(;i.length<l.length;)i=i.concat(i);return Math.max(...l.map((d,_)=>Ws(d)+Ws(i[_])))}function Ws(i){return Number(i.slice(0,-1).replace(",","."))*1e3}function ml(){return document.body.offsetHeight}var Gs=new WeakMap,ys=new WeakMap,Es={name:"TransitionGroup",props:h.extend({},pl,{tag:String,moveClass:String}),setup(i,l){var{slots:d}=l,_=jn(),A=Ar(),C,k;return nr(()=>{if(!!C.length){var D=i.moveClass||"".concat(i.name||"v","-move");if(!!m(C[0].el,_.vnode.el,D)){C.forEach(bl),C.forEach(a);var H=C.filter(u);ml(),H.forEach(ne=>{var ve=ne.el,Be=ve.style;Mr(ve,D),Be.transform=Be.webkitTransform=Be.transitionDuration="";var ue=ve._moveCb=ke=>{ke&&ke.target!==ve||(!ke||/transform$/.test(ke.propertyName))&&(ve.removeEventListener("transitionend",ue),ve._moveCb=null,la(ve,D))};ve.addEventListener("transitionend",ue)})}}}),()=>{var D=y.toRaw(i),H=Hs(D),ne=D.tag||te;C=k,k=d.default?Ri(d.default()):[];for(var ve=0;ve<k.length;ve++){var Be=k[ve];Be.key!=null&&Or(Be,_i(Be,H,A,_))}if(C)for(var ue=0;ue<C.length;ue++){var ke=C[ue];Or(ke,_i(ke,H,A,_)),Gs.set(ke,ke.el.getBoundingClientRect())}return qt(ne,null,k)}}},Ss=i=>delete i.mode;Es.props;var _l=Es;function bl(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),d=ys.get(i),_=l.left-d.left,A=l.top-d.top;if(_||A){var C=i.el.style;return C.transform=C.webkitTransform="translate(".concat(_,"px,").concat(A,"px)"),C.transitionDuration="0s",i}}function m(i,l,d){var _=i.cloneNode();i._vtc&&i._vtc.forEach(k=>{k.split(/\s+/).forEach(D=>D&&_.classList.remove(D))}),d.split(/\s+/).forEach(k=>k&&_.classList.add(k)),_.style.display="none";var A=l.nodeType===1?l:l.parentNode;A.appendChild(_);var{hasTransform:C}=bs(_);return A.removeChild(_),C}var S=i=>{var l=i.props["onUpdate:modelValue"];return h.isArray(l)?d=>h.invokeArrayFns(l,d):l},I={created(i,l,d){var{value:_,modifiers:{trim:A,number:C}}=l;i.value=_==null?"":_,i._assign=S(d),ms(i,"input",k=>{var D=k.detail.value,H=i.pageNode;i.pageNode=null,i.value=D,i.pageNode=H,A?D=D.trim():C&&(D=h.toNumber(D)),i._assign(D)})},beforeUpdate(i,l,d){var{value:_}=l;i._assign=S(d);var A=_==null?"":_;i.value!==A&&(i.value=A)}},O=I,F=["ctrl","shift","alt","meta"],W={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(d=>i["".concat(d,"Key")]&&!l.includes(d))},G=(i,l)=>{var d=function(_){for(var A=0;A<l.length;A++){var C=W[l[A]];if(C&&C(_,l))return}for(var k=arguments.length,D=new Array(k>1?k-1:0),H=1;H<k;H++)D[H-1]=arguments[H];return i(_,...D)};return d.modifiers=l,d},le={esc:"escape",space:" ",up:"arrow-up",left:"arrow-left",right:"arrow-right",down:"arrow-down",delete:"backspace"},We=(i,l)=>d=>{if("key"in d){var _=h.hyphenate(d.key);if(l.some(A=>A===_||le[A]===_))return i(d)}},it={beforeMount(i,l){var{value:d}=l;ge(i,d)},updated(i,l){var{value:d,oldValue:_}=l;!d!=!_&&ge(i,d)},beforeUnmount(i,l){var{value:d}=l;ge(i,d)}};function ge(i,l){i.setAttribute(".vShow",!!l)}var Ye=h.extend({patchProp:gl,forcePatchProp:R.forcePatchProp},jo),Je;function mt(){return Je||(Je=$a(Ye))}var at=function(){mt().render(...arguments)},Se=function(){var i=mt().createApp(...arguments),{mount:l}=i;return i.mount=d=>(h.isString(d)&&(d=qa(d)),d&&l(d,!1,!1)),i},Ee=Se;function Ae(){}function lt(){}function Ve(i){return h.isObject(i)?R.JSON_PROTOCOL+JSON.stringify(i):i}var Tt=i=>Ve(i);return Object.defineProperty(E,"camelize",{enumerable:!0,get:function(){return h.camelize}}),Object.defineProperty(E,"capitalize",{enumerable:!0,get:function(){return h.capitalize}}),Object.defineProperty(E,"normalizeClass",{enumerable:!0,get:function(){return h.normalizeClass}}),Object.defineProperty(E,"normalizeProps",{enumerable:!0,get:function(){return h.normalizeProps}}),Object.defineProperty(E,"normalizeStyle",{enumerable:!0,get:function(){return h.normalizeStyle}}),Object.defineProperty(E,"toDisplayString",{enumerable:!0,get:function(){return h.toDisplayString}}),Object.defineProperty(E,"toHandlerKey",{enumerable:!0,get:function(){return h.toHandlerKey}}),Object.defineProperty(E,"EffectScope",{enumerable:!0,get:function(){return y.EffectScope}}),Object.defineProperty(E,"ReactiveEffect",{enumerable:!0,get:function(){return y.ReactiveEffect}}),Object.defineProperty(E,"customRef",{enumerable:!0,get:function(){return y.customRef}}),Object.defineProperty(E,"effect",{enumerable:!0,get:function(){return y.effect}}),Object.defineProperty(E,"effectScope",{enumerable:!0,get:function(){return y.effectScope}}),Object.defineProperty(E,"getCurrentScope",{enumerable:!0,get:function(){return y.getCurrentScope}}),Object.defineProperty(E,"isProxy",{enumerable:!0,get:function(){return y.isProxy}}),Object.defineProperty(E,"isReactive",{enumerable:!0,get:function(){return y.isReactive}}),Object.defineProperty(E,"isReadonly",{enumerable:!0,get:function(){return y.isReadonly}}),Object.defineProperty(E,"isRef",{enumerable:!0,get:function(){return y.isRef}}),Object.defineProperty(E,"isShallow",{enumerable:!0,get:function(){return y.isShallow}}),Object.defineProperty(E,"markRaw",{enumerable:!0,get:function(){return y.markRaw}}),Object.defineProperty(E,"onScopeDispose",{enumerable:!0,get:function(){return y.onScopeDispose}}),Object.defineProperty(E,"proxyRefs",{enumerable:!0,get:function(){return y.proxyRefs}}),Object.defineProperty(E,"reactive",{enumerable:!0,get:function(){return y.reactive}}),Object.defineProperty(E,"readonly",{enumerable:!0,get:function(){return y.readonly}}),Object.defineProperty(E,"ref",{enumerable:!0,get:function(){return y.ref}}),Object.defineProperty(E,"shallowReactive",{enumerable:!0,get:function(){return y.shallowReactive}}),Object.defineProperty(E,"shallowReadonly",{enumerable:!0,get:function(){return y.shallowReadonly}}),Object.defineProperty(E,"shallowRef",{enumerable:!0,get:function(){return y.shallowRef}}),Object.defineProperty(E,"stop",{enumerable:!0,get:function(){return y.stop}}),Object.defineProperty(E,"toRaw",{enumerable:!0,get:function(){return y.toRaw}}),Object.defineProperty(E,"toRef",{enumerable:!0,get:function(){return y.toRef}}),Object.defineProperty(E,"toRefs",{enumerable:!0,get:function(){return y.toRefs}}),Object.defineProperty(E,"triggerRef",{enumerable:!0,get:function(){return y.triggerRef}}),Object.defineProperty(E,"unref",{enumerable:!0,get:function(){return y.unref}}),E.BaseTransition=Dt,E.BaseTransitionPropsValidators=Xr,E.Comment=pe,E.Fragment=te,E.KeepAlive=ji,E.Static=Ie,E.Suspense=kn,E.Teleport=Z,E.Text=ce,E.Transition=Za,E.TransitionGroup=_l,E.assertNumber=It,E.callWithAsyncErrorHandling=Ot,E.callWithErrorHandling=Vt,E.cloneVNode=ei,E.compatUtils=$o,E.computed=ds,E.createApp=Se,E.createBlock=dn,E.createComment=qa,E.createCommentVNode=Un,E.createElement=Ho,E.createElementBlock=Mt,E.createElementVNode=Ut,E.createHydrationRenderer=Ha,E.createPropsRestProxy=Er,E.createRenderer=$a,E.createSSRApp=Ee,E.createSlots=Q,E.createStaticVNode=ja,E.createTextNode=oa,E.createTextVNode=qi,E.createVNode=qt,E.createVueApp=Se,E.defineAsyncComponent=ai,E.defineComponent=Tr,E.defineEmits=xs,E.defineExpose=hs,E.defineProps=Vo,E.getCurrentInstance=jn,E.getTransitionRawChildren=Ri,E.guardReactiveProps=ci,E.h=Ji,E.handleError=P,E.initCustomFormatter=ia,E.inject=Zn,E.injectHook=mr,E.isMemoSame=ps,E.isRuntimeOnly=Wr,E.isVNode=Gt,E.mergeDefaults=wn,E.mergeProps=yr,E.nextTick=gr,E.onActivated=to,E.onBeforeActivate=Ae,E.onBeforeDeactivate=lt,E.onBeforeMount=er,E.onBeforeUnmount=cr,E.onBeforeUpdate=Gn,E.onDeactivated=En,E.onErrorCaptured=ko,E.onMounted=tr,E.onRenderTracked=no,E.onRenderTriggered=No,E.onServerPrefetch=go,E.onUnmounted=ho,E.onUpdated=nr,E.openBlock=ct,E.popScopeId=da,E.provide=Nn,E.pushScopeId=wo,E.queuePostFlushCb=vi,E.registerRuntimeCompiler=fs,E.render=at,E.renderList=B,E.renderSlot=he,E.resolveComponent=ro,E.resolveDirective=Mi,E.resolveDynamicComponent=vo,E.resolveFilter=Ms,E.resolveTransitionHooks=_i,E.setBlockTracking=yt,E.setDevtoolsHook=sn,E.setTransitionHooks=Or,E.ssrContextKey=Uo,E.ssrUtils=Hl,E.toHandlers=de,E.transformVNodeArgs=en,E.useAttrs=Nt,E.useCssModule=zo,E.useCssVars=Ka,E.useSSRContext=Na,E.useSlots=xe,E.useTransitionState=Ar,E.vModelDynamic=O,E.vModelText=I,E.vShow=it,E.version=dl,E.warn=Fe,E.watch=vr,E.watchEffect=Ni,E.watchPostEffect=Hi,E.watchSyncEffect=oi,E.withAsyncContext=Oi,E.withCtx=Zo,E.withDefaults=Bs,E.withDirectives=jr,E.withKeys=We,E.withMemo=gs,E.withModifiers=G,E.withScopeId=Ui,E.wp=Tt,Object.defineProperty(E,"__esModule",{value:!0}),E}({},p,w,s);return N.__TYPE__="vue",N}function lv(f,s,p){let w=p.Vue,N=p.setTimeout,E=p.clearTimeout,h=p.setInterval,y=p.clearInterval,R=p.__uniConfig,Fe=p.__uniRoutes,It=p.VueShared,Vt=p.UniShared;var Ot=function(z,J,hn){"use strict";var un="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",yn=function(){let e=new Uint8Array(256);for(var t=0;t<un.length;t++)e[un.charCodeAt(t)]=t;return e}();function Jn(e){var t=new Uint8Array(e),n,r=t.length,o="";for(n=0;n<r;n+=3)o+=un[t[n]>>2],o+=un[(t[n]&3)<<4|t[n+1]>>4],o+=un[(t[n+1]&15)<<2|t[n+2]>>6],o+=un[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 gi(e){var t=e.length*.75,n=e.length,r,o=0,c,g,b,V;e[e.length-1]==="="&&(t--,e[e.length-2]==="="&&t--);var T=new ArrayBuffer(t),L=new Uint8Array(T);for(r=0;r<n;r+=4)c=yn[e.charCodeAt(r)],g=yn[e.charCodeAt(r+1)],b=yn[e.charCodeAt(r+2)],V=yn[e.charCodeAt(r+3)],L[o++]=c<<2|g>>4,L[o++]=(g&15)<<4|b>>2,L[o++]=(b&3)<<6|V&63;return T}let pi=["original","compressed"],qr=["album","camera"],gr=["GET","OPTIONS","HEAD","POST","PUT","DELETE","TRACE","CONNECT","PATCH"];function Sn(e,t){return!e||t.indexOf(e)===-1?t[0]:e}function pr(e,t){return!z.isArray(e)||e.length===0||e.find(n=>t.indexOf(n)===-1)?t:e}function Lr(e,t){console.warn(`${e}: ${t}`)}function Jr(e,t,n,r){r||(r=Lr);for(let o in n){let c=Pn(o,t[o],n[o],!z.hasOwn(t,o));z.isString(c)&&r(e,c)}}function vi(e,t,n,r){if(!n)return;if(!z.isArray(n))return Jr(e,t[0]||Object.create(null),n,r);let o=n.length,c=t.length;for(let g=0;g<o;g++){let b=n[g],V=Object.create(null);c>g&&(V[b.name]=t[g]),Jr(e,V,{[b.name]:b},r)}}function Pn(e,t,n,r){z.isPlainObject(n)||(n={type:n});let{type:o,required:c,validator:g}=n;if(c&&r)return'Missing required args: "'+e+'"';if(!(t==null&&!c)){if(o!=null){let b=!1,V=z.isArray(o)?o:[o],T=[];for(let L=0;L<V.length&&!b;L++){let{valid:_e,expectedType:we}=nt(t,V[L]);T.push(we||""),b=_e}if(!b)return At(e,t,T)}if(g)return g(t)}}let ze=z.makeMap("String,Number,Boolean,Function,Symbol");function nt(e,t){let n,r=Qt(t);if(ze(r)){let o=typeof e;n=o===r.toLowerCase(),!n&&o==="object"&&(n=e instanceof t)}else r==="Object"?n=z.isObject(e):r==="Array"?n=z.isArray(e):n=e instanceof t||z.toRawType(e)===Qt(t);return{valid:n,expectedType:r}}function At(e,t,n){let r=`Invalid args: type check failed for args "${e}". Expected ${n.map(z.capitalize).join(", ")}`,o=n[0],c=z.toRawType(t),g=Tn(t,o),b=Tn(t,c);return n.length===1&&sn(o)&&!or(o,c)&&(r+=` with value ${g}`),r+=`, got ${c} `,sn(c)&&(r+=`with value ${b}.`),r}function Qt(e){let t=e&&e.toString().match(/^\s*function (\w+)/);return t?t[1]:""}function Tn(e,t){return t==="String"?`"${e}"`:t==="Number"?`${Number(e)}`:`${e}`}function sn(e){return["string","number","boolean"].some(n=>e.toLowerCase()===n)}function or(...e){return e.some(t=>t.toLowerCase()==="boolean")}function Wn(e){return function(){try{return e.apply(e,arguments)}catch(t){console.error(t)}}}let An=1,gn={};function wr(e,t,n,r=!1){return gn[e]={name:t,keepAlive:r,callback:n},e}function Kr(e,t,n){if(typeof e=="number"){let r=gn[e];if(r)return r.keepAlive||delete gn[e],r.callback(t,n)}return t}function wo(e){for(let t in gn)if(gn[t].name===e)return!0;return!1}function da(e,t){for(let n in gn){let r=gn[n];r.callback===t&&r.name===e&&delete gn[n]}}function Ui(e){ot.off("api."+e)}function Zo(e){ot.on("api."+e,t=>{for(let n in gn){let r=gn[n];r.name===e&&r.callback(t)}})}function Xo(e,t){return wr(An++,e,t,!0)}let $i="success",ri="fail",Co="complete";function Ao(e){let t={};for(let n in e){let r=e[n];z.isFunction(r)&&(t[n]=Wn(r),delete e[n])}return t}function Oo(e,t){return!e||e.indexOf(":fail")===-1?t+":ok":t+e.substring(e.indexOf(":fail"))}function Xi(e,t={},{beforeAll:n,beforeSuccess:r}={}){z.isPlainObject(t)||(t={});let{success:o,fail:c,complete:g}=Ao(t),b=z.isFunction(o),V=z.isFunction(c),T=z.isFunction(g),L=An++;return wr(L,e,_e=>{_e=_e||{},_e.errMsg=Oo(_e.errMsg,e),z.isFunction(n)&&n(_e),_e.errMsg===e+":ok"?(z.isFunction(r)&&r(_e,t),b&&o(_e)):V&&c(_e),T&&g(_e)}),L}let mi="success",To="fail",uo="complete",kn={},Cr={};function Qi(e,t){return function(n){return e(n,t)||n}}function Kn(e,t,n){let r=!1;for(let o=0;o<e.length;o++){let c=e[o];if(r)r=Promise.resolve(Qi(c,n));else{let g=c(t,n);if(z.isPromise(g)&&(r=Promise.resolve(g)),g===!1)return{then(){},catch(){}}}}return r||{then(o){return o(t)},catch(){}}}function eo(e,t={}){return[mi,To,uo].forEach(n=>{let r=e[n];if(!z.isArray(r))return;let o=t[n];t[n]=function(g){Kn(r,g,t).then(b=>z.isFunction(o)&&o(b)||b)}}),t}function Po(e,t){let n=[];z.isArray(kn.returnValue)&&n.push(...kn.returnValue);let r=Cr[e];return r&&z.isArray(r.returnValue)&&n.push(...r.returnValue),n.forEach(o=>{t=o(t)||t}),t}function fo(e){let t=Object.create(null);Object.keys(kn).forEach(r=>{r!=="returnValue"&&(t[r]=kn[r].slice())});let n=Cr[e];return n&&Object.keys(n).forEach(r=>{r!=="returnValue"&&(t[r]=(t[r]||[]).concat(n[r]))}),t}function ii(e,t,n,r){let o=fo(e);return o&&Object.keys(o).length?z.isArray(o.invoke)?Kn(o.invoke,n).then(g=>t(eo(fo(e),g),...r)):t(eo(o,n),...r):t(n,...r)}function ar(e){return!!(z.isPlainObject(e)&&[$i,ri,Co].find(t=>z.isFunction(e[t])))}function kr(e){return e}function Nn(e,t){return(n={},...r)=>ar(n)?Po(e,ii(e,t,n,r)):Po(e,new Promise((o,c)=>{ii(e,t,z.extend(n,{success:o,fail:c}),r)}))}function Zn(e,t){let n=e[0];if(!t||!z.isPlainObject(t.formatArgs)&&z.isPlainObject(n))return;let r=t.formatArgs,o=Object.keys(r);for(let c=0;c<o.length;c++){let g=o[c],b=r[g];if(z.isFunction(b)){let V=b(e[0][g],n);if(z.isString(V))return V}else z.hasOwn(n,g)||(n[g]=b)}}function Ni(e,t,n){return Kr(e,z.extend(n||{},{errMsg:t+":ok"}))}function Hi(e,t,n,r){return Kr(e,z.extend({errMsg:t+":fail"+(n?" "+n:"")},r))}function oi(e,t,n,r){if(r&&r.beforeInvoke){let c=r.beforeInvoke(t);if(z.isString(c))return c}let o=Zn(t,r);if(o)return o}function Fr(e){if(!z.isFunction(e))throw new Error('Invalid args: type check failed for args "callback". Expected Function')}function vr(e,t,n){return r=>{Fr(r);let o=oi(e,[r],void 0,n);if(o)throw new Error(o);let c=!wo(e);Xo(e,r),c&&(Zo(e),t())}}function ki(e,t,n){return r=>{Fr(r);let o=oi(e,[r],void 0,n);if(o)throw new Error(o);e=e.replace("off","on"),da(e,r),wo(e)||(Ui(e),t())}}function Io(e){return!e||z.isString(e)?e:e.stack?(console.error(e.message+J.LINEFEED+e.stack),e.message):e}function Vr(e,t,n,r){return o=>{let c=Xi(e,o,r),g=oi(e,[o],n,r);return g?Hi(c,e,g):t(o,{resolve:b=>Ni(c,e,b),reject:(b,V)=>Hi(c,e,Io(b),V)})}}function Zr(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 Ar(e,t,n,r){return Vr(e,t,n,r)}function pn(e,t,n){return vr(e,t,n)}function Xr(e,t,n){return ki(e,t,n)}function Ur(e,t,n,r){return Nn(e,Vr(e,t,void 0,r))}function Dt(e,t,n,r){return Zr(e,t,void 0,r)}function Te(e,t,n,r){return Nn(e,Ar(e,t,void 0,r))}let _i="base64ToArrayBuffer",bi=[{name:"base64",type:String,required:!0}],yi="arrayBufferToBase64",Or=[{name:"arrayBuffer",type:[ArrayBuffer,Uint8Array],required:!0}],Ri=Dt(_i,e=>gi(e),bi),Tr=Dt(yi,e=>Jn(e),Or);function Rr(){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 ai(e,t,n){e.$page.meta.isNVue?Ei(e,t,n):Pr(e,t,n)}function Pr(e,t,n){ot.invokeViewMethod("requestComponentInfo",{reqs:t.map(r=>(r.component&&(r.component=r.component.$el.nodeId),r))},e.$page.id,n)}function Ei(e,t,n){let r=fn(t),o=new Array(r.length);ji(r,e.$el,o),$r(e.$requireNativePlugin("dom"),o,0,[],c=>{n(c)})}function fn(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 ji(e,t,n){let r=t.children;if(!z.isArray(r))return!1;for(let o=0;o<r.length;o++){let c=r[o];if(c.attr){let g=e.indexOf(c.attr.id);if(g>=0&&(n[g]={id:e[g],ref:c.ref,dataset:J.parseNVueDataset(c.attr)},e.length===1))break}c.children&&ji(e,c,n)}}function $r(e,t,n,r,o){let c=t[n];e.getComponentRect(c.ref,g=>{g.size.id=c.id,g.size.dataset=c.dataset,r.push(g.size),n+=1,n<t.length?$r(e,t,n,r,o):o(r)})}function to(e,t){ot.invokeViewMethod("setPageMeta",t,e.$page.id)}let En=e=>e!==null&&typeof e=="object",Hr=["{","}"];class sr{constructor(){this._caches=Object.create(null)}interpolate(t,n,r=Hr){if(!n)return[t];let o=this._caches[t];return o||(o=mr(t,r),this._caches[t]=o),Qr(o,n)}}let Si=/^(?:\d)+/,xi=/^(?:\w)+/;function mr(e,[t,n]){let r=[],o=0,c="";for(;o<e.length;){let g=e[o++];if(g===t){c&&r.push({type:"text",value:c}),c="";let b="";for(g=e[o++];g!==void 0&&g!==n;)b+=g,g=e[o++];let V=g===n,T=Si.test(b)?"list":V&&xi.test(b)?"named":"unknown";r.push({value:b,type:T})}else c+=g}return c&&r.push({type:"text",value:c}),r}function Qr(e,t){let n=[],r=0,o=Array.isArray(t)?"list":En(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 er="zh-Hans",tr="zh-Hant",Gn="en",nr="fr",cr="es",ho=Object.prototype.hasOwnProperty,go=(e,t)=>ho.call(e,t),No=new sr;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 er;if(e.indexOf("zh")===0)return e.indexOf("-hans")>-1?er:e.indexOf("-hant")>-1||no(e,["-tw","-hk","-mo","-cht"])?tr:er;let n=[Gn,nr,cr];t&&Object.keys(t).length>0&&(n=Object.keys(t));let r=ko(e,n);if(r)return r}class xr{constructor({locale:t,fallbackLocale:n,messages:r,watcher:o,formater:c}){this.locale=Gn,this.fallbackLocale=Gn,this.message={},this.messages={},this.watchers=[],n&&(this.fallbackLocale=n),this.formater=c||No,this.messages=r||{},this.setLocale(t||Gn),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 po(e,t){e.$watchLocale?e.$watchLocale(n=>{t.setLocale(n)}):e.$watch(()=>e.$locale,n=>{t.setLocale(n)})}function Ro(){return typeof P!="undefined"&&P.getLocale?P.getLocale():typeof global!="undefined"&&global.getLocale?global.getLocale():Gn}function ro(e,t={},n,r){typeof e!="string"&&([e,t]=[t,e]),typeof e!="string"&&(e=Ro()),typeof n!="string"&&(n=typeof R!="undefined"&&R.fallbackLocale||Gn);let o=new xr({locale:e,fallbackLocale:n,messages:t,watcher:r}),c=(g,b)=>{if(typeof wt!="function")c=function(V,T){return o.t(V,T)};else{let V=!1;c=function(T,L){let _e=wt().$vm;return _e&&(_e.$locale,V||(V=!0,po(_e,o))),o.t(T,L)}}return c(g,b)};return{i18n:o,f(g,b,V){return o.f(g,b,V)},t(g,b){return c(g,b)},add(g,b,V=!0){return o.add(g,b,V)},watch(g){return o.watchLocale(g)},getLocale(){return o.getLocale()},setLocale(g){return o.setLocale(g)}}}function Bi(e,t){return e.indexOf(t[0])>-1}let vo=J.once(()=>typeof R!="undefined"&&R.locales&&!!Object.keys(R.locales).length),Mi;function zi(){let e=P.getLocale(),t=R.locales;return t[e]||t[R.fallbackLocale]||t.en||{}}function Qo(e){return Bi(e,J.I18N_JSON_DELIMITERS)?ae().f(e,zi(),J.I18N_JSON_DELIMITERS):e}function B(e,t){if(t.length===1){if(e){let r=b=>z.isString(b)&&Bi(b,J.I18N_JSON_DELIMITERS),o=t[0],c=[];if(z.isArray(e)&&(c=e.filter(b=>r(b[o]))).length)return c;let g=e[t[0]];if(r(g))return e}return}let n=t.shift();return B(e&&e[n],t)}function Q(e,t){return t.map(n=>he(e,n))}function he(e,t){let n=B(e,t);if(!n)return!1;let r=t[t.length-1];if(z.isArray(n))n.forEach(o=>he(o,[r]));else{let o=n[r];Object.defineProperty(n,r,{get(){return Qo(o)},set(c){o=c}})}return!0}function ae(){if(!Mi){let e;if(typeof wt=="function"?e=f.requireModule("plus").getLanguage():e=s.webview.currentWebview().getStyle().locale,Mi=ro(e),vo()){let t=Object.keys(R.locales||{});t.length&&t.forEach(n=>Mi.add(n,R.locales[n])),Mi.setLocale(e)}}return Mi}function de(e,t,n){return t.reduce((r,o,c)=>(r[e+o]=n[c],r),{})}let vt=J.once(()=>{let e="uni.app.",t=["quit"];ae().add(Gn,de(e,t,["Press back button again to exit"]),!1),ae().add(cr,de(e,t,["Pulse otra vez para salir"]),!1),ae().add(nr,de(e,t,["Appuyez \xE0 nouveau pour quitter l'application"]),!1),ae().add(er,de(e,t,["\u518D\u6309\u4E00\u6B21\u9000\u51FA\u5E94\u7528"]),!1),ae().add(tr,de(e,t,["\u518D\u6309\u4E00\u6B21\u9000\u51FA\u61C9\u7528"]),!1)}),kt=J.once(()=>{let e="uni.showActionSheet.",t=["cancel"];ae().add(Gn,de(e,t,["Cancel"]),!1),ae().add(cr,de(e,t,["Cancelar"]),!1),ae().add(nr,de(e,t,["Annuler"]),!1),ae().add(er,de(e,t,["\u53D6\u6D88"]),!1),ae().add(tr,de(e,t,["\u53D6\u6D88"]),!1)}),X=J.once(()=>{let e="uni.showModal.",t=["cancel","confirm"];ae().add(Gn,de(e,t,["Cancel","OK"]),!1),ae().add(cr,de(e,t,["Cancelar","OK"]),!1),ae().add(nr,de(e,t,["Annuler","OK"]),!1),ae().add(er,de(e,t,["\u53D6\u6D88","\u786E\u5B9A"]),!1),ae().add(tr,de(e,t,["\u53D6\u6D88","\u78BA\u5B9A"]),!1)}),K=J.once(()=>{let e="uni.chooseImage.",t=["cancel","sourceType.album","sourceType.camera"];ae().add(Gn,de(e,t,["Cancel","Album","Camera"]),!1),ae().add(cr,de(e,t,["Cancelar","\xC1lbum","C\xE1mara"]),!1),ae().add(nr,de(e,t,["Annuler","Album","Cam\xE9ra"]),!1),ae().add(er,de(e,t,["\u53D6\u6D88","\u4ECE\u76F8\u518C\u9009\u62E9","\u62CD\u6444"]),!1),ae().add(tr,de(e,t,["\u53D6\u6D88","\u5F9E\u76F8\u518A\u9078\u64C7","\u62CD\u651D"]),!1)}),ie=J.once(()=>{let e="uni.chooseVideo.",t=["cancel","sourceType.album","sourceType.camera"];ae().add(Gn,de(e,t,["Cancel","Album","Camera"]),!1),ae().add(cr,de(e,t,["Cancelar","\xC1lbum","C\xE1mara"]),!1),ae().add(nr,de(e,t,["Annuler","Album","Cam\xE9ra"]),!1),ae().add(er,de(e,t,["\u53D6\u6D88","\u4ECE\u76F8\u518C\u9009\u62E9","\u62CD\u6444"]),!1),ae().add(tr,de(e,t,["\u53D6\u6D88","\u5F9E\u76F8\u518A\u9078\u64C7","\u62CD\u651D"]),!1)}),Ne=J.once(()=>{let e="uni.previewImage.",t=["cancel","button.save","save.success","save.fail"];ae().add(Gn,de(e,t,["Cancel","Save Image","Saved successfully","Save failed"]),!1),ae().add(cr,de(e,t,["Cancelar","Guardar imagen","Guardado exitosamente","Error al guardar"]),!1),ae().add(nr,de(e,t,["Annuler","Guardar imagen","Enregistr\xE9 avec succ\xE8s","\xC9chec de la sauvegarde"]),!1),ae().add(er,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),ae().add(tr,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)}),st=J.once(()=>{let e="uni.setClipboardData.",t=["success","fail"];ae().add(Gn,de(e,t,["Content copied","Copy failed, please copy manually"]),!1),ae().add(cr,de(e,t,["Contenido copiado","Error al copiar, copie manualmente"]),!1),ae().add(nr,de(e,t,["Contenu copi\xE9","\xC9chec de la copie, copiez manuellement"]),!1),ae().add(er,de(e,t,["\u5185\u5BB9\u5DF2\u590D\u5236","\u590D\u5236\u5931\u8D25\uFF0C\u8BF7\u624B\u52A8\u590D\u5236"]),!1),ae().add(tr,de(e,t,["\u5167\u5BB9\u5DF2\u5FA9\u5236","\u5FA9\u5236\u5931\u6557\uFF0C\u8ACB\u624B\u52D5\u5FA9\u88FD"]),!1)}),Xt=J.once(()=>{let e="uni.scanCode.",t=["title","album","fail","flash.on","flash.off"];ae().add(Gn,de(e,t,["Scan code","Album","Recognition failure","Tap to turn light on","Tap to turn light off"]),!1),ae().add(cr,de(e,t,["C\xF3digo de escaneo","\xC1lbum","\xC9chec de la reconnaissance","Toque para encender la luz","Toque para apagar la luz"]),!1),ae().add(nr,de(e,t,["Code d\u2019analyse","Album","Fallo de reconocimiento","Appuyez pour activer l'\xE9clairage","Appuyez pour d\xE9sactiver l'\xE9clairage"]),!1),ae().add(er,de(e,t,["\u626B\u7801","\u76F8\u518C","\u8BC6\u522B\u5931\u8D25","\u8F7B\u89E6\u7167\u4EAE","\u8F7B\u89E6\u5173\u95ED"]),!1),ae().add(tr,de(e,t,["\u6383\u78BC","\u76F8\u518A","\u8B58\u5225\u5931\u6557","\u8F15\u89F8\u7167\u4EAE","\u8F15\u89F8\u95DC\u9589"]),!1)}),xn=J.once(()=>{let e="uni.startSoterAuthentication.",t=["authContent","waitingContent"];ae().add(Gn,de(e,t,["Fingerprint recognition","Unrecognizable"]),!1),ae().add(cr,de(e,t,["Reconocimiento de huellas dactilares","Irreconocible"]),!1),ae().add(nr,de(e,t,["Reconnaissance de l'empreinte digitale","M\xE9connaissable"]),!1),ae().add(er,de(e,t,["\u6307\u7EB9\u8BC6\u522B\u4E2D...","\u65E0\u6CD5\u8BC6\u522B"]),!1),ae().add(tr,de(e,t,["\u6307\u7D0B\u8B58\u5225\u4E2D...","\u7121\u6CD5\u8B58\u5225"]),!1)});function Dn(e){if(vo())return Q(e,[["titleText"],["searchInput","placeholder"],["buttons","text"]])}function _r(e){if(vo()){let t="caption";return Q(e,[["contentdown",t],["contentover",t],["contentrefresh",t]])}}function Br(e){let t=new J.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 mo="invokeViewApi",xo="invokeServiceApi";function Bo(e){return e=e+"",e.indexOf("rpx")!==-1||e.indexOf("upx")!==-1}function Ln(e,t=!1){if(t)return Yn(e);if(z.isString(e)){let n=parseInt(e)||0;return Bo(e)?P.upx2px(n):n}return e}function Yn(e){return Bo(e)?e.replace(/(\d+(\.\d+)?)[ru]px/g,(t,n)=>P.upx2px(parseFloat(n))+"px"):e}function Fn(e){let t=J.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 wi(){let e=In(),t=e.length;if(t)return e[t-1]}function is(){let e=wi();if(e)return e.$page.meta}function ha(){let e=is();return e?e.id:-1}function br(){let e=wi();if(e)return e.$vm}let Ta=["navigationBar","pullToRefresh"];function La(){return JSON.parse(JSON.stringify(R.globalStyle||{}))}function Fa(e,t){let n=La(),r=z.extend({id:t},n,e);Ta.forEach(c=>{r[c]=z.extend({},n[c],e[c])});let{navigationBar:o}=r;return o.titleText&&o.titleImage&&(o.titleText=""),r}function Va(e){return JSON.parse(Ln(JSON.stringify(e),!0))}function Ua(e){return e.offset&&(e.offset=Ln(e.offset)),e.height&&(e.height=Ln(e.height)),e.range&&(e.range=Ln(e.range)),e}function ga(e,t,n,r,o,c){let{id:g,route:b}=r,V=J.normalizeStyles(r.navigationBar,R.themeConfig,c).titleColor;return{id:g,path:J.addLeadingSlash(b),route:b,fullPath:t,options:n,meta:r,openType:e,eventChannel:o,statusBarStyle:V==="#ffffff"?"light":"dark"}}function Pa(e,t,n){let r=e.$[t];!z.isArray(r)||n.__weh&&z.remove(r,n.__weh)}function Vn(e,t,n){if(z.isString(e))n=t,t=e,e=br();else if(typeof e=="number"){let o=In().find(c=>c.$page.id===e);o?e=o.$vm:e=br()}if(!e)return;if(e.__call_hook)return e.__call_hook(t,n);let r=e.$[t];return r&&J.invokeArrayFns(r,n)}function Mo(e){if(e.indexOf("/")===0)return e;let t="",n=In();return n.length&&(t=n[n.length-1].$page.route),ea(t,e)}function ea(e,t){if(t.indexOf("/")===0)return t;if(t.indexOf("./")===0)return ea(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),J.addLeadingSlash(c.concat(n).join("/"))}function Wi(e,t=!1){return t?Fe.find(n=>n.path===e||n.alias===e):Fe.find(n=>n.path===e)}function os(e){let t=Wi(e);if(t)return t.meta}function as(e,t,n){let r=Wi(J.addLeadingSlash(t));if(r){let{meta:c}=r;delete c.tabBarIndex,c.isQuit=c.isTabBar=!1}let o=Wi(J.addLeadingSlash(n));if(o){let{meta:c}=o;c.tabBarIndex=e,c.isQuit=c.isTabBar=!0;let g=R.tabBar;g&&g.list&&g.list[e]&&(g.list[e].pagePath=J.removeLeadingSlash(n))}}let Do,ss,io;function si(){return typeof window=="object"&&typeof navigator=="object"&&typeof document=="object"?"webview":"v8"}function Ci(){return Do.webview.currentWebview().id}let Gi,li,ur={};function lr(e){let t=e.data&&e.data.__message;if(!t||!t.__page)return;let n=t.__page,r=ur[n];r&&r(t),t.keep||delete ur[n]}function $a(e,t){si()==="v8"?io?(Gi&&Gi.close(),Gi=new io(Ci()),Gi.onmessage=lr):li||(li=ss.requireModule("globalEvent"),li.addEventListener("plusMessage",lr)):window.__plusMessage=lr,ur[e]=t}class Ha{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):Do.webview.postMessageToUniNView&&Do.webview.postMessageToUniNView(n,r)}close(){this.webview.close()}}function Yi({context:e={},url:t,data:n={},style:r={},onMessage:o,onClose:c}){let g=R.darkmode;Do=e.plus||s,ss=e.weex||(typeof f=="object"?f:null),io=e.BroadcastChannel||(typeof BroadcastChannel=="object"?BroadcastChannel:null);let b={autoBackButton:!0,titleSize:"17px"},V=`page${Date.now()}`;r=z.extend({},r),r.titleNView!==!1&&r.titleNView!=="none"&&(r.titleNView=z.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:Do.screen.resolutionWidth}};r=z.extend(T,r);let L=Do.webview.create("",V,r,{extras:{from:Ci(),runtime:si(),data:z.extend({},n,{darkmode:g}),useGlobalEvent:!io}});return L.addEventListener("close",c),$a(V,_e=>{z.isFunction(o)&&o(_e.data),_e.keep||L.close("auto")}),L.show(r.animationType,r.animationDuration),new Ha(L)}let oo=(e,t)=>ot.emit("api."+e,t),ao=1;function ls(e){return(e||ha())+"."+mo}let pa=(e,t,n,r)=>{let{subscribe:o,publishHandler:c}=ot,g=r?ao++:0;r&&o(mo+"."+g,r,!0),c(ls(n),{id:g,name:e,args:t},n)},Lo=(e,t,n,r)=>{let{subscribe:o,unsubscribe:c,publishHandler:g}=ot,b=ao++,V=mo+"."+b;return o(V,n),g(ls(r),{id:b,name:e,args:t},r),()=>{c(V)}},va=Object.create(null);function v(){ot.subscribe(xo,$)}function x(e,t){va[e]||(va[e]=t)}function $({id:e,name:t,args:n},r){let o=g=>{e&&ot.publishHandler(xo+"."+e,g,r)},c=va[t];c?c(n,o):o({})}let U=z.extend(Br("view"),{invokeOnCallback:oo,invokeViewMethod:pa,invokeViewMethodKeepAlive:Lo});function Z(){let{on:e}=ot;e(J.ON_RESIZE,q),e(J.ON_APP_ENTER_FOREGROUND,te),e(J.ON_APP_ENTER_BACKGROUND,ce)}function q(e){Vn(wi(),J.ON_RESIZE,e),ot.invokeOnCallback("onWindowResize",e)}function te(e){let t=wi();Vn(wt(),J.ON_SHOW,e),Vn(t,J.ON_SHOW)}function ce(){Vn(wt(),J.ON_HIDE),Vn(wi(),J.ON_HIDE)}let pe=[J.ON_PAGE_SCROLL,J.ON_REACH_BOTTOM];function Ie(){pe.forEach(e=>ot.subscribe(e,fe(e)))}function fe(e){return(t,n)=>{Vn(parseInt(n),e,t)}}function Ce(){Z(),Ie()}function ct(e){e.$vm=e,e.$mpType="app";let t=hn.ref(ae().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 Ht(){return{path:"",query:{},scene:1001,referrerInfo:{appId:"",extraData:{}}}}function yt(e,t){let n=e.$options||{};n.globalData=z.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(J.SCHEME_RE.test(e)||J.DATA_RE.test(e))return e;if(dn(e))return"file://"+Mt(e);let t="file://"+Mt("_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+ea(J.addLeadingSlash(__id__),e);{let n=wi();if(n)return t+ea(J.addLeadingSlash(n.route),e)}}return e}let Mt=J.cacheStringFunction(e=>s.io.convertLocalFileSystemURL(e).replace(/^\/?apps\//,"/android_asset/apps/").replace(/\/$/,""));function dn(e){return e.indexOf("_www")===0||e.indexOf("_doc")===0||e.indexOf("_documents")===0||e.indexOf("_downloads")===0}let Gt="success",dt="fail",Bn=[Gt,dt,"complete"];function Yt(e,t,n,r){if(!e)return;if(typeof n=="undefined")return e[t]();let[,o]=ta(n,r);return Object.keys(o).length?e[t](ci(t,o)):e[t]()}function jt(e,t,n,r){if(!e)return;let[o,c]=ta(n,r);return Object.keys(c).length?e[t](o,ci(t,c)):e[t](o)}function Ut(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 ta(e={},t){let n=Object.create(null),r=function(c){let g=e[c];z.isFunction(g)&&(n[c]=g,delete e[c])};return Bn.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===Gt?r.errMsg=`${e}:ok`:o===dt&&(r.errMsg=e+":fail "+(r.msg?" "+r.msg:"")),delete r.code,delete r.msg,z.isFunction(c)&&c(r),o===Gt||o===dt){let g=t.complete;z.isFunction(g)&&g(r)}}}let ei;function qi(){return ei}function ja(e){let t=e.$;Object.defineProperty(t.ctx,"$children",{get(){return Hn().map(r=>r.$vm)}});let n=t.appContext;ei=z.extend(n.app,{mountPage(r,o,c){let g=hn.createVNode(r,o);g.appContext=n,g.__page_container__=c,hn.render(g,c);let b=g.component.proxy;return b.__page_container__=c,b},unmountPage:r=>{let{__page_container__:o}=r;o&&(o.isUnmounted=!0,hn.render(null,o))}})}let Un=[];function $n(e){if(!e.$page.meta.isNVue)return Un.push(e);let n=Un.findIndex(r=>r.$page.id===e.$page.id);n>-1?Un.splice(n,1,e):Un.push(e)}function Ir(e){return Un.find(t=>t.$page.id===e)}function Hn(){return Un}function yr(){let e=[];return Un.forEach(t=>{t.$.__isTabBar?t.$.__isActive&&e.push(t):e.push(t)}),e}function zr(){let e=wi();!e||na(e)}function na(e){let t=Un.findIndex(n=>n===e);t!==-1&&(e.$page.meta.isNVue||qi().unmountPage(e),Un.splice(t,1))}let cs={play(e){return Yt(e,"play")},pause(e){return Yt(e,"pause")},seek(e,t){return jt(e,"seek",t.position)},stop(e){return Yt(e,"stop")},sendDanmu(e,t){return jt(e,"sendDanmu",t)},playbackRate(e,t){return jt(e,"playbackRate",t.rate)},requestFullScreen(e,t={}){return jt(e,"requestFullScreen",t)},exitFullScreen(e){return Yt(e,"exitFullScreen")},showStatusBar(e){return Yt(e,"showStatusBar")},hideStatusBar(e){return Yt(e,"hideStatusBar")}};function on(e,t,n,r){let o=Ir(t);if(o==null?void 0:o.$page.meta.isNVue){let c=o.$vm;return cs[n](Ut(e,c),r)}ot.invokeViewMethod("video."+e,{videoId:e,type:n,data:r},t)}let _n={getCenterLocation(e,t){return Yt(e,"getCenterLocation",t)},moveToLocation(e,t){return jt(e,"moveToLocation",t)},translateMarker(e,t){return jt(e,"translateMarker",t,["animationEnd"])},includePoints(e,t){return jt(e,"includePoints",t)},getRegion(e,t){return Yt(e,"getRegion",t)},getScale(e,t){return Yt(e,"getScale",t)},addCustomLayer(e,t){return jt(e,"addCustomLayer",t)},removeCustomLayer(e,t){return jt(e,"removeCustomLayer",t)},addGroundOverlay(e,t){return jt(e,"addGroundOverlay",t)},removeGroundOverlay(e,t){return jt(e,"removeGroundOverlay",t)},updateGroundOverlay(e,t){return jt(e,"updateGroundOverlay",t)},initMarkerCluster(e,t){return jt(e,"initMarkerCluster",t)},addMarkers(e,t){return jt(e,"addMarkers",t)},removeMarkers(e,t){return jt(e,"removeMarkers",t)},moveAlong(e,t){return jt(e,"moveAlong",t)},setLocMarkerIcon(e,t){return jt(e,"setLocMarkerIcon",t)},openMapApp(e,t){return jt(e,"openMapApp",t)},on(e,t){return e.on(t.name,t.callback)}};function jn(e,t,n,r,o){let c=Ir(t);if(c==null?void 0:c.$page.meta.isNVue){let g=c.$vm;return _n[n](Ut(e,g),r)}ot.invokeViewMethod("map."+e,{type:n,data:r},t,o)}function qn(e){return`IntersectionObserver.${e}`}function Ai({reqId:e,component:t,options:n,callback:r},o){let c=qn(e);ot.invokeViewMethod("addIntersectionObserver",{reqId:e,component:t.$el.nodeId,options:n,eventName:c},o),ot.subscribe(c,r)}function us({reqId:e,component:t},n){ot.invokeViewMethod("removeIntersectionObserver",{reqId:e,component:t.$el.nodeId},n),ot.unsubscribe(qn(e))}function za(e){return`MediaQueryObserver.${e}`}function Ia({reqId:e,component:t,options:n,callback:r},o){let c=za(e);ot.invokeViewMethod("addMediaQueryObserver",{reqId:e,component:t.$el.nodeId,options:n,eventName:c},o),ot.subscribe(c,r)}function ra({reqId:e,component:t},n){ot.invokeViewMethod("removeMediaQueryObserver",{reqId:e,component:t.$el.nodeId},n),ot.unsubscribe(za(e))}let so=200,Wa=["unknown","none","ethernet","wifi","2g","3g","4g","5g"],fs="_doc/uniapp_temp",Wr=`${fs}_${Date.now()}`;function Ga(e){let t=e.split("/");return t[t.length-1]}function Ya(e){let t=e.split(".");return t.length>1?"."+t[t.length-1]:""}let Fo="backbutton";function Di(){P.navigateBack({from:"backbutton",success(){}})}let _o=Ht(),bo=Ht();function ds(){return z.extend({},bo)}function Vo(){return z.extend({},_o)}function xs({path:e,query:t,referrerInfo:n}){z.extend(_o,{path:e,query:t?J.parseQuery(t):{},referrerInfo:n||{}})}function hs({path:e,query:t,referrerInfo:n}){return z.extend(bo,{path:e,query:t?J.parseQuery(t):{},referrerInfo:n||{},channel:s.runtime.channel,launcher:s.runtime.launcher}),z.extend(_o,bo),z.extend({},bo)}function Bs(){let e=f.requireModule("plus");if(e.getRedirectInfo){let{path:t,query:n,extraData:r,userAction:o,fromAppid:c}=e.getRedirectInfo()||{},g={appId:c,extraData:{}};return r&&(g.extraData=r),{path:t||"",query:n?"?"+n:"",referrerInfo:g,userAction:o}}}var xe={};(function(e){var t=typeof Uint8Array!="undefined"&&typeof Uint16Array!="undefined"&&typeof Int32Array!="undefined";function n(c,g){return Object.prototype.hasOwnProperty.call(c,g)}e.assign=function(c){for(var g=Array.prototype.slice.call(arguments,1);g.length;){var b=g.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,g){return c.length===g?c:c.subarray?c.subarray(0,g):(c.length=g,c)};var r={arraySet:function(c,g,b,V,T){if(g.subarray&&c.subarray){c.set(g.subarray(b,b+V),T);return}for(var L=0;L<V;L++)c[T+L]=g[b+L]},flattenChunks:function(c){var g,b,V,T,L,_e;for(V=0,g=0,b=c.length;g<b;g++)V+=c[g].length;for(_e=new Uint8Array(V),T=0,g=0,b=c.length;g<b;g++)L=c[g],_e.set(L,T),T+=L.length;return _e}},o={arraySet:function(c,g,b,V,T){for(var L=0;L<V;L++)c[T+L]=g[b+L]},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)})(xe);var Nt={},Pt={},wn={},Er=xe,Oi=4,Ji=0,Uo=1,Na=2;function ia(e){for(var t=e.length;--t>=0;)e[t]=0}var gs=0,ps=1,dl=2,$l=3,Hl=258,Ms=29,$o=256,Ho=$o+1+Ms,oa=30,qa=19,vs=2*Ho+1,jo=15,Ds=16,jl=7,Ls=256,ms=16,hl=17,Fs=18,Ja=[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],_s=[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],Vs=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7],Us=[16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15],gl=512,zo=new Array((Ho+2)*2);ia(zo);var Ka=new Array(oa*2);ia(Ka);var ma=new Array(gl);ia(ma);var ka=new Array(Hl-$l+1);ia(ka);var yo=new Array(Ms);ia(yo);var aa=new Array(oa);ia(aa);function Za(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 $s,pl,sa;function Xa(e,t){this.dyn_tree=e,this.max_code=0,this.stat_desc=t}function Hs(e){return e<256?ma[e]:ma[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>Ds-n?(e.bi_buf|=t<<e.bi_valid&65535,Qa(e,e.bi_buf),e.bi_buf=t>>Ds-e.bi_valid,e.bi_valid+=n-Ds):(e.bi_buf|=t<<e.bi_valid&65535,e.bi_valid+=n)}function Mr(e,t,n){ti(e,n[t*2],n[t*2+1])}function la(e,t){var n=0;do n|=e&1,e>>>=1,n<<=1;while(--t>0);return n>>>1}function vl(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,g=t.stat_desc.extra_bits,b=t.stat_desc.extra_base,V=t.stat_desc.max_length,T,L,_e,we,Pe,ft,ht=0;for(we=0;we<=jo;we++)e.bl_count[we]=0;for(n[e.heap[e.heap_max]*2+1]=0,T=e.heap_max+1;T<vs;T++)L=e.heap[T],we=n[n[L*2+1]*2+1]+1,we>V&&(we=V,ht++),n[L*2+1]=we,!(L>r)&&(e.bl_count[we]++,Pe=0,L>=b&&(Pe=g[L-b]),ft=n[L*2],e.opt_len+=ft*(we+Pe),c&&(e.static_len+=ft*(o[L*2+1]+Pe)));if(ht!==0){do{for(we=V-1;e.bl_count[we]===0;)we--;e.bl_count[we]--,e.bl_count[we+1]+=2,e.bl_count[V]--,ht-=2}while(ht>0);for(we=V;we!==0;we--)for(L=e.bl_count[we];L!==0;)_e=e.heap[--T],!(_e>r)&&(n[_e*2+1]!==we&&(e.opt_len+=(we-n[_e*2+1])*n[_e*2],n[_e*2+1]=we),L--)}}function js(e,t,n){var r=new Array(jo+1),o=0,c,g;for(c=1;c<=jo;c++)r[c]=o=o+n[c-1]<<1;for(g=0;g<=t;g++){var b=e[g*2+1];b!==0&&(e[g*2]=la(r[b]++,b))}}function bs(){var e,t,n,r,o,c=new Array(jo+1);for(n=0,r=0;r<Ms-1;r++)for(yo[r]=n,e=0;e<1<<Ja[r];e++)ka[n++]=r;for(ka[n-1]=r,o=0,r=0;r<16;r++)for(aa[r]=o,e=0;e<1<<_s[r];e++)ma[o++]=r;for(o>>=7;r<oa;r++)for(aa[r]=o<<7,e=0;e<1<<_s[r]-7;e++)ma[256+o++]=r;for(t=0;t<=jo;t++)c[t]=0;for(e=0;e<=143;)zo[e*2+1]=8,e++,c[8]++;for(;e<=255;)zo[e*2+1]=9,e++,c[9]++;for(;e<=279;)zo[e*2+1]=7,e++,c[7]++;for(;e<=287;)zo[e*2+1]=8,e++,c[8]++;for(js(zo,Ho+1,c),e=0;e<oa;e++)Ka[e*2+1]=5,Ka[e*2]=la(e,5);$s=new Za(zo,Ja,$o+1,Ho,jo),pl=new Za(Ka,_s,0,oa,jo),sa=new Za(new Array(0),Vs,0,qa,jl)}function zs(e){var t;for(t=0;t<Ho;t++)e.dyn_ltree[t*2]=0;for(t=0;t<oa;t++)e.dyn_dtree[t*2]=0;for(t=0;t<qa;t++)e.bl_tree[t*2]=0;e.dyn_ltree[Ls*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 ml(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 Es(e,t,n){var r,o,c=0,g,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?Mr(e,o,t):(g=ka[o],Mr(e,g+$o+1,t),b=Ja[g],b!==0&&(o-=yo[g],ti(e,o,b)),r--,g=Hs(r),Mr(e,g,n),b=_s[g],b!==0&&(r-=aa[g],ti(e,r,b)));while(c<e.last_lit);Mr(e,Ls,t)}function Ss(e,t){var n=t.dyn_tree,r=t.stat_desc.static_tree,o=t.stat_desc.has_stree,c=t.stat_desc.elems,g,b,V=-1,T;for(e.heap_len=0,e.heap_max=vs,g=0;g<c;g++)n[g*2]!==0?(e.heap[++e.heap_len]=V=g,e.depth[g]=0):n[g*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,g=e.heap_len>>1;g>=1;g--)ys(e,n,g);T=c;do g=e.heap[1],e.heap[1]=e.heap[e.heap_len--],ys(e,n,1),b=e.heap[1],e.heap[--e.heap_max]=g,e.heap[--e.heap_max]=b,n[T*2]=n[g*2]+n[b*2],e.depth[T]=(e.depth[g]>=e.depth[b]?e.depth[g]:e.depth[b])+1,n[g*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 _l(e,t,n){var r,o=-1,c,g=t[0*2+1],b=0,V=7,T=4;for(g===0&&(V=138,T=3),t[(n+1)*2+1]=65535,r=0;r<=n;r++)c=g,g=t[(r+1)*2+1],!(++b<V&&c===g)&&(b<T?e.bl_tree[c*2]+=b:c!==0?(c!==o&&e.bl_tree[c*2]++,e.bl_tree[ms*2]++):b<=10?e.bl_tree[hl*2]++:e.bl_tree[Fs*2]++,b=0,o=c,g===0?(V=138,T=3):c===g?(V=6,T=3):(V=7,T=4))}function bl(e,t,n){var r,o=-1,c,g=t[0*2+1],b=0,V=7,T=4;for(g===0&&(V=138,T=3),r=0;r<=n;r++)if(c=g,g=t[(r+1)*2+1],!(++b<V&&c===g)){if(b<T)do Mr(e,c,e.bl_tree);while(--b!==0);else c!==0?(c!==o&&(Mr(e,c,e.bl_tree),b--),Mr(e,ms,e.bl_tree),ti(e,b-3,2)):b<=10?(Mr(e,hl,e.bl_tree),ti(e,b-3,3)):(Mr(e,Fs,e.bl_tree),ti(e,b-11,7));b=0,o=c,g===0?(V=138,T=3):c===g?(V=6,T=3):(V=7,T=4)}}function a(e){var t;for(_l(e,e.dyn_ltree,e.l_desc.max_code),_l(e,e.dyn_dtree,e.d_desc.max_code),Ss(e,e.bl_desc),t=qa-1;t>=3&&e.bl_tree[Us[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[Us[o]*2+1],3);bl(e,e.dyn_ltree,t-1),bl(e,e.dyn_dtree,n-1)}function m(e){var t=4093624447,n;for(n=0;n<=31;n++,t>>>=1)if(t&1&&e.dyn_ltree[n*2]!==0)return Ji;if(e.dyn_ltree[9*2]!==0||e.dyn_ltree[10*2]!==0||e.dyn_ltree[13*2]!==0)return Uo;for(n=32;n<$o;n++)if(e.dyn_ltree[n*2]!==0)return Uo;return Ji}var S=!1;function I(e){S||(bs(),S=!0),e.l_desc=new Xa(e.dyn_ltree,$s),e.d_desc=new Xa(e.dyn_dtree,pl),e.bl_desc=new Xa(e.bl_tree,sa),e.bi_buf=0,e.bi_valid=0,zs(e)}function O(e,t,n,r){ti(e,(gs<<1)+(r?1:0),3),ml(e,t,n,!0)}function F(e){ti(e,ps<<1,3),Mr(e,Ls,zo),vl(e)}function W(e,t,n,r){var o,c,g=0;e.level>0?(e.strm.data_type===Na&&(e.strm.data_type=m(e)),Ss(e,e.l_desc),Ss(e,e.d_desc),g=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===Oi||c===o?(ti(e,(ps<<1)+(r?1:0),3),Es(e,zo,Ka)):(ti(e,(dl<<1)+(r?1:0),3),u(e,e.l_desc.max_code+1,e.d_desc.max_code+1,g+1),Es(e,e.dyn_ltree,e.dyn_dtree)),zs(e),r&&Ws(e)}function G(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[(ka[n]+$o+1)*2]++,e.dyn_dtree[Hs(t)*2]++),e.last_lit===e.lit_bufsize-1}wn._tr_init=I,wn._tr_stored_block=O,wn._tr_flush_block=W,wn._tr_tally=G,wn._tr_align=F;function le(e,t,n,r){for(var o=e&65535|0,c=e>>>16&65535|0,g=0;n!==0;){g=n>2e3?2e3:n,n-=g;do o=o+t[r++]|0,c=c+o|0;while(--g);o%=65521,c%=65521}return o|c<<16|0}var We=le;function it(){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=it();function Ye(e,t,n,r){var o=ge,c=r+n;e^=-1;for(var g=r;g<c;g++)e=e>>>8^o[(e^t[g])&255];return e^-1}var Je=Ye,mt={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"},at=xe,Se=wn,Ee=We,Ae=Je,lt=mt,Ve=0,Tt=1,i=3,l=4,d=5,_=0,A=1,C=-2,k=-3,D=-5,H=-1,ne=1,ve=2,Be=3,ue=4,ke=0,Ge=2,ut=8,Qe=9,Re=15,me=8,ye=29,Le=256,Oe=Le+1+ye,bt=30,Ct=19,Ke=2*Oe+1,Rt=15,M=3,j=258,se=j+M+1,re=32,oe=42,Ue=69,rt=73,qe=91,Ze=103,$e=113,$t=666,pt=1,xt=2,Bt=3,Mn=4,Rn=3;function vn(e,t){return e.msg=lt[t],t}function bn(e){return(e<<1)-(e>4?9:0)}function fr(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&&(at.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 Jt(e,t){Se._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 an(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 Y(e,t,n,r){var o=e.avail_in;return o>r&&(o=r),o===0?0:(e.avail_in-=o,at.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=Ae(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,g=e.prev_length,b=e.nice_match,V=e.strstart>e.w_size-se?e.strstart-(e.w_size-se):0,T=e.window,L=e.w_mask,_e=e.prev,we=e.strstart+j,Pe=T[r+g-1],ft=T[r+g];e.prev_length>=e.good_match&&(n>>=2),b>e.lookahead&&(b=e.lookahead);do if(o=t,!(T[o+g]!==ft||T[o+g-1]!==Pe||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<we);if(c=j-(we-r),r=we-j,c>g){if(e.match_start=t,g=c,c>=b)break;Pe=T[r+g-1],ft=T[r+g]}}while((t=_e[t&L])>V&&--n!==0);return g<=e.lookahead?g:e.lookahead}function be(e){var t=e.w_size,n,r,o,c,g;do{if(c=e.window_size-e.lookahead-e.strstart,e.strstart>=t+(t-se)){at.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=Y(e.strm,e.window,e.strstart+e.lookahead,c),e.lookahead+=r,e.lookahead+e.insert>=M)for(g=e.strstart-e.insert,e.ins_h=e.window[g],e.ins_h=(e.ins_h<<e.hash_shift^e.window[g+1])&e.hash_mask;e.insert&&(e.ins_h=(e.ins_h<<e.hash_shift^e.window[g+M-1])&e.hash_mask,e.prev[g&e.w_mask]=e.head[e.ins_h],e.head[e.ins_h]=g,g++,e.insert--,!(e.lookahead+e.insert<M)););}while(e.lookahead<se&&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===Ve)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,Jt(e,!1),e.strm.avail_out===0)||e.strstart-e.block_start>=e.w_size-se&&(Jt(e,!1),e.strm.avail_out===0))return pt}return e.insert=0,t===l?(Jt(e,!0),e.strm.avail_out===0?Bt:Mn):(e.strstart>e.block_start&&(Jt(e,!1),e.strm.avail_out===0),pt)}function De(e,t){for(var n,r;;){if(e.lookahead<se){if(be(e),e.lookahead<se&&t===Ve)return pt;if(e.lookahead===0)break}if(n=0,e.lookahead>=M&&(e.ins_h=(e.ins_h<<e.hash_shift^e.window[e.strstart+M-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-se&&(e.match_length=ee(e,n)),e.match_length>=M)if(r=Se._tr_tally(e,e.strstart-e.match_start,e.match_length-M),e.lookahead-=e.match_length,e.match_length<=e.max_lazy_match&&e.lookahead>=M){e.match_length--;do e.strstart++,e.ins_h=(e.ins_h<<e.hash_shift^e.window[e.strstart+M-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=Se._tr_tally(e,0,e.window[e.strstart]),e.lookahead--,e.strstart++;if(r&&(Jt(e,!1),e.strm.avail_out===0))return pt}return e.insert=e.strstart<M-1?e.strstart:M-1,t===l?(Jt(e,!0),e.strm.avail_out===0?Bt:Mn):e.last_lit&&(Jt(e,!1),e.strm.avail_out===0)?pt:xt}function Xe(e,t){for(var n,r,o;;){if(e.lookahead<se){if(be(e),e.lookahead<se&&t===Ve)return pt;if(e.lookahead===0)break}if(n=0,e.lookahead>=M&&(e.ins_h=(e.ins_h<<e.hash_shift^e.window[e.strstart+M-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=M-1,n!==0&&e.prev_length<e.max_lazy_match&&e.strstart-n<=e.w_size-se&&(e.match_length=ee(e,n),e.match_length<=5&&(e.strategy===ne||e.match_length===M&&e.strstart-e.match_start>4096)&&(e.match_length=M-1)),e.prev_length>=M&&e.match_length<=e.prev_length){o=e.strstart+e.lookahead-M,r=Se._tr_tally(e,e.strstart-1-e.prev_match,e.prev_length-M),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+M-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=M-1,e.strstart++,r&&(Jt(e,!1),e.strm.avail_out===0))return pt}else if(e.match_available){if(r=Se._tr_tally(e,0,e.window[e.strstart-1]),r&&Jt(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=Se._tr_tally(e,0,e.window[e.strstart-1]),e.match_available=0),e.insert=e.strstart<M-1?e.strstart:M-1,t===l?(Jt(e,!0),e.strm.avail_out===0?Bt:Mn):e.last_lit&&(Jt(e,!1),e.strm.avail_out===0)?pt:xt}function _t(e,t){for(var n,r,o,c,g=e.window;;){if(e.lookahead<=j){if(be(e),e.lookahead<=j&&t===Ve)return pt;if(e.lookahead===0)break}if(e.match_length=0,e.lookahead>=M&&e.strstart>0&&(o=e.strstart-1,r=g[o],r===g[++o]&&r===g[++o]&&r===g[++o])){c=e.strstart+j;do;while(r===g[++o]&&r===g[++o]&&r===g[++o]&&r===g[++o]&&r===g[++o]&&r===g[++o]&&r===g[++o]&&r===g[++o]&&o<c);e.match_length=j-(c-o),e.match_length>e.lookahead&&(e.match_length=e.lookahead)}if(e.match_length>=M?(n=Se._tr_tally(e,1,e.match_length-M),e.lookahead-=e.match_length,e.strstart+=e.match_length,e.match_length=0):(n=Se._tr_tally(e,0,e.window[e.strstart]),e.lookahead--,e.strstart++),n&&(Jt(e,!1),e.strm.avail_out===0))return pt}return e.insert=0,t===l?(Jt(e,!0),e.strm.avail_out===0?Bt:Mn):e.last_lit&&(Jt(e,!1),e.strm.avail_out===0)?pt:xt}function et(e,t){for(var n;;){if(e.lookahead===0&&(be(e),e.lookahead===0)){if(t===Ve)return pt;break}if(e.match_length=0,n=Se._tr_tally(e,0,e.window[e.strstart]),e.lookahead--,e.strstart++,n&&(Jt(e,!1),e.strm.avail_out===0))return pt}return e.insert=0,t===l?(Jt(e,!0),e.strm.avail_out===0?Bt:Mn):e.last_lit&&(Jt(e,!1),e.strm.avail_out===0)?pt:xt}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,Xe),new tt(8,16,32,32,Xe),new tt(8,16,128,128,Xe),new tt(8,32,128,256,Xe),new tt(32,128,258,1024,Xe),new tt(32,258,258,4096,Xe)];function zt(e){e.window_size=2*e.w_size,fr(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=M-1,e.match_available=0,e.ins_h=0}function Lt(){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=ut,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 at.Buf16(Ke*2),this.dyn_dtree=new at.Buf16((2*bt+1)*2),this.bl_tree=new at.Buf16((2*Ct+1)*2),fr(this.dyn_ltree),fr(this.dyn_dtree),fr(this.bl_tree),this.l_desc=null,this.d_desc=null,this.bl_desc=null,this.bl_count=new at.Buf16(Rt+1),this.heap=new at.Buf16(2*Oe+1),fr(this.heap),this.heap_len=0,this.heap_max=0,this.depth=new at.Buf16(2*Oe+1),fr(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 Wt(e){var t;return!e||!e.state?vn(e,C):(e.total_in=e.total_out=0,e.data_type=Ge,t=e.state,t.pending=0,t.pending_out=0,t.wrap<0&&(t.wrap=-t.wrap),t.status=t.wrap?oe:$e,e.adler=t.wrap===2?0:1,t.last_flush=Ve,Se._tr_init(t),_)}function On(e){var t=Wt(e);return t===_&&zt(e.state),t}function Gr(e,t){return!e||!e.state||e.state.wrap!==2?C:(e.state.gzhead=t,_)}function Xn(e,t,n,r,o,c){if(!e)return C;var g=1;if(t===H&&(t=6),r<0?(g=0,r=-r):r>15&&(g=2,r-=16),o<1||o>Qe||n!==ut||r<8||r>15||t<0||t>9||c<0||c>ue)return vn(e,C);r===8&&(r=9);var b=new Lt;return e.state=b,b.strm=e,b.wrap=g,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+M-1)/M),b.window=new at.Buf8(b.w_size*2),b.head=new at.Buf16(b.hash_size),b.prev=new at.Buf16(b.w_size),b.lit_bufsize=1<<o+6,b.pending_buf_size=b.lit_bufsize*4,b.pending_buf=new at.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,On(e)}function ui(e,t){return Xn(e,t,ut,Re,me,ke)}function Wo(e,t){var n,r,o,c;if(!e||!e.state||t>d||t<0)return e?vn(e,C):C;if(r=e.state,!e.output||!e.input&&e.avail_in!==0||r.status===$t&&t!==l)return vn(e,e.avail_out===0?D:C);if(r.strm=e,n=r.last_flush,r.last_flush=t,r.status===oe)if(r.wrap===2)e.adler=0,an(r,31),an(r,139),an(r,8),r.gzhead?(an(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)),an(r,r.gzhead.time&255),an(r,r.gzhead.time>>8&255),an(r,r.gzhead.time>>16&255),an(r,r.gzhead.time>>24&255),an(r,r.level===9?2:r.strategy>=ve||r.level<2?4:0),an(r,r.gzhead.os&255),r.gzhead.extra&&r.gzhead.extra.length&&(an(r,r.gzhead.extra.length&255),an(r,r.gzhead.extra.length>>8&255)),r.gzhead.hcrc&&(e.adler=Ae(e.adler,r.pending_buf,r.pending,0)),r.gzindex=0,r.status=Ue):(an(r,0),an(r,0),an(r,0),an(r,0),an(r,0),an(r,r.level===9?2:r.strategy>=ve||r.level<2?4:0),an(r,Rn),r.status=$e);else{var g=ut+(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,g|=b<<6,r.strstart!==0&&(g|=re),g+=31-g%31,r.status=$e,lo(r,g),r.strstart!==0&&(lo(r,e.adler>>>16),lo(r,e.adler&65535)),e.adler=1}if(r.status===Ue)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=Ae(e.adler,r.pending_buf,r.pending-o,o)),ni(e),o=r.pending,r.pending===r.pending_buf_size));)an(r,r.gzhead.extra[r.gzindex]&255),r.gzindex++;r.gzhead.hcrc&&r.pending>o&&(e.adler=Ae(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=Ae(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,an(r,c)}while(c!==0);r.gzhead.hcrc&&r.pending>o&&(e.adler=Ae(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=Ae(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,an(r,c)}while(c!==0);r.gzhead.hcrc&&r.pending>o&&(e.adler=Ae(e.adler,r.pending_buf,r.pending-o,o)),c===0&&(r.status=Ze)}else r.status=Ze;if(r.status===Ze&&(r.gzhead.hcrc?(r.pending+2>r.pending_buf_size&&ni(e),r.pending+2<=r.pending_buf_size&&(an(r,e.adler&255),an(r,e.adler>>8&255),e.adler=0,r.status=$e)):r.status=$e),r.pending!==0){if(ni(e),e.avail_out===0)return r.last_flush=-1,_}else if(e.avail_in===0&&bn(t)<=bn(n)&&t!==l)return vn(e,D);if(r.status===$t&&e.avail_in!==0)return vn(e,D);if(e.avail_in!==0||r.lookahead!==0||t!==Ve&&r.status!==$t){var V=r.strategy===ve?et(r,t):r.strategy===Be?_t(r,t):He[r.level].func(r,t);if((V===Bt||V===Mn)&&(r.status=$t),V===pt||V===Bt)return e.avail_out===0&&(r.last_flush=-1),_;if(V===xt&&(t===Tt?Se._tr_align(r):t!==d&&(Se._tr_stored_block(r,0,0,!1),t===i&&(fr(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?(an(r,e.adler&255),an(r,e.adler>>8&255),an(r,e.adler>>16&255),an(r,e.adler>>24&255),an(r,e.total_in&255),an(r,e.total_in>>8&255),an(r,e.total_in>>16&255),an(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!==Ue&&t!==rt&&t!==qe&&t!==Ze&&t!==$e&&t!==$t?vn(e,C):(e.state=null,t===$e?vn(e,k):_))}function ws(e,t){var n=t.length,r,o,c,g,b,V,T,L;if(!e||!e.state||(r=e.state,g=r.wrap,g===2||g===1&&r.status!==oe||r.lookahead))return C;for(g===1&&(e.adler=Ee(e.adler,t,n,0)),r.wrap=0,n>=r.w_size&&(g===0&&(fr(r.head),r.strstart=0,r.block_start=0,r.insert=0),L=new at.Buf8(r.w_size),at.arraySet(L,t,n-r.w_size,r.w_size,0),t=L,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>=M;){o=r.strstart,c=r.lookahead-(M-1);do r.ins_h=(r.ins_h<<r.hash_shift^r.window[o+M-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=M-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=M-1,r.match_available=0,e.next_in=V,e.input=T,e.avail_in=b,r.wrap=g,_}Pt.deflateInit=ui,Pt.deflateInit2=Xn,Pt.deflateReset=On,Pt.deflateResetKeep=Wt,Pt.deflateSetHeader=Gr,Pt.deflate=Wo,Pt.deflateEnd=es,Pt.deflateSetDictionary=ws,Pt.deflateInfo="pako deflate (from Nodeca project)";var rr={},Ra=xe,Cs=!0,Ki=!0;try{String.fromCharCode.apply(null,[0])}catch(e){Cs=!1}try{String.fromCharCode.apply(null,new Uint8Array(1))}catch(e){Ki=!1}for(var Go=new Ra.Buf8(256),co=0;co<256;co++)Go[co]=co>=252?6:co>=248?5:co>=240?4:co>=224?3:co>=192?2:1;Go[254]=Go[254]=1,rr.string2buf=function(e){var t,n,r,o,c,g=e.length,b=0;for(o=0;o<g;o++)n=e.charCodeAt(o),(n&64512)===55296&&o+1<g&&(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 Ra.Buf8(b),c=0,o=0;c<b;o++)n=e.charCodeAt(o),(n&64512)===55296&&o+1<g&&(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 _a(e,t){if(t<65534&&(e.subarray&&Ki||!e.subarray&&Cs))return String.fromCharCode.apply(null,Ra.shrinkBuf(e,t));for(var n="",r=0;r<t;r++)n+=String.fromCharCode(e[r]);return n}rr.buf2binstring=function(e){return _a(e,e.length)},rr.binstring2buf=function(e){for(var t=new Ra.Buf8(e.length),n=0,r=t.length;n<r;n++)t[n]=e.charCodeAt(n);return t},rr.buf2string=function(e,t){var n,r,o,c,g=t||e.length,b=new Array(g*2);for(r=0,n=0;n<g;){if(o=e[n++],o<128){b[r++]=o;continue}if(c=Go[o],c>4){b[r++]=65533,n+=c-1;continue}for(o&=c===2?31:c===3?15:7;c>1&&n<g;)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 _a(b,r)},rr.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+Go[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 ca=ts,ua=Pt,Yo=xe,yl=rr,Ys=mt,bc=ca,Wl=Object.prototype.toString,Xv=0,pu=4,El=0,Uf=1,$f=2,Qv=-1,em=0,tm=8;function qs(e){if(!(this instanceof qs))return new qs(e);this.options=Yo.assign({level:Qv,method:tm,chunkSize:16384,windowBits:15,memLevel:8,strategy:em,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 bc,this.strm.avail_out=0;var n=ua.deflateInit2(this.strm,t.level,t.method,t.windowBits,t.memLevel,t.strategy);if(n!==El)throw new Error(Ys[n]);if(t.header&&ua.deflateSetHeader(this.strm,t.header),t.dictionary){var r;if(typeof t.dictionary=="string"?r=yl.string2buf(t.dictionary):Wl.call(t.dictionary)==="[object ArrayBuffer]"?r=new Uint8Array(t.dictionary):r=t.dictionary,n=ua.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?pu:Xv,typeof e=="string"?n.input=yl.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 Yo.Buf8(r),n.next_out=0,n.avail_out=r),o=ua.deflate(n,c),o!==Uf&&o!==El)return this.onEnd(o),this.ended=!0,!1;(n.avail_out===0||n.avail_in===0&&(c===pu||c===$f))&&(this.options.to==="string"?this.onData(yl.buf2binstring(Yo.shrinkBuf(n.output,n.next_out))):this.onData(Yo.shrinkBuf(n.output,n.next_out)))}while((n.avail_in>0||n.avail_out===0)&&o!==Uf);return c===pu?(o=ua.deflateEnd(this.strm),this.onEnd(o),this.ended=!0,o===El):(c===$f&&(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=Yo.flattenChunks(this.chunks)),this.chunks=[],this.err=e,this.msg=this.strm.msg};function vu(e,t){var n=new qs(t);if(n.push(e,!0),n.err)throw n.msg||Ys[n.err];return n.result}function nm(e,t){return t=t||{},t.raw=!0,vu(e,t)}function rm(e,t){return t=t||{},t.gzip=!0,vu(e,t)}Nt.Deflate=qs,Nt.deflate=vu,Nt.deflateRaw=nm,Nt.gzip=rm;var Gl={},ba={},yc=30,im=12,om=function(t,n){var r,o,c,g,b,V,T,L,_e,we,Pe,ft,ht,Ft,St,mn,tn,nn,Et,Kt,cn,Zt,Cn,hr,rn;r=t.state,o=t.next_in,hr=t.input,c=o+(t.avail_in-5),g=t.next_out,rn=t.output,b=g-(n-t.avail_out),V=g+(t.avail_out-257),T=r.dmax,L=r.wsize,_e=r.whave,we=r.wnext,Pe=r.window,ft=r.hold,ht=r.bits,Ft=r.lencode,St=r.distcode,mn=(1<<r.lenbits)-1,tn=(1<<r.distbits)-1;e:do{ht<15&&(ft+=hr[o++]<<ht,ht+=8,ft+=hr[o++]<<ht,ht+=8),nn=Ft[ft&mn];t:for(;;){if(Et=nn>>>24,ft>>>=Et,ht-=Et,Et=nn>>>16&255,Et===0)rn[g++]=nn&65535;else if(Et&16){Kt=nn&65535,Et&=15,Et&&(ht<Et&&(ft+=hr[o++]<<ht,ht+=8),Kt+=ft&(1<<Et)-1,ft>>>=Et,ht-=Et),ht<15&&(ft+=hr[o++]<<ht,ht+=8,ft+=hr[o++]<<ht,ht+=8),nn=St[ft&tn];n:for(;;){if(Et=nn>>>24,ft>>>=Et,ht-=Et,Et=nn>>>16&255,Et&16){if(cn=nn&65535,Et&=15,ht<Et&&(ft+=hr[o++]<<ht,ht+=8,ht<Et&&(ft+=hr[o++]<<ht,ht+=8)),cn+=ft&(1<<Et)-1,cn>T){t.msg="invalid distance too far back",r.mode=yc;break e}if(ft>>>=Et,ht-=Et,Et=g-b,cn>Et){if(Et=cn-Et,Et>_e&&r.sane){t.msg="invalid distance too far back",r.mode=yc;break e}if(Zt=0,Cn=Pe,we===0){if(Zt+=L-Et,Et<Kt){Kt-=Et;do rn[g++]=Pe[Zt++];while(--Et);Zt=g-cn,Cn=rn}}else if(we<Et){if(Zt+=L+we-Et,Et-=we,Et<Kt){Kt-=Et;do rn[g++]=Pe[Zt++];while(--Et);if(Zt=0,we<Kt){Et=we,Kt-=Et;do rn[g++]=Pe[Zt++];while(--Et);Zt=g-cn,Cn=rn}}}else if(Zt+=we-Et,Et<Kt){Kt-=Et;do rn[g++]=Pe[Zt++];while(--Et);Zt=g-cn,Cn=rn}for(;Kt>2;)rn[g++]=Cn[Zt++],rn[g++]=Cn[Zt++],rn[g++]=Cn[Zt++],Kt-=3;Kt&&(rn[g++]=Cn[Zt++],Kt>1&&(rn[g++]=Cn[Zt++]))}else{Zt=g-cn;do rn[g++]=rn[Zt++],rn[g++]=rn[Zt++],rn[g++]=rn[Zt++],Kt-=3;while(Kt>2);Kt&&(rn[g++]=rn[Zt++],Kt>1&&(rn[g++]=rn[Zt++]))}}else if((Et&64)===0){nn=St[(nn&65535)+(ft&(1<<Et)-1)];continue n}else{t.msg="invalid distance code",r.mode=yc;break e}break}}else if((Et&64)===0){nn=Ft[(nn&65535)+(ft&(1<<Et)-1)];continue t}else if(Et&32){r.mode=im;break e}else{t.msg="invalid literal/length code",r.mode=yc;break e}break}}while(o<c&&g<V);Kt=ht>>3,o-=Kt,ht-=Kt<<3,ft&=(1<<ht)-1,t.next_in=o,t.next_out=g,t.avail_in=o<c?5+(c-o):5-(o-c),t.avail_out=g<V?257+(V-g):257-(g-V),r.hold=ft,r.bits=ht},Hf=xe,Sl=15,jf=852,zf=592,Wf=0,mu=1,Gf=2,am=[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],sm=[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],lm=[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],cm=[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],um=function(t,n,r,o,c,g,b,V){var T=V.bits,L=0,_e=0,we=0,Pe=0,ft=0,ht=0,Ft=0,St=0,mn=0,tn=0,nn,Et,Kt,cn,Zt,Cn=null,hr=0,rn,Aa=new Hf.Buf16(Sl+1),Kc=new Hf.Buf16(Sl+1),Zc=null,Ap=0,Op,Xc,Qc;for(L=0;L<=Sl;L++)Aa[L]=0;for(_e=0;_e<o;_e++)Aa[n[r+_e]]++;for(ft=T,Pe=Sl;Pe>=1&&Aa[Pe]===0;Pe--);if(ft>Pe&&(ft=Pe),Pe===0)return c[g++]=1<<24|64<<16|0,c[g++]=1<<24|64<<16|0,V.bits=1,0;for(we=1;we<Pe&&Aa[we]===0;we++);for(ft<we&&(ft=we),St=1,L=1;L<=Sl;L++)if(St<<=1,St-=Aa[L],St<0)return-1;if(St>0&&(t===Wf||Pe!==1))return-1;for(Kc[1]=0,L=1;L<Sl;L++)Kc[L+1]=Kc[L]+Aa[L];for(_e=0;_e<o;_e++)n[r+_e]!==0&&(b[Kc[n[r+_e]]++]=_e);if(t===Wf?(Cn=Zc=b,rn=19):t===mu?(Cn=am,hr-=257,Zc=sm,Ap-=257,rn=256):(Cn=lm,Zc=cm,rn=-1),tn=0,_e=0,L=we,Zt=g,ht=ft,Ft=0,Kt=-1,mn=1<<ft,cn=mn-1,t===mu&&mn>jf||t===Gf&&mn>zf)return 1;for(;;){Op=L-Ft,b[_e]<rn?(Xc=0,Qc=b[_e]):b[_e]>rn?(Xc=Zc[Ap+b[_e]],Qc=Cn[hr+b[_e]]):(Xc=32+64,Qc=0),nn=1<<L-Ft,Et=1<<ht,we=Et;do Et-=nn,c[Zt+(tn>>Ft)+Et]=Op<<24|Xc<<16|Qc|0;while(Et!==0);for(nn=1<<L-1;tn&nn;)nn>>=1;if(nn!==0?(tn&=nn-1,tn+=nn):tn=0,_e++,--Aa[L]===0){if(L===Pe)break;L=n[r+b[_e]]}if(L>ft&&(tn&cn)!==Kt){for(Ft===0&&(Ft=ft),Zt+=we,ht=L-Ft,St=1<<ht;ht+Ft<Pe&&(St-=Aa[ht+Ft],!(St<=0));)ht++,St<<=1;if(mn+=1<<ht,t===mu&&mn>jf||t===Gf&&mn>zf)return 1;Kt=tn&cn,c[Kt]=ft<<24|ht<<16|Zt-g|0}}return tn!==0&&(c[Zt+tn]=L-Ft<<24|64<<16|0),V.bits=ft,0},qo=xe,_u=We,xa=Je,fm=om,Yl=um,dm=0,Yf=1,qf=2,Jf=4,hm=5,Ec=6,Js=0,gm=1,pm=2,fa=-2,Kf=-3,Zf=-4,vm=-5,Xf=8,Qf=1,ed=2,td=3,nd=4,rd=5,id=6,od=7,ad=8,sd=9,ld=10,Sc=11,ns=12,bu=13,cd=14,yu=15,ud=16,fd=17,dd=18,hd=19,wc=20,Cc=21,gd=22,pd=23,vd=24,md=25,_d=26,Eu=27,bd=28,yd=29,Sr=30,Ed=31,mm=32,_m=852,bm=592,ym=15,Em=ym;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 qo.Buf16(320),this.work=new qo.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?fa:(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 qo.Buf32(_m),t.distcode=t.distdyn=new qo.Buf32(bm),t.sane=1,t.back=-1,Js)}function Cd(e){var t;return!e||!e.state?fa:(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))?fa:(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!==Js&&(e.state=null),n):fa}function wm(e){return Od(e,Em)}var Td=!0,Su,wu;function Cm(e){if(Td){var t;for(Su=new qo.Buf32(512),wu=new qo.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,Su,0,e.work,{bits:9}),t=0;t<32;)e.lens[t++]=5;Yl(qf,e.lens,0,32,wu,0,e.work,{bits:5}),Td=!1}e.lencode=Su,e.lenbits=9,e.distcode=wu,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 qo.Buf8(c.wsize)),r>=c.wsize?(qo.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),qo.arraySet(c.window,t,n-r,o,c.wnext),r-=o,r?(qo.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 Am(e,t){var n,r,o,c,g,b,V,T,L,_e,we,Pe,ft,ht,Ft=0,St,mn,tn,nn,Et,Kt,cn,Zt,Cn=new qo.Buf8(4),hr,rn,Aa=[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 fa;n=e.state,n.mode===ns&&(n.mode=bu),g=e.next_out,o=e.output,V=e.avail_out,c=e.next_in,r=e.input,b=e.avail_in,T=n.hold,L=n.bits,_e=b,we=V,Zt=Js;e:for(;;)switch(n.mode){case Qf:if(n.wrap===0){n.mode=bu;break}for(;L<16;){if(b===0)break e;b--,T+=r[c++]<<L,L+=8}if(n.wrap&2&&T===35615){n.check=0,Cn[0]=T&255,Cn[1]=T>>>8&255,n.check=xa(n.check,Cn,2,0),T=0,L=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=Sr;break}if((T&15)!==Xf){e.msg="unknown compression method",n.mode=Sr;break}if(T>>>=4,L-=4,cn=(T&15)+8,n.wbits===0)n.wbits=cn;else if(cn>n.wbits){e.msg="invalid window size",n.mode=Sr;break}n.dmax=1<<cn,e.adler=n.check=1,n.mode=T&512?ld:ns,T=0,L=0;break;case ed:for(;L<16;){if(b===0)break e;b--,T+=r[c++]<<L,L+=8}if(n.flags=T,(n.flags&255)!==Xf){e.msg="unknown compression method",n.mode=Sr;break}if(n.flags&57344){e.msg="unknown header flags set",n.mode=Sr;break}n.head&&(n.head.text=T>>8&1),n.flags&512&&(Cn[0]=T&255,Cn[1]=T>>>8&255,n.check=xa(n.check,Cn,2,0)),T=0,L=0,n.mode=td;case td:for(;L<32;){if(b===0)break e;b--,T+=r[c++]<<L,L+=8}n.head&&(n.head.time=T),n.flags&512&&(Cn[0]=T&255,Cn[1]=T>>>8&255,Cn[2]=T>>>16&255,Cn[3]=T>>>24&255,n.check=xa(n.check,Cn,4,0)),T=0,L=0,n.mode=nd;case nd:for(;L<16;){if(b===0)break e;b--,T+=r[c++]<<L,L+=8}n.head&&(n.head.xflags=T&255,n.head.os=T>>8),n.flags&512&&(Cn[0]=T&255,Cn[1]=T>>>8&255,n.check=xa(n.check,Cn,2,0)),T=0,L=0,n.mode=rd;case rd:if(n.flags&1024){for(;L<16;){if(b===0)break e;b--,T+=r[c++]<<L,L+=8}n.length=T,n.head&&(n.head.extra_len=T),n.flags&512&&(Cn[0]=T&255,Cn[1]=T>>>8&255,n.check=xa(n.check,Cn,2,0)),T=0,L=0}else n.head&&(n.head.extra=null);n.mode=id;case id:if(n.flags&1024&&(Pe=n.length,Pe>b&&(Pe=b),Pe&&(n.head&&(cn=n.head.extra_len-n.length,n.head.extra||(n.head.extra=new Array(n.head.extra_len)),qo.arraySet(n.head.extra,r,c,Pe,cn)),n.flags&512&&(n.check=xa(n.check,r,Pe,c)),b-=Pe,c+=Pe,n.length-=Pe),n.length))break e;n.length=0,n.mode=od;case od:if(n.flags&2048){if(b===0)break e;Pe=0;do cn=r[c+Pe++],n.head&&cn&&n.length<65536&&(n.head.name+=String.fromCharCode(cn));while(cn&&Pe<b);if(n.flags&512&&(n.check=xa(n.check,r,Pe,c)),b-=Pe,c+=Pe,cn)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;Pe=0;do cn=r[c+Pe++],n.head&&cn&&n.length<65536&&(n.head.comment+=String.fromCharCode(cn));while(cn&&Pe<b);if(n.flags&512&&(n.check=xa(n.check,r,Pe,c)),b-=Pe,c+=Pe,cn)break e}else n.head&&(n.head.comment=null);n.mode=sd;case sd:if(n.flags&512){for(;L<16;){if(b===0)break e;b--,T+=r[c++]<<L,L+=8}if(T!==(n.check&65535)){e.msg="header crc mismatch",n.mode=Sr;break}T=0,L=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(;L<32;){if(b===0)break e;b--,T+=r[c++]<<L,L+=8}e.adler=n.check=Sd(T),T=0,L=0,n.mode=Sc;case Sc:if(n.havedict===0)return e.next_out=g,e.avail_out=V,e.next_in=c,e.avail_in=b,n.hold=T,n.bits=L,pm;e.adler=n.check=1,n.mode=ns;case ns:if(t===hm||t===Ec)break e;case bu:if(n.last){T>>>=L&7,L-=L&7,n.mode=Eu;break}for(;L<3;){if(b===0)break e;b--,T+=r[c++]<<L,L+=8}switch(n.last=T&1,T>>>=1,L-=1,T&3){case 0:n.mode=cd;break;case 1:if(Cm(n),n.mode=wc,t===Ec){T>>>=2,L-=2;break e}break;case 2:n.mode=fd;break;case 3:e.msg="invalid block type",n.mode=Sr}T>>>=2,L-=2;break;case cd:for(T>>>=L&7,L-=L&7;L<32;){if(b===0)break e;b--,T+=r[c++]<<L,L+=8}if((T&65535)!==(T>>>16^65535)){e.msg="invalid stored block lengths",n.mode=Sr;break}if(n.length=T&65535,T=0,L=0,n.mode=yu,t===Ec)break e;case yu:n.mode=ud;case ud:if(Pe=n.length,Pe){if(Pe>b&&(Pe=b),Pe>V&&(Pe=V),Pe===0)break e;qo.arraySet(o,r,c,Pe,g),b-=Pe,c+=Pe,V-=Pe,g+=Pe,n.length-=Pe;break}n.mode=ns;break;case fd:for(;L<14;){if(b===0)break e;b--,T+=r[c++]<<L,L+=8}if(n.nlen=(T&31)+257,T>>>=5,L-=5,n.ndist=(T&31)+1,T>>>=5,L-=5,n.ncode=(T&15)+4,T>>>=4,L-=4,n.nlen>286||n.ndist>30){e.msg="too many length or distance symbols",n.mode=Sr;break}n.have=0,n.mode=dd;case dd:for(;n.have<n.ncode;){for(;L<3;){if(b===0)break e;b--,T+=r[c++]<<L,L+=8}n.lens[Aa[n.have++]]=T&7,T>>>=3,L-=3}for(;n.have<19;)n.lens[Aa[n.have++]]=0;if(n.lencode=n.lendyn,n.lenbits=7,hr={bits:n.lenbits},Zt=Yl(dm,n.lens,0,19,n.lencode,0,n.work,hr),n.lenbits=hr.bits,Zt){e.msg="invalid code lengths set",n.mode=Sr;break}n.have=0,n.mode=hd;case hd:for(;n.have<n.nlen+n.ndist;){for(;Ft=n.lencode[T&(1<<n.lenbits)-1],St=Ft>>>24,mn=Ft>>>16&255,tn=Ft&65535,!(St<=L);){if(b===0)break e;b--,T+=r[c++]<<L,L+=8}if(tn<16)T>>>=St,L-=St,n.lens[n.have++]=tn;else{if(tn===16){for(rn=St+2;L<rn;){if(b===0)break e;b--,T+=r[c++]<<L,L+=8}if(T>>>=St,L-=St,n.have===0){e.msg="invalid bit length repeat",n.mode=Sr;break}cn=n.lens[n.have-1],Pe=3+(T&3),T>>>=2,L-=2}else if(tn===17){for(rn=St+3;L<rn;){if(b===0)break e;b--,T+=r[c++]<<L,L+=8}T>>>=St,L-=St,cn=0,Pe=3+(T&7),T>>>=3,L-=3}else{for(rn=St+7;L<rn;){if(b===0)break e;b--,T+=r[c++]<<L,L+=8}T>>>=St,L-=St,cn=0,Pe=11+(T&127),T>>>=7,L-=7}if(n.have+Pe>n.nlen+n.ndist){e.msg="invalid bit length repeat",n.mode=Sr;break}for(;Pe--;)n.lens[n.have++]=cn}}if(n.mode===Sr)break;if(n.lens[256]===0){e.msg="invalid code -- missing end-of-block",n.mode=Sr;break}if(n.lenbits=9,hr={bits:n.lenbits},Zt=Yl(Yf,n.lens,0,n.nlen,n.lencode,0,n.work,hr),n.lenbits=hr.bits,Zt){e.msg="invalid literal/lengths set",n.mode=Sr;break}if(n.distbits=6,n.distcode=n.distdyn,hr={bits:n.distbits},Zt=Yl(qf,n.lens,n.nlen,n.ndist,n.distcode,0,n.work,hr),n.distbits=hr.bits,Zt){e.msg="invalid distances set",n.mode=Sr;break}if(n.mode=wc,t===Ec)break e;case wc:n.mode=Cc;case Cc:if(b>=6&&V>=258){e.next_out=g,e.avail_out=V,e.next_in=c,e.avail_in=b,n.hold=T,n.bits=L,fm(e,we),g=e.next_out,o=e.output,V=e.avail_out,c=e.next_in,r=e.input,b=e.avail_in,T=n.hold,L=n.bits,n.mode===ns&&(n.back=-1);break}for(n.back=0;Ft=n.lencode[T&(1<<n.lenbits)-1],St=Ft>>>24,mn=Ft>>>16&255,tn=Ft&65535,!(St<=L);){if(b===0)break e;b--,T+=r[c++]<<L,L+=8}if(mn&&(mn&240)===0){for(nn=St,Et=mn,Kt=tn;Ft=n.lencode[Kt+((T&(1<<nn+Et)-1)>>nn)],St=Ft>>>24,mn=Ft>>>16&255,tn=Ft&65535,!(nn+St<=L);){if(b===0)break e;b--,T+=r[c++]<<L,L+=8}T>>>=nn,L-=nn,n.back+=nn}if(T>>>=St,L-=St,n.back+=St,n.length=tn,mn===0){n.mode=_d;break}if(mn&32){n.back=-1,n.mode=ns;break}if(mn&64){e.msg="invalid literal/length code",n.mode=Sr;break}n.extra=mn&15,n.mode=gd;case gd:if(n.extra){for(rn=n.extra;L<rn;){if(b===0)break e;b--,T+=r[c++]<<L,L+=8}n.length+=T&(1<<n.extra)-1,T>>>=n.extra,L-=n.extra,n.back+=n.extra}n.was=n.length,n.mode=pd;case pd:for(;Ft=n.distcode[T&(1<<n.distbits)-1],St=Ft>>>24,mn=Ft>>>16&255,tn=Ft&65535,!(St<=L);){if(b===0)break e;b--,T+=r[c++]<<L,L+=8}if((mn&240)===0){for(nn=St,Et=mn,Kt=tn;Ft=n.distcode[Kt+((T&(1<<nn+Et)-1)>>nn)],St=Ft>>>24,mn=Ft>>>16&255,tn=Ft&65535,!(nn+St<=L);){if(b===0)break e;b--,T+=r[c++]<<L,L+=8}T>>>=nn,L-=nn,n.back+=nn}if(T>>>=St,L-=St,n.back+=St,mn&64){e.msg="invalid distance code",n.mode=Sr;break}n.offset=tn,n.extra=mn&15,n.mode=vd;case vd:if(n.extra){for(rn=n.extra;L<rn;){if(b===0)break e;b--,T+=r[c++]<<L,L+=8}n.offset+=T&(1<<n.extra)-1,T>>>=n.extra,L-=n.extra,n.back+=n.extra}if(n.offset>n.dmax){e.msg="invalid distance too far back",n.mode=Sr;break}n.mode=md;case md:if(V===0)break e;if(Pe=we-V,n.offset>Pe){if(Pe=n.offset-Pe,Pe>n.whave&&n.sane){e.msg="invalid distance too far back",n.mode=Sr;break}Pe>n.wnext?(Pe-=n.wnext,ft=n.wsize-Pe):ft=n.wnext-Pe,Pe>n.length&&(Pe=n.length),ht=n.window}else ht=o,ft=g-n.offset,Pe=n.length;Pe>V&&(Pe=V),V-=Pe,n.length-=Pe;do o[g++]=ht[ft++];while(--Pe);n.length===0&&(n.mode=Cc);break;case _d:if(V===0)break e;o[g++]=n.length,V--,n.mode=Cc;break;case Eu:if(n.wrap){for(;L<32;){if(b===0)break e;b--,T|=r[c++]<<L,L+=8}if(we-=V,e.total_out+=we,n.total+=we,we&&(e.adler=n.check=n.flags?xa(n.check,o,we,g-we):_u(n.check,o,we,g-we)),we=V,(n.flags?T:Sd(T))!==n.check){e.msg="incorrect data check",n.mode=Sr;break}T=0,L=0}n.mode=bd;case bd:if(n.wrap&&n.flags){for(;L<32;){if(b===0)break e;b--,T+=r[c++]<<L,L+=8}if(T!==(n.total&4294967295)){e.msg="incorrect length check",n.mode=Sr;break}T=0,L=0}n.mode=yd;case yd:Zt=gm;break e;case Sr:Zt=Kf;break e;case Ed:return Zf;case mm:default:return fa}return e.next_out=g,e.avail_out=V,e.next_in=c,e.avail_in=b,n.hold=T,n.bits=L,(n.wsize||we!==e.avail_out&&n.mode<Sr&&(n.mode<Eu||t!==Jf))&&Pd(e,e.output,e.next_out,we-e.avail_out),_e-=e.avail_in,we-=e.avail_out,e.total_in+=_e,e.total_out+=we,n.total+=we,n.wrap&&we&&(e.adler=n.check=n.flags?xa(n.check,o,we,e.next_out-we):_u(n.check,o,we,e.next_out-we)),e.data_type=n.bits+(n.last?64:0)+(n.mode===ns?128:0)+(n.mode===wc||n.mode===yu?256:0),(_e===0&&we===0||t===Jf)&&Zt===Js&&(Zt=vm),Zt}function Om(e){if(!e||!e.state)return fa;var t=e.state;return t.window&&(t.window=null),e.state=null,Js}function Tm(e,t){var n;return!e||!e.state||(n=e.state,(n.wrap&2)===0)?fa:(n.head=t,t.done=!1,Js)}function Pm(e,t){var n=t.length,r,o,c;return!e||!e.state||(r=e.state,r.wrap!==0&&r.mode!==Sc)?fa:r.mode===Sc&&(o=1,o=_u(o,t,n,0),o!==r.check)?Kf:(c=Pd(e,t,n,n),c?(r.mode=Ed,Zf):(r.havedict=1,Js))}ba.inflateReset=Cd,ba.inflateReset2=Ad,ba.inflateResetKeep=wd,ba.inflateInit=wm,ba.inflateInit2=Od,ba.inflate=Am,ba.inflateEnd=Om,ba.inflateGetHeader=Tm,ba.inflateSetDictionary=Pm,ba.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 Im(){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 Nm=Im,wl=ba,ql=xe,Ac=rr,Yr=Id,Cu=mt,km=ca,Rm=Nm,Nd=Object.prototype.toString;function Ks(e){if(!(this instanceof Ks))return new Ks(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 km,this.strm.avail_out=0;var n=wl.inflateInit2(this.strm,t.windowBits);if(n!==Yr.Z_OK)throw new Error(Cu[n]);if(this.header=new Rm,wl.inflateGetHeader(this.strm,this.header),t.dictionary&&(typeof t.dictionary=="string"?t.dictionary=Ac.string2buf(t.dictionary):Nd.call(t.dictionary)==="[object ArrayBuffer]"&&(t.dictionary=new Uint8Array(t.dictionary)),t.raw&&(n=wl.inflateSetDictionary(this.strm,t.dictionary),n!==Yr.Z_OK)))throw new Error(Cu[n])}Ks.prototype.push=function(e,t){var n=this.strm,r=this.options.chunkSize,o=this.options.dictionary,c,g,b,V,T,L=!1;if(this.ended)return!1;g=t===~~t?t:t===!0?Yr.Z_FINISH:Yr.Z_NO_FLUSH,typeof e=="string"?n.input=Ac.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=wl.inflate(n,Yr.Z_NO_FLUSH),c===Yr.Z_NEED_DICT&&o&&(c=wl.inflateSetDictionary(this.strm,o)),c===Yr.Z_BUF_ERROR&&L===!0&&(c=Yr.Z_OK,L=!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&&(g===Yr.Z_FINISH||g===Yr.Z_SYNC_FLUSH))&&(this.options.to==="string"?(b=Ac.utf8border(n.output,n.next_out),V=n.next_out-b,T=Ac.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&&(L=!0)}while((n.avail_in>0||n.avail_out===0)&&c!==Yr.Z_STREAM_END);return c===Yr.Z_STREAM_END&&(g=Yr.Z_FINISH),g===Yr.Z_FINISH?(c=wl.inflateEnd(this.strm),this.onEnd(c),this.ended=!0,c===Yr.Z_OK):(g===Yr.Z_SYNC_FLUSH&&(this.onEnd(Yr.Z_OK),n.avail_out=0),!0)},Ks.prototype.onData=function(e){this.chunks.push(e)},Ks.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 Au(e,t){var n=new Ks(t);if(n.push(e,!0),n.err)throw n.msg||Cu[n.err];return n.result}function xm(e,t){return t=t||{},t.raw=!0,Au(e,t)}Gl.Inflate=Ks,Gl.inflate=Au,Gl.inflateRaw=xm,Gl.ungzip=Au;var Bm=xe.assign,Mm=Nt,Dm=Gl,Lm=Id,kd={};Bm(kd,Mm,Dm,Lm);var Rd=kd;let Fm="upx2px",Vm=[{name:"upx",type:[Number,String],required:!0}],Um=1e-4,$m=750,xd=!1,Ou=0,Bd=0,Md=960,Dd=375,Ld=750;function Hm(){let{platform:e,pixelRatio:t,windowWidth:n}=Rr();Ou=n,Bd=t,xd=e==="ios"}function Tu(e,t){let n=Number(e);return isNaN(n)?t:n}function jm(){let e=R.globalStyle||{};Md=Tu(e.rpxCalcMaxDeviceWidth,960),Dd=Tu(e.rpxCalcBaseDeviceWidth,375),Ld=Tu(e.rpxCalcBaseDeviceWidth,750)}let zm=Dt(Fm,(e,t)=>{if(Ou===0&&(Hm(),jm()),e=Number(e),e===0)return 0;let n=t||Ou;n=e===Ld||n<=Md?n:Dd;let r=e/$m*n;return r<0&&(r=-r),r=Math.floor(r+Um),r===0&&(Bd===1||!xd?r=1:r=.5),e<0?-r:r},Vm),Wm="addInterceptor",Gm="removeInterceptor",Fd=[{name:"method",type:[String,Object],required:!0}],Ym=Fd;function Vd(e,t){Object.keys(t).forEach(n=>{z.isFunction(t[n])&&(e[n]=qm(e[n],t[n]))})}function Ud(e,t){!e||!t||Object.keys(t).forEach(n=>{let r=e[n],o=t[n];z.isArray(r)&&z.isFunction(o)&&z.remove(r,o)})}function qm(e,t){let n=t?e?e.concat(t):z.isArray(t)?t:[t]:e;return n&&Jm(n)}function Jm(e){let t=[];for(let n=0;n<e.length;n++)t.indexOf(e[n])===-1&&t.push(e[n]);return t}let Km=Dt(Wm,(e,t)=>{z.isString(e)&&z.isPlainObject(t)?Vd(Cr[e]||(Cr[e]={}),t):z.isPlainObject(e)&&Vd(kn,e)},Fd),Zm=Dt(Gm,(e,t)=>{z.isString(e)?z.isPlainObject(t)?Ud(Cr[e],t):delete Cr[e]:z.isPlainObject(e)&&Ud(kn,e)},Ym),Xm={},Qm="$on",$d=[{name:"event",type:String,required:!0},{name:"callback",type:Function,required:!0}],e_="$once",t_=$d,n_="$off",r_=[{name:"event",type:[String,Array]},{name:"callback",type:Function}],i_="$emit",o_=[{name:"event",type:String,required:!0}],Zs=new J.Emitter,a_=Dt(Qm,(e,t)=>(Zs.on(e,t),()=>Zs.off(e,t)),$d),s_=Dt(e_,(e,t)=>(Zs.once(e,t),()=>Zs.off(e,t)),t_),l_=Dt(n_,(e,t)=>{if(!e){Zs.e={};return}z.isArray(e)||(e=[e]),e.forEach(n=>Zs.off(n,t))},r_),c_=Dt(i_,(e,...t)=>{Zs.emit(e,...t)},o_),Hd=[{name:"id",type:String,required:!0}],u_="createVideoContext",f_="createMapContext",d_=Hd,h_="createCanvasContext",g_=[{name:"canvasId",type:String,required:!0},{name:"componentInstance",type:Object}],p_="createInnerAudioContext",v_="createLivePusherContext",m_=Hd.concat({name:"componentInstance",type:Object}),__=[.5,.8,1,1.25,1.5,2];class Pu{constructor(t,n){this.id=t,this.pageId=n}play(){on(this.id,this.pageId,"play")}pause(){on(this.id,this.pageId,"pause")}stop(){on(this.id,this.pageId,"stop")}seek(t){on(this.id,this.pageId,"seek",{position:t})}sendDanmu(t){on(this.id,this.pageId,"sendDanmu",t)}playbackRate(t){~__.indexOf(t)||(t=1),on(this.id,this.pageId,"playbackRate",{rate:t})}requestFullScreen(t={}){on(this.id,this.pageId,"requestFullScreen",t)}exitFullScreen(){on(this.id,this.pageId,"exitFullScreen")}showStatusBar(){on(this.id,this.pageId,"showStatusBar")}hideStatusBar(){on(this.id,this.pageId,"hideStatusBar")}}let b_=Dt(u_,(e,t)=>t?new Pu(e,Fn(t)):new Pu(e,Fn(br()))),y_=(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)},Ti=(e,t,n,r)=>{jn(e,t,n,r,o=>{r&&y_(r,o)})};class Iu{constructor(t,n){this.id=t,this.pageId=n}getCenterLocation(t){Ti(this.id,this.pageId,"getCenterLocation",t)}moveToLocation(t){Ti(this.id,this.pageId,"moveToLocation",t)}getScale(t){Ti(this.id,this.pageId,"getScale",t)}getRegion(t){Ti(this.id,this.pageId,"getRegion",t)}includePoints(t){Ti(this.id,this.pageId,"includePoints",t)}translateMarker(t){Ti(this.id,this.pageId,"translateMarker",t)}$getAppMap(){return s.maps.getMapById(this.pageId+"-map-"+this.id)}addCustomLayer(t){Ti(this.id,this.pageId,"addCustomLayer",t)}removeCustomLayer(t){Ti(this.id,this.pageId,"removeCustomLayer",t)}addGroundOverlay(t){Ti(this.id,this.pageId,"addGroundOverlay",t)}removeGroundOverlay(t){Ti(this.id,this.pageId,"removeGroundOverlay",t)}updateGroundOverlay(t){Ti(this.id,this.pageId,"updateGroundOverlay",t)}initMarkerCluster(t){Ti(this.id,this.pageId,"initMarkerCluster",t)}addMarkers(t){Ti(this.id,this.pageId,"addMarkers",t)}removeMarkers(t){Ti(this.id,this.pageId,"removeMarkers",t)}moveAlong(t){Ti(this.id,this.pageId,"moveAlong",t)}setLocMarkerIcon(t){Ti(this.id,this.pageId,"setLocMarkerIcon",t)}openMapApp(t){Ti(this.id,this.pageId,"openMapApp",t)}on(t,n){Ti(this.id,this.pageId,"on",{name:t,callback:n})}}let E_=Dt(f_,(e,t)=>t?new Iu(e,Fn(t)):new Iu(e,Fn(br())),d_);function As(e,t){return function(n,r){n?r[e]=Math.round(n):typeof t!="undefined"&&(r[e]=t)}}let jd=As("width"),zd=As("height"),S_="canvasGetImageData",Wd={formatArgs:{x:As("x"),y:As("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}},w_="canvasPutImageData",C_=Wd,A_=z.extend({data:{type:Uint8ClampedArray,required:!0}},Gd,{height:{type:Number}}),Yd={PNG:"png",JPG:"jpg",JPEG:"jpg"},O_="canvasToTempFilePath",T_={formatArgs:{x:As("x",0),y:As("y",0),width:jd,height:zd,destWidth:As("destWidth"),destHeight:As("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}}},P_={x:Number,y:Number,width:Number,height:Number,destWidth:Number,destHeight:Number,canvasId:{type:String,required:!0},fileType:String,quality:Number};function Oc(e,t,n,r,o){ot.invokeViewMethod(`canvas.${e}`,{type:n,data:r},t,c=>{o&&o(c)})}var I_=["scale","rotate","translate","setTransform","transform"],N_=["drawImage","fillText","fill","stroke","fillRect","strokeRect","clearRect","strokeText"],k_=["setFillStyle","setTextAlign","setStrokeStyle","setGlobalAlpha","setShadow","setFontSize","setLineCap","setLineJoin","setLineWidth","setMiterLimit","setTextBaseline","setLineDash"];function R_(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 Nu(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(z.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),g=parseInt(t[1].slice(6,8),16);return g=g>=0?g:255,[r,o,c,g]}return console.error("unsupported color:"+e),[0,0,0,255]}class Jd{constructor(t,n){this.type=t,this.data=n,this.colorStop=[]}addColorStop(t,n){this.colorStop.push([t,Nu(n)])}}class x_{constructor(t,n){this.type="pattern",this.data=t,this.colorStop=n}}class B_{constructor(t){this.width=t}}class Jl{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=[],Oc(this.id,this.pageId,"actionsChanged",{actions:r,reserve:t},n)}createLinearGradient(t,n,r,o){return new Jd("linear",[t,n,r,o])}createCircularGradient(t,n,r){return new Jd("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 x_(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(`(${R_.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,g){this.path.push({method:"bezierCurveTo",data:[t,n,r,o,c,g]}),this.subpath.push([c,g])}arc(t,n,r,o,c,g=!1){this.path.push({method:"arc",data:[t,n,r,o,c,g]}),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]),g=r[7],b=[];o.forEach(function(T,L){["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):L===0?(b.push({method:"setFontStyle",data:["normal"]}),n.state.fontStyle="normal"):L===1&&V()}),o.length===1&&V(),o=b.map(function(T){return T.data[0]}).join(" "),this.state.fontSize=c,this.state.fontFamily=g,this.actions.push({method:"setFont",data:[`${o} ${c}px ${g}`]})}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 M_=J.once(()=>{[...I_,...N_].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,g){this.actions.push({method:"fillPath",data:[{method:"rect",data:[r,o,c,g]}]})};case"strokeRect":return function(r,o,c,g){this.actions.push({method:"strokePath",data:[{method:"rect",data:[r,o,c,g]}]})};case"fillText":case"strokeText":return function(r,o,c,g){var b=[r.toString(),o,c];typeof g=="number"&&b.push(g),this.actions.push({method:n,data:b})};case"drawImage":return function(r,o,c,g,b,V,T,L,_e){_e===void 0&&(V=o,T=c,L=g,_e=b,o=void 0,c=void 0,g=void 0,b=void 0);var we;function Pe(ft){return typeof ft=="number"}we=Pe(o)&&Pe(c)&&Pe(g)&&Pe(b)?[r,V,T,L,_e,o,c,g,b]:Pe(L)&&Pe(_e)?[r,V,T,L,_e]:[r,V,T],this.actions.push({method:n,data:we})};default:return function(...r){this.actions.push({method:n,data:r})}}}Jl.prototype[e]=t(e)}),k_.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",Nu(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,g){g=Nu(g),this.actions.push({method:n,data:[r,o,c,g]}),this.state.shadowBlur=c,this.state.shadowColor=g,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})}}}Jl.prototype[e]=t(e)})}),D_=Dt(h_,(e,t)=>{if(M_(),t)return new Jl(e,Fn(t));let n=Fn(br());if(n)return new Jl(e,n);ot.emit(J.ON_ERROR,"createCanvasContext:fail")},g_),L_=Te(S_,({canvasId:e,x:t,y:n,width:r,height:o},{resolve:c,reject:g})=>{let b=Fn(br());if(!b){g();return}function V(T){if(T.errMsg&&T.errMsg.indexOf("fail")!==-1){g("",T);return}let L=T.data;L&&L.length&&(T.compressed&&(L=Rd.inflateRaw(L)),T.data=new Uint8ClampedArray(L)),delete T.compressed,c(T)}Oc(e,b,"getImageData",{x:t,y:n,width:r,height:o},V)},Gd,Wd),F_=Te(w_,({canvasId:e,data:t,x:n,y:r,width:o,height:c},{resolve:g,reject:b})=>{var V=Fn(br());if(!V){b();return}let T,L=()=>{Oc(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}g(_e)})};s.os.name!=="iOS"||typeof __WEEX_DEVTOOL__=="boolean"?(t=Rd.deflateRaw(t,{to:"string"}),T=!0):t=Array.prototype.slice.call(t),L()},A_,C_),V_=Te(O_,({x:e=0,y:t=0,width:n,height:r,destWidth:o,destHeight:c,canvasId:g,fileType:b,quality:V},{resolve:T,reject:L})=>{var _e=Fn(br());if(!_e){L();return}let we=`${Wr}/canvas`;Oc(g,_e,"toTempFilePath",{x:e,y:t,width:n,height:r,destWidth:o,destHeight:c,fileType:b,quality:V,dirname:we},Pe=>{if(Pe.errMsg&&Pe.errMsg.indexOf("fail")!==-1){L("",Pe);return}T(Pe)})},P_,T_),Kd=["onCanplay","onPlay","onPause","onStop","onEnded","onTimeUpdate","onError","onWaiting","onSeeking","onSeeked"],U_=["offCanplay","offPlay","offPause","offStop","offEnded","offTimeUpdate","offError","offWaiting","offSeeking","offSeeked"],$_={thresholds:[0],initialRatio:0,observeAll:!1},H_=["top","right","bottom","left"],j_=1;function Zd(e={}){return H_.map(t=>`${Number(e[t])||0}px`).join(" ")}class Xd{constructor(t,n){this._pageId=Fn(t),this._component=t,this._options=z.extend({},$_,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){!z.isFunction(n)||(this._options.selector=t,this._reqId=j_++,Ai({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 z_=Dt("createIntersectionObserver",(e,t)=>(e=J.resolveComponentInstance(e),e&&!Fn(e)&&(t=e,e=null),e?new Xd(e,t):new Xd(br(),t))),W_=1;class Qd{constructor(t){this._pageId=t.$page&&t.$page.id,this._component=t}observe(t,n){!z.isFunction(n)||(this._reqId=W_++,Ia({reqId:this._reqId,component:this._component,options:t,callback:n},this._pageId))}disconnect(){this._reqId&&ra({reqId:this._reqId,component:this._component},this._pageId)}}let G_=Dt("createMediaQueryObserver",e=>(e=J.resolveComponentInstance(e),e&&!Fn(e)&&(e=null),e?new Qd(e):new Qd(br()))),Y_=0,ku={};function q_(e,t,n,r){let o={options:r},c=r&&("success"in r||"fail"in r||"complete"in r);if(c){let g=String(Y_++);o.callbackId=g,ku[g]=r}ot.invokeViewMethod(`editor.${e}`,{type:n,data:o},t,({callbackId:g,data:b})=>{c&&(J.callOptions(ku[g],b),delete ku[g])})}class J_{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){q_(this.id,this.pageId,t,n)}}let K_={canvas:Jl,map:Iu,video:Pu,editor:J_};function eh(e){if(e&&e.contextInfo){let{id:t,type:n,page:r}=e.contextInfo,o=K_[n];e.context=new o(t,r),delete e.contextInfo}}class Ru{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 Z_{constructor(t){this._component=void 0,this._page=t,this._queue=[],this._queueCb=[]}exec(t){return ai(this._page,this._queue,n=>{let r=this._queueCb;n.forEach((o,c)=>{z.isArray(o)?o.forEach(eh):eh(o);let g=r[c];z.isFunction(g)&&g.call(this,o)}),z.isFunction(t)&&t.call(this,n)}),this._nodesRef}in(t){return this._component=J.resolveComponentInstance(t),this}select(t){return this._nodesRef=new Ru(this,this._component,t,!0)}selectAll(t){return this._nodesRef=new Ru(this,this._component,t,!1)}selectViewport(){return this._nodesRef=new Ru(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 X_=Dt("createSelectorQuery",e=>(e=J.resolveComponentInstance(e),e&&!Fn(e)&&(e=null),new Z_(e||br()))),Q_="createAnimation",eb={formatArgs:{}},tb={duration:Number,timingFunction:String,delay:Number,transformOrigin:String},nb={duration:400,timingFunction:"linear",delay:0,transformOrigin:"50% 50% 0"};class th{constructor(t){this.actions=[],this.currentTransform={},this.currentStepAnimates=[],this.option=z.extend({},nb,t)}_getOption(t){let n={transition:z.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 rb=J.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}})}),ib=Dt(Q_,e=>(rb(),new th(e)),tb,eb),nh="onTabBarMidButtonTap",ob=pn(nh,()=>{}),ab="onWindowResize",sb="offWindowResize",lb=pn(ab,()=>{}),cb=Xr(sb,()=>{}),rh="setLocale",ub="getLocale",ih="onLocaleChange",Kl=Dt(ub,()=>{let e=wt({allowDefault:!0});return e&&e.$vm?e.$vm.$locale:ae().getLocale()}),fb=pn(ih,()=>{}),db=Dt(rh,e=>{let t=wt();return t&&t.$vm.$locale!==e?(t.$vm.$locale=e,In().forEach(o=>{ot.publishHandler(rh,e,o.$page.id)}),f.requireModule("plus").setLanguage(e),ot.invokeOnCallback(ih,{locale:e}),!0):!1}),hb=Te("setPageMeta",(e,{resolve:t})=>{t(to(br(),e))}),oh="getSelectedTextRange",gb=Te(oh,(e,{resolve:t,reject:n})=>{ot.invokeViewMethod(oh,{},ha(),r=>{typeof r.end=="undefined"&&typeof r.start=="undefined"?n("no focused"):t(r)})}),Tc={[J.ON_UNHANDLE_REJECTION]:[],[J.ON_PAGE_NOT_FOUND]:[],[J.ON_ERROR]:[],[J.ON_SHOW]:[],[J.ON_HIDE]:[]};function Zl(e,t){let n=wt({allowDefault:!0});if(n&&n.$vm)return hn.injectHook(e,t,n.$vm.$);Tc[e].push(t)}function pb(e){Object.keys(Tc).forEach(t=>{Tc[t].forEach(n=>{hn.injectHook(t,n,e)})})}function Xl(e,t){let n=wt({allowDefault:!0});if(n&&n.$vm)return Pa(n.$vm,e,t);z.remove(Tc[e],t)}function vb(e){Zl(J.ON_UNHANDLE_REJECTION,e)}function mb(e){Xl(J.ON_UNHANDLE_REJECTION,e)}function _b(e){Zl(J.ON_PAGE_NOT_FOUND,e)}function bb(e){Xl(J.ON_PAGE_NOT_FOUND,e)}function yb(e){Zl(J.ON_ERROR,e)}function Eb(e){Xl(J.ON_ERROR,e)}function Sb(e){Zl(J.ON_SHOW,e)}function wb(e){Xl(J.ON_SHOW,e)}function Cb(e){Zl(J.ON_HIDE,e)}function Ab(e){Xl(J.ON_HIDE,e)}let Ob=Dt("getEnterOptionsSync",()=>Vo()),Tb=Dt("getLaunchOptionsSync",()=>ds()),Ql,xu,Bu,ah;function sh(e){try{return JSON.parse(e)}catch(t){}return e}function Mu(e){if(e.type==="enabled")Bu=!0,ah=e.offline;else if(e.type==="clientId")Ql=e.cid,xu=e.errMsg,lh(Ql,e.errMsg);else if(e.type==="pushMsg"){let t={type:"receive",data:sh(e.message)};for(let n=0;n<Os.length&&(Os[n](t),!t.stopped);n++);}else e.type==="click"&&Os.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 Pb=Te("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 Bu=="undefined"&&(Bu=!1,Ql="",xu="uniPush is not enabled"),Du.push((r,o)=>{r?t({cid:r}):n(o)}),typeof Ql!="undefined"&&lh(Ql,xu)})}),Os=[],ch=!1,Ib=e=>{Os.indexOf(e)===-1&&Os.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})}))},Nb=e=>{if(!e)Os.length=0;else{let t=Os.indexOf(e);t>-1&&Os.splice(t,1)}},kb="canIUse",Rb=[{name:"schema",type:String,required:!0}],xb="getBackgroundAudioManager",Bb="makePhoneCall",Mb={phoneNumber:String},Db="addPhoneContact",Lb={formatArgs:{firstName(e){if(!e)return"addPhoneContact:fail parameter error: parameter.firstName should not be empty;"}}},Fb={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},Vb="getClipboardData",Ub="setClipboardData",$b={formatArgs:{showToast:!0},beforeInvoke(){st()},beforeSuccess(e,t){if(!t.showToast)return;let{t:n}=ae(),r=n("uni.setClipboardData.success");r&&P.showToast({title:r,icon:"success",mask:!1})}},Hb={data:{type:String,required:!0},showToast:{type:Boolean}},uh="onAccelerometer",jb="offAccelerometer",zb="startAccelerometer",Wb="stopAccelerometer",fh="onCompass",Gb="offCompass",Yb="startCompass",qb="stopCompass",Jb="vibrateShort",Kb="vibrateLong",dh="onBluetoothDeviceFound",hh="onBluetoothAdapterStateChange",gh="onBLEConnectionStateChange",ph="onBLECharacteristicValueChange",Zb="startBluetoothDevicesDiscovery",Xb={services:Array,allowDuplicatesKey:Boolean,interval:Number},Qb="getConnectedBluetoothDevices",e0={services:{type:Array,required:!0}},t0="createBLEConnection",n0={deviceId:{type:String,required:!0}},r0="closeBLEConnection",i0={deviceId:{type:String,required:!0}},o0="getBLEDeviceServices",a0={deviceId:{type:String,required:!0}},s0="getBLEDeviceCharacteristics",l0={deviceId:{type:String,required:!0},serviceId:{type:String,required:!0}},c0="notifyBLECharacteristicValueChange",u0={deviceId:{type:String,required:!0},serviceId:{type:String,required:!0},characteristicId:{type:String,required:!0},state:{type:Boolean,required:!0}},f0="readBLECharacteristicValue",d0={deviceId:{type:String,required:!0},serviceId:{type:String,required:!0},characteristicId:{type:String,required:!0}},h0="writeBLECharacteristicValue",g0={deviceId:{type:String,required:!0},serviceId:{type:String,required:!0},characteristicId:{type:String,required:!0},value:{type:Array,required:!0}},p0="setBLEMTU",v0={deviceId:{type:String,required:!0},mtu:{type:Number,required:!0}},m0="getBLEDeviceRSSI",_0={deviceId:{type:String,required:!0}},vh="onBeaconUpdate",mh="onBeaconServiceChange",b0="getBeacons",y0="startBeaconDiscovery",E0={uuids:{type:Array,required:!0}},S0="stopBeaconDiscovery",w0="getScreenBrightness",C0="setScreenBrightness",A0="setKeepScreenOn",O0="checkIsSupportSoterAuthentication",T0="checkIsSoterEnrolledInDevice",P0=["fingerPrint","facial","speech"],I0={formatArgs:{checkAuthMode(e,t){if(!e||!P0.includes(e))return"checkAuthMode \u586B\u5199\u9519\u8BEF"}}},N0={checkAuthMode:String},k0="startSoterAuthentication",R0={formatArgs:{requestAuthModes(e,t){if(!e.includes("fingerPrint")&&!e.includes("facial"))return"requestAuthModes \u586B\u5199\u9519\u8BEF"}}},x0={requestAuthModes:{type:Array,required:!0},challenge:String,authContent:String},B0="scanCode",M0={onlyFromCamera:Boolean,scanType:Array,autoDecodeCharSet:Boolean,sound:String,autoZoom:Boolean},D0=["default","none"],L0={formatArgs:{sound(e,t){D0.includes(e)||(t.sound="none")},autoZoom(e,t){typeof e=="undefined"&&(t.autoZoom=!0)}}},F0="getSystemSetting",V0="getAppAuthorizeSetting",U0="openAppAuthorizeSetting",$0="getStorage",_h={key:{type:String,required:!0}},H0="getStorageSync",bh=[{name:"key",type:String,required:!0}],j0="setStorage",z0={key:{type:String,required:!0},data:{required:!0}},W0="setStorageSync",G0=[{name:"key",type:String,required:!0},{name:"data",required:!0}],yh="removeStorage",Y0=_h,q0=bh,J0="saveFile",K0={formatArgs:{tempFilePath(e,t){t.tempFilePath=je(e)}}},Z0={tempFilePath:{type:String,required:!0}},X0="getSavedFileList",Q0="removeSavedFile",ey={formatArgs:{filePath(e,t){t.filePath=je(e)}}},ty={filePath:{type:String,required:!0}},ny="getFileInfo",ry={formatArgs:{filePath(e,t){t.filePath=je(e)}}},iy={filePath:{type:String,required:!0}},oy="getSavedFileInfo",ay={formatArgs:{filePath(e,t){t.filePath=je(e)}}},sy={filePath:{type:String,required:!0}},ly="openDocument",cy={formatArgs:{filePath(e,t){t.filePath=je(e)}}},uy={filePath:{type:String,required:!0},fileType:String},fy="hideKeyboard",dy="showKeyboard",hy="chooseLocation",gy={keyword:String,latitude:Number,longitude:Number},py="getLocation",Eh=["wgs84","gcj02"],vy={formatArgs:{type(e,t){e=(e||"").toLowerCase(),Eh.indexOf(e)===-1?t.type=Eh[0]:t.type=e},altitude(e,t){t.altitude=e||!1}}},my={type:String,altitude:Boolean},_y="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)}.`}},by={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}}},yy={latitude:Number,longitude:Number,scale:Number,name:String,address:String},Ey="chooseImage",Sy={formatArgs:{count(e,t){(!e||e<=0)&&(t.count=9)},sizeType(e,t){t.sizeType=pr(e,pi)},sourceType(e,t){t.sourceType=pr(e,qr)},extension(e,t){if(e instanceof Array&&e.length===0)return"param extension should not be empty.";e||(t.extension=["*"])}}},wy={count:Number,sizeType:[Array,String],sourceType:Array,extension:Array},Cy="chooseVideo",Ay={formatArgs:{sourceType(e,t){t.sourceType=pr(e,qr)},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=["*"])}}},Oy={sourceType:Array,compressed:Boolean,maxDuration:Number,camera:String,extension:Array},Ty="getImageInfo",Py={formatArgs:{src(e,t){t.src=je(e)}}},Iy={src:{type:String,required:!0}},Ny="previewImage",ky={formatArgs:{urls(e,t){t.urls=e.map(n=>z.isString(n)&&n?je(n):"")},current(e,t){typeof e=="number"?t.current=e>0&&e<t.urls.length?e:0:z.isString(e)&&e&&(t.current=je(e))}}},Ry={urls:{type:Array,required:!0},current:{type:[Number,String]}},xy="closePreviewImage",By="getVideoInfo",My={formatArgs:{src(e,t){t.src=je(e)}}},Dy={src:{type:String,required:!0}},Ly="saveImageToPhotosAlbum",Fy={formatArgs:{filePath(e,t){t.filePath=je(e)}}},Vy={filePath:{type:String,required:!0}},Uy="saveVideoToPhotosAlbum",$y={formatArgs:{filePath(e,t){t.filePath=je(e)}}},Hy={filePath:{type:String,required:!0}},jy="getRecorderManager",zy="compressImage",Wy={formatArgs:{src(e,t){t.src=je(e)}}},Gy={src:{type:String,required:!0}},Yy="compressVideo",qy={formatArgs:{src(e,t){t.src=je(e)}}},Jy={src:{type:String,required:!0},quality:String,bitrate:Number,fps:Number,resolution:Number},Ky="request",Zy={JSON:"json"},Xy=["text","arraybuffer"],Qy="text",wh=encodeURIComponent;function eE(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),g={};c.forEach(b=>{let V=b.split("=");g[V[0]]=V[1]});for(let b in t)if(z.hasOwn(t,b)){let V=t[b];typeof V=="undefined"||V===null?V="":z.isPlainObject(V)&&(V=JSON.stringify(V)),g[wh(b)]=wh(V)}return o=Object.keys(g).map(b=>`${b}=${g[b]}`).join("&"),e+(o?"?"+o:"")+(r?"#"+r:"")}let tE={method:String,data:[Object,String,Array,ArrayBuffer],url:{type:String,required:!0},header:Object,dataType:String,responseType:String,withCredentials:Boolean},nE={formatArgs:{method(e,t){t.method=Sn((e||"").toUpperCase(),gr)},data(e,t){t.data=e||""},url(e,t){t.method===gr[0]&&z.isPlainObject(t.data)&&Object.keys(t.data).length&&(t.url=eE(e,t.data))},header(e,t){let n=t.header=e||{};t.method!==gr[0]&&(Object.keys(n).find(r=>r.toLowerCase()==="content-type")||(n["Content-Type"]="application/json"))},dataType(e,t){t.dataType=(e||Zy.JSON).toLowerCase()},responseType(e,t){t.responseType=(e||"").toLowerCase(),Xy.indexOf(t.responseType)===-1&&(t.responseType=Qy)}}},rE="configMTLS",iE={certificates:{type:Array,required:!0}},oE={formatArgs:{certificates(e){if(e.some(t=>z.toRawType(t.host)!=="String"))return"\u53C2\u6570\u914D\u7F6E\u9519\u8BEF\uFF0C\u8BF7\u786E\u8BA4\u540E\u91CD\u8BD5"}}},aE="downloadFile",sE={formatArgs:{header(e,t){t.header=e||{}}}},lE={url:{type:String,required:!0},header:Object,timeout:Number},cE="uploadFile",uE={formatArgs:{filePath(e,t){e&&(t.filePath=je(e))},header(e,t){t.header=e||{}},formData(e,t){t.formData=e||{}}}},fE={url:{type:String,required:!0},files:Array,filePath:String,name:String,header:Object,formData:Object,timeout:Number},dE="connectSocket",hE={formatArgs:{header(e,t){t.header=e||{}},method(e,t){t.method=Sn((e||"").toUpperCase(),gr)},protocols(e,t){z.isString(e)&&(t.protocols=[e])}}},gE={url:{type:String,required:!0},header:{type:Object},method:String,protocols:[Array,String]},pE="sendSocketMessage",vE={data:[String,ArrayBuffer]},mE="closeSocket",_E={code:Number,reason:String},bE="startLocationUpdate",Ch="onLocationChange",yE="stopLocationUpdate",EE="offLocationChange",SE="offLocationChangeError",Ah="onLocationChangeError",Oh=["wgs84","gcj02"],wE={type:String},CE={formatArgs:{type(e,t){e=(e||"").toLowerCase(),Oh.indexOf(e)===-1?t.type=Oh[1]:t.type=e}}};function AE(e){if(!z.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("="),g=c.shift(),b=c.length>0?c.join("="):"";r.push(g+"="+encodeURIComponent(b))}),r.length?e+"?"+r.join("&"):e}let OE=["slide-in-right","slide-in-left","slide-in-top","slide-in-bottom","fade-in","zoom-out","zoom-fade-out","pop-in","none"],TE=["slide-out-right","slide-out-left","slide-out-top","slide-out-bottom","fade-out","zoom-in","zoom-fade-in","pop-out","none"],Cl={url:{type:String,required:!0}},Lu="navigateTo",Fu="redirectTo",Th="reLaunch",Pc="switchTab",PE="navigateBack",Vu="preloadPage",Ph="unPreloadPage",IE=z.extend({},Cl,Ih(OE)),NE=z.extend({delta:{type:Number}},Ih(TE)),kE=Cl,RE=Cl,xE=Cl,BE=Cl,ME=Cl,DE=Nc(Lu),LE=Nc(Fu),FE=Nc(Th),VE=Nc(Pc),UE={formatArgs:{delta(e,t){e=parseInt(e+"")||1,t.delta=Math.min(In().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 Ic;function $E(){Ic=""}function Nc(e){return{formatArgs:{url:HE(e)},beforeAll:$E}}function HE(e){return function(n,r){if(!n)return'Missing required args: "url"';n=Mo(n);let o=n.split("?")[0],c=Wi(o,!0);if(!c)return"page `"+n+"` is not found";if(e===Lu||e===Fu){if(c.meta.isTabBar)return`can not ${e} a tabbar page`}else if(e===Pc&&!c.meta.isTabBar)return"can not switch to no-tabBar page";if((e===Pc||e===Vu)&&c.meta.isTabBar&&r.openType!=="appLaunch"&&(n=o),c.meta.isEntry&&(n=n.replace(c.alias,"/")),r.url=AE(n),e!==Ph){if(e===Vu){if(!c.meta.isNVue)return"can not preload vue page";if(c.meta.isTabBar){let g=In(),b=c.path.slice(1);if(g.find(V=>V.route===b))return"tabBar page `"+b+"` already exists"}return}if(Ic===n&&r.openType!=="appLaunch")return`${Ic} locked`;R.ready&&(Ic=n)}}}let jE="hideLoading",zE="hideToast",Nh="loadFontFace",WE={family:{type:String,required:!0},source:{type:String,required:!0},desc:Object},GE=["#ffffff","#000000"],YE="setNavigationBarColor",qE={formatArgs:{animation(e,t){e||(e={duration:0,timingFunc:"linear"}),t.animation={duration:e.duration||0,timingFunc:e.timingFunc||"linear"}}}},JE={frontColor:{type:String,required:!0,validator(e){if(GE.indexOf(e)===-1)return`invalid frontColor "${e}"`}},backgroundColor:{type:String,required:!0},animation:Object},KE="setNavigationBarTitle",ZE={title:{type:String,required:!0}},XE="showNavigationBarLoading",QE="hideNavigationBarLoading",kh="pageScrollTo",eS={scrollTop:Number,selector:String,duration:Number},tS={formatArgs:{duration:300}},nS="showActionSheet",rS={itemList:{type:Array,required:!0},title:String,itemColor:String,popover:Object},iS={formatArgs:{itemColor:"#000"}},oS="showLoading",aS={title:String,mask:Boolean},sS={formatArgs:{title:"",mask:!1}},lS="showModal",cS={title:String,content:String,showCancel:Boolean,cancelText:String,cancelColor:String,confirmText:String,confirmColor:String},uS={beforeInvoke(){X()},formatArgs:{title:"",content:"",placeholderText:"",showCancel:!0,editable:!1,cancelText(e,t){if(!z.hasOwn(t,"cancelText")){let{t:n}=ae();t.cancelText=n("uni.showModal.cancel")}},cancelColor:"#000",confirmText(e,t){if(!z.hasOwn(t,"confirmText")){let{t:n}=ae();t.confirmText=n("uni.showModal.confirm")}},confirmColor:J.PRIMARY_COLOR}},fS="showToast",dS=["success","loading","none","error"],hS={title:String,icon:String,image:String,duration:Number,mask:Boolean},gS={formatArgs:{title:"",icon(e,t){t.icon=Sn(e,dS)},image(e,t){e?t.image=je(e):t.image=""},duration:1500,mask:!1}},pS="startPullDownRefresh",vS="stopPullDownRefresh",ec={index:{type:Number,required:!0}},Ts={beforeInvoke(){let e=is();if(e&&!e.isTabBar)return"not TabBar page"},formatArgs:{index(e){if(!R.tabBar.list[e])return"tabbar item not found"}}},mS="setTabBarItem",_S=z.extend({text:String,iconPath:String,selectedIconPath:String,pagePath:String},ec),bS={beforeInvoke:Ts.beforeInvoke,formatArgs:z.extend({pagePath(e,t){e&&(t.pagePath=J.removeLeadingSlash(e))}},Ts.formatArgs)},yS="setTabBarStyle",ES={color:String,selectedColor:String,backgroundColor:String,backgroundImage:String,backgroundRepeat:String,borderStyle:String},SS=/^(linear|radial)-gradient\(.+?\);?$/,wS={beforeInvoke:Ts.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},AS="showTabBar",OS=Rh,TS="hideTabBarRedDot",PS=ec,IS=Ts,NS="showTabBarRedDot",kS=ec,RS=Ts,xS="removeTabBarBadge",BS=ec,MS=Ts,DS="setTabBarBadge",LS=z.extend({text:{type:String,required:!0}},ec),FS={beforeInvoke:Ts.beforeInvoke,formatArgs:z.extend({text(e,t){J.getLen(e)>=4&&(t.text="...")}},Ts.formatArgs)},VS="getProvider",US={service:{type:String,required:!0}},$S="login",HS={provider:String,scopes:[String,Array],timeout:Number,univerifyStyle:Object,onlyAuthorize:Boolean},jS="getUserInfo",zS={provider:String,withCredentials:Boolean,timeout:Number,lang:String},WS="ggetUserProfilegetUserProfile",GS={provider:String,withCredentials:Boolean,timeout:Number,lang:String},YS="preLogin",qS={UNIVERIFY:"univerify"},JS={formatArgs:{provider(e,t){if(Object.values(qS).indexOf(String(e))<0)return"provider error"}}},KS={provider:{type:String,required:!0}},ZS="closeAuthView",XS="getCheckBoxState",QS="getUniverifyManager",ew="share",xh=["WXSceneSession","WXSceneTimeline","WXSceneFavorite"],tw={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"}}},nw={provider:{type:String,required:!0},type:Number,title:String,scene:String,summary:String,href:String,imageUrl:String,mediaUrl:String,miniProgram:Object},rw="shareWithSystem",Bh=["text","image"],iw={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=Sn(e,Bh)}}},ow={type:String,summary:String,href:String,imageUrl:String},aw="requestPayment",sw={provider:{type:String,required:!0},orderInfo:{type:[String,Object],required:!0},timeStamp:String,nonceStr:String,package:String,signType:String,paySign:String},lw="createPushMessage",cw={formatArgs:{content(e){if(!e)return"content is required"}}},uw="createRewardedVideoAd",fw={formatArgs:{adpid:"",adUnitId:""}},dw={adpid:String,adUnitId:String},hw="createFullScreenVideoAd",gw={formatArgs:{adpid:""}},pw={adpid:String},vw="createInterstitialAd",mw={formatArgs:{adpid:"",adUnitId:""}},_w={adpid:String,adUnitId:String},bw="createInteractiveAd",yw={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)}}},Ew={adpid:{type:String,required:!0},provider:{type:String,required:!0}};function Xs(e,t){return function(r){delete r.code,delete r.message,z.isFunction(t)&&(r=t(r)),e(r)}}function dr(e,t){return function(r){r=r||{},t=r.message||t||"",delete r.message,e(t,z.extend({code:0},r))}}function Al(e,t){return function(){e()(function(r){r&&(delete r.code,delete r.message),ot.invokeOnCallback(t,r)})}}function fi(e,t,n){return function(r,{resolve:o,reject:c}){e()(z.extend({},z.isFunction(t)?t(r):r,{success:Xs(o,n),fail:dr(c)}))}}function tc(e=""){if(!(R.tabBar&&z.isArray(R.tabBar.list)))return!1;try{if(!e){let n=In();if(!n.length)return!1;let r=n[n.length-1];return r?r.$page.meta.isTabBar:!1}/^\//.test(e)||(e=J.addLeadingSlash(e));let t=Wi(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=z.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 ww=Dt(W0,(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){}},G0),Cw=Te(j0,({key:e,data:t},{resolve:n,reject:r})=>{let o=typeof t,c=o==="string"?t:JSON.stringify({type:o,data:t});try{let g=s.storage;o==="string"&&Uu(c)!==void 0?g.setItemAsync(e+ya,o,()=>{}):g.removeItemAsync(e+ya,()=>{}),g.setItemAsync(e,c,n,dr(r))}catch(g){r(g.message)}},z0);function $u(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,z.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 Aw=Dt(H0,e=>{let t=s.storage.getItem(e),r=(s.storage.getItem(e+ya)||"").toLowerCase();return z.isString(t)?$u(r,t):""},bh),Ow=Te($0,({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:$u(b,o.data)})},function(){t({data:$u("",o.data)})})},dr(n))},_h),Tw=Dt(yh,e=>{s.storage.removeItem(e+ya),s.storage.removeItem(e)},q0),Pw=Te(yh,({key:e},{resolve:t,reject:n})=>{s.storage.removeItemAsync(e+ya,()=>{}),s.storage.removeItemAsync(e,t,dr(n))},Y0),Iw=Dt("clearStorageSync",()=>{s.storage.clear()}),Nw=Te("clearStorage",(e,{resolve:t,reject:n})=>{s.storage.clearAsync(t,dr(n))}),Mh=Dt("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}}),kw=Te("getStorageInfo",(e,{resolve:t})=>{t(Mh())}),Rw=Te(ny,(e,{resolve:t,reject:n})=>{s.io.getFileInfo(z.extend(e,{success:Xs(t),fail:dr(n)}))},iy,ry),xw=0,Dh="uniapp_save",Bw=`_doc/${Dh}`;function Mw(e,t){t=t||function(){},s.io.requestFileSystem(s.io.PRIVATE_DOC,n=>{n.root.getDirectory(Dh,{create:!0},e,t)},t)}let Dw=Te(J0,({tempFilePath:e},{resolve:t,reject:n})=>{let r=dr(n),o=`${Date.now()}${xw++}${Ya(e)}`;s.io.resolveLocalFileSystemURL(e,c=>{Mw(g=>{c.copyTo(g,o,()=>{let b=Bw+"/"+o;t({savedFilePath:b})},r)},r)},r)},Z0,K0),Lw="uniapp_save";function Fw(e,t){t=t||function(){},s.io.requestFileSystem(s.io.PRIVATE_DOC,n=>{n.root.getDirectory(Lw,{create:!0},e,t)},t)}let Vw=Te(X0,(e,{resolve:t,reject:n})=>{let r=dr(n);Fw(o=>{var c=o.createReader(),g=[];c.readEntries(b=>{b&&b.length?b.forEach(V=>{V.getMetadata(T=>{g.push({filePath:s.io.convertAbsoluteFileSystem(V.fullPath),createTime:T.modificationTime.getTime(),size:T.size}),g.length===b.length&&t({fileList:g})},r,!1)}):t({fileList:g})},r)},r)}),Uw=Te(oy,({filePath:e},{resolve:t,reject:n})=>{let r=dr(n);s.io.resolveLocalFileSystemURL(e,o=>{o.getMetadata(c=>{t({createTime:c.modificationTime.getTime(),size:c.size})},r,!1)},r)},sy,ay),$w=Te(Q0,({filePath:e},{resolve:t,reject:n})=>{let r=dr(n);s.io.resolveLocalFileSystemURL(e,o=>{o.remove(()=>{t()},r)},r)},ty,ey),Hw=Te(ly,({filePath:e,fileType:t},{resolve:n,reject:r})=>{let o=dr(r);s.runtime.openDocument(je(e),void 0,n,o)},uy,cy),jw=Dt(kb,e=>!!z.hasOwn(P,e),Rb),nc,Lh=s.navigator.setStatusBarStyle;function zw(e){Lh=e}function Fh(e){nc=e,Lh(e)}s.navigator.setStatusBarStyle=Fh;function Ba(e){if(!e){let t=wi();if(!t||(e=t.$page.statusBarStyle,!e||e===nc))return}e!==nc&&(nc=e,s.navigator.setStatusBarStyle(e))}function Vh(e){ot.on(J.ON_THEME_CHANGE,e)}function Ww(e){ot.off(J.ON_THEME_CHANGE,e)}function Gw(){return Uh()==="dark"?"light":"dark"}function Uh(){return s.navigator.getUIStyle()}function Yw(){if(R.darkmode){let e=Gw();Ba(e),Hn().forEach(n=>{n.$page.statusBarStyle=e})}}function Hu(e){if(R.darkmode){let t={},n=s.navigator.getUIStyle(),r=ic();return r&&r.hostTheme&&(n=r.hostTheme),t=J.normalizeStyles(e,R.themeConfig,n),t}return e}function qw(e,t){if(R.darkmode){let n=()=>{let{list:r=[],color:o,selectedColor:c,backgroundColor:g,borderStyle:b}=Hu(t);e&&e.setTabBarStyle({color:o,selectedColor:c,backgroundColor:g,borderStyle:b}),e&&e.setTabBarItems({list:r.map(V=>({iconPath:V.iconPath,selectedIconPath:V.selectedIconPath,visible:V.visible}))})};n(),Vh(n)}}function $h(e,t){if(R.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",()=>Ww(n))}}let rc,ju=!0,ir;function Jw(e,t,n){!ir||(e==="none"?(ir.hideTabBarRedDot({index:t}),ir.removeTabBarBadge({index:t})):e==="text"?ir.setTabBarBadge({index:t,text:n}):e==="redDot"&&ir.showTabBarRedDot({index:t}))}function Kw(e){ir&&ir.setTabBarItems(e)}function Zw(e,t,n,r,o,c){let g={index:e};if(t!==void 0&&(g.text=t),n&&(g.iconPath=je(n)),r&&(g.selectedIconPath=je(r)),c!==void 0&&(g.iconfont=c),o!==void 0){g.visible=rc.list[e].visible=o,delete g.index;let b=rc.list.map(V=>({visible:V.visible}));b[e]=g,Kw({list:b})}else ir&&ir.setTabBarItem(g)}function Xw(e){ir&&ir.setTabBarStyle(e)}function Qw(e){ju=!1,ir&&ir.hideTabBar({animation:e})}function eC(e){ju=!0,ir&&ir.showTabBar({animation:e})}let kc=[];var di={id:"0",init(e,t){e&&e.list.length&&(rc=e);try{ir=f.requireModule("uni-tabview")}catch(n){console.log(`uni.requireNativePlugin("uni-tabview") error ${n}`)}ir.onMaskClick(()=>{kc.forEach(n=>{n()})}),ir&&ir.onClick(({index:n})=>{t(rc.list[n],n)}),ir&&ir.onMidButtonClick(()=>ot.invokeOnCallback(nh)),qw(ir,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?(ir&&ir.switchSelect({index:t}),!0):!1},setTabBarBadge:Jw,setTabBarItem:Zw,setTabBarStyle:Xw,hideTabBar:Qw,showTabBar:eC,append(e){ir&&ir.append({id:e.id},({code:t})=>{t!==0&&N(()=>{this.append(e)},20)})},get config(){return rc||R.tabBar},get visible(){return ju},get height(){let e=this.config;return(e&&e.height?parseFloat(e.height):J.TABBAR_HEIGHT)+s.navigator.getSafeAreaInsets().deviceBottom},get cover(){let e=this.config;return e&&["extralight","light","dark"].indexOf(e.blurEffect)>=0},setStyle({mask:e}){ir.setMask({color:e})},addEventListener(e,t){kc.push(t)},removeEventListener(e,t){let n=kc.indexOf(t);kc.splice(n,1)}};function Rc(){let e=wi();return e?e.$getAppWebview():null}function Hh(e){return e?e.$getAppWebview():Rc()}let jh=null;function zh(){return jh}function zu(e){jh=e}function Wu(){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 tC(){let{resolutionWidth:e,resolutionHeight:t}=s.screen.getCurrentSize()||{resolutionWidth:0,resolutionHeight:0};return{screenWidth:Math.round(e),screenHeight:Math.round(t)}}let Gh=Dt("getWindowInfo",()=>{let e=s.os.name.toLowerCase()==="ios",{screenWidth:t,screenHeight:n}=tC(),r=Wu(),o,c={height:0,cover:!1},g=Rc();if(g){let ft=g.getStyle(),ht=ft&&ft.titleNView;ht&&ht.type&&ht.type!=="none"&&(c.height=ht.type==="transparent"?0:r+J.NAVBAR_HEIGHT,c.cover=ht.type==="transparent"||ht.type==="float"),o=g.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,L=n-c.height-b.height,_e=n-(c.cover?0:c.height)-(b.cover?0:b.height),we=t;(!b.height||b.cover)&&!o.bottom&&o.deviceBottom&&(L-=o.deviceBottom,_e-=o.deviceBottom),o=e?o:{left:0,right:0,top:c.height&&!c.cover?0:r,bottom:0};let Pe={left:o.left,right:we-o.right,top:o.top,bottom:_e-o.bottom,width:we-o.left-o.right,height:_e-o.top-o.bottom};return{pixelRatio:s.screen.scale,screenWidth:t,screenHeight:n,windowWidth:we,windowHeight:L,statusBarHeight:r,safeArea:Pe,safeAreaInsets:{top:o.top,right:o.right,bottom:o.bottom,left:o.left},windowTop:V,windowBottom:T,screenTop:n-L}}),Ea,xc=!0;function ic(){if(!xc)return;let{getSystemInfoSync:e}=f.requireModule("plus");if(Ea=e(),z.isString(Ea))try{Ea=JSON.parse(Ea)}catch(t){}return Ea}let Yh=Dt("getDeviceInfo",()=>{ic();let{deviceBrand:e="",deviceModel:t,osName:n,osVersion:r,deviceOrientation:o,deviceType:c,deviceId:g}=Ea,b=e.toLowerCase(),V=n.toLowerCase();return{brand:b,deviceBrand:b,deviceModel:t,devicePixelRatio:s.screen.scale,deviceId:g,deviceOrientation:o,deviceType:c,model:t,platform:V,system:`${V==="ios"?"iOS":"Android"} ${r}`}}),qh=Dt("getAppBaseInfo",()=>{ic();let{hostPackageName:e,hostName:t,hostVersion:n,hostLanguage:r,osLanguage:o,hostTheme:c,appId:g,appName:b,appVersion:V,appVersionCode:T,appWgtVersion:L}=Ea;return{appId:g,appName:b,appVersion:V,appVersionCode:T,appWgtVersion:L,appLanguage:Kl?Kl():o,enableDebug:!1,hostPackageName:e,hostName:t,hostVersion:n,hostLanguage:r,hostTheme:c,hostFontSizeSetting:void 0,hostSDKVersion:void 0,language:o,SDKVersion:"",theme:Uh(),version:s.runtime.innerVersion}}),Jh=Dt("getSystemInfoSync",()=>{xc=!0,ic(),xc=!1;let e=Gh(),t=Yh(),n=qh();xc=!0;let r={fontSizeSetting:n.hostFontSizeSetting,osName:Ea.osName.toLowerCase()};Ea.hostName&&(r.hostSDKVersion=Ea.uniRuntimeVersion);let o=z.extend(Ea,e,t,n,r);return delete o.screenTop,delete o.enableDebug,R.darkmode||delete o.theme,J.sortObject(o)}),nC=Te("getSystemInfo",(e,{resolve:t})=>t(Jh())),Ol=null,rC=pn(fh,()=>{Kh()}),iC=Xr(Gb,()=>{Zh()}),Kh=Te(Yb,(e,{resolve:t,reject:n})=>{Ol||(Ol=s.orientation.watchOrientation(r=>{ot.invokeOnCallback(fh,{direction:r.magneticHeading})},r=>{n(r.message),Ol=null},{frequency:so})),N(t,so)}),Zh=Te(qb,(e,{resolve:t})=>{Ol&&(s.orientation.clearWatch(Ol),Ol=null),t()}),oC=Te(Jb,(e,{resolve:t})=>{s.device.vibrate(15),t()}),aC=Te(Kb,(e,{resolve:t})=>{s.device.vibrate(400),t()}),Tl=null,sC=pn(uh,()=>{Xh()}),lC=Xr(jb,()=>{Qh()}),Xh=Te(zb,(e,{resolve:t,reject:n})=>{Tl||(Tl=s.accelerometer.watchAcceleration(r=>{ot.invokeOnCallback(uh,{x:r&&r.xAxis||0,y:r&&r.yAxis||0,z:r&&r.zAxis||0})},r=>{Tl=null,n(`startAccelerometer:fail ${r.message}`)},{frequency:so})),N(t,so)}),Qh=Te(Wb,(e,{resolve:t})=>{Tl&&(s.accelerometer.clearWatch(Tl),Tl=null),t()}),cC=pn(dh,Al(()=>s.bluetooth.onBluetoothDeviceFound.bind(s.bluetooth),dh)),uC=pn(hh,Al(()=>s.bluetooth.onBluetoothAdapterStateChange.bind(s.bluetooth),hh)),fC=pn(gh,Al(()=>s.bluetooth.onBLEConnectionStateChange.bind(s.bluetooth),gh)),dC=pn(ph,Al(()=>s.bluetooth.onBLECharacteristicValueChange.bind(s.bluetooth),ph)),hC=Te("openBluetoothAdapter",fi(()=>s.bluetooth.openBluetoothAdapter.bind(s.bluetooth))),gC=Te("closeBluetoothAdapter",fi(()=>s.bluetooth.closeBluetoothAdapter.bind(s.bluetooth))),pC=Te("getBluetoothAdapterState",fi(()=>s.bluetooth.getBluetoothAdapterState.bind(s.bluetooth))),vC=Te(Zb,fi(()=>s.bluetooth.startBluetoothDevicesDiscovery.bind(s.bluetooth)),Xb),mC=Te("stopBluetoothDevicesDiscovery",fi(()=>s.bluetooth.stopBluetoothDevicesDiscovery.bind(s.bluetooth))),_C=Te("getBluetoothDevices",fi(()=>s.bluetooth.getBluetoothDevices.bind(s.bluetooth))),bC=Te(Qb,fi(()=>s.bluetooth.getConnectedBluetoothDevices.bind(s.bluetooth)),e0),yC=Te(t0,fi(()=>s.bluetooth.createBLEConnection.bind(s.bluetooth)),n0),EC=Te(r0,fi(()=>s.bluetooth.closeBLEConnection.bind(s.bluetooth)),i0),SC=Te(o0,fi(()=>s.bluetooth.getBLEDeviceServices.bind(s.bluetooth)),a0),wC=Te(s0,fi(()=>s.bluetooth.getBLEDeviceCharacteristics.bind(s.bluetooth)),l0),CC=Te(c0,fi(()=>s.bluetooth.notifyBLECharacteristicValueChange.bind(s.bluetooth)),u0),AC=Te(f0,fi(()=>s.bluetooth.readBLECharacteristicValue.bind(s.bluetooth)),d0),OC=Te(h0,fi(()=>s.bluetooth.writeBLECharacteristicValue.bind(s.bluetooth)),g0),TC=Te(p0,fi(()=>s.bluetooth.setBLEMTU.bind(s.bluetooth)),v0),PC=Te(m0,fi(()=>s.bluetooth.getBLEDeviceRSSI.bind(s.bluetooth)),_0),IC=pn(vh,Al(()=>s.ibeacon.onBeaconUpdate.bind(s.ibeacon),vh)),NC=pn(mh,Al(()=>s.ibeacon.onBeaconServiceChange.bind(s.ibeacon),mh)),kC=Te(b0,fi(()=>s.ibeacon.getBeacons.bind(s.ibeacon))),RC=Te(y0,fi(()=>s.ibeacon.startBeaconDiscovery.bind(s.ibeacon)),E0),xC=Te(S0,fi(()=>s.ibeacon.stopBeaconDiscovery.bind(s.ibeacon))),BC=Te(Bb,({phoneNumber:e},{resolve:t})=>(s.device.dial(e),t()),Mb),MC={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"}]},DC=["type","preferred"];function Gu(e,t,n){let r=0;return Object.keys(n).forEach(o=>{let c=n[o];typeof c!=="object"?DC.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={};Gu(V,t,b)&&e[o].push(V)}),e[o].length?r++:delete e[o]):(e[o]={},Gu(e[o],t,c)?r++:delete e[o])}),r}let LC=Te(Db,(e,{resolve:t,reject:n})=>{!e.photoFilePath&&(e.photoFilePath=""),s.contacts.getAddressBook(s.contacts.ADDRESSBOOK_PHONE,r=>{let o=r.create();Gu(o,e,MC),o.save(()=>t(),c=>n())},r=>n())},Fb,Lb);function Jo(e){return typeof f!="undefined"?f.requireModule(e):__requireNativePlugin__(e)}function eg(e,t,n){return Jo("plus").sendNativeEvent(e,t,n)}let FC=Te(Vb,(e,{resolve:t,reject:n})=>{Jo("clipboard").getString(o=>{o.result==="success"?t({data:o.data}):n("getClipboardData:fail")})}),VC=Te(Ub,(e,{resolve:t})=>{Jo("clipboard").setString(e.data),t()},Hb,$b),tg="onNetworkStatusChange";function ng(){rg().then(({networkType:e})=>{ot.invokeOnCallback(tg,{isConnected:e!=="none",networkType:e})})}let UC=pn(tg,()=>{s.globalEvent.addEventListener("netchange",ng)}),$C=Xr("offNetworkStatusChange",()=>{s.globalEvent.removeEventListener("netchange",ng)}),rg=Te("getNetworkType",(e,{resolve:t})=>{let n=Wa[s.networkinfo.getCurrentType()]||"unknown";return t({networkType:n})});function ig(){if(s.os.name.toLowerCase()!=="ios")return!1;let t=Jo("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"}},HC=Te(O0,(e,{resolve:t,reject:n})=>{ag(t)}),sg=({checkAuthMode:e,resolve:t,reject:n})=>{let r=(c,g)=>n&&n(c,g),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=Jo("faceID"),g=c&&c.isKeyguardSecure()&&c.isEnrolledFaceID();return o({isEnrolled:g}),{isEnrolled:g,errMsg:"checkIsSoterEnrolledInDevice:ok"}}return r("not support",{isEnrolled:!1}),{isEnrolled:!1,errMsg:"checkIsSoterEnrolledInDevice:fail not support"}}return r("not support",{isEnrolled:!1}),{isEnrolled:!1,errMsg:"checkIsSoterEnrolledInDevice:fail not support"}},jC=Te(T0,({checkAuthMode:e},{resolve:t,reject:n})=>{sg({checkAuthMode:e,resolve:t,reject:n})},N0,I0),zC=Te(k0,({requestAuthModes:e,challenge:t=!1,authContent:n},{resolve:r,reject:o})=>{xn();let{t:c}=ae(),{supportMode:g}=ag();if(!g.length)return o("not support",{authMode:"fingerPrint",errCode:90001});let b=[];if(e.forEach(ft=>{g.indexOf(ft)>-1&&b.push(ft)}),!b.length)return o("startSoterAuthentication:fail no corresponding mode",{authMode:"fingerPrint",errCode:90003});let V=[];if(b.forEach(ft=>{sg({checkAuthMode:ft}).isEnrolled&&V.push(ft)}),!V.length)return o(`startSoterAuthentication:fail no ${b[0]} enrolled`,{authMode:b[0],errCode:90011});let T=V[0],L=null,_e,we=n||c("uni.startSoterAuthentication.authContent"),Pe=ft=>{let{code:ht}=ft,Ft={authMode:T},St={4:()=>{L?(E(_e),L.setTitle(c("uni.startSoterAuthentication.waitingContent")),_e=N(()=>{L&&L.setTitle(we)},1e3)):o("",z.extend(Ft,{errCode:90009}))},5:()=>{s.nativeUI.closeWaiting(),o("authenticate freeze. please try again later",z.extend(Ft,{errCode:90010}))},6:()=>{s.nativeUI.closeWaiting(),o("cancel",z.extend(Ft,{errCode:90008}))}};ht&&St[ht]?St[ht]():(s.nativeUI.closeWaiting(),o("",z.extend(Ft,{errCode:90007})))};T==="fingerPrint"?(s.os.name.toLowerCase()==="android"&&(L=s.nativeUI.showWaiting(we),L.onclose=function(){s.fingerprint.cancel()}),s.fingerprint.authenticate(()=>{s.nativeUI.closeWaiting(),r({authMode:T,errCode:0})},Pe,{message:we})):T==="facial"&&Jo("faceID").authenticate({message:we},ht=>{ht.type==="success"&&ht.code===0?r({authMode:T,errCode:0}):Pe(ht)})},x0,R0),WC=Te(B0,(e,{resolve:t,reject:n})=>{Xt();let{t:r}=ae(),c=Wh()!=="light",g,b=!1,V=Yi({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:L}){g=L,b=T==="marked"},onClose(){c&&s.navigator.setStatusBarStyle("dark"),g?b?(delete g.message,t(g)):n(g.message):n("cancel")}});c&&(s.navigator.setStatusBarStyle("light"),V.webview.addEventListener("popGesture",({type:T,result:L})=>{T==="start"?s.navigator.setStatusBarStyle("dark"):T==="end"&&!L&&s.navigator.setStatusBarStyle("light")}))},M0,L0),lg=e=>{ot.invokeOnCallback(J.ON_THEME_CHANGE,e)},GC=pn(J.ON_THEME_CHANGE,()=>{ot.on(J.ON_THEME_CHANGE,lg)}),YC=Xr(J.OFF_THEME_CHANGE,()=>{ot.off(J.ON_THEME_CHANGE,lg)}),qC=Te(w0,(e,{resolve:t})=>{let n=s.screen.getBrightness(!1);t({value:n})}),JC=Te(C0,(e,{resolve:t})=>{s.screen.setBrightness(e.value,!1),t()}),KC=Te(A0,(e,{resolve:t})=>{s.device.setWakelock(!!e.keepScreenOn),t()}),ZC=Dt(F0,()=>{let{getSystemSetting:e}=f.requireModule("plus"),t=e();try{typeof t=="string"&&(t=JSON.parse(t))}catch(n){}return t}),cg=Dt(V0,()=>{let{getAppAuthorizeSetting:e}=f.requireModule("plus"),t=e();try{typeof t=="string"&&(t=JSON.parse(t))}catch(n){}for(let n in t)z.hasOwn(t,n)&&t[n]==="undefined"&&(t[n]=void 0);return t}),XC=Te(U0,(e,{resolve:t,reject:n})=>{let{openAppAuthorizeSetting:r}=f.requireModule("plus");r(c=>{c.type==="success"?t():n()})}),QC=Te(Ty,(e,{resolve:t,reject:n})=>{let r=Wr+"/download/";s.io.getImageInfo(z.extend(e,{savePath:r,filename:r,success:Xs(t),fail:dr(n)}))},Iy,Py),eA=Te(By,(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:dr(n)})},Dy,My),tA=Te(Ny,({current:e=0,indicator:t="number",loop:n=!1,urls:r,longPressActions:o},{resolve:c,reject:g})=>{Ne();let{t:b}=ae();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 L=[],_e="",we=o&&z.isPlainObject(o);we?(L=o.itemList?o.itemList:[],_e=o.itemColor?o.itemColor:"#000000"):(L=[b("uni.previewImage.button.save")],_e="#000000");let Pe={buttons:L.map(ft=>({title:ft,color:_e})),cancel:b("uni.previewImage.cancel")};s.nativeUI.actionSheet(Pe,ft=>{if(ft.index>0){if(we){z.isFunction(o.success)&&o.success({tapIndex:ft.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 we&&z.isFunction(o.fail)&&o.fail({errMsg:"showActionSheet:fail cancel"})})}}),c()},Ry,ky),nA=Te(xy,(e,{resolve:t,reject:n})=>{try{s.nativeUI.closePreviewImage(),t()}catch(r){n()}}),Yu,Pl=!1,qu,Il=(e,t={})=>{rA(z.extend({state:e},t))},oc={start({duration:e=6e4,sampleRate:t,numberOfChannels:n,encodeBitRate:r,format:o="mp3",frameSize:c}={}){if(Pl)return Il("start");Yu=s.audio.getRecorder(),Yu.record({format:o,samplerate:t?String(t):void 0,filename:Wr+"/recorder/"},g=>Il("stop",{tempFilePath:g}),g=>Il("error",{errMsg:g.message})),qu=N(()=>{oc.stop()},e),Il("start"),Pl=!0},stop(){Pl&&(Yu.stop(),Pl=!1,qu&&E(qu))},pause(){Pl&&Il("error",{errMsg:"Unsupported operation: pause"})},resume(){Pl&&Il("error",{errMsg:"Unsupported operation: resume"})}},Qs={pause:null,resume:null,start:null,stop:null,error:null};function rA(e){let t=e.state;delete e.state,delete e.errMsg,t&&z.isFunction(Qs[t])&&Qs[t](e)}class iA{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,oA=Dt(jy,()=>ug||(ug=new iA)),aA=Te(Uy,(e,{resolve:t,reject:n})=>{s.gallery.save(e.filePath,Xs(t),dr(n))},Hy,$y),sA=Te(Ly,(e,{resolve:t,reject:n})=>{s.gallery.save(e.filePath,Xs(t),dr(n))},Vy,Fy),lA=Te(zy,(e,{resolve:t,reject:n})=>{let r=`${Wr}/compressed/${Date.now()}_${Ga(e.src)}`,{compressedWidth:o,compressedHeight:c}=e;typeof o=="number"&&(e.width=o+"px"),typeof c=="number"&&(e.height=c+"px"),s.zip.compressImage(z.extend({},e,{dst:r}),()=>{t({tempFilePath:r})},n)},Gy,Wy),cA=Te(Yy,(e,{resolve:t,reject:n})=>{let r=`${Wr}/compressed/${Date.now()}_${Ga(e.src)}`;s.zip.compressVideo(z.extend({},e,{filename:r}),o=>{t({tempFilePath:r,size:o.size})},n)},Jy,qy);function uA(e){return new Promise((t,n)=>{s.io.resolveLocalFileSystemURL(e,function(r){r.getMetadata(t,n,!1)},n)})}let fA=Te(Ey,({count:e,sizeType:t,sourceType:n,crop:r}={},{resolve:o,reject:c})=>{K();let{t:g}=ae(),b=dr(c);function V(_e){let we=[],Pe=[];Promise.all(_e.map(ft=>uA(ft))).then(ft=>{ft.forEach((ht,Ft)=>{let St=_e[Ft];Pe.push(St),we.push({path:St,size:ht.size})}),o({tempFilePaths:Pe,tempFiles:we})}).catch(b)}function T(){s.camera.getCamera().captureImage(we=>V([we]),b,{filename:Wr+"/camera/",resolution:"high",crop:r,sizeType:t})}function L(){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")){L();return}else if(n.includes("camera")){T();return}}s.nativeUI.actionSheet({cancel:g("uni.chooseImage.cancel"),buttons:[{title:g("uni.chooseImage.sourceType.camera")},{title:g("uni.chooseImage.sourceType.album")}]},_e=>{switch(_e.index){case 1:T();break;case 2:L();break;default:b();break}})},wy,Sy),dA=Te(Cy,({sourceType:e,compressed:t,maxDuration:n,camera:r},{resolve:o,reject:c})=>{ie();let{t:g}=ae(),b=dr(c);function V(_e){s.io.getVideoInfo({filePath:_e,success(we){let Pe={errMsg:"chooseVideo:ok",tempFilePath:_e,size:we.size,duration:we.duration,width:we.width,height:we.height};o(Pe)},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 L(){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")){L();return}}s.nativeUI.actionSheet({cancel:g("uni.chooseVideo.cancel"),buttons:[{title:g("uni.chooseVideo.sourceType.camera")},{title:g("uni.chooseVideo.sourceType.album")}]},_e=>{switch(_e.index){case 1:L();break;case 2:T();break;default:b();break}})},Oy,Ay),hA=Te(dy,(e,{resolve:t})=>{s.key.showSoftKeybord(),t()}),gA=Te(fy,(e,{resolve:t})=>{s.key.hideSoftKeybord(),t()});function fg(e){ot.invokeOnCallback(J.ON_KEYBOARD_HEIGHT_CHANGE,e)}let pA=pn(J.ON_KEYBOARD_HEIGHT_CHANGE,()=>{ot.on(J.ON_KEYBOARD_HEIGHT_CHANGE,fg)}),vA=Xr(J.ON_KEYBOARD_HEIGHT_CHANGE,()=>{ot.off(J.ON_KEYBOARD_HEIGHT_CHANGE,fg)});class mA{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){!z.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 _A=Ur(aE,({url:e,header:t,timeout:n},{resolve:r,reject:o})=>{n=(n||R.networkTimeout&&R.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}`)}),g=new mA(c);for(let b in t)z.hasOwn(t,b)&&c.setRequestHeader(b,t[b]);return c.start(),g},lE,sE),bA=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 yA(e,t){if(z.isString(e.data)&&e.data.charCodeAt(0)===65279&&(e.data=e.data.slice(1)),e.statusCode=parseInt(String(e.statusCode),10),z.isPlainObject(e.header)&&(e.header=Object.keys(e.header).reduce(function(n,r){let o=e.header[r];return z.isArray(o)?n[r]=o.join(","):z.isString(o)&&(n[r]=o),n},{})),t.dataType&&t.dataType.toLowerCase()==="json")try{e.data=JSON.parse(e.data)}catch(n){}return e}class EA{constructor(t){this._requestTask=t}abort(){this._requestTask.abort()}offHeadersReceived(){}onHeadersReceived(){}}let SA=Ur(Ky,(e,{resolve:t,reject:n})=>{let{header:r,method:o,data:c,timeout:g,url:b,responseType:V,sslVerify:T,firstIpv4:L,tls:_e}=e,we;for(let Et in r)if(Et.toLowerCase()==="content-type"){we=r[Et];break}o!=="GET"&&we.indexOf("application/json")===0&&z.isPlainObject(c)&&(c=JSON.stringify(c));let Pe=Jo("stream"),ft={},ht,Ft,St=!1;for(let Et in r)if(!St&&Et.toLowerCase()==="content-type"){if(St=!0,ft["Content-Type"]=r[Et],o!=="GET"&&r[Et].indexOf("application/x-www-form-urlencoded")===0&&!z.isString(c)&&!(c instanceof ArrayBuffer)){let Kt=[];for(let cn in c)z.hasOwn(c,cn)&&Kt.push(encodeURIComponent(cn)+"="+encodeURIComponent(c[cn]));c=Kt.join("&")}}else ft[Et]=r[Et];!St&&o==="POST"&&(ft["Content-Type"]="application/x-www-form-urlencoded; charset=UTF-8"),g&&(ht=N(()=>{Ft=!0,n("timeout")},g+200));let mn={method:o,url:b.trim(),headers:ft,type:V==="arraybuffer"?"base64":"text",timeout:g||6e5,sslVerify:!T,firstIpv4:L,tls:_e},tn=!1;o!=="GET"&&(toString.call(c)==="[object ArrayBuffer]"?tn=!0:mn.body=z.isString(c)?c:JSON.stringify(c));let nn=({ok:Et,status:Kt,data:cn,headers:Zt,errorMsg:Cn})=>{if(Ft)return;ht&&E(ht);let hr=Kt;if(hr>0)t(yA({data:Et&&V==="arraybuffer"?Ri(cn):cn,statusCode:hr,header:Zt,cookies:bA(Zt)},e));else{let rn="abort statusCode:"+hr;Cn&&(rn=rn+" "+Cn),n(rn)}};return tn?Pe.fetchWithArrayBuffer({"@type":"binary",base64:Tr(c)},mn,nn):Pe.fetch(mn,nn),new EA({abort(){Ft=!0,ht&&E(ht),n("abort")}})},tE,nE),wA=Te(rE,({certificates:e},{resolve:t,reject:n})=>{Jo("stream").configMTLS(e,({type:o,code:c,message:g})=>{switch(o){case"success":t({code:c});break;case"fail":n(g,{code:c});break}})},iE,oE),Nl=[],kl={},Ju={open:"",close:"",error:"",message:""},ac;function CA(e){let t=String(Date.now()),n;try{ac||(ac=Jo("uni-webSocket"),AA(ac)),ac.WebSocket({id:t,url:e.url,protocol:z.isArray(e.protocols)?e.protocols.join(","):e.protocols,header:e.header})}catch(r){n=r}return{socket:ac,socketId:t,errMsg:n}}function AA(e){e.onopen(t=>{let n=kl[t.id];!n||n._socketOnOpen()}),e.onmessage(t=>{let n=kl[t.id];!n||n._socketOnMessage(t)}),e.onerror(t=>{let n=kl[t.id];!n||n._socketOnError()}),e.onclose(t=>{let{id:n,code:r,reason:o}=t,c=kl[n];!c||c._socketOnClose({code:r,reason:o})})}class OA{constructor(t,n){this.id=n,this._socket=t,this._callbacks={open:[],close:[],error:[],message:[]},this.CLOSED=3,this.CLOSING=2,this.CONNECTING=0,this.OPEN=1,this.readyState=this.CLOSED,!!this._socket}_socketOnOpen(){this.readyState=this.OPEN,this.socketStateChange("open")}_socketOnMessage(t){this.socketStateChange("message",{data:typeof t.data=="object"?Ri(t.data.base64):t.data})}_socketOnError(){this.socketStateChange("error"),this.onErrorOrClose()}_socketOnClose(t){this.socketStateChange("close",t),this.onErrorOrClose()}onErrorOrClose(){this.readyState=this.CLOSED,delete kl[this.id];let t=Nl.indexOf(this);t>=0&&Nl.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===Nl[0]&&Ju[t]&&ot.invokeOnCallback(Ju[t],c),this._callbacks[t].forEach(g=>{z.isFunction(g)&&g(c)})}send(t,n=!0){this.readyState!==this.OPEN&&J.callOptions(t,"sendSocketMessage:fail WebSocket is not connected");try{this._socket.send({id:this.id,data:typeof t.data=="object"?{"@type":"binary",base64:Tr(t.data)}:t.data}),n&&J.callOptions(t,"sendSocketMessage:ok")}catch(r){n&&J.callOptions(t,`sendSocketMessage:fail ${r}`)}}close(t,n=!0){this.readyState=this.CLOSING;try{this._socket.close(z.extend({id:this.id,args:t})),n&&J.callOptions(t,"closeSocket:ok")}catch(r){n&&J.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 TA=Ur(dE,({url:e,protocols:t,header:n,method:r},{resolve:o,reject:c})=>{let{socket:g,socketId:b,errMsg:V}=CA({url:e,protocols:t,header:n,method:r}),T=new OA(g,b);return V?N(()=>{c(V)},0):(Nl.push(T),kl[b]=T),N(()=>{o()},0),T},gE,hE),PA=Te(pE,(e,{resolve:t,reject:n})=>{let r=Nl[0];if(!r||r.readyState!==r.OPEN){n("WebSocket is not connected");return}r.send({data:e.data},!1),t()},vE),IA=Te(mE,(e,{resolve:t,reject:n})=>{let r=Nl[0];if(!r){n("WebSocket is not connected");return}r.readyState=r.CLOSING,r.close(e,!1),t()},_E);function Bc(e){let t=`onSocket${z.capitalize(e)}`;return pn(t,()=>{Ju[e]=t})}let NA=Bc("open"),kA=Bc("error"),RA=Bc("message"),xA=Bc("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){!z.isFunction(t)||this._callbacks.push(t)}onHeadersReceived(){}offProgressUpdate(t){let n=this._callbacks.indexOf(t);n>=0&&this._callbacks.splice(n,1)}offHeadersReceived(){}}let MA=Ur(cE,({url:e,timeout:t,header:n,formData:r,files:o,filePath:c,name:g},{resolve:b,reject:V})=>{t=(t||R.networkTimeout&&R.networkTimeout.uploadFile||60*1e3)/1e3;let T=s.uploader.createUpload(e,{timeout:t,retry:0,retryInterval:0},(_e,we)=>{we?b({data:_e.responseText,statusCode:we}):V(`statusCode: ${we}`)});for(let _e in n)z.hasOwn(n,_e)&&T.setRequestHeader(_e,String(n[_e]));for(let _e in r)z.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:g});let L=new BA(T);return T.start(),L},fE,uE),Ps={},DA=["play","canplay","ended","stop","waiting","seeking","seeked","pause"],dg="playback",LA=200,FA=e=>{let t=Ps[e];!t||t.initStateChage||(t.initStateChage=!0,t.addEventListener("error",n=>{hg({state:"error",audioId:e,errMsg:"MediaError",errCode:n.code})}),DA.forEach(n=>{t.addEventListener(n,()=>{n==="play"?t.isStopped=!1:n==="stop"&&(t.isStopped=!0),hg({state:n,audioId:e})})}))};function VA(){let e=`${Date.now()}${Math.random()}`,t=Ps[e]=s.audio.createPlayer("");return t.src="",t.volume=1,t.startTime=0,t.setSessionCategory(dg),{errMsg:"createAudioInstance:ok",audioId:e}}function UA({audioId:e,src:t,startTime:n,autoplay:r=!1,loop:o=!1,obeyMuteSwitch:c,volume:g,sessionCategory:b=dg,playbackRate:V}){let T=Ps[e];if(T){let L={loop:o,autoplay:r};if(t){let _e=je(t);T.src!==_e&&(T.src=L.src=_e)}n&&(T.startTime=L.startTime=n),typeof g=="number"&&(T.volume=L.volume=g),T.setStyles(L),b&&T.setSessionCategory(b),V&&T.playbackRate&&T.playbackRate(V),FA(e)}return{errMsg:"setAudioState:ok"}}function $A({audioId:e}){let t=Ps[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 HA({operationType:e,audioId:t,currentTime:n}){let r=Ps[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 Ku=Object.create(null),hg=({state:e,audioId:t,errMsg:n,errCode:r})=>{let o=Ku[t];if(o)if(Xu(o,e,n,r),e==="play"){let c=o.currentTime;Xu(o,"timeUpdate"),o.__timing=h(()=>{o.currentTime!==c&&Xu(o,"timeUpdate")},LA)}else(e==="pause"||e==="stop"||e==="error")&&y(o.__timing)},jA=[{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 Zu{constructor(t){this.id=t,this._callbacks={},this._options={},Kd.forEach(n=>{this._callbacks[n]=[]}),jA.forEach(n=>{let r=n.name;Object.defineProperty(this,r,{get:()=>{let o=n.cache?this._options:$A({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,UA(z.extend({},this._options,{audioId:this.id}))}})}),zA()}play(){this._operate("play")}pause(){this._operate("pause")}stop(){this._operate("stop")}seek(t){this._operate("seek",{currentTime:t*1e3})}destroy(){y(this.__timing),Ps[this.id]&&(Ps[this.id].close(),delete Ps[this.id]),delete Ku[this.id]}_operate(t,n){HA(z.extend({},n,{audioId:this.id,operationType:t}))}}let zA=J.once(()=>{Kd.forEach(e=>{Zu.prototype[e]=function(t){z.isFunction(t)&&this._callbacks[e].push(t)}}),U_.forEach(e=>{Zu.prototype[e]=function(t){let n=this._callbacks[e],r=n.indexOf(t);r>=0&&n.splice(r,1)}})});function Xu(e,t,n,r){let o=`on${z.capitalize(t)}`;e._callbacks[o].forEach(c=>{z.isFunction(c)&&c(t==="error"?{errMsg:n,errCode:r}:{})})}let WA=Dt(p_,()=>{let{audioId:e}=VA(),t=new Zu(e);return Ku[e]=t,t}),GA=["canplay","play","pause","stop","ended","timeUpdate","prev","next","error","waiting"],gg={canplay:[],play:[],pause:[],stop:[],ended:[],timeUpdate:[],prev:[],next:[],error:[],waiting:[]},ln,Qu=null,YA=250,qA=["play","pause","ended","stop","canplay"];function JA(){Mc(),el({state:"timeUpdate"}),Qu=h(()=>{el({state:"timeUpdate"})},YA)}function Mc(){Qu!==null&&y(Qu)}function KA(){if(ln)return;let e=ot.invokeOnCallback;ln=s.audio.createPlayer({autoplay:!0,backgroundControl:!0}),ln.src=ln.title=ln.epname=ln.singer=ln.coverImgUrl=ln.webUrl="",ln.startTime=0,qA.forEach(t=>{ln.addEventListener(t,()=>{t==="play"?(ln.isStopped=!1,JA()):t==="stop"&&(ln.isStopped=!0),(t==="pause"||t==="ended"||t==="stop")&&Mc();let n=`onMusic${t[0].toUpperCase()+t.slice(1)}`;e(n,{dataUrl:ln.src,errMsg:`${n}:ok`}),el({state:t,dataUrl:ln.src})})}),ln.addEventListener("waiting",()=>{Mc(),el({state:"waiting",dataUrl:ln.src})}),ln.addEventListener("error",t=>{Mc(),e("onMusicError",{dataUrl:ln.src,errMsg:"Error:"+t.message}),el({state:"error",dataUrl:ln.src,errMsg:t.message,errCode:t.code})}),ln.addEventListener("prev",()=>{el({state:"prev"})}),ln.addEventListener("next",()=>{el({state:"next"})})}function ZA(){let e={duration:0,currentTime:0,paused:!1,src:"",buffered:0,title:"",epname:"",singer:"",coverImgUrl:"",webUrl:"",startTime:0,errMsg:"getBackgroundAudioState:ok"};if(ln){let t={duration:ln.getDuration()||0,currentTime:ln.isStopped?0:ln.getPosition(),paused:ln.isPaused(),src:ln.src,buffered:ln.getBuffered(),title:ln.title,epname:ln.epname,singer:ln.singer,coverImgUrl:ln.coverImgUrl,webUrl:ln.webUrl,startTime:ln.startTime};e=z.extend(e,t)}return e}function pg(e,t){KA();let n=["src","startTime","coverImgUrl","webUrl","singer","epname","title"];if(t==="playbackRate"){let o=e[t];ln.playbackRate&&ln.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)),ln[o]=r[o]=c}}),ln.setStyles(r)}function XA({operationType:e,src:t,position:n,api:r="operateMusicPlayer",title:o,coverImgUrl:c}){var g=["resume","pause","stop"];return g.indexOf(e)>0?ln&&ln[e]():e==="play"?(pg({src:t,startTime:n,title:o,coverImgUrl:c}),ln.play()):e==="seek"&&ln&&ln.seekTo(n),{errMsg:`${r}:ok`}}function QA({operationType:e,src:t,startTime:n,currentTime:r}){return XA({operationType:e,src:t,position:n||r||0,api:"operateBackgroundAudio"})}function el({state:e,errMsg:t,errCode:n,dataUrl:r}){gg[e].forEach(o=>{z.isFunction(o)&&o(e==="error"?{errMsg:t,errCode:n}:{})})}let eO=J.once(()=>{GA.forEach(e=>{vg.prototype[`on${z.capitalize(e)}`]=function(t){gg[e].push(t)}})}),tO=[{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={},tO.forEach(t=>{let n=t.name;Object.defineProperty(this,n,{get:()=>{let r=t.cache?this._options:ZA();return n in r?r[n]:t.default},set:t.readonly?void 0:r=>{this._options[n]=r,pg(this._options,n)}})}),eO()}play(){this._operate("play")}pause(){this._operate("pause")}stop(){this._operate("stop")}seek(t){this._operate("seek",{currentTime:t})}_operate(t,n){QA(z.extend({},n,{operationType:t}))}}let mg,nO=Dt(xb,()=>mg||(mg=new vg));class rO{constructor(t,n){this.id=t,this.ctx=n}start(t){return Yt(this.ctx,"start",t)}stop(t){return Yt(this.ctx,"stop",t)}pause(t){return Yt(this.ctx,"pause",t)}resume(t){return Yt(this.ctx,"resume",t)}switchCamera(t){return Yt(this.ctx,"switchCamera",t)}snapshot(t){return Yt(this.ctx,"snapshot",t)}toggleTorch(t){return Yt(this.ctx,"toggleTorch",t)}playBGM(t){return jt(this.ctx,"playBGM",t)}stopBGM(t){return Yt(this.ctx,"stopBGM",t)}pauseBGM(t){return Yt(this.ctx,"pauseBGM",t)}resumeBGM(t){return Yt(this.ctx,"resumeBGM",t)}setBGMVolume(t){return jt(this.ctx,"setBGMVolume",t)}startPreview(t){return Yt(this.ctx,"startPreview",t)}stopPreview(t){return Yt(this.ctx,"stopPreview",t)}}function Is(e,t,n,r){ot.invokeViewMethod("livepusher."+e,{livePusherId:e,type:n,data:r},t)}class iO{constructor(t,n){this.id=t,this.pageId=n}start(){Is(this.id,this.pageId,"start")}stop(){Is(this.id,this.pageId,"stop")}pause(){Is(this.id,this.pageId,"pause")}resume(){Is(this.id,this.pageId,"resume")}switchCamera(){Is(this.id,this.pageId,"switchCamera")}startPreview(){Is(this.id,this.pageId,"preview")}stopPreview(){Is(this.id,this.pageId,"stop")}snapshot(){Is(this.id,this.pageId,"snapshot")}}let oO=Dt(v_,(e,t)=>{if(t.$page.meta.isNVue){if(!t)return console.warn("uni.createLivePusherContext: 2 arguments required, but only 1 present");let n=Ut(e,t);return n?new rO(e,n):console.warn("Can not find `"+e+"`")}return new iO(e,t.$page.id)},m_),Pi=3.141592653589793,Dc=6378245,Lc=.006693421622965943;function aO(e,t){if(t=+t,e=+e,_g(e,t))return[e,t];let n=bg(e-105,t-35),r=yg(e-105,t-35),o=t/180*Pi,c=Math.sin(o);c=1-Lc*c*c;let g=Math.sqrt(c);n=n*180/(Dc*(1-Lc)/(c*g)*Pi),r=r*180/(Dc/g*Math.cos(o)*Pi);let b=t+n,V=e+r;return[e*2-V,t*2-b]}function sO(e,t){if(t=+t,e=+e,_g(e,t))return[e,t];let n=bg(e-105,t-35),r=yg(e-105,t-35),o=t/180*Pi,c=Math.sin(o);c=1-Lc*c*c;let g=Math.sqrt(c);n=n*180/(Dc*(1-Lc)/(c*g)*Pi),r=r*180/(Dc/g*Math.cos(o)*Pi);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*Pi)+20*Math.sin(2*e*Pi))*2/3,n+=(20*Math.sin(t*Pi)+40*Math.sin(t/3*Pi))*2/3,n+=(160*Math.sin(t/12*Pi)+320*Math.sin(t*Pi/30))*2/3,n},yg=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*Pi)+20*Math.sin(2*e*Pi))*2/3,n+=(20*Math.sin(e*Pi)+40*Math.sin(e/3*Pi))*2/3,n+=(150*Math.sin(e/12*Pi)+300*Math.sin(e/30*Pi))*2/3,n};function Eg(e,t,n){let r=t.coords;if(e!==t.coordsType){let o;e==="wgs84"?o=aO(r.longitude,r.latitude):e==="gcj02"&&(o=sO(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 lO=Te(py,({type:e="wgs84",geocode:t=!1,altitude:n=!1,highAccuracyExpireTime:r,isHighAccuracy:o=!1},{resolve:c,reject:g})=>{s.geolocation.getCurrentPosition(b=>{Eg(e,b,c)},b=>{if(b.code===1501){Eg(e,b,c);return}g("getLocation:fail "+b.message)},{geocode:t,enableHighAccuracy:o||n,timeout:r,coordsType:e})},my,vy),cO=Te(hy,(e,{resolve:t,reject:n})=>{let o=Wh()!=="light",c,g=Yi({url:"__uniappchooselocation",data:z.extend({},e,{locale:Kl()}),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"),g.webview.addEventListener("popGesture",({type:b,result:V})=>{b==="start"?s.navigator.setStatusBarStyle("dark"):b==="end"&&!V&&s.navigator.setStatusBarStyle("light")}))},gy),uO=Te(_y,(e,{resolve:t,reject:n})=>(Yi({url:"__uniappopenlocation",data:z.extend({},e,{locale:Kl()}),style:{titleNView:{type:"transparent"},popGesture:"close",backButtonAutoControl:"close"},onClose(){n("cancel")}}),t()),yy,by),Fc=!1,sc=0,fO=Te(bE,(e,{resolve:t,reject:n})=>{sc=sc||s.geolocation.watchPosition(r=>{Fc=!0,ot.invokeOnCallback(Ch,r.coords)},r=>{Fc||(n(r.message),Fc=!0),ot.invokeOnCallback(Ah,{errMsg:`onLocationChange:fail ${r.message}`})},{coordsType:e==null?void 0:e.type}),N(t,100)},wE,CE),dO=Te(yE,(e,{resolve:t})=>{sc&&(s.geolocation.clearWatch(sc),Fc=!1,sc=0),t()}),hO=pn(Ch,()=>{}),gO=Xr(EE,()=>{}),pO=pn(Ah,()=>{}),vO=Xr(SE,()=>{}),mO=Te(lS,({title:e="",content:t="",showCancel:n=!0,cancelText:r,cancelColor:o,confirmText:c,confirmColor:g,editable:b=!1,placeholderText:V=""}={},{resolve:T})=>{let L=n?[r,c]:[c],_e=b?V:L;t=t||" ",s.nativeUI[b?"prompt":"confirm"](t,we=>{if(n){let Pe=we.index===1,ft={confirm:Pe,cancel:we.index===0||we.index===-1};Pe&&b&&(ft.content=we.value),T(ft)}else{let Pe={confirm:we.index===0,cancel:!1};b&&(Pe.content=we.value),T(Pe)}},e,_e,L)},cS,uS),_O={light:{itemColor:"#000000"},dark:{itemColor:"rgba(255, 255, 255, 0.8)"}},bO=Te(nS,({itemList:e=[],itemColor:t,title:n="",popover:r},{resolve:o,reject:c})=>{t==="#000"&&R.darkmode&&(t=_O[s.navigator.getUIStyle()].itemColor),kt();let{t:g}=ae(),b={title:n,cancel:g("uni.showActionSheet.cancel"),buttons:e.map(V=>({title:V,color:t}))};s.nativeUI.actionSheet(z.extend(b,{popover:r}),V=>{V.index>0?o({tapIndex:V.index-1}):c("showActionSheet:fail cancel")})},rS,iS),lc,ef=!1,Vc="",Uc,yO=Te(oS,(e,t)=>Sg(z.extend({},e,{type:"loading",icon:"loading"}),t),aS,sS),Sg=({title:e="",icon:t="success",image:n="",duration:r=1500,mask:o=!1,position:c,type:g="toast",style:b},{resolve:V,reject:T})=>{if($c(""),Vc=g,["top","center","bottom"].includes(String(c)))s.nativeUI.toast(e,{verticalAlign:c}),ef=!0;else{t&&!~["success","loading","error","none"].indexOf(t)&&(t="success");let L={modal:o,back:"transmit",padding:"10px",size:"16px"};!n&&(!t||t==="none")?L.loading={display:"none"}:(L.width="140px",L.height="112px"),n?L.loading={display:"block",height:"55px",icon:n,interval:r}:["success","error"].indexOf(t)!==-1&&(L.loading={display:"block",height:"55px",icon:t==="success"?"__uniappsuccess.png":"__uniapperror.png",interval:r});try{lc=s.nativeUI.showWaiting(e,z.extend(L,b))}catch(_e){T(`${_e}`)}}return Vc==="toast"&&(Uc=N(()=>{$c("")},r)),V()},EO=Te(fS,Sg,hS,gS),SO=Te(zE,(e,t)=>$c("toast",t)),wO=Te(jE,(e,t)=>$c("loading",t));function $c(e="toast",t){return e&&e!==Vc||(Uc&&(E(Uc),Uc=null),ef?s.nativeUI.closeToast():lc&&lc.close&&lc.close(),lc=null,ef=!1,Vc=""),t&&t.resolve()}let CO=Te(pS,(e,{resolve:t,reject:n})=>{let r=zh();if(r&&r.endPullToRefresh(),r=Rc(),!r)return n();r.beginPullToRefresh(),zu(r),t()}),AO=Te(vS,(e,{resolve:t,reject:n})=>{let r=zh()||Rc();if(!r)return n();r.endPullToRefresh(),zu(null),t()}),OO=Te(Nh,(e,{resolve:t,reject:n})=>{let r=Fn(br());ot.invokeViewMethod(Nh,e,r,o=>{o?n(o):t()})},WE),TO=Te(kh,(e,{resolve:t})=>{let n=Fn(br());ot.invokeViewMethod(kh,e,n,t)},eS,tS),PO=Te(KE,({__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()},ZE),IO=Te(XE,(e,{resolve:t})=>{s.nativeUI.showWaiting("",{modal:!1}),t()}),NO=Te(QE,(e,{resolve:t})=>{s.nativeUI.closeWaiting(),t()});function kO(e){let t=In();!t.length||(t[t.length-1].$page.statusBarStyle=e)}let RO=Te(YE,({__page__:e,frontColor:t,backgroundColor:n},{resolve:r,reject:o})=>{let c=Hh(e);if(c){let g={};t&&(g.titleColor=t),n&&(g.backgroundColor=n);let b=t==="#000000"?"dark":"light";s.navigator.setStatusBarStyle(b),kO(b);let V=c.getStyle();V&&V.titleNView&&(V.titleNView.autoBackButton&&(g.backButton=g.backButton||{},g.backButton.color=t),c.setStyle({titleNView:g})),r()}else o()},JE,qE),xO=Te(DS,({index:e,text:t},{resolve:n,reject:r})=>{di.setTabBarBadge("text",e,t),n()},LS,FS),BO=Te(mS,({index:e,text:t,iconPath:n,selectedIconPath:r,pagePath:o,visible:c,iconfont:g},{resolve:b})=>{if(di.setTabBarItem(e,t,n,r,c,g),o){let V=R.tabBar.list[e];if(V){let T=V.pagePath,L=J.removeLeadingSlash(o);L!==T&&as(e,T,L)}}b()},_S,bS),MO=Te(yS,(e={},{resolve:t,reject:n})=>{if(!tc())return n("not TabBar page");e.borderStyle=J.normalizeTabBarStyles(e.borderStyle),di.setTabBarStyle(e),t()},ES,wS),DO=Te(CS,(e,{resolve:t,reject:n})=>{let r=e&&e.animation;if(!tc())return n("not TabBar page");di.hideTabBar(Boolean(r)),t()},Rh),LO=Te(AS,(e,{resolve:t,reject:n})=>{let r=e&&e.animation;if(!tc())return n("not TabBar page");di.showTabBar(Boolean(r)),t()},OS),FO=Te(NS,({index:e},{resolve:t,reject:n})=>{di.setTabBarBadge("redDot",e),t()},kS,RS),wg=e=>di.setTabBarBadge("none",e),VO=Te(xS,({index:e},{resolve:t,reject:n})=>{wg(e),t()},BS,MS),UO=Te(TS,({index:e},{resolve:t,reject:n})=>{wg(e),t()},PS,IS),Cg="vdSync",$O="__uniapp__service",Rl="onWebviewReady",HO=0,jO="webviewInserted",zO="webviewRemoved",Ag="UniAppSubNVue";class WO{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:g}){Jo("uni-tabview").setMask({color:g})}}: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})})}};Jo("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}},$O)}onMessage(t){this.initMessage(),this.callbacks.push(t)}}let GO=function(e,t){return new WO(e,t)};function YO(e,t,n,r,o,c,g){s!==n&&(w=hn=e,f=t,s=n,zw(s.navigator.setStatusBarStyle),s.navigator.setStatusBarStyle=Fh,N=r,E=o,h=c,y=g),R.serviceReady=!0}function qO(){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 JO(e){z.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 f!="undefined"||typeof s!="undefined"){let t=s.push.getClientInfo();e(null,[t.id],[t])}else e(null,[])}},KO=Te(VS,({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(g=>(typeof g.serviceReady=="boolean"&&(g.isAppExist=g.serviceReady),typeof g.nativeClient=="boolean"&&(g.isAppExist=g.nativeClient),g))})}):n("service not found")},US),Hc;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=Te($S,(e,{resolve:t,reject:n})=>{let r=e.provider||"weixin",o=dr(n),c=r==="apple",g=c?{scope:"email"}:e.univerifyStyle?{univerifyStyle:QO(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 L=T.target.authResult,_e=T.target.appleInfo;t({code:L.code,authResult:L,appleInfo:_e})},o,g)}c||r==="univerify"?V():b.logout(V,V)}).catch(o)},HS),Pg=(e,{resolve:t,reject:n})=>{let r=e.provider||"weixin",o=dr(n);cc(r).then(c=>{c.getUserInfo(g=>{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")})},ZO=Te(jS,Pg,zS),XO=Te(WS,Pg,GS),Ig=Te(YS,({provider:e},{resolve:t,reject:n})=>{let r=Xs(t),o=dr(n);cc(e).then(c=>c.preLogin(r,o)).catch(o)},KS,JS),Ng=()=>cc("univerify").then(e=>e.closeAuthView()),kg=Dt(ZS,Ng),Rg=Te(XS,(e,{resolve:t,reject:n})=>{let r=Xs(t),o=dr(n);try{cc("univerify").then(c=>{let g=c.getCheckBoxState();r({state:g})})}catch(c){o(c)}});function QO(e,t){return z.isPlainObject(e)&&z.isPlainObject(e.buttons)&&z.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};z.isPlainObject(Hc)?Hc._triggerUniverifyButtonsClick(o):Ng().then(()=>{t(o)})}}),e}class eT{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){ot.on(this.eventName,t)}offButtonsClick(t){ot.off(this.eventName,t)}_triggerUniverifyButtonsClick(t){ot.emit(this.eventName,t)}_getOptions(t={}){return z.extend({},t,{provider:this.provider})}}let tT=Dt(QS,()=>Hc||(Hc=new eT)),nT=Te(lw,(e,{resolve:t,reject:n})=>{let r=cg();if(r.notificationAuthorized!=="authorized")return n("notificationAuthorized: "+r.notificationAuthorized);let o=z.extend({},e);delete o.content,delete o.payload,s.push.createMessage(e.content,e.payload,o),t()},void 0,cw),rT=Dt("registerRuntime",e=>{z.extend(jsRuntime,e)}),iT={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"}},oT=e=>{e.type=e.type||0;let{provider:t,type:n,title:r,summary:o,href:c,imageUrl:g,mediaUrl:b,scene:V,miniProgram:T,openCustomerServiceChat:L,corpid:_e,customerUrl:we}=e;z.isString(g)&&g&&(g=je(g));let Pe=iT[n];if(Pe){let ft={provider:t,type:Pe.name,title:r,content:o,href:c,pictures:[g],thumbs:g?[g]:void 0,media:b,miniProgram:T,extra:{scene:V},openCustomerServiceChat:L,corpid:_e,url:we};return t==="weixin"&&(n===1||n===2)&&delete ft.thumbs,ft}return"\u5206\u4EAB\u53C2\u6570 type \u4E0D\u6B63\u786E"},xg=function(e,t,n,r,o="share"){let c=dr(r),g=t.openCustomerServiceChat?"openCustomerServiceChat":"send";try{e[g](t,()=>{n()},c)}catch(b){c({message:`${t.provider} ${g} \u65B9\u6CD5\u8C03\u7528\u5931\u8D25`})}},aT=Te(ew,(e,{resolve:t,reject:n})=>{let r=oT(e),o=dr(n);if(z.isString(r))return n(r);s.share.getServices(c=>{let g=c.find(({id:b})=>b===r.provider);g?g.authenticated?xg(g,r,t,n):g.authorize(()=>xg(g,r,t,n),o):n("service not found")},o)},nw,tw),sT=Te(rw,({type:e,imageUrl:t,summary:n,href:r},{resolve:o,reject:c})=>{let g=dr(c);z.isString(t)&&t&&(t=je(t)),s.share.sendWithSystem({type:e,pictures:t?[t]:void 0,content:n,href:r},()=>o(),g)},ow,iw),lT=Te(aw,(e,{resolve:t,reject:n})=>{let r=e.provider,o=dr(n);s.payment.getChannels(c=>{let g=c.find(({id:b})=>b===r);g?s.payment.request(g,e.orderInfo,b=>{t(b)},o):n("service not found")},o)},sw),Bg=eg,cT=Te("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()})}),Mg=[];function Dg(e){Mg.push(e)}let uT=Dg;function fT(e,t){Mg.forEach(n=>n(e,t))}function dT(e,t,...n){let r=pT(e,t,n);r&&console[e](r)}function hT(){return typeof __channelId__=="string"&&__channelId__}function gT(e,t){switch(z.toRawType(t)){case"Function":return"function() { [native code] }";default:return t}}function pT(e,t,n){return hT()?(n.push(t.replace("at ","uni-app:///")),console[e].apply(console,n)):n.map(function(o){let c=z.toTypeString(o).toLowerCase();if(["[object object]","[object array]","[object module]"].indexOf(c)!==-1)try{o="---BEGIN:JSON---"+JSON.stringify(o,gT)+"---END:JSON---"}catch(g){o=c}else if(o===null)o="---NULL---";else if(o===void 0)o="---UNDEFINED---";else{let g=z.toRawType(o).toUpperCase();g==="NUMBER"||g==="BOOLEAN"?o="---BEGIN:"+g+"---"+o+"---END:"+g+"---":o=String(o)}return o}).join("---COMMA---")+" "+t}let vT=1,tf,uc={};function Lg(e){if(typeof e=="function"){let t=Object.keys(uc).find(r=>uc[r]===e),n=t?parseInt(t):vT++;return uc[n]=e,n}else z.isPlainObject(e)&&Object.keys(e).forEach(t=>{e[t]=Lg(e[t])});return e}function mT(e,t,n,r){return rf(e,t,n,r)}function nf(){return tf||(tf=P.requireNativePlugin("UTS-Proxy")),tf}function Fg(e,t,n,r,o){if(!t)throw new Error("\u8FD4\u56DE\u503C\u4E3A\uFF1A"+JSON.stringify(t)+"\uFF1B\u8BF7\u6C42\u53C2\u6570\u4E3A\uFF1A"+JSON.stringify(e));if(z.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(of[n.options]){let c=Hg(z.extend({instanceId:t.params},of[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,nf().invokeSync(e,()=>{}))}function rf(e,{moduleName:t,moduleType:n,package:r,class:o,name:c,method:g,companion:b,params:V,return:T,errMsg:L},_e,we){let Pe=({id:ht,name:Ft,params:St,keepAlive:mn})=>{let tn=uc[ht];tn?(tn(...St),mn||delete uc[ht]):console.error(`${r}${o}.${c} ${Ft} is not found`)},ft=_e?{moduleName:t,moduleType:n,id:_e,name:c,method:V}:{moduleName:t,moduleType:n,package:r,class:o,name:g||c,companion:b,method:V};return(...ht)=>{if(L)throw new Error(L);let Ft=z.extend({},ft,{params:ht.map(St=>Lg(St))});return e?new Promise((St,mn)=>{nf().invokeAsync(Ft,tn=>{tn.type!=="return"?Pe(tn):tn.errMsg?mn(tn.errMsg):St(tn.params)})}):Fg(Ft,nf().invokeSync(Ft,Pe),T,_e,we)}}function Ug(e,t){return t.main&&!t.method&&typeof s!="undefined"&&s.os.name==="iOS"&&(t.method="s_"+t.name),rf(e,t,0)}let _T=Ug;function $g(e,t){return z.hasOwn(t,e+"ByJs")?e+"ByJs":e}function bT(e){return typeof e=="undefined"}function yT(e){return!bT(e.instanceId)}function Hg(e){let{moduleName:t,moduleType:n,package:r,class:o,methods:c,props:g,errMsg:b}=e,V={moduleName:t,moduleType:n,package:r,class:o,errMsg:b},T,L=[],_e={},we=[],Pe=!1;yT(e)?(Pe=!0,T=e.instanceId):(L=e.constructor.params,_e=e.staticMethods,we=e.staticProps),typeof s!="undefined"&&s.os.name==="iOS"&&L.find(Ft=>Ft.type==="UTSCallback"||Ft.type.indexOf("JSONObject")>0)&&L.push({name:"_byJs",type:"boolean"});let ft=class{constructor(...St){if(this.__instanceId=0,b)throw new Error(b);let mn={};if(Pe?typeof T=="number"&&(this.__instanceId=T):this.__instanceId=rf(!1,z.extend({name:"constructor",params:L},V),0).apply(null,St),!this.__instanceId)throw new Error(`new ${o} is failed`);let tn=this,nn=new Proxy(tn,{get(Et,Kt){if(!mn[Kt]){if(Kt=$g(Kt,c),z.hasOwn(c,Kt)){let{async:cn,params:Zt,return:Cn}=c[Kt];mn[Kt]=mT(!!cn,z.extend({name:Kt,params:Zt,return:Cn},V),tn.__instanceId,nn)}else if(g.includes(Kt))return Vg({moduleName:t,moduleType:n,id:tn.__instanceId,name:Kt,errMsg:b})}return mn[Kt]}});return nn}},ht={};return new Proxy(ft,{get(Ft,St,mn){if(St=$g(St,_e),z.hasOwn(_e,St)){if(!ht[St]){let{async:tn,params:nn,return:Et}=_e[St];ht[St]=Ug(!!tn,z.extend({name:St,companion:!0,params:nn,return:Et},V))}return ht[St]}return we.includes(St)?Vg(z.extend({name:St,companion:!0},V)):Reflect.get(Ft,St,mn)}})}function ET(e,t){return typeof s!="undefined"&&s.os.name==="Android"?"uts.sdk."+(t?"modules.":"")+e:""}function ST(e,t){return typeof s=="undefined"?"":jg(e,s.os.name==="iOS"?"IndexSwift":"IndexKt",t)}function jg(e,t,n){return typeof s=="undefined"?"":s.os.name==="Android"?t:s.os.name==="iOS"?"UTSSDK"+(n?"Modules":"")+z.capitalize(e)+z.capitalize(t):""}let of={};function wT(e,t){of[e]=t}let zg={};function CT(e,t){zg[e]=t}function AT(e){let t=zg[e];return t||console.error(`${e} is not found`),t}let Eo={load:"load",close:"close",error:"error",adClicked:"adClicked"};class Wg{constructor(){this._callbacks={}}onLoad(t){this._addEventListener(Eo.load,t)}onClose(t){this._addEventListener(Eo.close,t)}onError(t){this._addEventListener(Eo.error,t)}offLoad(t){this._removeEventListener(Eo.load,t)}offClose(t){this._removeEventListener(Eo.close,t)}offError(t){this._removeEventListener(Eo.error,t)}_addEventListener(t,n){!z.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 af extends Wg{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(Eo.load,{})}),r.onClose(o=>{this._isLoaded=!1,this._isLoading=!1,this._dispatchEvent(Eo.close,o),this.preload===!0&&this._loadAd()}),r.onError(o=>{this._isLoading=!1;let c={code:o.code,errMsg:o.message};this._dispatchEvent(Eo.error,c);let g=new Error(JSON.stringify(c));this._loadPromiseReject!=null&&(this._loadPromiseReject(g),this._loadPromiseReject=null),this._showPromiseReject!=null&&(this._showPromiseReject(g),this._showPromiseReject=null)}),r.onAdClicked&&r.onAdClicked(()=>{this._dispatchEvent(Eo.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 OT extends af{constructor(t){super(s.ad.createRewardedVideoAd(t),t);this._loadAd()}}let TT=Dt(uw,e=>new OT(e),dw,fw);class PT extends af{constructor(t){super(s.ad.createFullScreenVideoAd(t),t);this.preload=!1}}let IT=Dt(hw,e=>new PT(e),pw,gw);class NT extends af{constructor(t){super(s.ad.createInterstitialAd(t),t);this.preload=!1,this._loadAd()}}let kT=Dt(vw,e=>new NT(e),_w,mw),Sa={},tl={};function RT(e){let t=e.provider;if(Sa[t]||(Sa[t]={}),typeof Sa[t].plugin=="object"){e.success(Sa[t].plugin);return}if(tl[t]||(tl[t]=[]),tl[t].push(e),Sa[t].status===!0){e.__plugin=Sa[t].plugin;return}Sa[t].status=!0;let n=Jo(t);if(!n||!n.initSDK){tl[t].forEach(r=>{r.fail({code:-1,message:"provider ["+t+"] invalid"})}),tl[t].length=0,Sa[t].status=!1;return}Sa[t].plugin=n,e.__plugin=n,n.initSDK(r=>{let o=r.code===1||r.code==="1";o?Sa[t].plugin=n:Sa[t].status=!1,tl[t].forEach(c=>{o?c.success(c.__plugin):c.fail(r)}),tl[t].length=0})}class xT extends Wg{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,N(()=>{this._init()})}_init(){this._adError="",RT({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(Eo.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(Eo.load,t)},t=>{this._isLoading=!1,this._showPromiseReject!=null&&(this._showPromiseReject(this._createError(t)),this._showPromiseReject=null),this._dispatchEvent(Eo.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(Eo.error,t)})}_createError(t){return new Error(JSON.stringify(t))}}let BT=Dt(bw,e=>new xT(e),Ew,yw),Gg=s.os.name==="Android"&&parseInt(s.os.version)<6,MT=Gg?"slide-in-right":"pop-in",jc=300,Yg=Gg?"slide-out-right":"pop-out",DT="_www/__uniappview.html",LT="webviewId",FT="uniMPNativeEvent";function VT(e,t,n){n&&t.isNVue&&(e.uniNView={path:n,defaultFontSize:R.defaultFontSize,viewport:R.viewport})}let UT=/^#[a-z0-9]{6}$/i;function $T(e){return e&&(UT.test(e)||e==="transparent")}function HT(e,t){let{backgroundColor:n}=t;!n||!$T(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 jT(e,t){e.popGesture==="hide"&&delete e.popGesture,t.isQuit&&(e.popGesture=s.os.name==="iOS"?"appback":"none")}function zT(e,t){if(!t.enablePullDownRefresh)return;let n=Ua(z.extend({},s.os.name==="Android"?GT:YT,t.pullToRefresh));e.pullToRefresh=WT(n,t)}function WT(e,t){let n=_r(e);if(!n)return e;let[r,o,c]=n;return(r||o||c)&&P.onLocaleChange(()=>{let g=s.webview.getWebviewById(t.id+"");if(!g)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}),g.setStyle({pullToRefresh:b})}),e}let GT={support:!0,style:"circle"},YT={support:!0,style:"default",height:"50px",range:"200px",contentdown:{caption:""},contentover:{caption:""},contentrefresh:{caption:""}};function qT(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 g=n[c];c==="titleImage"&&g?o.tags=KT(g):c==="buttons"&&z.isArray(g)?o.buttons=g.map((b,V)=>(b.onclick=ZT(V),b)):o[c]=g}),e.titleNView=JT(o,t)}function JT(e,t){let n=Dn(e);if(!n)return e;let[r,o]=n;return(r||o)&&P.onLocaleChange(()=>{let c=s.webview.getWebviewById(t.id+"");if(!c)return;let g={};r&&(g.titleText=e.titleText),o&&(g.searchInput={placeholder:e.searchInput.placeholder}),c.setStyle({titleNView:g})}),e}function KT(e){return[{tag:"img",src:e,position:{left:"auto",top:"auto",width:"auto",height:"26px"}}]}function ZT(e){return function(n){n.index=e,Vn(J.ON_NAVIGATION_BAR_BUTTON_TAP,n)}}function qg(e,t,n){let r={bounce:"vertical"};return Object.keys(t).forEach(o=>{XT.indexOf(o)===-1&&(r[o]=t[o])}),n.id!=="1"&&VT(r,t,e),jT(r,t),HT(r,t),qT(r,t),zT(r,t),r}let XT=["id","route","isNVue","isQuit","isEntry","isTabBar","tabBarIndex","windowTop","topWindow","leftWindow","rightWindow","maxWidth","usingComponents","disableScroll","enablePullDownRefresh","navigationBar","pullToRefresh","onReachBottomDistance","pageOrientation","backgroundColor"],Jg=2;function Kg(){return Jg}function Zg(){return Jg++}function Xg(e){return e}function Qg(e,t){let n=t?J.stringifyQuery(t,Xg):"";return{path:e.slice(1),query:n&&n.slice(1)}}function QT(e,t,n){let r=n?J.stringifyQuery(n,Xg):"";return{isTab:e,arguments:JSON.stringify({path:t.slice(1),query:r&&r.slice(1)})}}function eP({path:e,query:t,routeOptions:n,webviewExtras:r}){let o=()=>qg(e,Hu(n.meta),{id:c+""}),c=Zg(),g=o();g.uniPageUrl=Qg(e,t),g.isTab=!!n.meta.isTabBar;let b=s.webview.create("",String(c),g,z.extend({nvue:!0,__path__:e,__query__:JSON.stringify(t)},r));return $h(b,o),b}let Li;function ep(e){Li=e}function tP(){return Li}function nP(){return(!Li||Li.__uniapp_route)&&(Li=s.webview.create(DT,String(Zg()),{contentAdjust:!1})),Li}function rP(e){let{popupSubNVueWebviews:t}=e;!t||e.addEventListener("close",()=>{Object.keys(t).forEach(n=>{t[n].close("none")})})}function tp(e){return R.realEntryPagePath&&e.$page.route===R.entryPagePath}function np(){R.entryPagePath=R.realEntryPagePath,delete R.realEntryPagePath,P.reLaunch({url:J.addLeadingSlash(R.entryPagePath)})}function iP(e){let t;e.addEventListener("popGesture",n=>{if(n.type==="start"){let r=In(),o=r[r.length-2];t=nc;let c=o&&o.$page.statusBarStyle;c&&Ba(c)}else if(n.type==="end"&&!n.result)Ba(t);else if(n.type==="end"&&n.result){let r=In().length,o=wi();zr(),Ba(),o&&r===1&&tp(o)?np():Vn(J.ON_SHOW)}})}function oP(e){if(e.nvue)return;let t=e.id,{subscribe:n,unsubscribe:r}=ot,o=(c,g)=>{if(t!==g)return;r(Rl,o);let b=Ir(parseInt(g));b&&b.__page_container__.restore()};e.addEventListener("recovery",()=>{n(Rl,o)})}function aP(e){let{emit:t}=ot,n=function({width:r,height:o}){let g={deviceOrientation:Math.abs(s.navigator.getOrientation())===90?"landscape":"portrait",size:{windowWidth:Math.ceil(r),windowHeight:Math.ceil(o)}};t(J.ON_RESIZE,g,parseInt(e.id))};e.addEventListener("resize",J.debounce(n,50,{setTimeout:N,clearTimeout:E}))}let rp={pullToRefresh:J.ON_PULL_DOWN_REFRESH,titleNViewSearchInputChanged:J.ON_NAVIGATION_BAR_SEARCH_INPUT_CHANGED,titleNViewSearchInputConfirmed:J.ON_NAVIGATION_BAR_SEARCH_INPUT_CONFIRMED,titleNViewSearchInputClicked:J.ON_NAVIGATION_BAR_SEARCH_INPUT_CLICKED,titleNViewSearchInputFocusChanged:J.ON_NAVIGATION_BAR_SEARCH_INPUT_FOCUS_CHANGED};function sP(e){let t=parseInt(e.id);Object.keys(rp).forEach(n=>{let r=rp[n];e.addEventListener(n,o=>{r===J.ON_PULL_DOWN_REFRESH&&zu(e),Vn(t,r,o)})}),rP(e),aP(e),s.os.name==="iOS"&&(oP(e),iP(e))}function lP(e,t,n,r){let o=()=>qg(t,Hu(r),e),c=o();c.uniPageUrl=Qg(t,n);let g=!!r.isTabBar;r.isNVue?c.isTab=g:c.debugRefresh=QT(g,t,n),c.locale=f.requireModule("plus").getLanguage(),$h(e,o),e.setStyle(c)}function cP(e,t,n){(n.subNVues||[]).forEach(o=>{if(!o.path)return;let c=Va(o.style||{}),g=o.type==="navigationBar",b=o.type==="popup";c.uniNView={path:o.path.replace(".nvue",".js"),defaultFontSize:R.defaultFontSize,viewport:R.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;g?(c.position="dock",c.dock="top",c.top="0",c.width="100%",c.height=String(J.NAVBAR_HEIGHT+Wu()),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 L=s.webview.create("",o.id,c,V);if(b){T.popupSubNVueWebviews||(T.popupSubNVueWebviews={}),T.popupSubNVueWebviews[L.id]=L;let _e=function(){T.setStyle({mask:"none"}),L.hide("auto")};T.addEventListener("maskClick",_e);let we=!1;L.addEventListener("show",()=>{we||(s.key.removeEventListener("backbutton",Di),s.key.addEventListener("backbutton",_e),we=!0)}),L.addEventListener("hide",()=>{we&&(s.key.removeEventListener("backbutton",_e),s.key.addEventListener("backbutton",Di),we=!1)}),L.addEventListener("close",()=>{delete T.popupSubNVueWebviews[L.id],we&&(s.key.removeEventListener("backbutton",_e),s.key.addEventListener("backbutton",Di),we=!1)})}else e.append(L)})}function uP(e,t,n,r){(e.id==="1"||!r.isNVue)&&lP(e,t,n,r),cP(e,t,r),sP(e)}function ip(e){return e.routeOptions.meta.isNVue?eP(e):Kg()===2?s.webview.getLaunchWebview():tP()}function op(e,t){ot.once(Rl+"."+e,t)}let wa=!1;function ap(e,t,n){wa={path:e,nvue:os(e).isNVue,callback:t}}function sp(e,t,n){na(e),nl(e.$getAppWebview(),t,n)}function zc(e,t,n=!1){if(!n&&wa)return console.error(`Waiting to navigate to: ${wa.path}, do not operate continuously: ${e}.`);if(R.renderer==="native")return In().length===0?ap(e,t,"waitForReady"):t();let r=!Li||Li&&Li.__uniapp_route,o=Li&&!Li.loaded;r||o?ap(e,t,r?"waitForCreate":"waitForReady"):t(),o&&op(Li.id,Wc)}function Wc(){if(!wa)return;let{callback:e}=wa;return wa=!1,e()}function lp(){if(R.renderer==="native")return wa&&wa.nvue?Wc():void 0;let e=nP();if(!!wa){if(wa.nvue)return Wc();e.loaded?wa.callback():op(e.id,Wc)}}function nl(e,t,n){e[e.__preload__?"hide":"close"](t,n)}function Gc(e,t,n,r,o){typeof o=="undefined"&&(o=e.nvue?0:100);let c=function(){c._called||(c._called=!0,r&&r(),lp())};c._called=!1,N(()=>{let g=N(()=>{c()},n+150);e.show(t,n,()=>{c._called||E(g),c()})},o)}function fP(e,t){let n=e.children();if(!n||!n.length)return t();let r=n.find(o=>o.id.indexOf(LT)===0)||n[0];r.canBack(({canBack:o})=>{o?r.back():t()})}let dP=Te(PE,(e,{resolve:t,reject:n})=>{let r=wi();if(!r)return n("getCurrentPages is empty");if(Vn(r,J.ON_BACK_PRESS,{from:e.from||"navigateBack"}))return t();if(P.hideToast(),P.hideLoading(),r.$page.meta.isQuit)hP();else if(tp(r))np();else{let{delta:o,animationType:c,animationDuration:g}=e;gP(o,c,g)}return t()},NE,UE),Yc=0;function hP(){vt(),Yc?Date.now()-Yc<2e3&&s.runtime.quit():(Yc=Date.now(),s.nativeUI.toast(ae().t("uni.app.quit")),N(()=>{Yc=0},2e3))}function gP(e,t,n){let r=In(),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 g=function(V){t?nl(V,t,n||jc):c.$page.openType==="redirectTo"?nl(V,Yg,jc):nl(V,"auto"),r.slice(o-e,o).forEach(T=>na(T)),Ba(),Vn(J.ON_SHOW)},b=s.webview.getWebviewById(c.$page.id+"");if(!c.__uniapp_webview)return g(b);fP(b,()=>{g(b)})}class pP extends J.UniNode{constructor(t,n,r=!1){super(J.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=[J.ACTION_TYPE_PAGE_CREATE,n],this.createdAction=[J.ACTION_TYPE_PAGE_CREATED],this.normalizeDict=this._normalizeDict.bind(this),this._update=this.update.bind(this),r&&this.setup()}_normalizeDict(t,n=!0){if(!z.isPlainObject(t))return this.addDict(t);let r=[];return Object.keys(t).forEach(o=>{let c=[this.addDict(o)],g=t[o];n?c.push(this.addDict(g)):c.push(g),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===J.ON_PAGE_SCROLL||t===J.ON_REACH_BOTTOM)&&!this.scrollAction&&(this.scrollAction=[J.ACTION_TYPE_PAGE_SCROLL,this.options.onReachBottomDistance],this.push(this.scrollAction))}onCreate(t,n){return _P(this,t.nodeId,n),t}onInsertBefore(t,n,r){return bP(this,n,t.nodeId,r&&r.nodeId||-1),n}onRemoveChild(t){return yP(this,t.nodeId),t}onAddEvent(t,n,r){t.parentNode&&EP(this,t.nodeId,n,r)}onAddWxsEvent(t,n,r,o){t.parentNode&&SP(this,t.nodeId,n,r,o)}onRemoveEvent(t,n){t.parentNode&&wP(this,t.nodeId,n)}onSetAttribute(t,n,r){t.parentNode&&AP(this,t.nodeId,n,r)}onRemoveAttribute(t,n){t.parentNode&&OP(this,t.nodeId,n)}onTextContent(t,n){t.parentNode&&up(this,t.nodeId,n)}onNodeValue(t,n){t.parentNode&&up(this,t.nodeId,n)}genId(){return this._id++}push(t,n){if(!this.isUnmounted){switch(t[0]){case J.ACTION_TYPE_CREATE:this._createActionMap.set(t[1],t);break;case J.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]!==J.ACTION_TYPE_INSERT&&this.updateActions.push(t),this._updating||(this._updating=!0,hn.queuePostFlushCb(this._update))}}restore(){this.clear(),this.setup(),this.scrollAction&&this.push(this.scrollAction);let t=n=>{this.onCreate(n,n.nodeName),this.onInsertBefore(n.parentNode,n,null),n.childNodes.forEach(r=>{t(r)})};this.childNodes.forEach(n=>t(n)),this.push(this.createdAction)}setup(){this.send([this.createAction])}update(){let{dicts:t,updateActions:n,_createActionMap:r}=this;this._created||(this._created=!0,n.push(this.createdAction)),n.length&&(t.length&&n.unshift([HO,t]),this.send(n)),this.clear()}clear(){this.dicts.length=0,this.updateActions.length=0,this._updating=!1,this._createActionMap.clear()}send(t){ot.publishHandler(Cg,t,this.pageId)}fireEvent(t,n){let r=cp(t,this);r&&r.dispatchEvent(n)}}function vP(e){let t=Ir(e);return t?t.__page_container__:null}function sf(e,t,n){if(typeof n=="number"&&(n=vP(n)),n[e]===t)return n;let{childNodes:r}=n;for(let o=0;o<r.length;o++){let c=sf(e,t,r[o]);if(c)return c}return null}function cp(e,t){return sf("nodeId",e,t)}function mP(e,t){return sf("nodeName",e.toUpperCase(),t)}function _P(e,t,n){e.push([J.ACTION_TYPE_CREATE,t,e.addDict(n),-1,-1])}function bP(e,t,n,r){let o=t.toJSON({attr:!0,normalize:e.normalizeDict});e.push([J.ACTION_TYPE_INSERT,t.nodeId,n,r],Object.keys(o).length?o:void 0)}function yP(e,t){e.push([J.ACTION_TYPE_REMOVE,t])}function EP(e,t,n,r){e.push([J.ACTION_TYPE_ADD_EVENT,t,e.addDict(n),r])}function SP(e,t,n,r,o){e.push([J.ACTION_TYPE_ADD_WXS_EVENT,t,e.addDict(n),e.addDict(r),o])}function wP(e,t,n){e.push([J.ACTION_TYPE_REMOVE_EVENT,t,e.addDict(n)])}function CP(e,t,n){return t==="style"&&z.isPlainObject(n)?e.normalizeDict(n):e.addDict(n)}function AP(e,t,n,r){e.push([J.ACTION_TYPE_SET_ATTRIBUTE,t,e.addDict(n),CP(e,n,r)])}function OP(e,t,n){e.push([J.ACTION_TYPE_REMOVE_ATTRIBUTE,t,e.addDict(n)])}function up(e,t,n){e.push([J.ACTION_TYPE_SET_TEXT,t,e.addDict(n)])}function TP(e,t,n){return new pP(e,t,n)}function fp(e){let t=e.setup;return e.inheritAttrs=!1,e.setup=(n,r)=>{let{attrs:{__pageId:o,__pagePath:c,__pageQuery:g,__pageInstance:b}}=r,T=hn.getCurrentInstance().proxy;if(gt(T,b),$n(dp(o,T,b)),hn.onMounted(()=>{hn.nextTick(()=>{Vn(T,J.ON_READY)})}),hn.onBeforeUnmount(()=>{Vn(T,J.ON_UNLOAD)}),t)return t(g,r)},e}function dp(e,t,n){{let r=()=>s.webview.getWebviewById(e+"");t.$getAppWebview=r,t.$.ctx.$scope={$getAppWebview:r}}return t.getOpenerEventChannel=()=>(n.eventChannel||(n.eventChannel=new J.EventChannel(e)),n.eventChannel),t}function PP(e){return z.isFunction(e)}let hp=new Map;function IP(e,t){hp.set(e,J.once(kP(t)))}function NP(e,t,n,r,o){let c=TP(e,o,!0),g=qi(),b=hp.get(t)(),V=T=>g.mountPage(T,{__pageId:e,__pagePath:t,__pageQuery:n,__pageInstance:r},c);return z.isPromise(b)?b.then(T=>V(T)):V(b)}function kP(e){return()=>PP(e)?e().then(t=>fp(t)):fp(e)}let gp=!1;function pp(){if(gp)return;gp=!0;let e,t;if(f.requireModule("plus").getRedirectInfo){let{path:c,query:g,referrerInfo:b}=Bs();c&&(e=c,t=g),R.referrerInfo=b}else{let c=s.runtime.arguments;if(!c)return;try{let g=JSON.parse(c);e=g.path||g.pathName,t=g.query?"?"+g.query:""}catch(g){}}if(!e||e===R.entryPagePath){t&&(R.entryPageQuery=t);return}let r=J.addLeadingSlash(e),o=Wi(r);!o||(o.meta.isTabBar||(R.realEntryPagePath=R.realEntryPagePath||R.entryPagePath),R.entryPagePath=e,R.entryPageQuery=t)}function qc(e,t){let n=JSON.parse(JSON.stringify(Wi(e)));return n.meta=Fa(n.meta),t!=="preloadPage"&&!R.realEntryPagePath&&(t==="reLaunch"||In().length===0)?n.meta.isQuit=!0:n.meta.isTabBar||(n.meta.isQuit=!1),n}let Ca={};function RP(e){let t=Object.keys(Ca).find(n=>Ca[n].id===e.id);t&&delete Ca[t]}function xP({url:e}){let t=Ca[e];return t&&(t.__page__&&In().find(n=>n===t.__page__)?t.__preload__=!1:t.close("none"),delete Ca[e]),t}function BP({url:e,path:t,query:n}){if(!Ca[e]){let r=qc(t,"preloadPage");Ca[e]=ip({path:t,routeOptions:r,query:n,webviewExtras:{__preload__:!0}})}return Ca[e]}function fc({url:e,path:t,query:n,openType:r,webview:o,nvuePageVm:c,eventChannel:g}){if(o&&pp(),Ca[e]){o=Ca[e];let we=o;if(we.__page__)if(In().find(Pe=>Pe===we.__page__))o=void 0;else return g&&(we.__page__.$page.eventChannel=g),r==="launch"?MP(e,t,n,we,c,g):$n(we.__page__),we}let b=qc(t,r);o?(o=s.webview.getWebviewById(o.id),o.nvue=b.meta.isNVue):o=ip({path:t,routeOptions:b,query:n}),b.meta.id=parseInt(o.id),!!b.meta.isTabBar&&di.append(o),uP(o,t,n,b.meta);let T=t.slice(1);o.__uniapp_route=T;let L=ga(r,e,n,b.meta,g,R.darkmode?s.navigator.getUIStyle():"light"),_e=parseInt(o.id);return o.nvue?c?LP(_e,c,L):vp(_e,o,L):NP(_e,T,n,L,DP(b)),o}function MP(e,t,n,r,o,c){let g=qc(t,"preloadPage");g.meta.id=parseInt(r.id);let b=ga("preloadPage",e,n,g.meta,c,R.darkmode?s.navigator.getUIStyle():"light");gt(o,b),r.__page__=o}function DP({meta:e}){let t=Wu(),{platform:n,pixelRatio:r,windowWidth:o}=Rr();return{css:!0,route:e.route,version:1,locale:"",platform:n,pixelRatio:r,windowWidth:o,disableScroll:e.disableScroll===!0,onPageScroll:!1,onPageReachBottom:!1,onReachBottomDistance:z.hasOwn(e,"onReachBottomDistance")?e.onReachBottomDistance:J.ON_REACH_BOTTOM_DISTANCE,statusbarHeight:t,windowTop:e.navigationBar.type==="float"?t+J.NAVBAR_HEIGHT:0,windowBottom:di.indexOf(e.route)>=0&&di.cover?di.height:0}}function LP(e,t,n){gt(t,n),$n(dp(e,t,n)),e===1&&(R.splashscreen&&R.splashscreen.autoclose&&!R.splashscreen.alwaysShowBeforeRender&&s.navigator.closeSplashscreen(),R.onReady(function(){lp()}))}function vp(e,t,n){let r={$:{},$getAppWebview(){return t},getOpenerEventChannel(){return n.eventChannel||(n.eventChannel=new J.EventChannel(e)),n.eventChannel},__setup(o,c){o.$getAppWebview=()=>t,o.getOpenerEventChannel=c.getOpenerEventChannel,gt(o,n),t.__preload__&&(t.__page__=o);let g=Hn(),b=g.findIndex(V=>V===c);b>-1&&g.splice(b,1,o)}};gt(r,n),t.__preload__?(t.__page__=r,t.addEventListener("show",()=>{Vn(t.__page__,J.ON_SHOW)}),t.addEventListener("hide",()=>{Vn(t.__page__,J.ON_HIDE)})):$n(r)}let mp=(e,{resolve:t,reject:n})=>{let{url:r,events:o,animationType:c,animationDuration:g}=e,{path:b,query:V}=J.parseUrl(r),[T,L]=UP(b,c,g);zc(b,()=>{VP({url:r,path:b,query:V,events:o,aniType:T,aniDuration:L}).then(t).catch(n)},e.openType==="appLaunch")},FP=Te(Lu,mp,IE,DE);function VP({url:e,path:t,query:n,events:r,aniType:o,aniDuration:c}){Vn(J.ON_HIDE);let g=new J.EventChannel(Kg()+1,r);return new Promise(b=>{Gc(fc({url:e,path:t,query:n,openType:"navigateTo",eventChannel:g}),o,c,()=>{b({eventChannel:g})}),Ba()})}function UP(e,t,n){let{globalStyle:r}=R,o=os(e);return[t||o.animationType||r.animationType||MT,n||o.animationDuration||r.animationDuration||jc]}let $P=Te(Fu,({url:e},{resolve:t,reject:n})=>{let{path:r,query:o}=J.parseUrl(e);zc(r,()=>{HP({url:e,path:r,query:o}).then(t).catch(n)})},kE,LE);function HP({url:e,path:t,query:n}){let r=wi();return r&&na(r),new Promise(o=>{Gc(fc({url:e,path:t,query:n,openType:"redirectTo"}),"none",0,()=>{if(r){let c=r.$getAppWebview();c.__preload__&&RP(c),c.close("none")}o(void 0)}),Ba()})}let jP=({url:e},{resolve:t,reject:n})=>{let{path:r,query:o}=J.parseUrl(e);zc(r,()=>{zP({url:e,path:r,query:o}).then(t).catch(n)})};function zP({url:e,path:t,query:n}){return new Promise(r=>{let o=Hn().slice(0);Fe.find(g=>g.path===t).meta.isTabBar&&di.switchTab(t.slice(1)),Gc(fc({url:e,path:t,query:n,openType:"reLaunch"}),"none",0,()=>{o.forEach(g=>sp(g,"none")),r(void 0)}),Ba()})}let WP=Te(Th,jP,RE,FE),_p=(e,{resolve:t,reject:n})=>{let{url:r}=e,{path:o,query:c}=J.parseUrl(r);zc(o,()=>{YP({url:r,path:o,query:c}).then(t).catch(n)},e.openType==="appLaunch")},GP=Te(Pc,_p,xE,VE);function YP({url:e,path:t,query:n}){di.switchTab(t.slice(1));let r=In(),o=r.length,c=!1,g=!1,b;o>=1&&(b=r[o-1],b&&!b.$.__isTabBar?(g=!0,r.reverse().forEach(T=>{!T.$.__isTabBar&&T!==b&&sp(T,"none")}),na(b),N(()=>{b.$page.openType==="redirectTo"?nl(b.$getAppWebview(),Yg,jc):nl(b.$getAppWebview(),"auto")},100)):c=!0);let V;return Hn().forEach(T=>{J.addLeadingSlash(T.route)===t?(T.$.__isActive||(g=!0),T.$.__isActive=!0,V=T):T.$.__isTabBar&&(T.$.__isActive=!1)}),b===V&&(c=!1),b&&c&&Vn(b,J.ON_HIDE),new Promise(T=>{if(V){let L=V.$getAppWebview();L.show("none"),g&&!L.__preload__&&Vn(V,J.ON_SHOW),Ba(),T(void 0)}else Gc(fc({url:e,path:t,query:n,openType:"switchTab"}),"none",0,()=>{Ba(),T(void 0)},70)})}let qP=Dt(Ph,({url:e})=>{let t=xP({url:e});return t?{id:t.id,url:e,errMsg:"unPreloadPage:ok"}:{url:e,errMsg:"unPreloadPage:fail not found"}},ME),JP=Te(Vu,({url:e},{resolve:t})=>{if(Ca[e])return;let n=e.split("?"),r=n[0],o=J.parseQuery(n[1]||""),c=BP({url:e,path:r,query:o}),g=qc(r,"preloadPage");g.meta.id=parseInt(c.id);let b=ga("preloadPage",e,o,g.meta,void 0,R.darkmode?s.navigator.getUIStyle():"light");vp(parseInt(c.id),c,b),t({id:c.id,url:e,errMsg:"preloadPage:ok"})},BE);var KP={__proto__:null,$emit:c_,$off:l_,$on:a_,$once:s_,__log__:dT,addInterceptor:Km,addPhoneContact:LC,arrayBufferToBase64:Tr,base64ToArrayBuffer:Ri,canIUse:jw,canvasGetImageData:L_,canvasPutImageData:F_,canvasToTempFilePath:V_,checkIsSoterEnrolledInDevice:jC,checkIsSupportSoterAuthentication:HC,chooseImage:fA,chooseLocation:cO,chooseVideo:dA,clearStorage:Nw,clearStorageSync:Iw,closeAuthView:kg,closeBLEConnection:EC,closeBluetoothAdapter:gC,closePreviewImage:nA,closeSocket:IA,compressImage:lA,compressVideo:cA,configMTLS:wA,connectSocket:TA,createAnimation:ib,createBLEConnection:yC,createCanvasContext:D_,createFullScreenVideoAd:IT,createInnerAudioContext:WA,createInteractiveAd:BT,createIntersectionObserver:z_,createInterstitialAd:kT,createLivePusherContext:oO,createMapContext:E_,createMediaQueryObserver:G_,createPushMessage:nT,createRewardedVideoAd:TT,createSelectorQuery:X_,createVideoContext:b_,downloadFile:_A,getAppAuthorizeSetting:cg,getAppBaseInfo:qh,getBLEDeviceCharacteristics:wC,getBLEDeviceRSSI:PC,getBLEDeviceServices:SC,getBackgroundAudioManager:nO,getBeacons:kC,getBluetoothAdapterState:pC,getBluetoothDevices:_C,getCheckBoxState:Rg,getClipboardData:FC,getConnectedBluetoothDevices:bC,getDeviceInfo:Yh,getEnterOptionsSync:Ob,getFileInfo:Rw,getImageInfo:QC,getLaunchOptionsSync:Tb,getLocale:Kl,getLocation:lO,getNetworkType:rg,getProvider:KO,getPushClientId:Pb,getRecorderManager:oA,getSavedFileInfo:Uw,getSavedFileList:Vw,getScreenBrightness:qC,getSelectedTextRange:gb,getStorage:Ow,getStorageInfo:kw,getStorageInfoSync:Mh,getStorageSync:Aw,getSubNVueById:GO,getSystemInfo:nC,getSystemInfoSync:Jh,getSystemSetting:ZC,getUniverifyManager:tT,getUserInfo:ZO,getUserProfile:XO,getVideoInfo:eA,getWindowInfo:Gh,hideKeyboard:gA,hideLoading:wO,hideNavigationBarLoading:NO,hideTabBar:DO,hideTabBarRedDot:UO,hideToast:SO,initUTSClassName:jg,initUTSIndexClassName:ST,initUTSPackageName:ET,initUTSProxyClass:Hg,initUTSProxyFunction:_T,interceptors:Xm,invokePushCallback:Mu,loadFontFace:OO,login:Tg,makePhoneCall:BC,navigateBack:dP,navigateTo:FP,navigateToMiniProgram:cT,notifyBLECharacteristicValueChange:CC,offAccelerometerChange:lC,offAppHide:Ab,offAppShow:wb,offCompassChange:iC,offError:Eb,offKeyboardHeightChange:vA,offLocationChange:gO,offLocationChangeError:vO,offNetworkStatusChange:$C,offPageNotFound:bb,offPushMessage:Nb,offThemeChange:YC,offUnhandledRejection:mb,offWindowResize:cb,onAccelerometerChange:sC,onAppHide:Cb,onAppShow:Sb,onBLECharacteristicValueChange:dC,onBLEConnectionStateChange:fC,onBeaconServiceChange:NC,onBeaconUpdate:IC,onBluetoothAdapterStateChange:uC,onBluetoothDeviceFound:cC,onCompassChange:rC,onCreateVueApp:J.onCreateVueApp,onError:yb,onHostEventReceive:Dg,onKeyboardHeightChange:pA,onLocaleChange:fb,onLocationChange:hO,onLocationChangeError:pO,onNativeEventReceive:uT,onNetworkStatusChange:UC,onPageNotFound:_b,onPushMessage:Ib,onSocketClose:xA,onSocketError:kA,onSocketMessage:RA,onSocketOpen:NA,onTabBarMidButtonTap:ob,onThemeChange:GC,onUnhandledRejection:vb,onWindowResize:lb,openAppAuthorizeSetting:XC,openBluetoothAdapter:hC,openDocument:Hw,openLocation:uO,pageScrollTo:TO,preLogin:Ig,preloadPage:JP,previewImage:tA,reLaunch:WP,readBLECharacteristicValue:AC,redirectTo:$P,registerRuntime:rT,registerUTSInterface:wT,registerUTSPlugin:CT,removeInterceptor:Zm,removeSavedFile:$w,removeStorage:Pw,removeStorageSync:Tw,removeTabBarBadge:VO,request:SA,requestPayment:lT,requireGlobal:qO,requireNativePlugin:Jo,requireUTSPlugin:AT,restoreGlobal:YO,saveFile:Dw,saveImageToPhotosAlbum:sA,saveVideoToPhotosAlbum:aA,scanCode:WC,sendHostEvent:Bg,sendNativeEvent:eg,sendSocketMessage:PA,setBLEMTU:TC,setClipboardData:VC,setKeepScreenOn:KC,setLocale:db,setNavigationBarColor:RO,setNavigationBarTitle:PO,setPageMeta:hb,setScreenBrightness:JC,setStorage:Cw,setStorageSync:ww,setTabBarBadge:xO,setTabBarItem:BO,setTabBarStyle:MO,share:aT,shareWithSystem:sT,showActionSheet:bO,showKeyboard:hA,showLoading:yO,showModal:mO,showNavigationBarLoading:IO,showTabBar:LO,showTabBarRedDot:FO,showToast:EO,startAccelerometer:Xh,startBeaconDiscovery:RC,startBluetoothDevicesDiscovery:vC,startCompass:Kh,startLocationUpdate:fO,startPullDownRefresh:CO,startSoterAuthentication:zC,stopAccelerometer:Qh,stopBeaconDiscovery:xC,stopBluetoothDevicesDiscovery:mC,stopCompass:Zh,stopLocationUpdate:dO,stopPullDownRefresh:AO,switchTab:GP,syncDataToGlobal:JO,unPreloadPage:qP,uploadFile:MA,upx2px:zm,vibrateLong:aC,vibrateShort:oC,weexGetSystemInfoSync:ic,writeBLECharacteristicValue:OC};let ZP=z.extend(U,{publishHandler:XP});function XP(e,t,n){t=JSON.stringify(t),z.isArray(n)||(n=[n]);let r=`typeof UniViewJSBridge !== 'undefined' && UniViewJSBridge.subscribeHandler("${e}",${t},__PAGE_ID__)`;n.forEach(o=>{let c=String(o),g=s.webview.getWebviewById(c);g&&g.evalJS(r.replace("__PAGE_ID__",c))})}function QP(){let{tabBar:e}=R;if(!(e&&e.list&&e.list.length))return;let{entryPagePath:n}=R;e.selectedIndex=0;let r=e.list.findIndex(o=>o.pagePath===n);di.init(e,(o,c)=>{P.switchTab({url:J.addLeadingSlash(o.pagePath),openType:"switchTab",from:"tabBar",success(){Vn(J.ON_TAB_ITEM_TAP,{index:c,text:o.text,pagePath:o.pagePath})}})}),r!==-1&&(e.selectedIndex=r,r!==0&&di.switchTab(n))}function eI(){let e=s.globalEvent,t=f.requireModule("globalEvent"),{emit:n,publishHandler:r}=ot;f.config.preload?s.key.addEventListener(Fo,Di):e.addEventListener("splashclosed",()=>{s.key.addEventListener(Fo,Di)}),e.addEventListener("pause",()=>{n(J.ON_APP_ENTER_BACKGROUND)}),e.addEventListener("resume",()=>{let c=Bs();c&&c.userAction&&xs(c),n(J.ON_APP_ENTER_FOREGROUND,Vo())}),t.addEventListener("uistylechange",function(c){let g={theme:c.uistyle};n(J.ON_THEME_CHANGE,g),r(J.ON_THEME_CHANGE,g,ha()),Yw()});let o=0;e.addEventListener("KeyboardHeightChange",function(c){o!==c.height&&(o=c.height,n(J.ON_KEYBOARD_HEIGHT_CHANGE,{height:o}))}),t.addEventListener(FT,function(c){c&&c.event&&fT(c.event,c.data)}),e.addEventListener("plusMessage",bp),e.addEventListener("WebviewPostMessage",bp)}function bp({data:e}){e&&e.type&&ot.subscribeHandler("plusMessage."+e.type,e.args)}function yp(e,t,n=!1){ot.subscribe("plusMessage."+e,t,n)}function tI(e){pb(e.$);let{entryPagePath:t,entryPageQuery:n,referrerInfo:r}=R,o=hs({path:t,query:n,referrerInfo:r});Vn(e,J.ON_LAUNCH,o),Vn(e,J.ON_SHOW,o);let c=f.requireModule("plus").getAppState;(c&&Number(c()))===2&&Vn(e,J.ON_HIDE,o)}function Ep(e){return e=e.replace(/\/$/,""),e.indexOf("_")===0?s.io.convertLocalFileSystemURL(e):e}function nI(){let e=Ep(fs),t=Ep(Wr),n=t.split("/");n.pop();let r=n.join("/");s.io.resolveLocalFileSystemURL(s.io.convertAbsoluteFileSystem(r),o=>{o.createReader().readEntries(function(g){let b=g;b&&b.length&&b.forEach(function(V){V.isDirectory&&V.fullPath.indexOf(e)===0&&V.fullPath.indexOf(t)!==0&&V.removeRecursively()})})})}let Sp=0,xl=0,Jc=null,rl=null;function rI(e,t){if(Jc=null,rl&&(E(rl),rl=null),e.type==="onFocus")if(xl>0)e.detail.height=xl;else{rl=N(function(){e.detail.height=xl,t(e)},Sp),Jc=function(){rl&&(E(rl),rl=null),e.detail.height=xl,t(e)};return}t(e)}function iI(){Sp=s.os.name.toLowerCase()==="android"?300:700,ot.on(J.ON_KEYBOARD_HEIGHT_CHANGE,t=>{if(xl=t.height,xl>0){let n=Jc;Jc=null,n&&n()}})}function oI(e,t,n){let r=t.type;r==="onFocus"||r==="onBlur"?rI(t,o=>{n.fireEvent(e,o)}):n.fireEvent(e,t)}function aI(e,t){let n=Ir(parseInt(t));if(!n)return;let r=n.__page_container__;e.forEach(o=>{switch(o[0]){case J.ACTION_TYPE_EVENT:oI(o[1],o[2],r);break}})}let wp={};function sI(e,t,n){let{adpid:r,width:o}=e,c=r+"-"+o,g=wp[c];if(g&&g.length>0){t(g.splice(0,1)[0]);return}s.ad.getAds(e,b=>{let V=b.ads;t(V.splice(0,1)[0]),wp[c]=g?g.concat(V):V},b=>{n({errCode:b.code,errMsg:b.message})})}function lI(){x("getAdData",(e,t)=>{sI(e,n=>{t({code:0,data:n})},n=>{t({code:1,message:n})})})}let cI=["switchTab","reLaunch","redirectTo","navigateTo","navigateBack"];function uI(){cI.forEach(e=>{x(e,t=>{P[e](z.extend(t,{fail(n){console.error(n.errMsg)}}))})})}let Cp=!1;function fI(e,t){let n=t==="1";if(!(n&&Cp)){if(n?(Cp=!0,ep(s.webview.getLaunchWebview())):Li||ep(s.webview.getWebviewById(t)),!Li.loaded){if(Li.id!==t)return console.error(`webviewReady[${Li.id}][${t}] not match`);Li.loaded=!0}ot.emit(Rl+"."+t),n&&dI()}}function dI(){let{autoclose:e,alwaysShowBeforeRender:t}=R.splashscreen;e&&!t&&s.navigator.closeSplashscreen();let n=J.addLeadingSlash(R.entryPagePath),r=Wi(n);if(!r.meta.isNVue){let o={url:n+(R.entryPageQuery||""),openType:"appLaunch"},c={resolve(){},reject(){}};return r.meta.isTabBar?_p(o,c):mp(o,c)}}function hI(e,t){let n=Ir(parseInt(t));n&&(n.__uniapp_webview=!0)}function gI(e,t){let n=Ir(parseInt(t));n&&delete n.__uniapp_webview}let pI=({name:e,arg:t},n)=>{e==="postMessage"?vI(n[0],t):P[e](z.extend(t,{fail(r){console.error(r.errMsg)}}))};function vI(e,t){let n=mP("web-view",parseInt(e));n&&n.dispatchEvent(J.createUniEvent({type:"onMessage",target:Object.create(null),currentTarget:Object.create(null),detail:{data:[t]}}))}function mI({nodeId:e,ownerId:t,method:n,args:r},o){let c=cp(e,parseInt(o));if(!c)return;let g=_I(t,c.__vueParentComponent);!g||!g[n]||g[n](r)}function _I(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 bI(){let{subscribe:e,subscribeHandler:t,publishHandler:n}=ot;if(yp("subscribeHandler",({type:r,data:o,pageId:c})=>{t(r,o,c)}),yp(J.WEB_INVOKE_APPSERVICE,({data:r,webviewIds:o})=>{pI(r,o)}),R.renderer!=="native"){e(Rl,fI),e(Cg,aI),v(),lI(),uI(),e(jO,hI),e(zO,gI),e(J.ON_WXS_INVOKE_CALL_METHOD,mI);let r=Wi(J.addLeadingSlash(R.entryPagePath));r&&!r.meta.isNVue&&n(Rl,{},1)}}let Bl,lf={globalData:{}};function yI({allowDefault:e=!1}={}){if(Bl)return Bl;if(e)return lf;console.error("[warn]: getApp() failed. Learn more: https://uniapp.dcloud.io/collocation/frame/window?id=getapp.")}function EI(e){if(P.Vuex&&e.$store){let{useStore:t}=P.Vuex;P.Vuex.useStore=n=>n?t(n):e.$store}ja(e),Bl=e,ct(Bl),z.extend(Bl,lf),yt(Bl,lf.globalData),Ce(),pp(),QP(),eI(),iI(),bI(),tI(e),N(nI,1e4),R.ready=!0}var SI={uni:KP,getApp:yI,getCurrentPages:yr,__definePage:IP,__registerApp:EI,__registerPage:fc,UniServiceJSBridge:ZP};return SI}(It,Vt,w);Ot=Ot.default||Ot;let P=Ot.uni,wt=Ot.getApp,In=Ot.getCurrentPages,ot=Ot.UniServiceJSBridge;return Ot}var cv=uk(hk);function uv(f){}var fv=f=>{};var dv=f=>{let{registerUTSInterface:s,initUTSProxyClass:p,initUTSProxyFunction:w,initUTSPackageName:N,initUTSIndexClassName:E,initUTSClassName:h}=f,y="DCloudUniExit",R="uni-exit",Fe="built-in",It="",Vt=!0,Ot=N(y,Vt),P=E(y,Vt);f.exit=w(!1,{moduleName:R,moduleType:Fe,errMsg:It,main:!0,package:Ot,class:P,name:"exitByJs",params:[{name:"options",type:"UTSSDKModulesDCloudUniExitExitOptionsJSONObject",default:"UTSNull"}],return:""})};var hv=f=>{let{registerUTSInterface:s,initUTSProxyClass:p,initUTSProxyFunction:w,initUTSPackageName:N,initUTSIndexClassName:E,initUTSClassName:h}=f,y="DCloudUniFacialRecognitionVerify",R="FacialRecognitionVerify(\u5B9E\u4EBA\u8BA4\u8BC1)",Fe="built-in",It="",Vt=!0,Ot=N(y,Vt),P=E(y,Vt);f.startFacialRecognitionVerify=w(!1,{moduleName:R,moduleType:Fe,errMsg:It,main:!0,package:Ot,class:P,name:"startFacialRecognitionVerifyByJs",params:[{name:"faceStyle",type:"UTSSDKModulesDCloudUniFacialRecognitionVerifyStartFacialRecognitionVerifyOptionsJSONObject"}],return:""}),f.getFacialRecognitionMetaInfo=w(!1,{moduleName:R,moduleType:Fe,errMsg:It,main:!0,package:Ot,class:P,name:"getFacialRecognitionMetaInfoByJs",params:[],return:""})};var gv=f=>{let{registerUTSInterface:s,initUTSProxyClass:p,initUTSProxyFunction:w,initUTSPackageName:N,initUTSIndexClassName:E,initUTSClassName:h}=f,y="DCloudUniFileSystemManager",R="uni-file-manager",Fe="built-in",It="",Vt=!0,Ot=N(y,Vt),P=E(y,Vt);s("FileSystemManagerOptions",Object.assign({moduleName:R,moduleType:Fe,errMsg:It,package:Ot,class:h(y,"FileSystemManagerByJsProxy",Vt)},{methods:{readFileByJs:{async:!1,params:[{name:"options",type:"UTSSDKModulesDCloudUniFileSystemManagerReadFileOptionsJSONObject"}],return:{}},writeFileByJs:{async:!1,params:[{name:"options",type:"UTSSDKModulesDCloudUniFileSystemManagerWriteFileOptionsJSONObject"}],return:{}},unlinkByJs:{async:!1,params:[{name:"options",type:"UTSSDKModulesDCloudUniFileSystemManagerUnLinkOptionsJSONObject"}],return:{}},mkdirByJs:{async:!1,params:[{name:"options",type:"UTSSDKModulesDCloudUniFileSystemManagerMkDirOptionsJSONObject"}],return:{}},rmdirByJs:{async:!1,params:[{name:"options",type:"UTSSDKModulesDCloudUniFileSystemManagerRmDirOptionsJSONObject"}],return:{}},readdirByJs:{async:!1,params:[{name:"options",type:"UTSSDKModulesDCloudUniFileSystemManagerReadDirOptionsJSONObject"}],return:{}},accessByJs:{async:!1,params:[{name:"options",type:"UTSSDKModulesDCloudUniFileSystemManagerAccessOptionsJSONObject"}],return:{}},renameByJs:{async:!1,params:[{name:"options",type:"UTSSDKModulesDCloudUniFileSystemManagerRenameOptionsJSONObject"}],return:{}},copyFileByJs:{async:!1,params:[{name:"options",type:"UTSSDKModulesDCloudUniFileSystemManagerCopyFileOptionsJSONObject"}],return:{}},getFileInfoByJs:{async:!1,params:[{name:"options",type:"UTSSDKModulesDCloudUniFileSystemManagerGetFileInfoOptionsJSONObject"}],return:{}},statByJs:{async:!1,params:[{name:"options",type:"UTSSDKModulesDCloudUniFileSystemManagerStatOptionsJSONObject"}],return:{}}},props:[]})),f.getFileSystemManager=w(!1,{moduleName:R,moduleType:Fe,errMsg:It,main:!0,package:Ot,class:P,name:"getFileSystemManagerByJs",params:[],return:{type:"interface",options:"FileSystemManagerOptions"}})};var pv=f=>{};var vv=f=>{};var mv=f=>{};var _v=f=>{};var bv=f=>{};var yv=f=>{};var Ev=f=>{};var Sv=f=>{};var wv=f=>{let{registerUTSInterface:s,initUTSProxyClass:p,initUTSProxyFunction:w,initUTSPackageName:N,initUTSIndexClassName:E,initUTSClassName:h}=f,y="DCloudUniInstallApk",R="uni-installApk",Fe="built-in",It="",Vt=!0,Ot=N(y,Vt),P=E(y,Vt);f.installApk=w(!1,{moduleName:R,moduleType:Fe,errMsg:It,main:!0,package:Ot,class:P,name:"installApkByJs",params:[{name:"options",type:"UTSSDKModulesDCloudUniInstallApkInstallApkOptionsJSONObject"}],return:""})};var Cv=f=>{};var Av=f=>{};var Ov=f=>{};var Tv=f=>{};var Pv=f=>{};var Iv=f=>{};var Nv=f=>{};var kv=f=>{};function Rv(f){fv(f),dv(f),hv(f),gv(f),pv(f),vv(f),mv(f),_v(f),bv(f),yv(f),Ev(f),Sv(f),wv(f),Cv(f),Av(f),Ov(f),Tv(f),Pv(f),Iv(f),Nv(f),kv(f),uv(f)}var If,Nf,kf,Da,Rf,xf,Bf;function xv(){return Da?{__definePage:If,__registerApp:Nf,__registerPage:kf,uni:Da,wx:Da,getApp:Rf,getCurrentPages:xf,UniServiceJSBridge:Bf}:{}}function Bv(f){let{weex:s,plus:p,VueShared:w}=f;return Da||({__definePage:If,__registerApp:Nf,__registerPage:kf,uni:Da,getApp:Rf,getCurrentPages:xf,UniServiceJSBridge:Bf}=lv(s,p,f),Da.VueShared=w,Rv(Da),Rp(Da)),{__definePage:If,__registerApp:Nf,__registerPage:kf,plus:p,uni:Da,wx:Da,getApp:Rf,getCurrentPages:xf,UniServiceJSBridge:Bf}}function Mv(f,s){let{__uniConfig:p}=s;if(!p)return;let w=s.weex;w.document.__$automator__=!!p.automator;let N=p.renderer!=="native"&&w.config.bundleUrl.indexOf("app-service.js")!==-1;if(Fi(s,xv()),N?cv(s):(Dp(f,s),tv(s.Vue.parseClassStyles)),Fi(s,Bv(s)),w.config.plus_web_id==="1"){let R=w.requireModule("plus");R.setDefaultFontSize&&R.setDefaultFontSize(Math.round(s.plus.screen.resolutionWidth/20))}let{scale:E,deviceWidth:h,platform:y}=global.WXEnvironment;if(y.toLowerCase()==="ios"){let R=Math.ceil(h/E);w.requireModule("meta").setViewport({width:R,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 So(f,s=[]){return{module:"dom",method:f,args:s}}var Ul=class{constructor(s,p){this.id=s,this.batched=!1,this.updates=[],zn(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([So("createFinish")],s)}updateFinish(s){return this.handler([So("updateFinish")],s)}refreshFinish(s){return this.handler([So("refreshFinish")],s)}createBody(s){let p=s.toJSON(),w=p.children;delete p.children;let N=[So("createBody",[p])];return w&&N.push.apply(N,w.map(E=>So("addElement",[p.ref,E,-1]))),this.addActions(N)}addElement(s,p,w){return w>=0||(w=-1),this.addActions(So("addElement",[p,s.toJSON(),w]))}removeElement(s){if(Ii(s)){let p=s.map(w=>So("removeElement",[w]));return this.addActions(p)}return this.addActions(So("removeElement",[s]))}moveElement(s,p,w){return this.addActions(So("moveElement",[s,p,w]))}setAttr(s,p,w){return this.addActions(So("updateAttrs",[s,{[p]:w}]))}setStyle(s,p,w){return this.addActions(So("updateStyle",[s,{[p]:w}]))}setStyles(s,p){return this.addActions(So("updateStyle",[s,p]))}addEvent(s,p){return this.addActions(So("addEvent",[s,p]))}removeEvent(s,p){return this.addActions(So("removeEvent",[s,p]))}handler(s,p){return p&&p()}addActions(s){let p=this.updates,w=this.handler;if(Ii(s)||(s=[s]),this.batched)p.push.apply(p,s);else return w(s)}};var Mf={createBody:"callCreateBody",addElement:"callAddElement",removeElement:"callRemoveElement",moveElement:"callMoveElement",updateAttrs:"callUpdateAttrs",updateStyle:"callUpdateStyle",addEvent:"callAddEvent",removeEvent:"callRemoveEvent"};function Dv(f,s){let p=s||global.callNative;return zn(p)||console.error("[JS Runtime] no default handler"),function(N){Ii(N)||(N=[N]);for(let E=0;E<N.length;E++){let h=pk(f,N[E],p);if(h===-1)return h}}}function gk(f,s){return f==="dom"&&Mf[s]&&zn(global[Mf[s]])}function pk(f,s,p){let{module:w,method:N,args:E}=s;return gk(w,N)?global[Mf[N]](f,...E,"-1"):p(f,[s],"-1")}var du=class extends Zi{constructor(s){super();this.value=s,this.nodeType=3,this.type="text",this.value=""}toString(){return""+this.value}};var Lv={slider:{change:function(f){return{index:f.index,source:f.source}},scroll:function(f){return{offsetXRatio:f.offsetXRatio,offsetYRatio:f.offsetYRatio,drag:f.drag}}},"scroll-view":{scrollend:function(f){return{contentOffset:f.contentOffset}}}};function Fv(f){let{attr:s,offsetLeft:p,offsetTop:w}=f,N={};return s&&Object.keys(s).forEach(E=>{E.indexOf("data-")===0&&(N[E.replace("data-","")]=s[E])}),{id:s&&s.id||"",dataset:N,offsetLeft:p||0,offsetTop:w||0}}var vk=["a","div","list","cell","loading","refresh","recycle-list","scroller","indicator","waterfall","web","richtext"],mk=["viewappear","viewdisappear"],_k={markertap:["markerId"],controltap:["controlId"],regionchange:["causedBy"],end:["causedBy"],appear:["direction"],disappear:["direction"]};function Vv(f,s){let p=f.type;if(mk.indexOf(p)!==-1)return f;let w=f.currentTarget,N=w.type.replace("u-","");if(vk.indexOf(N)!==-1)return f;let{timestamp:E,target:h}=f;if(!s){let Fe=Lv[N];Fe?zn(Fe[p])?s=Fe[p](f):s=f.detail||{}:s=f.detail||{}}let y={type:p,timeStamp:E,target:Fv(h),currentTarget:Fv(w),detail:s,touches:p==="touchend"||p==="panend"?[]:f.changedTouches,changedTouches:f.changedTouches};f.componentId&&(y.componentId=f.componentId);let R=_k[p];return R&&R.forEach(Fe=>{il(f,Fe)&&(y[Fe]=f[Fe])}),y}function bk(f,s){let p=s.attrs||{};for(let N in p)f.setAttr(N,p[N],!0);let w=s.style||{};for(let N in w)f.setStyle(N,w[N],!0)}var Ko=class{constructor(s,p="",w){s=s?s.toString():"",this.id=s,this.URL=p,qp(s,this),this.nodeMap={};let N=Ko.Listener||Ul;this.listener=new N(s,w||Dv(s,Ko.handler)),this.taskCenter=new Vl(s,w?(E,h)=>w(h):Ko.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 Zi("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=>{gf(this,p)}}),Object.defineProperty(s,"insertBefore",{configurable:!0,enumerable:!0,writable:!0,value:(p,w)=>{gf(this,p,w)}}),Qn("debug")&&Vi(`Create document element (id: "${s.docId}", ref: "${s.ref}")`)}return this.documentElement}createBody(s,p){if(!this.body){let w=new Zi(s,p);pf(this,w),Qn("debug")&&Vi(`[createBody](${this.id},${w.type},${w.ref}) (${JSON.stringify(w.toJSON(!0))}).`)}return this.body}createElement(s,p){let w=new Zi(s,p);return Qn("debug")&&Vi(`[createElement](${this.id},${w.type},${w.ref}) (${JSON.stringify(w.toJSON(!0))}).`),w}createComment(s){return new cl(s)}createText(s){return new du(s)}fireEvent(s,p,w,N,E){if(!s)return;w=w||{},w.type=w.type||p,w.target=s,w.currentTarget=s,w.timestamp=Date.now(),N&&bk(s,N);let h=!0,y=this.getRef("_root");if(y&&y.attr){let R=y.attr.bubble;h=R==="true"||R===!0||h&&R===void 0}return w=Vv(w),s.fireEvent(p,w,h,E)}destroy(){Qn("debug")&&Vi(`[destroy](${this.id},document) Destroy document (id: "${this.id}", URL: "${this.URL}")`),this.taskCenter.destroyCallback(),delete this.listener,delete this.nodeMap,delete this.taskCenter,Jp(this.id)}};Ko.handler=null;var Uv={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 $v(f,s,p){var w=[s];function N(h){var y=new RegExp;return y.compile(h.replace(/<([^>]+)>/g,function(R,Fe){return f[Fe]?(w.push(Fe),f[Fe]instanceof RegExp?"("+f[Fe].source+")":"("+N(f[Fe]).source+")"):""}),p),y}var E=N(f[s]);this.exec=function(h){var y=E.exec(h);if(y==null)return null;for(var R=new String(y[0]),Fe=0;Fe<w.length;Fe++)y[Fe]&&(R[w[Fe]]=y[Fe]);return R},Object.defineProperty(this,"lastIndex",{get:function(){return E.lastIndex},set:function(h){E.lastIndex=h}})}function yk(){var f=new $v(Uv,"InputElementDiv","g"),s=new $v(Uv,"InputElementRegExp","g"),p;Object.defineProperty(this,"source",{get:function(){return p},set:function(w){p=w,f.lastIndex=0,s.lastIndex=0}}),this.reset=function(){f.lastIndex=0,s.lastIndex=0},this.getNextToken=function(w){var N=f.lastIndex,E;w?E=f:E=s;var h=E.exec(p);if(h&&E.lastIndex-N>h.length)throw new SyntaxError("Unexpected token ILLEGAL");return f.lastIndex=E.lastIndex,s.lastIndex=E.lastIndex,h}}var Hv={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 vc(f,s){this.name=f,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:"")+`
`,N=0;N<this.childNodes.length;N++)w+=this.childNodes[N].toString(p+"    ");return w}}function Ek(){var f,s={Program:"$"},p={};function w(y){p[JSON.stringify(y)]=y;for(var R=Object.getOwnPropertyNames(y);R.length;){var Fe=R.shift();!Hv[Fe]||Hv[Fe].forEach(function(Vt){y[Vt[0]]||R.push(Vt[0]);var Ot=y,P=null;Vt.forEach(function(wt){Ot[wt]||(Ot[wt]={}),P=Ot,Ot=Ot[wt]}),y[Fe].$div&&(Ot.$div=!0),Ot.$reduce=Fe,Ot.$count=Vt.length})}for(var It in y)typeof y[It]!="object"||It.charAt(0)=="$"||y[It].$closure||(p[JSON.stringify(y[It])]?y[It]=p[JSON.stringify(y[It])]:w(y[It]));y.$closure=!0}w(s);var N=[],E=[s],h=s;this.insertSymbol=function(R,Fe){for(;!h[R.name]&&h.$reduce;){for(var It=h.$count,Vt=new vc(h.$reduce);It--;)Vt.childNodes.push(N.pop()),E.pop();h=E[E.length-1],this.insertSymbol(Vt)}if(h=h[R.name],N.push(R),E.push(h),!h)throw new Error;return h.$div},this.reset=function(){h=s,N=[],E=[s]},Object.defineProperty(this,"grammarTree",{get:function(){try{for(;h.$reduce;){for(var y=h.$count,R=new vc(h.$reduce);y--;)R.childNodes.push(N.pop()),E.pop();h=E[E.length-1],this.insertSymbol(R)}if(N.length>0&&h[";"])return this.insertSymbol(new vc(";",";")),this.grammarTree;if(N.length!=1||N[0].name!="Program")throw new Error}catch(Fe){throw new SyntaxError("Unexpected end of input")}return N[0]}})}function Sk(){this.lexicalParser=new yk,this.syntacticalParser=new Ek;var f=["NullLiteral","BooleanLiteral","NumericLiteral","StringLiteral","RegularExpressionLiteral","Identifier","**","=>","{","}","(",")","[","]",".",";",",","<",">","<=",">=","==","!=","===","!==","+","-","*","%","++","--","<<",">>",">>>","&","|","^","!","~","&&","||","?",":","=","+=","-=","*=","%=","<<=",">>=",">>>=","&=","|=","^=","/","/=","instanceof","typeof","new","void","debugger","this","delete","in"],s={};f.forEach(function(p){Object.defineProperty(s,p,{})}),this.reset=function(){this.lexicalParser.reset(),this.syntacticalParser.reset()},this.parse=function(p,w){var N,E=!1;this.lexicalParser.source=p;for(var h=!1;N=this.lexicalParser.getNextToken(h);){w&&w(N);try{if(Object.getOwnPropertyNames(N).some(y=>s.hasOwnProperty(y)?(h=this.syntacticalParser.insertSymbol(new vc(y,N),E),E=!1,!0):!1))continue;(N.Keyword||N.Punctuator||N.DivPunctuator)&&s.hasOwnProperty(N.toString())&&(h=this.syntacticalParser.insertSymbol(new vc(N.toString(),N),E))}catch(y){throw new SyntaxError("Unexpected token "+N)}}return this.syntacticalParser.grammarTree}}var jv=new Sk;function wk(f){jv.reset(),this.tree=jv.parse(f),this.paths=[];var s=Object.create(null),p=this,w=Object.create(null);this.isSimple,this.isConst,E(this.tree),N(this.tree),this.paths.length===0&&(this.isConst=!0),this.setter=function(R){for(var Fe=s,It=0;It<R.length-1;It++)Fe[R[It]]||(Fe[R[It]]=Object.create(null)),Fe=Fe[R[It]];return{isCompleted:function(){for(var Vt in w)if(!w[Vt])return!1;return!0},set:function(Vt){if(w[R.join(".")]||(w[R.join(".")]=!0),Fe[R[It]]=Vt,this.isCompleted())return p.exec()}}},this.valueOf=this.exec=function(){try{return function(){return(0,eval)(f)}.call(s)}catch(R){}};function N(R){for(var Fe=R;Fe.childNodes.length<=1&&Fe.name!=="MemberExpression";)Fe=Fe.childNodes[0];Fe.name==="MemberExpression"?p.isSimple=!0:p.isSimple=!1}function E(R){if(R.name==="CallExpression"&&R.childNodes[R.childNodes.length-1].name!=="CallExpression"){var Fe=h(R.childNodes[1]);E(R.childNodes[0])}else if(R.name==="NewExpression"&&R.childNodes.length===1)var Fe=h(R.childNodes[0]);else if(R.name==="MemberExpression"&&R.childNodes.length===1)var Fe=h(R);else for(var It=0;It<R.childNodes.length;It++)E(R.childNodes[It])}function h(R){if(R.childNodes[0].name==="IdentifierName"){var Fe=h(R.childNodes[2]);return Fe&&(Fe=Fe.concat(R.childNodes[0].childNodes[0].token.toString())),y(Fe),Fe}else if(R.childNodes[0].name==="PrimaryExpression")if(R.childNodes[0].childNodes[0].name==="Identifier"){var Fe=[R.childNodes[0].childNodes[0].token.toString()];return y(Fe),Fe}else return null;else{if(R.childNodes[0].name==="]")return h(R.childNodes[3]),E(R.childNodes[1]),null;if(R.childNodes[0].name==="Arguments")return E(R.childNodes[0]),E(R.childNodes[1]),null;for(var It=0;It<R.childNodes.length;It++)E(R.childNodes[It])}}function y(R){for(var Fe=s,It=0;It<R.length-1;It++)Fe[R[It]]||(Fe[R[It]]=Object.create(null)),Fe=Fe[R[It]];p.paths.push(R),w[R.join(".")]=!1}}function ul(f){var s=f.childNodes.slice().reverse(),p=s.filter(R=>!R.token||!R.token.Punctuator);if(f.name==="UnaryExpression"&&s.length===2&&s[0].name==="-"&&p.length===1){var w=ul(p[0]);return w.value=-w.value,w}if(f.name==="Arguments"){for(var N=[],E=p[0];E;)E.childNodes.length===3&&(N.unshift(E.childNodes[0]),E=E.childNodes[2]),E.childNodes.length===1&&(N.unshift(E.childNodes[0]),E=null);return{type:"Arguments",children:N.map(R=>ul(R))}}if(p&&p.length===1){var w=ul(p[0]);return w}if(f.token&&["NullLiteral","BooleanLiteral","NumericLiteral","StringLiteral","Identifier"].some(R=>f.token[R])){var h=Object.keys(f.token).filter(R=>R.match(/Literal/)||R.match(/Identifier/))[0],y={NullLiteral:null,BooleanLiteral:Boolean(f.token),NumericLiteral:Number(f.token),StringLiteral:f.token,Identifier:f.token}[h];return{type:h,value:y}}return f.name==="CallExpression"?{type:"CallExpression",children:[ul(s[0]),ul(s[1])]}:{type:s.filter(R=>R.token&&R.token.Punctuator)[0].name,children:s.filter(R=>!R.token||!R.token.Punctuator).map(R=>ul(R))}}function zv(f){var s=new wk(f);return JSON.stringify(ul(s.tree),null)}function Ck(f,s){return s==="bind"&&(f==="bindingx"||f==="binding")}function Wv(f){if(!f)return;try{f=JSON.parse(f)}catch(p){}let s={};if(hi(f)?s.origin=f:f&&(s.origin=f.origin,s.transformed=f.transformed),!(!s.transformed&&!s.origin))return s.transformed=s.transformed||zv(s.origin),s}function Ak(f){return f&&(f.exitExpression=Wv(f.exitExpression),f.props&&f.props.forEach(s=>{s.expression=Wv(s.expression)}),f)}function Ok(f){return function(s={}){if(zn(f))return f({state:s.state==="end"?"exit":s.state,t:s.t!==void 0?s.t:s.deltaT})}}function Gv(f,s,p){return p&&(Ck(f,s)?function(w,N=function(){}){if(!w)throw new Error("should pass options for binding");return Ak(w),p(w,w&&w.eventType==="timing"?Ok(N):N)}:p)}function Tk(f,s){Object.defineProperty(f,"[[CurrentInstanceId]]",{value:s})}function Yv(f){return f["[[CurrentInstanceId]]"]}function Pk(f,s,p){let w=Dr(f);return!w||!zn(w.send)?(console.error(`[JS Framework] Failed to find taskCenter (${f}).`),null):(...N)=>w.send("module",{module:s,method:p},N)}function Ik(f,s,p,w){let N=Dr(f);return!N||!zn(N.send)?(console.error(`[JS Framework] Failed to find taskCenter (${f}).`),null):zn(w)?E=>N.send("module",{module:s,method:p},[E]):(console.error(`[JS Framework] ${s}.${p} must be assigned as a function.`),null)}var hu=class{constructor(s,p){Tk(this,String(s)),this.config=p||{},this.document=new Ko(s,this.config.bundleUrl),this.requireModule=this.requireModule.bind(this),this.importScript=this.importScript.bind(this),this.isRegisteredModule=cu,this.isRegisteredComponent=Tf}requireModule(s){let p=Yv(this);if(!(p&&this.document&&this.document.taskCenter)){console.error(`[JS Framework] Failed to requireModule("${s}"), instance (${p}) doesn't exist anymore.`);return}if(!cu(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={},N=av(s);for(let E in N)Object.defineProperty(w,E,{enumerable:!0,configurable:!0,get:()=>Gv(s,E,Pk(p,s,E)),set:h=>Ik(p,s,E,h)});return w}supports(s){if(!hi(s))return null;let p=s.match(/^@(\w+)\/([\w-]+)(\.(\w+))?$/i);if(p){let w=p[1],N=p[2],E=p[4];switch(w){case"module":return cu(N,E);case"component":return Tf(N)}}return null}importScript(s,p={}){let w=Yv(this),N=Dr(w);return new Promise(function(E,h){if(!N||!zn(N.send))return h(new Error(`[JS Framework] Failed to import script "${s}", no taskCenter (${w}) matched.`));try{N.send("module",{module:"script",method:"importScript"},[s,p],{callback:[y=>E(y),y=>h(y)]})}catch(y){h(y)}})}};function Nk(f,s){let p=Object.create(null);return p.service=Object.create(null),ks.forEach(({name:w,options:N})=>{let E=N.create;if(E)try{let h=E(f,s);Fi(p.service,h),Fi(p,h.instance)}catch(h){console.error(`[JS Runtime] Failed to create service ${w}.`)}}),delete p.service.instance,Oa(p.service),p}var kk={uid:0},Rk=zp(hc),xk=jp(hc);function qv(f,s,p){let w=new hu(f,s),N="Vue",E=Nk(f,{weex:w,nvue:w,config:s,created:Date.now(),framework:N});Oa(E);let h=Object.create(null);return Fi(h,Uk(w)),Fi(h,E,{SharedObject:kk,weex:w,nvue:w,requireModule:y=>w.requireModule(y),__WEEX_CALL_JAVASCRIPT__:Af,services:E}),h.plus=new h.WeexPlus(w),h.VueShared=hc,h.UniShared=Rk,h.VueReactivity=xk,Mv(f,h),Oa(h),h}function Bk(f,s,p={}){let w="Vue";p=df(p),p.env=df(global.WXEnvironment||{}),p.bundleType=w;let N=qv(f,p);Mk(s,N)}function Mk(f,s){let p=[],w=[];for(let h in s)p.push(h),w.push(s[h]);let E="(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;
`+f+" })(Object.create(this))";return new Function(...p,E)(...w)}function Dk(f){let s=rs(f);try{if(s&&s.body)return s.body.toJSON()}catch(p){console.error("[JS Framework] Failed to get the virtual dom tree.");return}}function Lk(f){Bp(f),ks.forEach(s=>{let p=s.options.destroy;p&&p(f)})}function Fk(f){Mp(f),ks.forEach(s=>{let p=s.options.refresh;p&&p(f)})}var Vk={createInstance:Bk,createInstanceContext:qv,getRoot:Dk,getDocument:rs,registerService:uu,unregisterService:fu,callJS(f,s){return Af(f,s)},registerComponents:sv,registerModules:ov,destroyInstance:Lk,refreshInstance:Fk};function Df(){return iv(),Vk}function Uk(f){if(global.setTimeout&&global.setInterval)return{setTimeout:global.setTimeout,setInterval:global.setInterval,clearTimeout:global.clearTimeout,clearInterval:global.clearInterval};let s=f.requireModule("timer");return{setTimeout:(...w)=>{let N=function(){w[0](...w.slice(2))};return s.setTimeout(N,w[1]),f.document.taskCenter.callbackManager.lastCallbackId.toString()},setInterval:(...w)=>{let N=function(){w[0](...w.slice(2))};return s.setInterval(N,w[1]),f.document.taskCenter.callbackManager.lastCallbackId.toString()},clearTimeout:w=>{s.clearTimeout(w)},clearInterval:w=>{s.clearInterval(w)}}}var Jv={Document:Ko,Element:Zi,Comment:cl,Listener:Ul,TaskCenter:Vl,sendTasks(...f){return zn(callNative)?callNative(...f):(global.callNative||(()=>{}))(...f)}};Ko.handler=Jv.sendTasks;var fl=Jv;function $k(){Oa(fl.Comment),Oa(fl.Listener),Oa(fl.Document.prototype),Oa(fl.Comment.prototype),Oa(fl.Listener.prototype)}var gu={service:{register:uu,unregister:fu,has:Pf},freezePrototype:$k,init:Df,config:fl};var Lf=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 Rs={},mc={};function Ff(){}Ff.prototype.postMessage=function(f){if(this._closed)throw new Error(`BroadcastChannel "${this.name}" is closed.`);let s=Rs[this.name];if(s&&s.length)for(let p=0;p<s.length;++p){let w=s[p];w._closed||w===this||zn(w.onmessage)&&w.onmessage(new Lf("message",{data:f}))}};Ff.prototype.close=function(){if(!this._closed&&(this._closed=!0,Rs[this.name])){let f=Rs[this.name].filter(s=>s!==this);f.length?Rs[this.name]=f:delete Rs[this.name]}};var Kv={create:f=>{if(mc[f]=[],zn(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,Rs[this.name]||(Rs[this.name]=[]),Rs[this.name].push(this),mc[f].push(this)}};return s.BroadcastChannel.prototype=Ff.prototype,{instance:s}},destroy:f=>{mc[f]&&(mc[f].forEach(s=>s.close()),delete mc[f])}};function Vf(){let{init:f}=gu;gu.service.register("BroadcastChannel",Kv),gu.freezePrototype();let s=f();for(let p in s)global[p]=(...w)=>{let N=s[p](...w);return N instanceof Error&&console.error(N.toString()),N}}var CB=global.console;function Zv(){if(Gp(),global.WXEnvironment&&global.WXEnvironment.platform!=="Web")global.console={debug:(...f)=>{Qn("debug")&&global.nativeLog(..._c(f),"__DEBUG")},log:(...f)=>{Qn("log")&&global.nativeLog(..._c(f),"__LOG")},info:(...f)=>{Qn("info")&&global.nativeLog(..._c(f),"__INFO")},warn:(...f)=>{Qn("warn")&&global.nativeLog(..._c(f),"__WARN")},error:(...f)=>{Qn("error")&&global.nativeLog(..._c(f),"__ERROR")}};else{let{debug:f,log:s,info:p,warn:w,error:N}=console;console.__ori__={debug:f,log:s,info:p,warn:w,error:N},console.debug=(...E)=>{Qn("debug")&&console.__ori__.debug.apply(console,E)},console.log=(...E)=>{Qn("log")&&console.__ori__.log.apply(console,E)},console.info=(...E)=>{Qn("info")&&console.__ori__.info.apply(console,E)},console.warn=(...E)=>{Qn("warn")&&console.__ori__.warn.apply(console,E)},console.error=(...E)=>{Qn("error")&&console.__ori__.error.apply(console,E)}}}function _c(f){return f.map(s=>{if(Ma(s).toLowerCase()==="[object object]")try{s=JSON.stringify(s)}catch(w){s="[object object]"}else s=String(s);return s})}Zv();Vf();})();
