Created
January 5, 2025 14:16
-
-
Save kannaiah/1dd481c0c502fe34600f5d1ae6760087 to your computer and use it in GitHub Desktop.
This file has been truncated, but you can view the full file.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
( | |
function () { | |
const e = document.createElement('link').relList; | |
if (e && e.supports && e.supports('modulepreload')) return; | |
for ( | |
const s of document.querySelectorAll('link[rel="modulepreload"]') | |
) n(s); | |
new MutationObserver( | |
s => { | |
for (const r of s) if (r.type === 'childList') for (const a of r.addedNodes) a.tagName === 'LINK' && | |
a.rel === 'modulepreload' && | |
n(a) | |
} | |
).observe(document, { | |
childList: !0, | |
subtree: !0 | |
}); | |
function t(s) { | |
const r = {}; | |
return s.integrity && | |
(r.integrity = s.integrity), | |
s.referrerpolicy && | |
(r.referrerPolicy = s.referrerpolicy), | |
s.crossorigin === 'use-credentials' ? r.credentials = 'include' : s.crossorigin === 'anonymous' ? r.credentials = 'omit' : r.credentials = 'same-origin', | |
r | |
} | |
function n(s) { | |
if (s.ep) return; | |
s.ep = !0; | |
const r = t(s); | |
fetch(s.href, r) | |
} | |
} | |
) (); | |
const jm = 'modulepreload', | |
Hm = function (i) { | |
return '/' + i | |
}, | |
Fu = {}, | |
Wo = function (e, t, n) { | |
if (!t || t.length === 0) return e(); | |
const s = document.getElementsByTagName('link'); | |
return Promise.all( | |
t.map( | |
r => { | |
if (r = Hm(r), r in Fu) return; | |
Fu[r] = !0; | |
const a = r.endsWith('.css'), | |
l = a ? '[rel="stylesheet"]' : ''; | |
if (!!n) for (let c = s.length - 1; c >= 0; c--) { | |
const h = s[c]; | |
if (h.href === r && (!a || h.rel === 'stylesheet')) return | |
} else if (document.querySelector(`link[href="${ r }"]${ l }`)) return; | |
const u = document.createElement('link'); | |
if ( | |
u.rel = a ? 'stylesheet' : jm, | |
a || | |
(u.as = 'script', u.crossOrigin = ''), | |
u.href = r, | |
document.head.appendChild(u), | |
a | |
) return new Promise( | |
(c, h) => { | |
u.addEventListener('load', c), | |
u.addEventListener('error', () => h(new Error(`Unable to preload CSS for ${ r }`))) | |
} | |
) | |
} | |
) | |
).then(() => e()) | |
}; /** | |
* @vue/shared v3.5.13 | |
* (c) 2018-present Yuxi (Evan) You and Vue contributors | |
* @license MIT | |
**/ | |
/*! #__NO_SIDE_EFFECTS__ */ function Uo(i) { | |
const e = Object.create(null); | |
for (const t of i.split(',')) e[t] = 1; | |
return t => t in e | |
} | |
const ze = {}, | |
$n = [], | |
Qt = () => { | |
}, | |
qm = () => !1, | |
ta = i => i.charCodeAt(0) === 111 && | |
i.charCodeAt(1) === 110 && | |
(i.charCodeAt(2) > 122 || i.charCodeAt(2) < 97), | |
jo = i => i.startsWith('onUpdate:'), | |
et = Object.assign, | |
Ho = (i, e) => { | |
const t = i.indexOf(e); | |
t > - 1 && | |
i.splice(t, 1) | |
}, | |
Gm = Object.prototype.hasOwnProperty, | |
Re = (i, e) => Gm.call(i, e), | |
ve = Array.isArray, | |
Ln = i => Ws(i) === '[object Map]', | |
ia = i => Ws(i) === '[object Set]', | |
Au = i => Ws(i) === '[object Date]', | |
_e = i => typeof i == 'function', | |
Qe = i => typeof i == 'string', | |
ei = i => typeof i == 'symbol', | |
De = i => i !== null && | |
typeof i == 'object', | |
bd = i => (De(i) || _e(i)) && | |
_e(i.then) && | |
_e(i.catch), | |
wd = Object.prototype.toString, | |
Ws = i => wd.call(i), | |
Km = i => Ws(i).slice(8, - 1), | |
kd = i => Ws(i) === '[object Object]', | |
qo = i => Qe(i) && | |
i !== 'NaN' && | |
i[0] !== '-' && | |
'' + parseInt(i, 10) === i, | |
us = Uo( | |
',key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted' | |
), | |
na = i => { | |
const e = Object.create(null); | |
return t => e[t] || | |
(e[t] = i(t)) | |
}, | |
Xm = /-(\w)/g, | |
qt = na(i => i.replace(Xm, (e, t) => t ? t.toUpperCase() : '')), | |
Jm = /\B([A-Z])/g, | |
mn = na(i => i.replace(Jm, '-$1').toLowerCase()), | |
sa = na(i => i.charAt(0).toUpperCase() + i.slice(1)), | |
kr = na(i => i ? `on${ sa(i) }` : ''), | |
zi = (i, e) => !Object.is(i, e), | |
_r = (i, ...e) => { | |
for (let t = 0; t < i.length; t++) i[t](...e) | |
}, | |
_d = (i, e, t, n = !1) => { | |
Object.defineProperty(i, e, { | |
configurable: !0, | |
enumerable: !1, | |
writable: n, | |
value: t | |
}) | |
}, | |
Ir = i => { | |
const e = parseFloat(i); | |
return isNaN(e) ? i : e | |
}, | |
Ym = i => { | |
const e = Qe(i) ? Number(i) : NaN; | |
return isNaN(e) ? i : e | |
}; | |
let Vu; | |
const Us = () => Vu || | |
( | |
Vu = typeof globalThis < 'u' ? globalThis : typeof self < 'u' ? self : typeof window < 'u' ? window : typeof global < 'u' ? global : { | |
} | |
); | |
function tt(i) { | |
if (ve(i)) { | |
const e = {}; | |
for (let t = 0; t < i.length; t++) { | |
const n = i[t], | |
s = Qe(n) ? tg(n) : tt(n); | |
if (s) for (const r in s) e[r] = s[r] | |
} | |
return e | |
} else if (Qe(i) || De(i)) return i | |
} | |
const Qm = /;(?![^(]*\))/g, | |
Zm = /:([^]+)/, | |
eg = /\/\*[^]*?\*\//g; | |
function tg(i) { | |
const e = {}; | |
return i.replace(eg, '').split(Qm).forEach( | |
t => { | |
if (t) { | |
const n = t.split(Zm); | |
n.length > 1 && | |
(e[n[0].trim()] = n[1].trim()) | |
} | |
} | |
), | |
e | |
} | |
function ie(i) { | |
let e = ''; | |
if (Qe(i)) e = i; | |
else if (ve(i)) for (let t = 0; t < i.length; t++) { | |
const n = ie(i[t]); | |
n && | |
(e += n + ' ') | |
} else if (De(i)) for (const t in i) i[t] && | |
(e += t + ' '); | |
return e.trim() | |
} | |
const ig = 'itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly', | |
ng = Uo(ig); | |
function xd(i) { | |
return !!i || | |
i === '' | |
} | |
function sg(i, e) { | |
if (i.length !== e.length) return !1; | |
let t = !0; | |
for (let n = 0; t && n < i.length; n++) t = Vn(i[n], e[n]); | |
return t | |
} | |
function Vn(i, e) { | |
if (i === e) return !0; | |
let t = Au(i), | |
n = Au(e); | |
if (t || n) return t && | |
n ? i.getTime() === e.getTime() : !1; | |
if (t = ei(i), n = ei(e), t || n) return i === e; | |
if (t = ve(i), n = ve(e), t || n) return t && | |
n ? sg(i, e) : !1; | |
if (t = De(i), n = De(e), t || n) { | |
if (!t || !n) return !1; | |
const s = Object.keys(i).length, | |
r = Object.keys(e).length; | |
if (s !== r) return !1; | |
for (const a in i) { | |
const l = i.hasOwnProperty(a), | |
o = e.hasOwnProperty(a); | |
if (l && !o || !l && o || !Vn(i[a], e[a])) return !1 | |
} | |
} | |
return String(i) === String(e) | |
} | |
function rg(i, e) { | |
return i.findIndex(t => Vn(t, e)) | |
} | |
const Td = i => !!(i && i.__v_isRef === !0), | |
F = i => Qe(i) ? i : i == null ? '' : ve(i) || | |
De(i) && | |
(i.toString === wd || !_e(i.toString)) ? Td(i) ? F(i.value) : JSON.stringify(i, Sd, 2) : String(i), | |
Sd = (i, e) => Td(e) ? Sd(i, e.value) : Ln(e) ? { | |
[ | |
`Map(${ e.size })` | |
]: [ | |
...e.entries() | |
].reduce((t, [ | |
n, | |
s | |
], r) => (t[Pa(n, r) + ' =>'] = s, t), { | |
}) | |
} | |
: ia(e) ? { | |
[ | |
`Set(${ e.size })` | |
]: [ | |
...e.values() | |
].map(t => Pa(t)) | |
} | |
: ei(e) ? Pa(e) : De(e) && | |
!ve(e) && | |
!kd(e) ? String(e) : e, | |
Pa = (i, e = '') => { | |
var t; | |
return ei(i) ? `Symbol(${ (t = i.description) != null ? t : e })` : i | |
}; /** | |
* @vue/reactivity v3.5.13 | |
* (c) 2018-present Yuxi (Evan) You and Vue contributors | |
* @license MIT | |
**/ | |
let vt; | |
class Ed { | |
constructor(e = !1) { | |
this.detached = e, | |
this._active = !0, | |
this.effects = [], | |
this.cleanups = [], | |
this._isPaused = !1, | |
this.parent = vt, | |
!e && | |
vt && | |
(this.index = (vt.scopes || (vt.scopes = [])).push(this) - 1) | |
} | |
get active() { | |
return this._active | |
} | |
pause() { | |
if (this._active) { | |
this._isPaused = !0; | |
let e, | |
t; | |
if (this.scopes) for (e = 0, t = this.scopes.length; e < t; e++) this.scopes[e].pause(); | |
for (e = 0, t = this.effects.length; e < t; e++) this.effects[e].pause() | |
} | |
} | |
resume() { | |
if (this._active && this._isPaused) { | |
this._isPaused = !1; | |
let e, | |
t; | |
if (this.scopes) for (e = 0, t = this.scopes.length; e < t; e++) this.scopes[e].resume(); | |
for (e = 0, t = this.effects.length; e < t; e++) this.effects[e].resume() | |
} | |
} | |
run(e) { | |
if (this._active) { | |
const t = vt; | |
try { | |
return vt = this, | |
e() | |
} finally { | |
vt = t | |
} | |
} | |
} | |
on() { | |
vt = this | |
} | |
off() { | |
vt = this.parent | |
} | |
stop(e) { | |
if (this._active) { | |
this._active = !1; | |
let t, | |
n; | |
for (t = 0, n = this.effects.length; t < n; t++) this.effects[t].stop(); | |
for (this.effects.length = 0, t = 0, n = this.cleanups.length; t < n; t++) this.cleanups[t](); | |
if (this.cleanups.length = 0, this.scopes) { | |
for (t = 0, n = this.scopes.length; t < n; t++) this.scopes[t].stop(!0); | |
this.scopes.length = 0 | |
} | |
if (!this.detached && this.parent && !e) { | |
const s = this.parent.scopes.pop(); | |
s && | |
s !== this && | |
(this.parent.scopes[this.index] = s, s.index = this.index) | |
} | |
this.parent = void 0 | |
} | |
} | |
} | |
function Cd(i) { | |
return new Ed(i) | |
} | |
function $d() { | |
return vt | |
} | |
function ag(i, e = !1) { | |
vt && | |
vt.cleanups.push(i) | |
} | |
let je; | |
const Ia = new WeakSet; | |
class Ld { | |
constructor(e) { | |
this.fn = e, | |
this.deps = void 0, | |
this.depsTail = void 0, | |
this.flags = 5, | |
this.next = void 0, | |
this.cleanup = void 0, | |
this.scheduler = void 0, | |
vt && | |
vt.active && | |
vt.effects.push(this) | |
} | |
pause() { | |
this.flags |= 64 | |
} | |
resume() { | |
this.flags & 64 && | |
( | |
this.flags &= - 65, | |
Ia.has(this) && | |
(Ia.delete(this), this.trigger()) | |
) | |
} | |
notify() { | |
this.flags & 2 && | |
!(this.flags & 32) || | |
this.flags & 8 || | |
Id(this) | |
} | |
run() { | |
if (!(this.flags & 1)) return this.fn(); | |
this.flags |= 2, | |
zu(this), | |
Nd(this); | |
const e = je, | |
t = Zt; | |
je = this, | |
Zt = !0; | |
try { | |
return this.fn() | |
} finally { | |
Md(this), | |
je = e, | |
Zt = t, | |
this.flags &= - 3 | |
} | |
} | |
stop() { | |
if (this.flags & 1) { | |
for (let e = this.deps; e; e = e.nextDep) Xo(e); | |
this.deps = this.depsTail = void 0, | |
zu(this), | |
this.onStop && | |
this.onStop(), | |
this.flags &= - 2 | |
} | |
} | |
trigger() { | |
this.flags & 64 ? Ia.add(this) : this.scheduler ? this.scheduler() : this.runIfDirty() | |
} | |
runIfDirty() { | |
Hl(this) && | |
this.run() | |
} | |
get dirty() { | |
return Hl(this) | |
} | |
} | |
let Pd = 0, | |
cs, | |
hs; | |
function Id(i, e = !1) { | |
if (i.flags |= 8, e) { | |
i.next = hs, | |
hs = i; | |
return | |
} | |
i.next = cs, | |
cs = i | |
} | |
function Go() { | |
Pd++ | |
} | |
function Ko() { | |
if (--Pd > 0) return; | |
if (hs) { | |
let e = hs; | |
for (hs = void 0; e; ) { | |
const t = e.next; | |
e.next = void 0, | |
e.flags &= - 9, | |
e = t | |
} | |
} | |
let i; | |
for (; cs; ) { | |
let e = cs; | |
for (cs = void 0; e; ) { | |
const t = e.next; | |
if (e.next = void 0, e.flags &= - 9, e.flags & 1) try { | |
e.trigger() | |
} catch (n) { | |
i || | |
(i = n) | |
} | |
e = t | |
} | |
} | |
if (i) throw i | |
} | |
function Nd(i) { | |
for (let e = i.deps; e; e = e.nextDep) e.version = - 1, | |
e.prevActiveLink = e.dep.activeLink, | |
e.dep.activeLink = e | |
} | |
function Md(i) { | |
let e, | |
t = i.depsTail, | |
n = t; | |
for (; n; ) { | |
const s = n.prevDep; | |
n.version === - 1 ? (n === t && (t = s), Xo(n), lg(n)) : e = n, | |
n.dep.activeLink = n.prevActiveLink, | |
n.prevActiveLink = void 0, | |
n = s | |
} | |
i.deps = e, | |
i.depsTail = t | |
} | |
function Hl(i) { | |
for (let e = i.deps; e; e = e.nextDep) if ( | |
e.dep.version !== e.version || | |
e.dep.computed && | |
(Rd(e.dep.computed) || e.dep.version !== e.version) | |
) return !0; | |
return !!i._dirty | |
} | |
function Rd(i) { | |
if ( | |
i.flags & 4 && | |
!(i.flags & 16) || | |
(i.flags &= - 17, i.globalVersion === _s) | |
) return; | |
i.globalVersion = _s; | |
const e = i.dep; | |
if (i.flags |= 2, e.version > 0 && !i.isSSR && i.deps && !Hl(i)) { | |
i.flags &= - 3; | |
return | |
} | |
const t = je, | |
n = Zt; | |
je = i, | |
Zt = !0; | |
try { | |
Nd(i); | |
const s = i.fn(i._value); | |
(e.version === 0 || zi(s, i._value)) && | |
(i._value = s, e.version++) | |
} catch (s) { | |
throw e.version++, | |
s | |
} finally { | |
je = t, | |
Zt = n, | |
Md(i), | |
i.flags &= - 3 | |
} | |
} | |
function Xo(i, e = !1) { | |
const { | |
dep: t, | |
prevSub: n, | |
nextSub: s | |
} | |
= i; | |
if ( | |
n && | |
(n.nextSub = s, i.prevSub = void 0), | |
s && | |
(s.prevSub = n, i.nextSub = void 0), | |
t.subs === i && | |
(t.subs = n, !n && t.computed) | |
) { | |
t.computed.flags &= - 5; | |
for (let r = t.computed.deps; r; r = r.nextDep) Xo(r, !0) | |
} | |
!e && | |
!--t.sc && | |
t.map && | |
t.map.delete(t.key) | |
} | |
function lg(i) { | |
const { | |
prevDep: e, | |
nextDep: t | |
} | |
= i; | |
e && | |
(e.nextDep = t, i.prevDep = void 0), | |
t && | |
(t.prevDep = e, i.nextDep = void 0) | |
} | |
let Zt = !0; | |
const Bd = []; | |
function Gi() { | |
Bd.push(Zt), | |
Zt = !1 | |
} | |
function Ki() { | |
const i = Bd.pop(); | |
Zt = i === void 0 ? !0 : i | |
} | |
function zu(i) { | |
const { | |
cleanup: e | |
} | |
= i; | |
if (i.cleanup = void 0, e) { | |
const t = je; | |
je = void 0; | |
try { | |
e() | |
} finally { | |
je = t | |
} | |
} | |
} | |
let _s = 0; | |
class og { | |
constructor(e, t) { | |
this.sub = e, | |
this.dep = t, | |
this.version = t.version, | |
this.nextDep = this.prevDep = this.nextSub = this.prevSub = this.prevActiveLink = void 0 | |
} | |
} | |
class Jo { | |
constructor(e) { | |
this.computed = e, | |
this.version = 0, | |
this.activeLink = void 0, | |
this.subs = void 0, | |
this.map = void 0, | |
this.key = void 0, | |
this.sc = 0 | |
} | |
track(e) { | |
if (!je || !Zt || je === this.computed) return; | |
let t = this.activeLink; | |
if (t === void 0 || t.sub !== je) t = this.activeLink = new og(je, this), | |
je.deps ? (t.prevDep = je.depsTail, je.depsTail.nextDep = t, je.depsTail = t) : je.deps = je.depsTail = t, | |
Od(t); | |
else if (t.version === - 1 && (t.version = this.version, t.nextDep)) { | |
const n = t.nextDep; | |
n.prevDep = t.prevDep, | |
t.prevDep && | |
(t.prevDep.nextDep = n), | |
t.prevDep = je.depsTail, | |
t.nextDep = void 0, | |
je.depsTail.nextDep = t, | |
je.depsTail = t, | |
je.deps === t && | |
(je.deps = n) | |
} | |
return t | |
} | |
trigger(e) { | |
this.version++, | |
_s++, | |
this.notify(e) | |
} | |
notify(e) { | |
Go(); | |
try { | |
for (let t = this.subs; t; t = t.prevSub) t.sub.notify() && | |
t.sub.dep.notify() | |
} finally { | |
Ko() | |
} | |
} | |
} | |
function Od(i) { | |
if (i.dep.sc++, i.sub.flags & 4) { | |
const e = i.dep.computed; | |
if (e && !i.dep.subs) { | |
e.flags |= 20; | |
for (let n = e.deps; n; n = n.nextDep) Od(n) | |
} | |
const t = i.dep.subs; | |
t !== i && | |
(i.prevSub = t, t && (t.nextSub = i)), | |
i.dep.subs = i | |
} | |
} | |
const Nr = new WeakMap, | |
sn = Symbol(''), | |
ql = Symbol(''), | |
xs = Symbol(''); | |
function pt(i, e, t) { | |
if (Zt && je) { | |
let n = Nr.get(i); | |
n || | |
Nr.set(i, n = new Map); | |
let s = n.get(t); | |
s || | |
(n.set(t, s = new Jo), s.map = n, s.key = t), | |
s.track() | |
} | |
} | |
function wi(i, e, t, n, s, r) { | |
const a = Nr.get(i); | |
if (!a) { | |
_s++; | |
return | |
} | |
const l = o => { | |
o && | |
o.trigger() | |
}; | |
if (Go(), e === 'clear') a.forEach(l); | |
else { | |
const o = ve(i), | |
u = o && | |
qo(t); | |
if (o && t === 'length') { | |
const c = Number(n); | |
a.forEach((h, d) => { | |
(d === 'length' || d === xs || !ei(d) && d >= c) && | |
l(h) | |
}) | |
} else switch ((t !== void 0 || a.has(void 0)) && l(a.get(t)), u && l(a.get(xs)), e) { | |
case 'add': | |
o ? u && | |
l(a.get('length')) : (l(a.get(sn)), Ln(i) && l(a.get(ql))); | |
break; | |
case 'delete': | |
o || | |
(l(a.get(sn)), Ln(i) && l(a.get(ql))); | |
break; | |
case 'set': | |
Ln(i) && | |
l(a.get(sn)); | |
break | |
} | |
} | |
Ko() | |
} | |
function ug(i, e) { | |
const t = Nr.get(i); | |
return t && | |
t.get(e) | |
} | |
function vn(i) { | |
const e = Pe(i); | |
return e === i ? e : (pt(e, 'iterate', xs), Vt(i) ? e : e.map(mt)) | |
} | |
function ra(i) { | |
return pt(i = Pe(i), 'iterate', xs), | |
i | |
} | |
const cg = { | |
__proto__: null, | |
[ | |
Symbol.iterator | |
]() { | |
return Na(this, Symbol.iterator, mt) | |
}, | |
concat(...i) { | |
return vn(this).concat(...i.map(e => ve(e) ? vn(e) : e)) | |
}, | |
entries() { | |
return Na(this, 'entries', i => (i[1] = mt(i[1]), i)) | |
}, | |
every(i, e) { | |
return mi(this, 'every', i, e, void 0, arguments) | |
}, | |
filter(i, e) { | |
return mi(this, 'filter', i, e, t => t.map(mt), arguments) | |
}, | |
find(i, e) { | |
return mi(this, 'find', i, e, mt, arguments) | |
}, | |
findIndex(i, e) { | |
return mi(this, 'findIndex', i, e, void 0, arguments) | |
}, | |
findLast(i, e) { | |
return mi(this, 'findLast', i, e, mt, arguments) | |
}, | |
findLastIndex(i, e) { | |
return mi(this, 'findLastIndex', i, e, void 0, arguments) | |
}, | |
forEach(i, e) { | |
return mi(this, 'forEach', i, e, void 0, arguments) | |
}, | |
includes(...i) { | |
return Ma(this, 'includes', i) | |
}, | |
indexOf(...i) { | |
return Ma(this, 'indexOf', i) | |
}, | |
join(i) { | |
return vn(this).join(i) | |
}, | |
lastIndexOf(...i) { | |
return Ma(this, 'lastIndexOf', i) | |
}, | |
map(i, e) { | |
return mi(this, 'map', i, e, void 0, arguments) | |
}, | |
pop() { | |
return is(this, 'pop') | |
}, | |
push(...i) { | |
return is(this, 'push', i) | |
}, | |
reduce(i, ...e) { | |
return Wu(this, 'reduce', i, e) | |
}, | |
reduceRight(i, ...e) { | |
return Wu(this, 'reduceRight', i, e) | |
}, | |
shift() { | |
return is(this, 'shift') | |
}, | |
some(i, e) { | |
return mi(this, 'some', i, e, void 0, arguments) | |
}, | |
splice(...i) { | |
return is(this, 'splice', i) | |
}, | |
toReversed() { | |
return vn(this).toReversed() | |
}, | |
toSorted(i) { | |
return vn(this).toSorted(i) | |
}, | |
toSpliced(...i) { | |
return vn(this).toSpliced(...i) | |
}, | |
unshift(...i) { | |
return is(this, 'unshift', i) | |
}, | |
values() { | |
return Na(this, 'values', mt) | |
} | |
}; | |
function Na(i, e, t) { | |
const n = ra(i), | |
s = n[e](); | |
return n !== i && | |
!Vt(i) && | |
( | |
s._next = s.next, | |
s.next = () => { | |
const r = s._next(); | |
return r.value && | |
(r.value = t(r.value)), | |
r | |
} | |
), | |
s | |
} | |
const hg = Array.prototype; | |
function mi(i, e, t, n, s, r) { | |
const a = ra(i), | |
l = a !== i && | |
!Vt(i), | |
o = a[e]; | |
if (o !== hg[e]) { | |
const h = o.apply(i, r); | |
return l ? mt(h) : h | |
} | |
let u = t; | |
a !== i && | |
( | |
l ? u = function (h, d) { | |
return t.call(this, mt(h), d, i) | |
} | |
: t.length > 2 && | |
(u = function (h, d) { | |
return t.call(this, h, d, i) | |
}) | |
); | |
const c = o.call(a, u, n); | |
return l && | |
s ? s(c) : c | |
} | |
function Wu(i, e, t, n) { | |
const s = ra(i); | |
let r = t; | |
return s !== i && | |
( | |
Vt(i) ? t.length > 3 && | |
(r = function (a, l, o) { | |
return t.call(this, a, l, o, i) | |
}) : r = function (a, l, o) { | |
return t.call(this, a, mt(l), o, i) | |
} | |
), | |
s[e](r, ...n) | |
} | |
function Ma(i, e, t) { | |
const n = Pe(i); | |
pt(n, 'iterate', xs); | |
const s = n[e](...t); | |
return (s === - 1 || s === !1) && | |
eu(t[0]) ? (t[0] = Pe(t[0]), n[e](...t)) : s | |
} | |
function is(i, e, t = []) { | |
Gi(), | |
Go(); | |
const n = Pe(i) [e].apply(i, t); | |
return Ko(), | |
Ki(), | |
n | |
} | |
const dg = Uo('__proto__,__v_isRef,__isVue'), | |
Dd = new Set( | |
Object.getOwnPropertyNames(Symbol).filter(i => i !== 'arguments' && i !== 'caller').map(i => Symbol[i]).filter(ei) | |
); | |
function fg(i) { | |
ei(i) || | |
(i = String(i)); | |
const e = Pe(this); | |
return pt(e, 'has', i), | |
e.hasOwnProperty(i) | |
} | |
class Fd { | |
constructor(e = !1, t = !1) { | |
this._isReadonly = e, | |
this._isShallow = t | |
} | |
get(e, t, n) { | |
if (t === '__v_skip') return e.__v_skip; | |
const s = this._isReadonly, | |
r = this._isShallow; | |
if (t === '__v_isReactive') return !s; | |
if (t === '__v_isReadonly') return s; | |
if (t === '__v_isShallow') return r; | |
if (t === '__v_raw') return n === (s ? r ? xg : Wd : r ? zd : Vd).get(e) || | |
Object.getPrototypeOf(e) === Object.getPrototypeOf(n) ? e : void 0; | |
const a = ve(e); | |
if (!s) { | |
let o; | |
if (a && (o = cg[t])) return o; | |
if (t === 'hasOwnProperty') return fg | |
} | |
const l = Reflect.get(e, t, Je(e) ? e : n); | |
return (ei(t) ? Dd.has(t) : dg(t)) || | |
(s || pt(e, 'get', t), r) ? l : Je(l) ? a && | |
qo(t) ? l : l.value : De(l) ? s ? Ud(l) : Wi(l) : l | |
} | |
} | |
class Ad extends Fd { | |
constructor(e = !1) { | |
super (!1, e) | |
} | |
set(e, t, n, s) { | |
let r = e[t]; | |
if (!this._isShallow) { | |
const o = ln(r); | |
if (!Vt(n) && !ln(n) && (r = Pe(r), n = Pe(n)), !ve(e) && Je(r) && !Je(n)) return o ? !1 : (r.value = n, !0) | |
} | |
const a = ve(e) && | |
qo(t) ? Number(t) < e.length : Re(e, t), | |
l = Reflect.set(e, t, n, Je(e) ? e : s); | |
return e === Pe(s) && | |
(a ? zi(n, r) && | |
wi(e, 'set', t, n) : wi(e, 'add', t, n)), | |
l | |
} | |
deleteProperty(e, t) { | |
const n = Re(e, t); | |
e[t]; | |
const s = Reflect.deleteProperty(e, t); | |
return s && | |
n && | |
wi(e, 'delete', t, void 0), | |
s | |
} | |
has(e, t) { | |
const n = Reflect.has(e, t); | |
return (!ei(t) || !Dd.has(t)) && | |
pt(e, 'has', t), | |
n | |
} | |
ownKeys(e) { | |
return pt(e, 'iterate', ve(e) ? 'length' : sn), | |
Reflect.ownKeys(e) | |
} | |
} | |
class pg extends Fd { | |
constructor(e = !1) { | |
super (!0, e) | |
} | |
set(e, t) { | |
return !0 | |
} | |
deleteProperty(e, t) { | |
return !0 | |
} | |
} | |
const mg = new Ad, | |
gg = new pg, | |
yg = new Ad(!0); | |
const Gl = i => i, | |
Zs = i => Reflect.getPrototypeOf(i); | |
function vg(i, e, t) { | |
return function (...n) { | |
const s = this.__v_raw, | |
r = Pe(s), | |
a = Ln(r), | |
l = i === 'entries' || | |
i === Symbol.iterator && | |
a, | |
o = i === 'keys' && | |
a, | |
u = s[i](...n), | |
c = t ? Gl : e ? Kl : mt; | |
return !e && | |
pt(r, 'iterate', o ? ql : sn), | |
{ | |
next() { | |
const { | |
value: h, | |
done: d | |
} | |
= u.next(); | |
return d ? { | |
value: h, | |
done: d | |
} | |
: { | |
value: l ? [ | |
c(h[0]), | |
c(h[1]) | |
] : c(h), | |
done: d | |
} | |
}, | |
[ | |
Symbol.iterator | |
]() { | |
return this | |
} | |
} | |
} | |
} | |
function er(i) { | |
return function (...e) { | |
return i === 'delete' ? !1 : i === 'clear' ? void 0 : this | |
} | |
} | |
function bg(i, e) { | |
const t = { | |
get(s) { | |
const r = this.__v_raw, | |
a = Pe(r), | |
l = Pe(s); | |
i || | |
(zi(s, l) && pt(a, 'get', s), pt(a, 'get', l)); | |
const { | |
has: o | |
} | |
= Zs(a), | |
u = e ? Gl : i ? Kl : mt; | |
if (o.call(a, s)) return u(r.get(s)); | |
if (o.call(a, l)) return u(r.get(l)); | |
r !== a && | |
r.get(s) | |
}, | |
get size() { | |
const s = this.__v_raw; | |
return !i && | |
pt(Pe(s), 'iterate', sn), | |
Reflect.get(s, 'size', s) | |
}, | |
has(s) { | |
const r = this.__v_raw, | |
a = Pe(r), | |
l = Pe(s); | |
return i || | |
(zi(s, l) && pt(a, 'has', s), pt(a, 'has', l)), | |
s === l ? r.has(s) : r.has(s) || | |
r.has(l) | |
}, | |
forEach(s, r) { | |
const a = this, | |
l = a.__v_raw, | |
o = Pe(l), | |
u = e ? Gl : i ? Kl : mt; | |
return !i && | |
pt(o, 'iterate', sn), | |
l.forEach((c, h) => s.call(r, u(c), u(h), a)) | |
} | |
}; | |
return et( | |
t, | |
i ? { | |
add: er('add'), | |
set: er('set'), | |
delete : er('delete'), | |
clear: er('clear') | |
} | |
: { | |
add(s) { | |
!e && | |
!Vt(s) && | |
!ln(s) && | |
(s = Pe(s)); | |
const r = Pe(this); | |
return Zs(r).has.call(r, s) || | |
(r.add(s), wi(r, 'add', s, s)), | |
this | |
}, | |
set(s, r) { | |
!e && | |
!Vt(r) && | |
!ln(r) && | |
(r = Pe(r)); | |
const a = Pe(this), | |
{ | |
has: l, | |
get: o | |
} | |
= Zs(a); | |
let u = l.call(a, s); | |
u || | |
(s = Pe(s), u = l.call(a, s)); | |
const c = o.call(a, s); | |
return a.set(s, r), | |
u ? zi(r, c) && | |
wi(a, 'set', s, r) : wi(a, 'add', s, r), | |
this | |
}, | |
delete (s) { | |
const r = Pe(this), | |
{ | |
has: a, | |
get: l | |
} | |
= Zs(r); | |
let o = a.call(r, s); | |
o || | |
(s = Pe(s), o = a.call(r, s)), | |
l && | |
l.call(r, s); | |
const u = r.delete(s); | |
return o && | |
wi(r, 'delete', s, void 0), | |
u | |
}, | |
clear() { | |
const s = Pe(this), | |
r = s.size !== 0, | |
a = s.clear(); | |
return r && | |
wi(s, 'clear', void 0, void 0), | |
a | |
} | |
} | |
), | |
[ | |
'keys', | |
'values', | |
'entries', | |
Symbol.iterator | |
].forEach(s => { | |
t[s] = vg(s, i, e) | |
}), | |
t | |
} | |
function Yo(i, e) { | |
const t = bg(i, e); | |
return (n, s, r) => s === '__v_isReactive' ? !i : s === '__v_isReadonly' ? i : s === '__v_raw' ? n : Reflect.get(Re(t, s) && s in n ? t : n, s, r) | |
} | |
const wg = { | |
get: Yo(!1, !1) | |
}, | |
kg = { | |
get: Yo(!1, !0) | |
}, | |
_g = { | |
get: Yo(!0, !1) | |
}; | |
const Vd = new WeakMap, | |
zd = new WeakMap, | |
Wd = new WeakMap, | |
xg = new WeakMap; | |
function Tg(i) { | |
switch (i) { | |
case 'Object': | |
case 'Array': | |
return 1; | |
case 'Map': | |
case 'Set': | |
case 'WeakMap': | |
case 'WeakSet': | |
return 2; | |
default: | |
return 0 | |
} | |
} | |
function Sg(i) { | |
return i.__v_skip || | |
!Object.isExtensible(i) ? 0 : Tg(Km(i)) | |
} | |
function Wi(i) { | |
return ln(i) ? i : Zo(i, !1, mg, wg, Vd) | |
} | |
function Qo(i) { | |
return Zo(i, !1, yg, kg, zd) | |
} | |
function Ud(i) { | |
return Zo(i, !0, gg, _g, Wd) | |
} | |
function Zo(i, e, t, n, s) { | |
if (!De(i) || i.__v_raw && !(e && i.__v_isReactive)) return i; | |
const r = s.get(i); | |
if (r) return r; | |
const a = Sg(i); | |
if (a === 0) return i; | |
const l = new Proxy(i, a === 2 ? n : t); | |
return s.set(i, l), | |
l | |
} | |
function Ui(i) { | |
return ln(i) ? Ui(i.__v_raw) : !!(i && i.__v_isReactive) | |
} | |
function ln(i) { | |
return !!(i && i.__v_isReadonly) | |
} | |
function Vt(i) { | |
return !!(i && i.__v_isShallow) | |
} | |
function eu(i) { | |
return i ? !!i.__v_raw : !1 | |
} | |
function Pe(i) { | |
const e = i && | |
i.__v_raw; | |
return e ? Pe(e) : i | |
} | |
function aa(i) { | |
return !Re(i, '__v_skip') && | |
Object.isExtensible(i) && | |
_d(i, '__v_skip', !0), | |
i | |
} | |
const mt = i => De(i) ? Wi(i) : i, | |
Kl = i => De(i) ? Ud(i) : i; | |
function Je(i) { | |
return i ? i.__v_isRef === !0 : !1 | |
} | |
function M(i) { | |
return jd(i, !1) | |
} | |
function Eg(i) { | |
return jd(i, !0) | |
} | |
function jd(i, e) { | |
return Je(i) ? i : new Cg(i, e) | |
} | |
class Cg { | |
constructor(e, t) { | |
this.dep = new Jo, | |
this.__v_isRef = !0, | |
this.__v_isShallow = !1, | |
this._rawValue = t ? e : Pe(e), | |
this._value = t ? e : mt(e), | |
this.__v_isShallow = t | |
} | |
get value() { | |
return this.dep.track(), | |
this._value | |
} | |
set value(e) { | |
const t = this._rawValue, | |
n = this.__v_isShallow || | |
Vt(e) || | |
ln(e); | |
e = n ? e : Pe(e), | |
zi(e, t) && | |
(this._rawValue = e, this._value = n ? e : mt(e), this.dep.trigger()) | |
} | |
} | |
function pe(i) { | |
return Je(i) ? i.value : i | |
} | |
const $g = { | |
get: (i, e, t) => e === '__v_raw' ? i : pe(Reflect.get(i, e, t)), | |
set: (i, e, t, n) => { | |
const s = i[e]; | |
return Je(s) && | |
!Je(t) ? (s.value = t, !0) : Reflect.set(i, e, t, n) | |
} | |
}; | |
function Hd(i) { | |
return Ui(i) ? i : new Proxy(i, $g) | |
} | |
function Lg(i) { | |
const e = ve(i) ? new Array(i.length) : { | |
}; | |
for (const t in i) e[t] = qd(i, t); | |
return e | |
} | |
class Pg { | |
constructor(e, t, n) { | |
this._object = e, | |
this._key = t, | |
this._defaultValue = n, | |
this.__v_isRef = !0, | |
this._value = void 0 | |
} | |
get value() { | |
const e = this._object[this._key]; | |
return this._value = e === void 0 ? this._defaultValue : e | |
} | |
set value(e) { | |
this._object[this._key] = e | |
} | |
get dep() { | |
return ug(Pe(this._object), this._key) | |
} | |
} | |
class Ig { | |
constructor(e) { | |
this._getter = e, | |
this.__v_isRef = !0, | |
this.__v_isReadonly = !0, | |
this._value = void 0 | |
} | |
get value() { | |
return this._value = this._getter() | |
} | |
} | |
function Uu(i, e, t) { | |
return Je(i) ? i : _e(i) ? new Ig(i) : De(i) && | |
arguments.length > 1 ? qd(i, e, t) : M(i) | |
} | |
function qd(i, e, t) { | |
const n = i[e]; | |
return Je(n) ? n : new Pg(i, e, t) | |
} | |
class Ng { | |
constructor(e, t, n) { | |
this.fn = e, | |
this.setter = t, | |
this._value = void 0, | |
this.dep = new Jo(this), | |
this.__v_isRef = !0, | |
this.deps = void 0, | |
this.depsTail = void 0, | |
this.flags = 16, | |
this.globalVersion = _s - 1, | |
this.next = void 0, | |
this.effect = this, | |
this.__v_isReadonly = !t, | |
this.isSSR = n | |
} | |
notify() { | |
if (this.flags |= 16, !(this.flags & 8) && je !== this) return Id(this, !0), | |
!0 | |
} | |
get value() { | |
const e = this.dep.track(); | |
return Rd(this), | |
e && | |
(e.version = this.dep.version), | |
this._value | |
} | |
set value(e) { | |
this.setter && | |
this.setter(e) | |
} | |
} | |
function Mg(i, e, t = !1) { | |
let n, | |
s; | |
return _e(i) ? n = i : (n = i.get, s = i.set), | |
new Ng(n, s, t) | |
} | |
const tr = {}, | |
Mr = new WeakMap; | |
let tn; | |
function Rg(i, e = !1, t = tn) { | |
if (t) { | |
let n = Mr.get(t); | |
n || | |
Mr.set(t, n = []), | |
n.push(i) | |
} | |
} | |
function Bg(i, e, t = ze) { | |
const { | |
immediate: n, | |
deep: s, | |
once: r, | |
scheduler: a, | |
augmentJob: l, | |
call: o | |
} | |
= t, | |
u = k => s ? k : Vt(k) || | |
s === !1 || | |
s === 0 ? ki(k, 1) : ki(k); | |
let c, | |
h, | |
d, | |
f, | |
p = !1, | |
g = !1; | |
if ( | |
Je(i) ? (h = () => i.value, p = Vt(i)) : Ui(i) ? (h = () => u(i), p = !0) : ve(i) ? ( | |
g = !0, | |
p = i.some(k => Ui(k) || Vt(k)), | |
h = () => i.map( | |
k => { | |
if (Je(k)) return k.value; | |
if (Ui(k)) return u(k); | |
if (_e(k)) return o ? o(k, 2) : k() | |
} | |
) | |
) : _e(i) ? e ? h = o ? () => o(i, 2) : i : h = () => { | |
if (d) { | |
Gi(); | |
try { | |
d() | |
} finally { | |
Ki() | |
} | |
} | |
const k = tn; | |
tn = c; | |
try { | |
return o ? o(i, 3, [ | |
f | |
]) : i(f) | |
} finally { | |
tn = k | |
} | |
} | |
: h = Qt, | |
e && | |
s | |
) { | |
const k = h, | |
S = s === !0 ? 1 / 0 : s; | |
h = () => ki(k(), S) | |
} | |
const w = $d(), | |
y = () => { | |
c.stop(), | |
w && | |
w.active && | |
Ho(w.effects, c) | |
}; | |
if (r && e) { | |
const k = e; | |
e = (...S) => { | |
k(...S), | |
y() | |
} | |
} | |
let b = g ? new Array(i.length).fill(tr) : tr; | |
const x = k => { | |
if (!(!(c.flags & 1) || !c.dirty && !k)) if (e) { | |
const S = c.run(); | |
if (s || p || (g ? S.some((B, z) => zi(B, b[z])) : zi(S, b))) { | |
d && | |
d(); | |
const B = tn; | |
tn = c; | |
try { | |
const z = [ | |
S, | |
b === tr ? void 0 : g && | |
b[0] === tr ? [] : b, | |
f | |
]; | |
o ? o(e, 3, z) : e(...z), | |
b = S | |
} finally { | |
tn = B | |
} | |
} | |
} else c.run() | |
}; | |
return l && | |
l(x), | |
c = new Ld(h), | |
c.scheduler = a ? () => a(x, !1) : x, | |
f = k => Rg(k, !1, c), | |
d = c.onStop = () => { | |
const k = Mr.get(c); | |
if (k) { | |
if (o) o(k, 4); | |
else for (const S of k) S(); | |
Mr.delete(c) | |
} | |
}, | |
e ? n ? x(!0) : b = c.run() : a ? a(x.bind(null, !0), !0) : c.run(), | |
y.pause = c.pause.bind(c), | |
y.resume = c.resume.bind(c), | |
y.stop = y, | |
y | |
} | |
function ki(i, e = 1 / 0, t) { | |
if (e <= 0 || !De(i) || i.__v_skip || (t = t || new Set, t.has(i))) return i; | |
if (t.add(i), e--, Je(i)) ki(i.value, e, t); | |
else if (ve(i)) for (let n = 0; n < i.length; n++) ki(i[n], e, t); | |
else if (ia(i) || Ln(i)) i.forEach(n => { | |
ki(n, e, t) | |
}); | |
else if (kd(i)) { | |
for (const n in i) ki(i[n], e, t); | |
for (const n of Object.getOwnPropertySymbols(i)) Object.prototype.propertyIsEnumerable.call(i, n) && | |
ki(i[n], e, t) | |
} | |
return i | |
} /** | |
* @vue/runtime-core v3.5.13 | |
* (c) 2018-present Yuxi (Evan) You and Vue contributors | |
* @license MIT | |
**/ | |
function js(i, e, t, n) { | |
try { | |
return n ? i(...n) : i() | |
} catch (s) { | |
la(s, e, t) | |
} | |
} | |
function ti(i, e, t, n) { | |
if (_e(i)) { | |
const s = js(i, e, t, n); | |
return s && | |
bd(s) && | |
s.catch(r => { | |
la(r, e, t) | |
}), | |
s | |
} | |
if (ve(i)) { | |
const s = []; | |
for (let r = 0; r < i.length; r++) s.push(ti(i[r], e, t, n)); | |
return s | |
} | |
} | |
function la(i, e, t, n = !0) { | |
const s = e ? e.vnode : null, | |
{ | |
errorHandler: r, | |
throwUnhandledErrorInProduction: a | |
} | |
= e && | |
e.appContext.config || | |
ze; | |
if (e) { | |
let l = e.parent; | |
const o = e.proxy, | |
u = `https://vuejs.org/error-reference/#runtime-${ t }`; | |
for (; l; ) { | |
const c = l.ec; | |
if (c) { | |
for (let h = 0; h < c.length; h++) if (c[h](i, o, u) === !1) return | |
} | |
l = l.parent | |
} | |
if (r) { | |
Gi(), | |
js(r, null, 10, [ | |
i, | |
o, | |
u | |
]), | |
Ki(); | |
return | |
} | |
} | |
Og(i, t, s, n, a) | |
} | |
function Og(i, e, t, n = !0, s = !1) { | |
if (s) throw i; | |
console.error(i) | |
} | |
const bt = []; | |
let ci = - 1; | |
const Pn = []; | |
let Bi = null, | |
_n = 0; | |
const Gd = Promise.resolve(); | |
let Rr = null; | |
function pi(i) { | |
const e = Rr || | |
Gd; | |
return i ? e.then(this ? i.bind(this) : i) : e | |
} | |
function Dg(i) { | |
let e = ci + 1, | |
t = bt.length; | |
for (; e < t; ) { | |
const n = e + t >>> 1, | |
s = bt[n], | |
r = Ts(s); | |
r < i || | |
r === i && | |
s.flags & 2 ? e = n + 1 : t = n | |
} | |
return e | |
} | |
function tu(i) { | |
if (!(i.flags & 1)) { | |
const e = Ts(i), | |
t = bt[bt.length - 1]; | |
!t || | |
!(i.flags & 2) && | |
e >= Ts(t) ? bt.push(i) : bt.splice(Dg(e), 0, i), | |
i.flags |= 1, | |
Kd() | |
} | |
} | |
function Kd() { | |
Rr || | |
(Rr = Gd.then(Jd)) | |
} | |
function Fg(i) { | |
ve(i) ? Pn.push(...i) : Bi && | |
i.id === - 1 ? Bi.splice(_n + 1, 0, i) : i.flags & 1 || | |
(Pn.push(i), i.flags |= 1), | |
Kd() | |
} | |
function ju(i, e, t = ci + 1) { | |
for (; t < bt.length; t++) { | |
const n = bt[t]; | |
if (n && n.flags & 2) { | |
if (i && n.id !== i.uid) continue; | |
bt.splice(t, 1), | |
t--, | |
n.flags & 4 && | |
(n.flags &= - 2), | |
n(), | |
n.flags & 4 || | |
(n.flags &= - 2) | |
} | |
} | |
} | |
function Xd(i) { | |
if (Pn.length) { | |
const e = [ | |
...new Set(Pn) | |
].sort((t, n) => Ts(t) - Ts(n)); | |
if (Pn.length = 0, Bi) { | |
Bi.push(...e); | |
return | |
} | |
for (Bi = e, _n = 0; _n < Bi.length; _n++) { | |
const t = Bi[_n]; | |
t.flags & 4 && | |
(t.flags &= - 2), | |
t.flags & 8 || | |
t(), | |
t.flags &= - 2 | |
} | |
Bi = null, | |
_n = 0 | |
} | |
} | |
const Ts = i => i.id == null ? i.flags & 2 ? - 1 : 1 / 0 : i.id; | |
function Jd(i) { | |
const e = Qt; | |
try { | |
for (ci = 0; ci < bt.length; ci++) { | |
const t = bt[ci]; | |
t && | |
!(t.flags & 8) && | |
( | |
t.flags & 4 && | |
(t.flags &= - 2), | |
js(t, t.i, t.i ? 15 : 14), | |
t.flags & 4 || | |
(t.flags &= - 2) | |
) | |
} | |
} finally { | |
for (; ci < bt.length; ci++) { | |
const t = bt[ci]; | |
t && | |
(t.flags &= - 2) | |
} | |
ci = - 1, | |
bt.length = 0, | |
Xd(), | |
Rr = null, | |
(bt.length || Pn.length) && | |
Jd() | |
} | |
} | |
let nt = null, | |
oa = null; | |
function Br(i) { | |
const e = nt; | |
return nt = i, | |
oa = i && | |
i.type.__scopeId || | |
null, | |
e | |
} | |
function Ag(i) { | |
oa = i | |
} | |
function Vg() { | |
oa = null | |
} | |
const zg = i => We; | |
function We(i, e = nt, t) { | |
if (!e || i._n) return i; | |
const n = (...s) => { | |
n._d && | |
ec( - 1); | |
const r = Br(e); | |
let a; | |
try { | |
a = i(...s) | |
} finally { | |
Br(r), | |
n._d && | |
ec(1) | |
} | |
return a | |
}; | |
return n._n = !0, | |
n._c = !0, | |
n._d = !0, | |
n | |
} | |
function Mt(i, e) { | |
if (nt === null) return i; | |
const t = ma(nt), | |
n = i.dirs || | |
(i.dirs = []); | |
for (let s = 0; s < e.length; s++) { | |
let[r, | |
a, | |
l, | |
o = ze] = e[s]; | |
r && | |
( | |
_e(r) && | |
(r = { | |
mounted: r, | |
updated: r | |
}), | |
r.deep && | |
ki(a), | |
n.push({ | |
dir: r, | |
instance: t, | |
value: a, | |
oldValue: void 0, | |
arg: l, | |
modifiers: o | |
}) | |
) | |
} | |
return i | |
} | |
function Yi(i, e, t, n) { | |
const s = i.dirs, | |
r = e && | |
e.dirs; | |
for (let a = 0; a < s.length; a++) { | |
const l = s[a]; | |
r && | |
(l.oldValue = r[a].value); | |
let o = l.dir[n]; | |
o && | |
(Gi(), ti(o, t, 8, [ | |
i.el, | |
l, | |
i, | |
e | |
]), Ki()) | |
} | |
} | |
const Wg = Symbol('_vte'), | |
Yd = i => i.__isTeleport, | |
Oi = Symbol('_leaveCb'), | |
ir = Symbol('_enterCb'); | |
function Qd() { | |
const i = { | |
isMounted: !1, | |
isLeaving: !1, | |
isUnmounting: !1, | |
leavingVNodes: new Map | |
}; | |
return Te(() => { | |
i.isMounted = !0 | |
}), | |
da(() => { | |
i.isUnmounting = !0 | |
}), | |
i | |
} | |
const Ot = [ | |
Function, | |
Array | |
], | |
Zd = { | |
mode: String, | |
appear: Boolean, | |
persisted: Boolean, | |
onBeforeEnter: Ot, | |
onEnter: Ot, | |
onAfterEnter: Ot, | |
onEnterCancelled: Ot, | |
onBeforeLeave: Ot, | |
onLeave: Ot, | |
onAfterLeave: Ot, | |
onLeaveCancelled: Ot, | |
onBeforeAppear: Ot, | |
onAppear: Ot, | |
onAfterAppear: Ot, | |
onAppearCancelled: Ot | |
}, | |
ef = i => { | |
const e = i.subTree; | |
return e.component ? ef(e.component) : e | |
}, | |
Ug = { | |
name: 'BaseTransition', | |
props: Zd, | |
setup(i, { | |
slots: e | |
}) { | |
const t = Lf(), | |
n = Qd(); | |
return () => { | |
const s = e.default && | |
iu(e.default(), !0); | |
if (!s || !s.length) return; | |
const r = tf(s), | |
a = Pe(i), | |
{ | |
mode: l | |
} | |
= a; | |
if (n.isLeaving) return Ra(r); | |
const o = Hu(r); | |
if (!o) return Ra(r); | |
let u = Ss(o, a, n, t, h => u = h); | |
o.type !== _t && | |
on(o, u); | |
let c = t.subTree && | |
Hu(t.subTree); | |
if (c && c.type !== _t && !nn(o, c) && ef(t).type !== _t) { | |
let h = Ss(c, a, n, t); | |
if (on(c, h), l === 'out-in' && o.type !== _t) return n.isLeaving = !0, | |
h.afterLeave = () => { | |
n.isLeaving = !1, | |
t.job.flags & 8 || | |
t.update(), | |
delete h.afterLeave, | |
c = void 0 | |
}, | |
Ra(r); | |
l === 'in-out' && | |
o.type !== _t ? h.delayLeave = (d, f, p) => { | |
const g = nf(n, c); | |
g[String(c.key)] = c, | |
d[Oi] = () => { | |
f(), | |
d[Oi] = void 0, | |
delete u.delayedLeave, | |
c = void 0 | |
}, | |
u.delayedLeave = () => { | |
p(), | |
delete u.delayedLeave, | |
c = void 0 | |
} | |
} | |
: c = void 0 | |
} else c && | |
(c = void 0); | |
return r | |
} | |
} | |
}; | |
function tf(i) { | |
let e = i[0]; | |
if (i.length > 1) { | |
for (const t of i) if (t.type !== _t) { | |
e = t; | |
break | |
} | |
} | |
return e | |
} | |
const jg = Ug; | |
function nf(i, e) { | |
const { | |
leavingVNodes: t | |
} | |
= i; | |
let n = t.get(e.type); | |
return n || | |
(n = Object.create(null), t.set(e.type, n)), | |
n | |
} | |
function Ss(i, e, t, n, s) { | |
const { | |
appear: r, | |
mode: a, | |
persisted: l = !1, | |
onBeforeEnter: o, | |
onEnter: u, | |
onAfterEnter: c, | |
onEnterCancelled: h, | |
onBeforeLeave: d, | |
onLeave: f, | |
onAfterLeave: p, | |
onLeaveCancelled: g, | |
onBeforeAppear: w, | |
onAppear: y, | |
onAfterAppear: b, | |
onAppearCancelled: x | |
} | |
= e, | |
k = String(i.key), | |
S = nf(t, i), | |
B = ($, L) => { | |
$ && | |
ti($, n, 9, L) | |
}, | |
z = ($, L) => { | |
const A = L[1]; | |
B($, L), | |
ve($) ? $.every(N => N.length <= 1) && | |
A() : $.length <= 1 && | |
A() | |
}, | |
I = { | |
mode: a, | |
persisted: l, | |
beforeEnter($) { | |
let L = o; | |
if (!t.isMounted) if (r) L = w || | |
o; | |
else return; | |
$[Oi] && | |
$[Oi](!0); | |
const A = S[k]; | |
A && | |
nn(i, A) && | |
A.el[Oi] && | |
A.el[Oi](), | |
B(L, [ | |
$ | |
]) | |
}, | |
enter($) { | |
let L = u, | |
A = c, | |
N = h; | |
if (!t.isMounted) if (r) L = y || | |
u, | |
A = b || | |
c, | |
N = x || | |
h; | |
else return; | |
let O = !1; | |
const se = $[ir] = G => { | |
O || | |
( | |
O = !0, | |
G ? B(N, [ | |
$ | |
]) : B(A, [ | |
$ | |
]), | |
I.delayedLeave && | |
I.delayedLeave(), | |
$[ir] = void 0 | |
) | |
}; | |
L ? z(L, [ | |
$, | |
se | |
]) : se() | |
}, | |
leave($, L) { | |
const A = String(i.key); | |
if ($[ir] && $[ir](!0), t.isUnmounting) return L(); | |
B(d, [ | |
$ | |
]); | |
let N = !1; | |
const O = $[Oi] = se => { | |
N || | |
( | |
N = !0, | |
L(), | |
se ? B(g, [ | |
$ | |
]) : B(p, [ | |
$ | |
]), | |
$[Oi] = void 0, | |
S[A] === i && | |
delete S[A] | |
) | |
}; | |
S[A] = i, | |
f ? z(f, [ | |
$, | |
O | |
]) : O() | |
}, | |
clone($) { | |
const L = Ss($, e, t, n, s); | |
return s && | |
s(L), | |
L | |
} | |
}; | |
return I | |
} | |
function Ra(i) { | |
if (ua(i)) return i = ji(i), | |
i.children = null, | |
i | |
} | |
function Hu(i) { | |
if (!ua(i)) return Yd(i.type) && | |
i.children ? tf(i.children) : i; | |
const { | |
shapeFlag: e, | |
children: t | |
} | |
= i; | |
if (t) { | |
if (e & 16) return t[0]; | |
if (e & 32 && _e(t.default)) return t.default() | |
} | |
} | |
function on(i, e) { | |
i.shapeFlag & 6 && | |
i.component ? (i.transition = e, on(i.component.subTree, e)) : i.shapeFlag & 128 ? ( | |
i.ssContent.transition = e.clone(i.ssContent), | |
i.ssFallback.transition = e.clone(i.ssFallback) | |
) : i.transition = e | |
} | |
function iu(i, e = !1, t) { | |
let n = [], | |
s = 0; | |
for (let r = 0; r < i.length; r++) { | |
let a = i[r]; | |
const l = t == null ? a.key : String(t) + String(a.key != null ? a.key : r); | |
a.type === D ? (a.patchFlag & 128 && s++, n = n.concat(iu(a.children, e, l))) : (e || a.type !== _t) && | |
n.push(l != null ? ji(a, { | |
key: l | |
}) : a) | |
} | |
if (s > 1) for (let r = 0; r < n.length; r++) n[r].patchFlag = - 2; | |
return n | |
} /*! #__NO_SIDE_EFFECTS__ */ function U(i, e) { | |
return _e(i) ? (() => et({ | |
name: i.name | |
}, e, { | |
setup: i | |
})) () : i | |
} | |
function sf(i) { | |
i.ids = [ | |
i.ids[0] + i.ids[2]++ + '-', | |
0, | |
0 | |
] | |
} | |
function Or(i, e, t, n, s = !1) { | |
if (ve(i)) { | |
i.forEach((p, g) => Or(p, e && (ve(e) ? e[g] : e), t, n, s)); | |
return | |
} | |
if (In(n) && !s) { | |
n.shapeFlag & 512 && | |
n.type.__asyncResolved && | |
n.component.subTree.component && | |
Or(i, e, t, n.component.subTree); | |
return | |
} | |
const r = n.shapeFlag & 4 ? ma(n.component) : n.el, | |
a = s ? null : r, | |
{ | |
i: l, | |
r: o | |
} | |
= i, | |
u = e && | |
e.r, | |
c = l.refs === ze ? l.refs = {} | |
: l.refs, | |
h = l.setupState, | |
d = Pe(h), | |
f = h === ze ? () => !1 : p => Re(d, p); | |
if ( | |
u != null && | |
u !== o && | |
(Qe(u) ? (c[u] = null, f(u) && (h[u] = null)) : Je(u) && (u.value = null)), | |
_e(o) | |
) js(o, l, 12, [ | |
a, | |
c | |
]); | |
else { | |
const p = Qe(o), | |
g = Je(o); | |
if (p || g) { | |
const w = () => { | |
if (i.f) { | |
const y = p ? f(o) ? h[o] : c[o] : o.value; | |
s ? ve(y) && | |
Ho(y, r) : ve(y) ? y.includes(r) || | |
y.push(r) : p ? (c[o] = [ | |
r | |
], f(o) && (h[o] = c[o])) : (o.value = [ | |
r | |
], i.k && (c[i.k] = o.value)) | |
} else p ? (c[o] = a, f(o) && (h[o] = a)) : g && | |
(o.value = a, i.k && (c[i.k] = a)) | |
}; | |
a ? (w.id = - 1, Lt(w, t)) : w() | |
} | |
} | |
} | |
Us().requestIdleCallback; | |
Us().cancelIdleCallback; | |
const In = i => !!i.type.__asyncLoader, | |
ua = i => i.type.__isKeepAlive; | |
function Hg(i, e) { | |
rf(i, 'a', e) | |
} | |
function qg(i, e) { | |
rf(i, 'da', e) | |
} | |
function rf(i, e, t = ot) { | |
const n = i.__wdc || | |
( | |
i.__wdc = () => { | |
let s = t; | |
for (; s; ) { | |
if (s.isDeactivated) return; | |
s = s.parent | |
} | |
return i() | |
} | |
); | |
if (ca(e, n, t), t) { | |
let s = t.parent; | |
for (; s && s.parent; ) ua(s.parent.vnode) && | |
Gg(n, e, t, s), | |
s = s.parent | |
} | |
} | |
function Gg(i, e, t, n) { | |
const s = ca(e, i, n, !0); | |
ct(() => { | |
Ho(n[e], s) | |
}, t) | |
} | |
function ca(i, e, t = ot, n = !1) { | |
if (t) { | |
const s = t[i] || | |
(t[i] = []), | |
r = e.__weh || | |
( | |
e.__weh = (...a) => { | |
Gi(); | |
const l = Hs(t), | |
o = ti(e, t, i, a); | |
return l(), | |
Ki(), | |
o | |
} | |
); | |
return n ? s.unshift(r) : s.push(r), | |
r | |
} | |
} | |
const $i = i => (e, t = ot) => { | |
(!$s || i === 'sp') && | |
ca(i, (...n) => e(...n), t) | |
}, | |
Kg = $i('bm'), | |
Te = $i('m'), | |
af = $i('bu'), | |
ha = $i('u'), | |
da = $i('bum'), | |
ct = $i('um'), | |
Xg = $i('sp'), | |
Jg = $i('rtg'), | |
Yg = $i('rtc'); | |
function Qg(i, e = ot) { | |
ca('ec', i, e) | |
} | |
const nu = 'components', | |
Zg = 'directives'; | |
function st(i, e) { | |
return su(nu, i, !0, e) || | |
i | |
} | |
const lf = Symbol.for('v-ndc'); | |
function Xl(i) { | |
return Qe(i) ? su(nu, i, !1) || | |
i : i || | |
lf | |
} | |
function e0(i) { | |
return su(Zg, i) | |
} | |
function su(i, e, t = !0, n = !1) { | |
const s = nt || | |
ot; | |
if (s) { | |
const r = s.type; | |
if (i === nu) { | |
const l = W0(r, !1); | |
if (l && (l === e || l === qt(e) || l === sa(qt(e)))) return r | |
} | |
const a = qu(s[i] || r[i], e) || | |
qu(s.appContext[i], e); | |
return !a && | |
n ? r : a | |
} | |
} | |
function qu(i, e) { | |
return i && | |
(i[e] || i[qt(e)] || i[sa(qt(e))]) | |
} | |
function ue(i, e, t, n) { | |
let s; | |
const r = t && | |
t[n], | |
a = ve(i); | |
if (a || Qe(i)) { | |
const l = a && | |
Ui(i); | |
let o = !1; | |
l && | |
(o = !Vt(i), i = ra(i)), | |
s = new Array(i.length); | |
for (let u = 0, c = i.length; u < c; u++) s[u] = e(o ? mt(i[u]) : i[u], u, void 0, r && r[u]) | |
} else if (typeof i == 'number') { | |
s = new Array(i); | |
for (let l = 0; l < i; l++) s[l] = e(l + 1, l, void 0, r && r[l]) | |
} else if (De(i)) if (i[Symbol.iterator]) s = Array.from(i, (l, o) => e(l, o, void 0, r && r[o])); | |
else { | |
const l = Object.keys(i); | |
s = new Array(l.length); | |
for (let o = 0, u = l.length; o < u; o++) { | |
const c = l[o]; | |
s[o] = e(i[c], c, o, r && r[o]) | |
} | |
} else s = []; | |
return t && | |
(t[n] = s), | |
s | |
} | |
function nr(i, e, t = {}, n, s) { | |
if (nt.ce || nt.parent && In(nt.parent) && nt.parent.ce) return e !== 'default' && | |
(t.name = e), | |
_(), | |
xe(D, null, [ | |
V('slot', t, n && n()) | |
], 64); | |
let r = i[e]; | |
r && | |
r._c && | |
(r._d = !1), | |
_(); | |
const a = r && | |
of (r(t)), | |
l = t.key || | |
a && | |
a.key, | |
o = xe( | |
D, | |
{ | |
key: (l && !ei(l) ? l : `_${ e }`) + (!a && n ? '_fb' : '') | |
}, | |
a || | |
(n ? n() : []), | |
a && | |
i._ === 1 ? 64 : - 2 | |
); | |
return !s && | |
o.scopeId && | |
(o.slotScopeIds = [ | |
o.scopeId + '-s' | |
]), | |
r && | |
r._c && | |
(r._d = !0), | |
o | |
} | |
function of (i) { | |
return i.some(e => Cs(e) ? !(e.type === _t || e.type === D && !of (e.children)) : !0) ? i : null | |
} | |
function t0(i, e) { | |
const t = {}; | |
for (const n in i) t[e && | |
/[A-Z]/.test(n) ? `on:${ n }` : kr(n)] = i[n]; | |
return t | |
} | |
const Jl = i => i ? Pf(i) ? ma(i) : Jl(i.parent) : null, | |
ds = et( | |
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 => Jl(i.parent), | |
$root: i => Jl(i.root), | |
$host: i => i.ce, | |
$emit: i => i.emit, | |
$options: i => ru(i), | |
$forceUpdate: i => i.f || | |
(i.f = () => { | |
tu(i.update) | |
}), | |
$nextTick: i => i.n || | |
(i.n = pi.bind(i.proxy)), | |
$watch: i => T0.bind(i) | |
} | |
), | |
Ba = (i, e) => i !== ze && | |
!i.__isScriptSetup && | |
Re(i, e), | |
i0 = { | |
get({ | |
_: i | |
}, e) { | |
if (e === '__v_skip') return !0; | |
const { | |
ctx: t, | |
setupState: n, | |
data: s, | |
props: r, | |
accessCache: a, | |
type: l, | |
appContext: o | |
} | |
= i; | |
let u; | |
if (e[0] !== '$') { | |
const f = a[e]; | |
if (f !== void 0) switch (f) { | |
case 1: | |
return n[e]; | |
case 2: | |
return s[e]; | |
case 4: | |
return t[e]; | |
case 3: | |
return r[e] | |
} else { | |
if (Ba(n, e)) return a[e] = 1, | |
n[e]; | |
if (s !== ze && Re(s, e)) return a[e] = 2, | |
s[e]; | |
if ((u = i.propsOptions[0]) && Re(u, e)) return a[e] = 3, | |
r[e]; | |
if (t !== ze && Re(t, e)) return a[e] = 4, | |
t[e]; | |
Yl && | |
(a[e] = 0) | |
} | |
} | |
const c = ds[e]; | |
let h, | |
d; | |
if (c) return e === '$attrs' && | |
pt(i.attrs, 'get', ''), | |
c(i); | |
if ((h = l.__cssModules) && (h = h[e])) return h; | |
if (t !== ze && Re(t, e)) return a[e] = 4, | |
t[e]; | |
if (d = o.config.globalProperties, Re(d, e)) return d[e] | |
}, | |
set({ | |
_: i | |
}, e, t) { | |
const { | |
data: n, | |
setupState: s, | |
ctx: r | |
} | |
= i; | |
return Ba(s, e) ? (s[e] = t, !0) : n !== ze && | |
Re(n, e) ? (n[e] = t, !0) : Re(i.props, e) || | |
e[0] === '$' && | |
e.slice(1) in i ? !1 : (r[e] = t, !0) | |
}, | |
has({ | |
_: { | |
data: i, | |
setupState: e, | |
accessCache: t, | |
ctx: n, | |
appContext: s, | |
propsOptions: r | |
} | |
}, a) { | |
let l; | |
return !!t[a] || | |
i !== ze && | |
Re(i, a) || | |
Ba(e, a) || | |
(l = r[0]) && | |
Re(l, a) || | |
Re(n, a) || | |
Re(ds, a) || | |
Re(s.config.globalProperties, a) | |
}, | |
defineProperty(i, e, t) { | |
return t.get != null ? i._.accessCache[e] = 0 : Re(t, 'value') && | |
this.set(i, e, t.value, null), | |
Reflect.defineProperty(i, e, t) | |
} | |
}; | |
function Gu(i) { | |
return ve(i) ? i.reduce((e, t) => (e[t] = null, e), { | |
}) : i | |
} | |
let Yl = !0; | |
function n0(i) { | |
const e = ru(i), | |
t = i.proxy, | |
n = i.ctx; | |
Yl = !1, | |
e.beforeCreate && | |
Ku(e.beforeCreate, i, 'bc'); | |
const { | |
data: s, | |
computed: r, | |
methods: a, | |
watch: l, | |
provide: o, | |
inject: u, | |
created: c, | |
beforeMount: h, | |
mounted: d, | |
beforeUpdate: f, | |
updated: p, | |
activated: g, | |
deactivated: w, | |
beforeDestroy: y, | |
beforeUnmount: b, | |
destroyed: x, | |
unmounted: k, | |
render: S, | |
renderTracked: B, | |
renderTriggered: z, | |
errorCaptured: I, | |
serverPrefetch: $, | |
expose: L, | |
inheritAttrs: A, | |
components: N, | |
directives: O, | |
filters: se | |
} | |
= e; | |
if (u && s0(u, n, null), a) for (const le in a) { | |
const ae = a[le]; | |
_e(ae) && | |
(n[le] = ae.bind(t)) | |
} | |
if (s) { | |
const le = s.call(t, t); | |
De(le) && | |
(i.data = Wi(le)) | |
} | |
if (Yl = !0, r) for (const le in r) { | |
const ae = r[le], | |
$e = _e(ae) ? ae.bind(t, t) : _e(ae.get) ? ae.get.bind(t, t) : Qt, | |
Oe = !_e(ae) && | |
_e(ae.set) ? ae.set.bind(t) : Qt, | |
Ye = q({ | |
get: $e, | |
set: Oe | |
}); | |
Object.defineProperty( | |
n, | |
le, | |
{ | |
enumerable: !0, | |
configurable: !0, | |
get: () => Ye.value, | |
set: it => Ye.value = it | |
} | |
) | |
} | |
if (l) for (const le in l) uf(l[le], n, t, le); | |
if (o) { | |
const le = _e(o) ? o.call(t) : o; | |
Reflect.ownKeys(le).forEach(ae => { | |
Nn(ae, le[ae]) | |
}) | |
} | |
c && | |
Ku(c, i, 'c'); | |
function te(le, ae) { | |
ve(ae) ? ae.forEach($e => le($e.bind(t))) : ae && | |
le(ae.bind(t)) | |
} | |
if ( | |
te(Kg, h), | |
te(Te, d), | |
te(af, f), | |
te(ha, p), | |
te(Hg, g), | |
te(qg, w), | |
te(Qg, I), | |
te(Yg, B), | |
te(Jg, z), | |
te(da, b), | |
te(ct, k), | |
te(Xg, $), | |
ve(L) | |
) if (L.length) { | |
const le = i.exposed || | |
(i.exposed = {}); | |
L.forEach( | |
ae => { | |
Object.defineProperty(le, ae, { | |
get: () => t[ae], | |
set: $e => t[ae] = $e | |
}) | |
} | |
) | |
} else i.exposed || | |
(i.exposed = {}); | |
S && | |
i.render === Qt && | |
(i.render = S), | |
A != null && | |
(i.inheritAttrs = A), | |
N && | |
(i.components = N), | |
O && | |
(i.directives = O), | |
$ && | |
sf(i) | |
} | |
function s0(i, e, t = Qt) { | |
ve(i) && | |
(i = Ql(i)); | |
for (const n in i) { | |
const s = i[n]; | |
let r; | |
De(s) ? 'default' in s ? r = zt(s.from || n, s.default, !0) : r = zt(s.from || n) : r = zt(s), | |
Je(r) ? Object.defineProperty( | |
e, | |
n, | |
{ | |
enumerable: !0, | |
configurable: !0, | |
get: () => r.value, | |
set: a => r.value = a | |
} | |
) : e[n] = r | |
} | |
} | |
function Ku(i, e, t) { | |
ti(ve(i) ? i.map(n => n.bind(e.proxy)) : i.bind(e.proxy), e, t) | |
} | |
function uf(i, e, t, n) { | |
let s = n.includes('.') ? xf(t, n) : () => t[n]; | |
if (Qe(i)) { | |
const r = e[i]; | |
_e(r) && | |
Ie(s, r) | |
} else if (_e(i)) Ie(s, i.bind(t)); | |
else if (De(i)) if (ve(i)) i.forEach(r => uf(r, e, t, n)); | |
else { | |
const r = _e(i.handler) ? i.handler.bind(t) : e[i.handler]; | |
_e(r) && | |
Ie(s, r, i) | |
} | |
} | |
function ru(i) { | |
const e = i.type, | |
{ | |
mixins: t, | |
extends : n | |
} | |
= e, | |
{ | |
mixins: s, | |
optionsCache: r, | |
config: { | |
optionMergeStrategies: a | |
} | |
} | |
= i.appContext, | |
l = r.get(e); | |
let o; | |
return l ? o = l : !s.length && | |
!t && | |
!n ? o = e : (o = {}, s.length && s.forEach(u => Dr(o, u, a, !0)), Dr(o, e, a)), | |
De(e) && | |
r.set(e, o), | |
o | |
} | |
function Dr(i, e, t, n = !1) { | |
const { | |
mixins: s, | |
extends : r | |
} | |
= e; | |
r && | |
Dr(i, r, t, !0), | |
s && | |
s.forEach(a => Dr(i, a, t, !0)); | |
for (const a in e) if (!(n && a === 'expose')) { | |
const l = r0[a] || | |
t && | |
t[a]; | |
i[a] = l ? l(i[a], e[a]) : e[a] | |
} | |
return i | |
} | |
const r0 = { | |
data: Xu, | |
props: Ju, | |
emits: Ju, | |
methods: os, | |
computed: os, | |
beforeCreate: yt, | |
created: yt, | |
beforeMount: yt, | |
mounted: yt, | |
beforeUpdate: yt, | |
updated: yt, | |
beforeDestroy: yt, | |
beforeUnmount: yt, | |
destroyed: yt, | |
unmounted: yt, | |
activated: yt, | |
deactivated: yt, | |
errorCaptured: yt, | |
serverPrefetch: yt, | |
components: os, | |
directives: os, | |
watch: l0, | |
provide: Xu, | |
inject: a0 | |
}; | |
function Xu(i, e) { | |
return e ? i ? function () { | |
return et(_e(i) ? i.call(this, this) : i, _e(e) ? e.call(this, this) : e) | |
} | |
: e : i | |
} | |
function a0(i, e) { | |
return os(Ql(i), Ql(e)) | |
} | |
function Ql(i) { | |
if (ve(i)) { | |
const e = {}; | |
for (let t = 0; t < i.length; t++) e[i[t]] = i[t]; | |
return e | |
} | |
return i | |
} | |
function yt(i, e) { | |
return i ? [ | |
...new Set([].concat(i, e)) | |
] : e | |
} | |
function os(i, e) { | |
return i ? et(Object.create(null), i, e) : e | |
} | |
function Ju(i, e) { | |
return i ? ve(i) && | |
ve(e) ? [ | |
...new Set([...i, | |
...e]) | |
] : et(Object.create(null), Gu(i), Gu(e ?? { | |
})) : e | |
} | |
function l0(i, e) { | |
if (!i) return e; | |
if (!e) return i; | |
const t = et(Object.create(null), i); | |
for (const n in e) t[n] = yt(i[n], e[n]); | |
return t | |
} | |
function cf() { | |
return { | |
app: null, | |
config: { | |
isNativeTag: qm, | |
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 | |
} | |
} | |
let o0 = 0; | |
function u0(i, e) { | |
return function (n, s = null) { | |
_e(n) || | |
(n = et({ | |
}, n)), | |
s != null && | |
!De(s) && | |
(s = null); | |
const r = cf(), | |
a = new WeakSet, | |
l = []; | |
let o = !1; | |
const u = r.app = { | |
_uid: o0++, | |
_component: n, | |
_props: s, | |
_container: null, | |
_context: r, | |
_instance: null, | |
version: j0, | |
get config() { | |
return r.config | |
}, | |
set config(c) { | |
}, | |
use(c, ...h) { | |
return a.has(c) || | |
( | |
c && | |
_e(c.install) ? (a.add(c), c.install(u, ...h)) : _e(c) && | |
(a.add(c), c(u, ...h)) | |
), | |
u | |
}, | |
mixin(c) { | |
return r.mixins.includes(c) || | |
r.mixins.push(c), | |
u | |
}, | |
component(c, h) { | |
return h ? (r.components[c] = h, u) : r.components[c] | |
}, | |
directive(c, h) { | |
return h ? (r.directives[c] = h, u) : r.directives[c] | |
}, | |
mount(c, h, d) { | |
if (!o) { | |
const f = u._ceVNode || | |
V(n, s); | |
return f.appContext = r, | |
d === !0 ? d = 'svg' : d === !1 && | |
(d = void 0), | |
h && | |
e ? e(f, c) : i(f, c, d), | |
o = !0, | |
u._container = c, | |
c.__vue_app__ = u, | |
ma(f.component) | |
} | |
}, | |
onUnmount(c) { | |
l.push(c) | |
}, | |
unmount() { | |
o && | |
( | |
ti(l, u._instance, 16), | |
i(null, u._container), | |
delete u._container.__vue_app__ | |
) | |
}, | |
provide(c, h) { | |
return r.provides[c] = h, | |
u | |
}, | |
runWithContext(c) { | |
const h = rn; | |
rn = u; | |
try { | |
return c() | |
} finally { | |
rn = h | |
} | |
} | |
}; | |
return u | |
} | |
} | |
let rn = null; | |
function Nn(i, e) { | |
if (ot) { | |
let t = ot.provides; | |
const n = ot.parent && | |
ot.parent.provides; | |
n === t && | |
(t = ot.provides = Object.create(n)), | |
t[i] = e | |
} | |
} | |
function zt(i, e, t = !1) { | |
const n = ot || | |
nt; | |
if (n || rn) { | |
const s = rn ? rn._context.provides : n ? n.parent == null ? n.vnode.appContext && | |
n.vnode.appContext.provides : n.parent.provides : void 0; | |
if (s && i in s) return s[i]; | |
if (arguments.length > 1) return t && | |
_e(e) ? e.call(n && n.proxy) : e | |
} | |
} | |
function c0() { | |
return !!(ot || nt || rn) | |
} | |
const hf = {}, | |
df = () => Object.create(hf), | |
ff = i => Object.getPrototypeOf(i) === hf; | |
function h0(i, e, t, n = !1) { | |
const s = {}, | |
r = df(); | |
i.propsDefaults = Object.create(null), | |
pf(i, e, s, r); | |
for (const a in i.propsOptions[0]) a in s || | |
(s[a] = void 0); | |
t ? i.props = n ? s : Qo(s) : i.type.props ? i.props = s : i.props = r, | |
i.attrs = r | |
} | |
function d0(i, e, t, n) { | |
const { | |
props: s, | |
attrs: r, | |
vnode: { | |
patchFlag: a | |
} | |
} | |
= i, | |
l = Pe(s), | |
[ | |
o | |
] = i.propsOptions; | |
let u = !1; | |
if ((n || a > 0) && !(a & 16)) { | |
if (a & 8) { | |
const c = i.vnode.dynamicProps; | |
for (let h = 0; h < c.length; h++) { | |
let d = c[h]; | |
if (fa(i.emitsOptions, d)) continue; | |
const f = e[d]; | |
if (o) if (Re(r, d)) f !== r[d] && | |
(r[d] = f, u = !0); | |
else { | |
const p = qt(d); | |
s[p] = Zl(o, l, p, f, i, !1) | |
} else f !== r[d] && | |
(r[d] = f, u = !0) | |
} | |
} | |
} else { | |
pf(i, e, s, r) && | |
(u = !0); | |
let c; | |
for (const h in l) (!e || !Re(e, h) && ((c = mn(h)) === h || !Re(e, c))) && | |
( | |
o ? t && | |
(t[h] !== void 0 || t[c] !== void 0) && | |
(s[h] = Zl(o, l, h, void 0, i, !0)) : delete s[h] | |
); | |
if (r !== l) for (const h in r) (!e || !Re(e, h) && !0) && | |
(delete r[h], u = !0) | |
} | |
u && | |
wi(i.attrs, 'set', '') | |
} | |
function pf(i, e, t, n) { | |
const [s, | |
r] = i.propsOptions; | |
let a = !1, | |
l; | |
if (e) for (let o in e) { | |
if (us(o)) continue; | |
const u = e[o]; | |
let c; | |
s && | |
Re(s, c = qt(o)) ? !r || | |
!r.includes(c) ? t[c] = u : (l || (l = {})) [c] = u : fa(i.emitsOptions, o) || | |
(!(o in n) || u !== n[o]) && | |
(n[o] = u, a = !0) | |
} | |
if (r) { | |
const o = Pe(t), | |
u = l || | |
ze; | |
for (let c = 0; c < r.length; c++) { | |
const h = r[c]; | |
t[h] = Zl(s, o, h, u[h], i, !Re(u, h)) | |
} | |
} | |
return a | |
} | |
function Zl(i, e, t, n, s, r) { | |
const a = i[t]; | |
if (a != null) { | |
const l = Re(a, 'default'); | |
if (l && n === void 0) { | |
const o = a.default; | |
if (a.type !== Function && !a.skipFactory && _e(o)) { | |
const { | |
propsDefaults: u | |
} | |
= s; | |
if (t in u) n = u[t]; | |
else { | |
const c = Hs(s); | |
n = u[t] = o.call(null, e), | |
c() | |
} | |
} else n = o; | |
s.ce && | |
s.ce._setProp(t, n) | |
} | |
a[0] && | |
(r && !l ? n = !1 : a[1] && (n === '' || n === mn(t)) && (n = !0)) | |
} | |
return n | |
} | |
const f0 = new WeakMap; | |
function mf(i, e, t = !1) { | |
const n = t ? f0 : e.propsCache, | |
s = n.get(i); | |
if (s) return s; | |
const r = i.props, | |
a = {}, | |
l = []; | |
let o = !1; | |
if (!_e(i)) { | |
const c = h => { | |
o = !0; | |
const [d, | |
f] = mf(h, e, !0); | |
et(a, d), | |
f && | |
l.push(...f) | |
}; | |
!t && | |
e.mixins.length && | |
e.mixins.forEach(c), | |
i.extends && | |
c(i.extends), | |
i.mixins && | |
i.mixins.forEach(c) | |
} | |
if (!r && !o) return De(i) && | |
n.set(i, $n), | |
$n; | |
if (ve(r)) for (let c = 0; c < r.length; c++) { | |
const h = qt(r[c]); | |
Yu(h) && | |
(a[h] = ze) | |
} else if (r) for (const c in r) { | |
const h = qt(c); | |
if (Yu(h)) { | |
const d = r[c], | |
f = a[h] = ve(d) || | |
_e(d) ? { | |
type: d | |
} | |
: et({ | |
}, d), | |
p = f.type; | |
let g = !1, | |
w = !0; | |
if (ve(p)) for (let y = 0; y < p.length; ++y) { | |
const b = p[y], | |
x = _e(b) && | |
b.name; | |
if (x === 'Boolean') { | |
g = !0; | |
break | |
} else x === 'String' && | |
(w = !1) | |
} else g = _e(p) && | |
p.name === 'Boolean'; | |
f[0] = g, | |
f[1] = w, | |
(g || Re(f, 'default')) && | |
l.push(h) | |
} | |
} | |
const u = [ | |
a, | |
l | |
]; | |
return De(i) && | |
n.set(i, u), | |
u | |
} | |
function Yu(i) { | |
return i[0] !== '$' && | |
!us(i) | |
} | |
const gf = i => i[0] === '_' || | |
i === '$stable', | |
au = i => ve(i) ? i.map(hi) : [ | |
hi(i) | |
], | |
p0 = (i, e, t) => { | |
if (e._n) return e; | |
const n = We((...s) => au(e(...s)), t); | |
return n._c = !1, | |
n | |
}, | |
yf = (i, e, t) => { | |
const n = i._ctx; | |
for (const s in i) { | |
if (gf(s)) continue; | |
const r = i[s]; | |
if (_e(r)) e[s] = p0(s, r, n); | |
else if (r != null) { | |
const a = au(r); | |
e[s] = () => a | |
} | |
} | |
}, | |
vf = (i, e) => { | |
const t = au(e); | |
i.slots.default = () => t | |
}, | |
bf = (i, e, t) => { | |
for (const n in e) (t || n !== '_') && | |
(i[n] = e[n]) | |
}, | |
m0 = (i, e, t) => { | |
const n = i.slots = df(); | |
if (i.vnode.shapeFlag & 32) { | |
const s = e._; | |
s ? (bf(n, e, t), t && _d(n, '_', s, !0)) : yf(e, n) | |
} else e && | |
vf(i, e) | |
}, | |
g0 = (i, e, t) => { | |
const { | |
vnode: n, | |
slots: s | |
} | |
= i; | |
let r = !0, | |
a = ze; | |
if (n.shapeFlag & 32) { | |
const l = e._; | |
l ? t && | |
l === 1 ? r = !1 : bf(s, e, t) : (r = !e.$stable, yf(e, s)), | |
a = e | |
} else e && | |
(vf(i, e), a = { | |
default: | |
1 | |
}); | |
if (r) for (const l in s) !gf(l) && | |
a[l] == null && | |
delete s[l] | |
}; | |
function y0() { | |
typeof __VUE_PROD_HYDRATION_MISMATCH_DETAILS__ != 'boolean' && | |
(Us().__VUE_PROD_HYDRATION_MISMATCH_DETAILS__ = !1) | |
} | |
const Lt = I0; | |
function v0(i) { | |
return b0(i) | |
} | |
function b0(i, e) { | |
y0(); | |
const t = Us(); | |
t.__VUE__ = !0; | |
const { | |
insert: n, | |
remove: s, | |
patchProp: r, | |
createElement: a, | |
createText: l, | |
createComment: o, | |
setText: u, | |
setElementText: c, | |
parentNode: h, | |
nextSibling: d, | |
setScopeId: f = Qt, | |
insertStaticContent: p | |
} | |
= i, | |
g = ( | |
E, | |
C, | |
R, | |
K = null, | |
j = null, | |
Y = null, | |
ce = void 0, | |
re = null, | |
ne = !!C.dynamicChildren | |
) => { | |
if (E === C) return; | |
E && | |
!nn(E, C) && | |
(K = H(E), it(E, j, Y, !0), E = null), | |
C.patchFlag === - 2 && | |
(ne = !1, C.dynamicChildren = null); | |
const { | |
type: ee, | |
ref: we, | |
shapeFlag: de | |
} | |
= C; | |
switch (ee) { | |
case pa: | |
w(E, C, R, K); | |
break; | |
case _t: | |
y(E, C, R, K); | |
break; | |
case xr: | |
E == null && | |
b(C, R, K, ce); | |
break; | |
case D: | |
N(E, C, R, K, j, Y, ce, re, ne); | |
break; | |
default: | |
de & 1 ? S(E, C, R, K, j, Y, ce, re, ne) : de & 6 ? O(E, C, R, K, j, Y, ce, re, ne) : (de & 64 || de & 128) && | |
ee.process(E, C, R, K, j, Y, ce, re, ne, me) | |
} | |
we != null && | |
j && | |
Or(we, E && E.ref, Y, C || E, !C) | |
}, | |
w = (E, C, R, K) => { | |
if (E == null) n(C.el = l(C.children), R, K); | |
else { | |
const j = C.el = E.el; | |
C.children !== E.children && | |
u(j, C.children) | |
} | |
}, | |
y = (E, C, R, K) => { | |
E == null ? n(C.el = o(C.children || ''), R, K) : C.el = E.el | |
}, | |
b = (E, C, R, K) => { | |
[ | |
E.el, | |
E.anchor | |
] = p(E.children, C, R, K, E.el, E.anchor) | |
}, | |
x = ({ | |
el: E, | |
anchor: C | |
}, R, K) => { | |
let j; | |
for (; E && E !== C; ) j = d(E), | |
n(E, R, K), | |
E = j; | |
n(C, R, K) | |
}, | |
k = ({ | |
el: E, | |
anchor: C | |
}) => { | |
let R; | |
for (; E && E !== C; ) R = d(E), | |
s(E), | |
E = R; | |
s(C) | |
}, | |
S = (E, C, R, K, j, Y, ce, re, ne) => { | |
C.type === 'svg' ? ce = 'svg' : C.type === 'math' && | |
(ce = 'mathml'), | |
E == null ? B(C, R, K, j, Y, ce, re, ne) : $(E, C, j, Y, ce, re, ne) | |
}, | |
B = (E, C, R, K, j, Y, ce, re) => { | |
let ne, | |
ee; | |
const { | |
props: we, | |
shapeFlag: de, | |
transition: ge, | |
dirs: ke | |
} | |
= E; | |
if ( | |
ne = E.el = a(E.type, Y, we && we.is, we), | |
de & 8 ? c(ne, E.children) : de & 16 && | |
I(E.children, ne, null, K, j, Oa(E, Y), ce, re), | |
ke && | |
Yi(E, null, K, 'created'), | |
z(ne, E, E.scopeId, ce, K), | |
we | |
) { | |
for (const Ue in we) Ue !== 'value' && | |
!us(Ue) && | |
r(ne, Ue, null, we[Ue], Y, K); | |
'value' in we && | |
r(ne, 'value', null, we.value, Y), | |
(ee = we.onVnodeBeforeMount) && | |
li(ee, K, E) | |
} | |
ke && | |
Yi(E, null, K, 'beforeMount'); | |
const Le = w0(j, ge); | |
Le && | |
ge.beforeEnter(ne), | |
n(ne, C, R), | |
((ee = we && we.onVnodeMounted) || Le || ke) && | |
Lt( | |
() => { | |
ee && | |
li(ee, K, E), | |
Le && | |
ge.enter(ne), | |
ke && | |
Yi(E, null, K, 'mounted') | |
}, | |
j | |
) | |
}, | |
z = (E, C, R, K, j) => { | |
if (R && f(E, R), K) for (let Y = 0; Y < K.length; Y++) f(E, K[Y]); | |
if (j) { | |
let Y = j.subTree; | |
if (C === Y || Sf(Y.type) && (Y.ssContent === C || Y.ssFallback === C)) { | |
const ce = j.vnode; | |
z(E, ce, ce.scopeId, ce.slotScopeIds, j.parent) | |
} | |
} | |
}, | |
I = (E, C, R, K, j, Y, ce, re, ne = 0) => { | |
for (let ee = ne; ee < E.length; ee++) { | |
const we = E[ee] = re ? Di(E[ee]) : hi(E[ee]); | |
g(null, we, C, R, K, j, Y, ce, re) | |
} | |
}, | |
$ = (E, C, R, K, j, Y, ce) => { | |
const re = C.el = E.el; | |
let { | |
patchFlag: ne, | |
dynamicChildren: ee, | |
dirs: we | |
} | |
= C; | |
ne |= E.patchFlag & 16; | |
const de = E.props || | |
ze, | |
ge = C.props || | |
ze; | |
let ke; | |
if ( | |
R && | |
Qi(R, !1), | |
(ke = ge.onVnodeBeforeUpdate) && | |
li(ke, R, C, E), | |
we && | |
Yi(C, E, R, 'beforeUpdate'), | |
R && | |
Qi(R, !0), | |
( | |
de.innerHTML && | |
ge.innerHTML == null || | |
de.textContent && | |
ge.textContent == null | |
) && | |
c(re, ''), | |
ee ? L(E.dynamicChildren, ee, re, R, K, Oa(C, j), Y) : ce || | |
ae(E, C, re, null, R, K, Oa(C, j), Y, !1), | |
ne > 0 | |
) { | |
if (ne & 16) A(re, de, ge, R, j); | |
else if ( | |
ne & 2 && | |
de.class !== ge.class && | |
r(re, 'class', null, ge.class, j), | |
ne & 4 && | |
r(re, 'style', de.style, ge.style, j), | |
ne & 8 | |
) { | |
const Le = C.dynamicProps; | |
for (let Ue = 0; Ue < Le.length; Ue++) { | |
const Be = Le[Ue], | |
Et = de[Be], | |
ft = ge[Be]; | |
(ft !== Et || Be === 'value') && | |
r(re, Be, Et, ft, j, R) | |
} | |
} | |
ne & 1 && | |
E.children !== C.children && | |
c(re, C.children) | |
} else !ce && | |
ee == null && | |
A(re, de, ge, R, j); | |
((ke = ge.onVnodeUpdated) || we) && | |
Lt(() => { | |
ke && | |
li(ke, R, C, E), | |
we && | |
Yi(C, E, R, 'updated') | |
}, K) | |
}, | |
L = (E, C, R, K, j, Y, ce) => { | |
for (let re = 0; re < C.length; re++) { | |
const ne = E[re], | |
ee = C[re], | |
we = ne.el && | |
(ne.type === D || !nn(ne, ee) || ne.shapeFlag & 70) ? h(ne.el) : R; | |
g(ne, ee, we, null, K, j, Y, ce, !0) | |
} | |
}, | |
A = (E, C, R, K, j) => { | |
if (C !== R) { | |
if (C !== ze) for (const Y in C) !us(Y) && | |
!(Y in R) && | |
r(E, Y, C[Y], null, j, K); | |
for (const Y in R) { | |
if (us(Y)) continue; | |
const ce = R[Y], | |
re = C[Y]; | |
ce !== re && | |
Y !== 'value' && | |
r(E, Y, re, ce, j, K) | |
} | |
'value' in R && | |
r(E, 'value', C.value, R.value, j) | |
} | |
}, | |
N = (E, C, R, K, j, Y, ce, re, ne) => { | |
const ee = C.el = E ? E.el : l(''), | |
we = C.anchor = E ? E.anchor : l(''); | |
let { | |
patchFlag: de, | |
dynamicChildren: ge, | |
slotScopeIds: ke | |
} | |
= C; | |
ke && | |
(re = re ? re.concat(ke) : ke), | |
E == null ? (n(ee, R, K), n(we, R, K), I(C.children || [], R, we, j, Y, ce, re, ne)) : de > 0 && | |
de & 64 && | |
ge && | |
E.dynamicChildren ? ( | |
L(E.dynamicChildren, ge, R, j, Y, ce, re), | |
(C.key != null || j && C === j.subTree) && | |
wf(E, C, !0) | |
) : ae(E, C, R, we, j, Y, ce, re, ne) | |
}, | |
O = (E, C, R, K, j, Y, ce, re, ne) => { | |
C.slotScopeIds = re, | |
E == null ? C.shapeFlag & 512 ? j.ctx.activate(C, R, K, ce, ne) : se(C, R, K, j, Y, ce, ne) : G(E, C, ne) | |
}, | |
se = (E, C, R, K, j, Y, ce) => { | |
const re = E.component = D0(E, K, j); | |
if (ua(E) && (re.ctx.renderer = me), F0(re, !1, ce), re.asyncDep) { | |
if (j && j.registerDep(re, te, ce), !E.el) { | |
const ne = re.subTree = V(_t); | |
y(null, ne, C, R) | |
} | |
} else te(re, E, C, R, j, Y, ce) | |
}, | |
G = (E, C, R) => { | |
const K = C.component = E.component; | |
if (L0(E, C, R)) if (K.asyncDep && !K.asyncResolved) { | |
le(K, C, R); | |
return | |
} else K.next = C, | |
K.update(); | |
else C.el = E.el, | |
K.vnode = C | |
}, | |
te = (E, C, R, K, j, Y, ce) => { | |
const re = () => { | |
if (E.isMounted) { | |
let { | |
next: de, | |
bu: ge, | |
u: ke, | |
parent: Le, | |
vnode: Ue | |
} | |
= E; | |
{ | |
const Ct = kf(E); | |
if (Ct) { | |
de && | |
(de.el = Ue.el, le(E, de, ce)), | |
Ct.asyncDep.then(() => { | |
E.isUnmounted || | |
re() | |
}); | |
return | |
} | |
} | |
let Be = de, | |
Et; | |
Qi(E, !1), | |
de ? (de.el = Ue.el, le(E, de, ce)) : de = Ue, | |
ge && | |
_r(ge), | |
(Et = de.props && de.props.onVnodeBeforeUpdate) && | |
li(Et, Le, de, Ue), | |
Qi(E, !0); | |
const ft = Da(E), | |
Kt = E.subTree; | |
E.subTree = ft, | |
g(Kt, ft, h(Kt.el), H(Kt), E, j, Y), | |
de.el = ft.el, | |
Be === null && | |
P0(E, ft.el), | |
ke && | |
Lt(ke, j), | |
(Et = de.props && de.props.onVnodeUpdated) && | |
Lt(() => li(Et, Le, de, Ue), j) | |
} else { | |
let de; | |
const { | |
el: ge, | |
props: ke | |
} | |
= C, | |
{ | |
bm: Le, | |
m: Ue, | |
parent: Be, | |
root: Et, | |
type: ft | |
} | |
= E, | |
Kt = In(C); | |
if ( | |
Qi(E, !1), | |
Le && | |
_r(Le), | |
!Kt && | |
(de = ke && ke.onVnodeBeforeMount) && | |
li(de, Be, C), | |
Qi(E, !0), | |
ge && | |
Xe | |
) { | |
const Ct = () => { | |
E.subTree = Da(E), | |
Xe(ge, E.subTree, E, j, null) | |
}; | |
Kt && | |
ft.__asyncHydrate ? ft.__asyncHydrate(ge, E, Ct) : Ct() | |
} else { | |
Et.ce && | |
Et.ce._injectChildStyle(ft); | |
const Ct = E.subTree = Da(E); | |
g(null, Ct, R, K, E, j, Y), | |
C.el = Ct.el | |
} | |
if (Ue && Lt(Ue, j), !Kt && (de = ke && ke.onVnodeMounted)) { | |
const Ct = C; | |
Lt(() => li(de, Be, Ct), j) | |
}(C.shapeFlag & 256 || Be && In(Be.vnode) && Be.vnode.shapeFlag & 256) && | |
E.a && | |
Lt(E.a, j), | |
E.isMounted = !0, | |
C = R = K = null | |
} | |
}; | |
E.scope.on(); | |
const ne = E.effect = new Ld(re); | |
E.scope.off(); | |
const ee = E.update = ne.run.bind(ne), | |
we = E.job = ne.runIfDirty.bind(ne); | |
we.i = E, | |
we.id = E.uid, | |
ne.scheduler = () => tu(we), | |
Qi(E, !0), | |
ee() | |
}, | |
le = (E, C, R) => { | |
C.component = E; | |
const K = E.vnode.props; | |
E.vnode = C, | |
E.next = null, | |
d0(E, C.props, K, R), | |
g0(E, C.children, R), | |
Gi(), | |
ju(E), | |
Ki() | |
}, | |
ae = (E, C, R, K, j, Y, ce, re, ne = !1) => { | |
const ee = E && | |
E.children, | |
we = E ? E.shapeFlag : 0, | |
de = C.children, | |
{ | |
patchFlag: ge, | |
shapeFlag: ke | |
} | |
= C; | |
if (ge > 0) { | |
if (ge & 128) { | |
Oe(ee, de, R, K, j, Y, ce, re, ne); | |
return | |
} else if (ge & 256) { | |
$e(ee, de, R, K, j, Y, ce, re, ne); | |
return | |
} | |
} | |
ke & 8 ? (we & 16 && Bt(ee, j, Y), de !== ee && c(R, de)) : we & 16 ? ke & 16 ? Oe(ee, de, R, K, j, Y, ce, re, ne) : Bt(ee, j, Y, !0) : (we & 8 && c(R, ''), ke & 16 && I(de, R, K, j, Y, ce, re, ne)) | |
}, | |
$e = (E, C, R, K, j, Y, ce, re, ne) => { | |
E = E || | |
$n, | |
C = C || | |
$n; | |
const ee = E.length, | |
we = C.length, | |
de = Math.min(ee, we); | |
let ge; | |
for (ge = 0; ge < de; ge++) { | |
const ke = C[ge] = ne ? Di(C[ge]) : hi(C[ge]); | |
g(E[ge], ke, R, null, j, Y, ce, re, ne) | |
} | |
ee > we ? Bt(E, j, Y, !0, !1, de) : I(C, R, K, j, Y, ce, re, ne, de) | |
}, | |
Oe = (E, C, R, K, j, Y, ce, re, ne) => { | |
let ee = 0; | |
const we = C.length; | |
let de = E.length - 1, | |
ge = we - 1; | |
for (; ee <= de && ee <= ge; ) { | |
const ke = E[ee], | |
Le = C[ee] = ne ? Di(C[ee]) : hi(C[ee]); | |
if (nn(ke, Le)) g(ke, Le, R, null, j, Y, ce, re, ne); | |
else break; | |
ee++ | |
} | |
for (; ee <= de && ee <= ge; ) { | |
const ke = E[de], | |
Le = C[ge] = ne ? Di(C[ge]) : hi(C[ge]); | |
if (nn(ke, Le)) g(ke, Le, R, null, j, Y, ce, re, ne); | |
else break; | |
de--, | |
ge-- | |
} | |
if (ee > de) { | |
if (ee <= ge) { | |
const ke = ge + 1, | |
Le = ke < we ? C[ke].el : K; | |
for (; ee <= ge; ) g(null, C[ee] = ne ? Di(C[ee]) : hi(C[ee]), R, Le, j, Y, ce, re, ne), | |
ee++ | |
} | |
} else if (ee > ge) for (; ee <= de; ) it(E[ee], j, Y, !0), | |
ee++; | |
else { | |
const ke = ee, | |
Le = ee, | |
Ue = new Map; | |
for (ee = Le; ee <= ge; ee++) { | |
const $t = C[ee] = ne ? Di(C[ee]) : hi(C[ee]); | |
$t.key != null && | |
Ue.set($t.key, ee) | |
} | |
let Be, | |
Et = 0; | |
const ft = ge - Le + 1; | |
let Kt = !1, | |
Ct = 0; | |
const ts = new Array(ft); | |
for (ee = 0; ee < ft; ee++) ts[ee] = 0; | |
for (ee = ke; ee <= de; ee++) { | |
const $t = E[ee]; | |
if (Et >= ft) { | |
it($t, j, Y, !0); | |
continue | |
} | |
let ai; | |
if ($t.key != null) ai = Ue.get($t.key); | |
else for (Be = Le; Be <= ge; Be++) if (ts[Be - Le] === 0 && nn($t, C[Be])) { | |
ai = Be; | |
break | |
} | |
ai === void 0 ? it($t, j, Y, !0) : ( | |
ts[ai - Le] = ee + 1, | |
ai >= Ct ? Ct = ai : Kt = !0, | |
g($t, C[ai], R, null, j, Y, ce, re, ne), | |
Et++ | |
) | |
} | |
const Ou = Kt ? k0(ts) : $n; | |
for (Be = Ou.length - 1, ee = ft - 1; ee >= 0; ee--) { | |
const $t = Le + ee, | |
ai = C[$t], | |
Du = $t + 1 < we ? C[$t + 1].el : K; | |
ts[ee] === 0 ? g(null, ai, R, Du, j, Y, ce, re, ne) : Kt && | |
(Be < 0 || ee !== Ou[Be] ? Ye(ai, R, Du, 2) : Be--) | |
} | |
} | |
}, | |
Ye = (E, C, R, K, j = null) => { | |
const { | |
el: Y, | |
type: ce, | |
transition: re, | |
children: ne, | |
shapeFlag: ee | |
} | |
= E; | |
if (ee & 6) { | |
Ye(E.component.subTree, C, R, K); | |
return | |
} | |
if (ee & 128) { | |
E.suspense.move(C, R, K); | |
return | |
} | |
if (ee & 64) { | |
ce.move(E, C, R, me); | |
return | |
} | |
if (ce === D) { | |
n(Y, C, R); | |
for (let de = 0; de < ne.length; de++) Ye(ne[de], C, R, K); | |
n(E.anchor, C, R); | |
return | |
} | |
if (ce === xr) { | |
x(E, C, R); | |
return | |
} | |
if (K !== 2 && ee & 1 && re) if (K === 0) re.beforeEnter(Y), | |
n(Y, C, R), | |
Lt(() => re.enter(Y), j); | |
else { | |
const { | |
leave: de, | |
delayLeave: ge, | |
afterLeave: ke | |
} | |
= re, | |
Le = () => n(Y, C, R), | |
Ue = () => { | |
de(Y, () => { | |
Le(), | |
ke && | |
ke() | |
}) | |
}; | |
ge ? ge(Y, Le, Ue) : Ue() | |
} else n(Y, C, R) | |
}, | |
it = (E, C, R, K = !1, j = !1) => { | |
const { | |
type: Y, | |
props: ce, | |
ref: re, | |
children: ne, | |
dynamicChildren: ee, | |
shapeFlag: we, | |
patchFlag: de, | |
dirs: ge, | |
cacheIndex: ke | |
} | |
= E; | |
if ( | |
de === - 2 && | |
(j = !1), | |
re != null && | |
Or(re, null, R, E, !0), | |
ke != null && | |
(C.renderCache[ke] = void 0), | |
we & 256 | |
) { | |
C.ctx.deactivate(E); | |
return | |
} | |
const Le = we & 1 && | |
ge, | |
Ue = !In(E); | |
let Be; | |
if (Ue && (Be = ce && ce.onVnodeBeforeUnmount) && li(Be, C, E), we & 6) Qs(E.component, R, K); | |
else { | |
if (we & 128) { | |
E.suspense.unmount(R, K); | |
return | |
} | |
Le && | |
Yi(E, null, C, 'beforeUnmount'), | |
we & 64 ? E.type.remove(E, C, R, me, K) : ee && | |
!ee.hasOnce && | |
(Y !== D || de > 0 && de & 64) ? Bt(ee, C, R, !1, !0) : (Y === D && de & 384 || !j && we & 16) && | |
Bt(ne, C, R), | |
K && | |
gn(E) | |
}(Ue && (Be = ce && ce.onVnodeUnmounted) || Le) && | |
Lt(() => { | |
Be && | |
li(Be, C, E), | |
Le && | |
Yi(E, null, C, 'unmounted') | |
}, R) | |
}, | |
gn = E => { | |
const { | |
type: C, | |
el: R, | |
anchor: K, | |
transition: j | |
} | |
= E; | |
if (C === D) { | |
yn(R, K); | |
return | |
} | |
if (C === xr) { | |
k(E); | |
return | |
} | |
const Y = () => { | |
s(R), | |
j && | |
!j.persisted && | |
j.afterLeave && | |
j.afterLeave() | |
}; | |
if (E.shapeFlag & 1 && j && !j.persisted) { | |
const { | |
leave: ce, | |
delayLeave: re | |
} | |
= j, | |
ne = () => ce(R, Y); | |
re ? re(E.el, Y, ne) : ne() | |
} else Y() | |
}, | |
yn = (E, C) => { | |
let R; | |
for (; E !== C; ) R = d(E), | |
s(E), | |
E = R; | |
s(C) | |
}, | |
Qs = (E, C, R) => { | |
const { | |
bum: K, | |
scope: j, | |
job: Y, | |
subTree: ce, | |
um: re, | |
m: ne, | |
a: ee | |
} | |
= E; | |
Qu(ne), | |
Qu(ee), | |
K && | |
_r(K), | |
j.stop(), | |
Y && | |
(Y.flags |= 8, it(ce, E, C, R)), | |
re && | |
Lt(re, C), | |
Lt(() => { | |
E.isUnmounted = !0 | |
}, C), | |
C && | |
C.pendingBranch && | |
!C.isUnmounted && | |
E.asyncDep && | |
!E.asyncResolved && | |
E.suspenseId === C.pendingId && | |
(C.deps--, C.deps === 0 && C.resolve()) | |
}, | |
Bt = (E, C, R, K = !1, j = !1, Y = 0) => { | |
for (let ce = Y; ce < E.length; ce++) it(E[ce], C, R, K, j) | |
}, | |
H = E => { | |
if (E.shapeFlag & 6) return H(E.component.subTree); | |
if (E.shapeFlag & 128) return E.suspense.next(); | |
const C = d(E.anchor || E.el), | |
R = C && | |
C[Wg]; | |
return R ? d(R) : C | |
}; | |
let fe = !1; | |
const he = (E, C, R) => { | |
E == null ? C._vnode && | |
it(C._vnode, null, null, !0) : g(C._vnode || null, E, C, null, null, null, R), | |
C._vnode = E, | |
fe || | |
(fe = !0, ju(), Xd(), fe = !1) | |
}, | |
me = { | |
p: g, | |
um: it, | |
m: Ye, | |
r: gn, | |
mt: se, | |
mc: I, | |
pc: ae, | |
pbc: L, | |
n: H, | |
o: i | |
}; | |
let Ne, | |
Xe; | |
return e && | |
([Ne, | |
Xe] = e(me)), | |
{ | |
render: he, | |
hydrate: Ne, | |
createApp: u0(he, Ne) | |
} | |
} | |
function Oa({ | |
type: i, | |
props: e | |
}, t) { | |
return t === 'svg' && | |
i === 'foreignObject' || | |
t === 'mathml' && | |
i === 'annotation-xml' && | |
e && | |
e.encoding && | |
e.encoding.includes('html') ? void 0 : t | |
} | |
function Qi({ | |
effect: i, | |
job: e | |
}, t) { | |
t ? (i.flags |= 32, e.flags |= 4) : (i.flags &= - 33, e.flags &= - 5) | |
} | |
function w0(i, e) { | |
return (!i || i && !i.pendingBranch) && | |
e && | |
!e.persisted | |
} | |
function wf(i, e, t = !1) { | |
const n = i.children, | |
s = e.children; | |
if (ve(n) && ve(s)) for (let r = 0; r < n.length; r++) { | |
const a = n[r]; | |
let l = s[r]; | |
l.shapeFlag & 1 && | |
!l.dynamicChildren && | |
( | |
(l.patchFlag <= 0 || l.patchFlag === 32) && | |
(l = s[r] = Di(s[r]), l.el = a.el), | |
!t && | |
l.patchFlag !== - 2 && | |
wf(a, l) | |
), | |
l.type === pa && | |
(l.el = a.el) | |
} | |
} | |
function k0(i) { | |
const e = i.slice(), | |
t = [ | |
0 | |
]; | |
let n, | |
s, | |
r, | |
a, | |
l; | |
const o = i.length; | |
for (n = 0; n < o; n++) { | |
const u = i[n]; | |
if (u !== 0) { | |
if (s = t[t.length - 1], i[s] < u) { | |
e[n] = s, | |
t.push(n); | |
continue | |
} | |
for (r = 0, a = t.length - 1; r < a; ) l = r + a >> 1, | |
i[t[l]] < u ? r = l + 1 : a = l; | |
u < i[t[r]] && | |
(r > 0 && (e[n] = t[r - 1]), t[r] = n) | |
} | |
} | |
for (r = t.length, a = t[r - 1]; r-- > 0; ) t[r] = a, | |
a = e[a]; | |
return t | |
} | |
function kf(i) { | |
const e = i.subTree.component; | |
if (e) return e.asyncDep && | |
!e.asyncResolved ? e : kf(e) | |
} | |
function Qu(i) { | |
if (i) for (let e = 0; e < i.length; e++) i[e].flags |= 8 | |
} | |
const _0 = Symbol.for('v-scx'), | |
x0 = () => zt(_0); | |
function Ie(i, e, t) { | |
return _f(i, e, t) | |
} | |
function _f(i, e, t = ze) { | |
const { | |
immediate: n, | |
deep: s, | |
flush: r, | |
once: a | |
} | |
= t, | |
l = et({ | |
}, t), | |
o = e && | |
n || | |
!e && | |
r !== 'post'; | |
let u; | |
if ($s) { | |
if (r === 'sync') { | |
const f = x0(); | |
u = f.__watcherHandles || | |
(f.__watcherHandles = []) | |
} else if (!o) { | |
const f = () => { | |
}; | |
return f.stop = Qt, | |
f.resume = Qt, | |
f.pause = Qt, | |
f | |
} | |
} | |
const c = ot; | |
l.call = (f, p, g) => ti(f, c, p, g); | |
let h = !1; | |
r === 'post' ? l.scheduler = f => { | |
Lt(f, c && c.suspense) | |
} | |
: r !== 'sync' && | |
(h = !0, l.scheduler = (f, p) => { | |
p ? f() : tu(f) | |
}), | |
l.augmentJob = f => { | |
e && | |
(f.flags |= 4), | |
h && | |
(f.flags |= 2, c && (f.id = c.uid, f.i = c)) | |
}; | |
const d = Bg(i, e, l); | |
return $s && | |
(u ? u.push(d) : o && d()), | |
d | |
} | |
function T0(i, e, t) { | |
const n = this.proxy, | |
s = Qe(i) ? i.includes('.') ? xf(n, i) : () => n[i] : i.bind(n, n); | |
let r; | |
_e(e) ? r = e : (r = e.handler, t = e); | |
const a = Hs(this), | |
l = _f(s, r.bind(n), t); | |
return a(), | |
l | |
} | |
function xf(i, e) { | |
const t = e.split('.'); | |
return () => { | |
let n = i; | |
for (let s = 0; s < t.length && n; s++) n = n[t[s]]; | |
return n | |
} | |
} | |
const S0 = (i, e) => e === 'modelValue' || | |
e === 'model-value' ? i.modelModifiers : i[`${ e }Modifiers`] || | |
i[`${ qt(e) }Modifiers`] || | |
i[`${ mn(e) }Modifiers`]; | |
function E0(i, e, ...t) { | |
if (i.isUnmounted) return; | |
const n = i.vnode.props || | |
ze; | |
let s = t; | |
const r = e.startsWith('update:'), | |
a = r && | |
S0(n, e.slice(7)); | |
a && | |
( | |
a.trim && | |
(s = t.map(c => Qe(c) ? c.trim() : c)), | |
a.number && | |
(s = t.map(Ir)) | |
); | |
let l, | |
o = n[l = kr(e)] || | |
n[l = kr(qt(e))]; | |
!o && | |
r && | |
(o = n[l = kr(mn(e))]), | |
o && | |
ti(o, i, 6, s); | |
const u = n[l + 'Once']; | |
if (u) { | |
if (!i.emitted) i.emitted = {}; | |
else if (i.emitted[l]) return; | |
i.emitted[l] = !0, | |
ti(u, i, 6, s) | |
} | |
} | |
function Tf(i, e, t = !1) { | |
const n = e.emitsCache, | |
s = n.get(i); | |
if (s !== void 0) return s; | |
const r = i.emits; | |
let a = {}, | |
l = !1; | |
if (!_e(i)) { | |
const o = u => { | |
const c = Tf(u, e, !0); | |
c && | |
(l = !0, et(a, c)) | |
}; | |
!t && | |
e.mixins.length && | |
e.mixins.forEach(o), | |
i.extends && | |
o(i.extends), | |
i.mixins && | |
i.mixins.forEach(o) | |
} | |
return !r && | |
!l ? (De(i) && n.set(i, null), null) : (ve(r) ? r.forEach(o => a[o] = null) : et(a, r), De(i) && n.set(i, a), a) | |
} | |
function fa(i, e) { | |
return !i || | |
!ta(e) ? !1 : ( | |
e = e.slice(2).replace(/Once$/, ''), | |
Re(i, e[0].toLowerCase() + e.slice(1)) || | |
Re(i, mn(e)) || | |
Re(i, e) | |
) | |
} | |
function Da(i) { | |
const { | |
type: e, | |
vnode: t, | |
proxy: n, | |
withProxy: s, | |
propsOptions: [ | |
r | |
], | |
slots: a, | |
attrs: l, | |
emit: o, | |
render: u, | |
renderCache: c, | |
props: h, | |
data: d, | |
setupState: f, | |
ctx: p, | |
inheritAttrs: g | |
} | |
= i, | |
w = Br(i); | |
let y, | |
b; | |
try { | |
if (t.shapeFlag & 4) { | |
const k = s || | |
n, | |
S = k; | |
y = hi(u.call(S, k, c, h, f, d, p)), | |
b = l | |
} else { | |
const k = e; | |
y = hi(k.length > 1 ? k(h, { | |
attrs: l, | |
slots: a, | |
emit: o | |
}) : k(h, null)), | |
b = e.props ? l : C0(l) | |
} | |
} catch (k) { | |
fs.length = 0, | |
la(k, i, 1), | |
y = V(_t) | |
} | |
let x = y; | |
if (b && g !== !1) { | |
const k = Object.keys(b), | |
{ | |
shapeFlag: S | |
} | |
= x; | |
k.length && | |
S & 7 && | |
(r && k.some(jo) && (b = $0(b, r)), x = ji(x, b, !1, !0)) | |
} | |
return t.dirs && | |
( | |
x = ji(x, null, !1, !0), | |
x.dirs = x.dirs ? x.dirs.concat(t.dirs) : t.dirs | |
), | |
t.transition && | |
on(x, t.transition), | |
y = x, | |
Br(w), | |
y | |
} | |
const C0 = i => { | |
let e; | |
for (const t in i) (t === 'class' || t === 'style' || ta(t)) && | |
((e || (e = {})) [t] = i[t]); | |
return e | |
}, | |
$0 = (i, e) => { | |
const t = {}; | |
for (const n in i) (!jo(n) || !(n.slice(9) in e)) && | |
(t[n] = i[n]); | |
return t | |
}; | |
function L0(i, e, t) { | |
const { | |
props: n, | |
children: s, | |
component: r | |
} | |
= i, | |
{ | |
props: a, | |
children: l, | |
patchFlag: o | |
} | |
= e, | |
u = r.emitsOptions; | |
if (e.dirs || e.transition) return !0; | |
if (t && o >= 0) { | |
if (o & 1024) return !0; | |
if (o & 16) return n ? Zu(n, a, u) : !!a; | |
if (o & 8) { | |
const c = e.dynamicProps; | |
for (let h = 0; h < c.length; h++) { | |
const d = c[h]; | |
if (a[d] !== n[d] && !fa(u, d)) return !0 | |
} | |
} | |
} else return (s || l) && | |
(!l || !l.$stable) ? !0 : n === a ? !1 : n ? a ? Zu(n, a, u) : !0 : !!a; | |
return !1 | |
} | |
function Zu(i, e, t) { | |
const n = Object.keys(e); | |
if (n.length !== Object.keys(i).length) return !0; | |
for (let s = 0; s < n.length; s++) { | |
const r = n[s]; | |
if (e[r] !== i[r] && !fa(t, r)) return !0 | |
} | |
return !1 | |
} | |
function P0({ | |
vnode: i, | |
parent: e | |
}, t) { | |
for (; e; ) { | |
const n = e.subTree; | |
if (n.suspense && n.suspense.activeBranch === i && (n.el = i.el), n === i) (i = e.vnode).el = t, | |
e = e.parent; | |
else break | |
} | |
} | |
const Sf = i => i.__isSuspense; | |
function I0(i, e) { | |
e && | |
e.pendingBranch ? ve(i) ? e.effects.push(...i) : e.effects.push(i) : Fg(i) | |
} | |
const D = Symbol.for('v-fgt'), | |
pa = Symbol.for('v-txt'), | |
_t = Symbol.for('v-cmt'), | |
xr = Symbol.for('v-stc'), | |
fs = []; | |
let It = null; | |
function _(i = !1) { | |
fs.push(It = i ? null : []) | |
} | |
function N0() { | |
fs.pop(), | |
It = fs[fs.length - 1] || | |
null | |
} | |
let Es = 1; | |
function ec(i, e = !1) { | |
Es += i, | |
i < 0 && | |
It && | |
e && | |
(It.hasOnce = !0) | |
} | |
function Ef(i) { | |
return i.dynamicChildren = Es > 0 ? It || | |
$n : null, | |
N0(), | |
Es > 0 && | |
It && | |
It.push(i), | |
i | |
} | |
function T(i, e, t, n, s, r) { | |
return Ef(m(i, e, t, n, s, r, !0)) | |
} | |
function xe(i, e, t, n, s) { | |
return Ef(V(i, e, t, n, s, !0)) | |
} | |
function Cs(i) { | |
return i ? i.__v_isVNode === !0 : !1 | |
} | |
function nn(i, e) { | |
return i.type === e.type && | |
i.key === e.key | |
} | |
const Cf = ({ | |
key: i | |
}) => i ?? null, | |
Tr = ({ | |
ref: i, | |
ref_key: e, | |
ref_for: t | |
}) => ( | |
typeof i == 'number' && | |
(i = '' + i), | |
i != null ? Qe(i) || | |
Je(i) || | |
_e(i) ? { | |
i: nt, | |
r: i, | |
k: e, | |
f: !!t | |
} | |
: i : null | |
); | |
function m(i, e = null, t = null, n = 0, s = null, r = i === D ? 0 : 1, a = !1, l = !1) { | |
const o = { | |
__v_isVNode: !0, | |
__v_skip: !0, | |
type: i, | |
props: e, | |
key: e && | |
Cf(e), | |
ref: e && | |
Tr(e), | |
scopeId: oa, | |
slotScopeIds: null, | |
children: t, | |
component: null, | |
suspense: null, | |
ssContent: null, | |
ssFallback: null, | |
dirs: null, | |
transition: null, | |
el: null, | |
anchor: null, | |
target: null, | |
targetStart: null, | |
targetAnchor: null, | |
staticCount: 0, | |
shapeFlag: r, | |
patchFlag: n, | |
dynamicProps: s, | |
dynamicChildren: null, | |
appContext: null, | |
ctx: nt | |
}; | |
return l ? (lu(o, t), r & 128 && i.normalize(o)) : t && | |
(o.shapeFlag |= Qe(t) ? 8 : 16), | |
Es > 0 && | |
!a && | |
It && | |
(o.patchFlag > 0 || r & 6) && | |
o.patchFlag !== 32 && | |
It.push(o), | |
o | |
} | |
const V = M0; | |
function M0(i, e = null, t = null, n = 0, s = null, r = !1) { | |
if ((!i || i === lf) && (i = _t), Cs(i)) { | |
const l = ji(i, e, !0); | |
return t && | |
lu(l, t), | |
Es > 0 && | |
!r && | |
It && | |
(l.shapeFlag & 6 ? It[It.indexOf(i)] = l : It.push(l)), | |
l.patchFlag = - 2, | |
l | |
} | |
if (U0(i) && (i = i.__vccOpts), e) { | |
e = R0(e); | |
let { | |
class : l, | |
style: o | |
} | |
= e; | |
l && | |
!Qe(l) && | |
(e.class = ie(l)), | |
De(o) && | |
(eu(o) && !ve(o) && (o = et({ | |
}, o)), e.style = tt(o)) | |
} | |
const a = Qe(i) ? 1 : Sf(i) ? 128 : Yd(i) ? 64 : De(i) ? 4 : _e(i) ? 2 : 0; | |
return m(i, e, t, n, s, a, r, !0) | |
} | |
function R0(i) { | |
return i ? eu(i) || | |
ff(i) ? et({ | |
}, i) : i : null | |
} | |
function ji(i, e, t = !1, n = !1) { | |
const { | |
props: s, | |
ref: r, | |
patchFlag: a, | |
children: l, | |
transition: o | |
} | |
= i, | |
u = e ? $f(s || { | |
}, e) : s, | |
c = { | |
__v_isVNode: !0, | |
__v_skip: !0, | |
type: i.type, | |
props: u, | |
key: u && | |
Cf(u), | |
ref: e && | |
e.ref ? t && | |
r ? ve(r) ? r.concat(Tr(e)) : [ | |
r, | |
Tr(e) | |
] : Tr(e) : r, | |
scopeId: i.scopeId, | |
slotScopeIds: i.slotScopeIds, | |
children: l, | |
target: i.target, | |
targetStart: i.targetStart, | |
targetAnchor: i.targetAnchor, | |
staticCount: i.staticCount, | |
shapeFlag: i.shapeFlag, | |
patchFlag: e && | |
i.type !== D ? a === - 1 ? 16 : a | 16 : a, | |
dynamicProps: i.dynamicProps, | |
dynamicChildren: i.dynamicChildren, | |
appContext: i.appContext, | |
dirs: i.dirs, | |
transition: o, | |
component: i.component, | |
suspense: i.suspense, | |
ssContent: i.ssContent && | |
ji(i.ssContent), | |
ssFallback: i.ssFallback && | |
ji(i.ssFallback), | |
el: i.el, | |
anchor: i.anchor, | |
ctx: i.ctx, | |
ce: i.ce | |
}; | |
return o && | |
n && | |
on(c, o.clone(c)), | |
c | |
} | |
function He(i = ' ', e = 0) { | |
return V(pa, null, i, e) | |
} | |
function un(i, e) { | |
const t = V(xr, null, i); | |
return t.staticCount = e, | |
t | |
} | |
function ye(i = '', e = !1) { | |
return e ? (_(), xe(_t, null, i)) : V(_t, null, i) | |
} | |
function hi(i) { | |
return i == null || | |
typeof i == 'boolean' ? V(_t) : ve(i) ? V(D, null, i.slice()) : Cs(i) ? Di(i) : V(pa, null, String(i)) | |
} | |
function Di(i) { | |
return i.el === null && | |
i.patchFlag !== - 1 || | |
i.memo ? i : ji(i) | |
} | |
function lu(i, e) { | |
let t = 0; | |
const { | |
shapeFlag: n | |
} | |
= i; | |
if (e == null) e = null; | |
else if (ve(e)) t = 16; | |
else if (typeof e == 'object') if (n & 65) { | |
const s = e.default; | |
s && | |
(s._c && (s._d = !1), lu(i, s()), s._c && (s._d = !0)); | |
return | |
} else { | |
t = 32; | |
const s = e._; | |
!s && | |
!ff(e) ? e._ctx = nt : s === 3 && | |
nt && | |
(nt.slots._ === 1 ? e._ = 1 : (e._ = 2, i.patchFlag |= 1024)) | |
} else _e(e) ? (e = { | |
default: | |
e, | |
_ctx: nt | |
}, t = 32) : (e = String(e), n & 64 ? (t = 16, e = [ | |
He(e) | |
]) : t = 8); | |
i.children = e, | |
i.shapeFlag |= t | |
} | |
function $f(...i) { | |
const e = {}; | |
for (let t = 0; t < i.length; t++) { | |
const n = i[t]; | |
for (const s in n) if (s === 'class') e.class !== n.class && | |
(e.class = ie([e.class, | |
n.class])); | |
else if (s === 'style') e.style = tt([e.style, | |
n.style]); | |
else if (ta(s)) { | |
const r = e[s], | |
a = n[s]; | |
a && | |
r !== a && | |
!(ve(r) && r.includes(a)) && | |
(e[s] = r ? [].concat(r, a) : a) | |
} else s !== '' && | |
(e[s] = n[s]) | |
} | |
return e | |
} | |
function li(i, e, t, n = null) { | |
ti(i, e, 7, [ | |
t, | |
n | |
]) | |
} | |
const B0 = cf(); | |
let O0 = 0; | |
function D0(i, e, t) { | |
const n = i.type, | |
s = (e ? e.appContext : i.appContext) || | |
B0, | |
r = { | |
uid: O0++, | |
vnode: i, | |
type: n, | |
parent: e, | |
appContext: s, | |
root: null, | |
next: null, | |
subTree: null, | |
effect: null, | |
update: null, | |
job: null, | |
scope: new Ed(!0), | |
render: null, | |
proxy: null, | |
exposed: null, | |
exposeProxy: null, | |
withProxy: null, | |
provides: e ? e.provides : Object.create(s.provides), | |
ids: e ? e.ids : [ | |
'', | |
0, | |
0 | |
], | |
accessCache: null, | |
renderCache: [], | |
components: null, | |
directives: null, | |
propsOptions: mf(n, s), | |
emitsOptions: Tf(n, s), | |
emit: null, | |
emitted: null, | |
propsDefaults: ze, | |
inheritAttrs: n.inheritAttrs, | |
ctx: ze, | |
data: ze, | |
props: ze, | |
attrs: ze, | |
slots: ze, | |
refs: ze, | |
setupState: ze, | |
setupContext: null, | |
suspense: t, | |
suspenseId: t ? t.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 r.ctx = { | |
_: r | |
}, | |
r.root = e ? e.root : r, | |
r.emit = E0.bind(null, r), | |
i.ce && | |
i.ce(r), | |
r | |
} | |
let ot = null; | |
const Lf = () => ot || | |
nt; | |
let Fr, | |
eo; | |
{ | |
const i = Us(), | |
e = (t, n) => { | |
let s; | |
return (s = i[t]) || | |
(s = i[t] = []), | |
s.push(n), | |
r => { | |
s.length > 1 ? s.forEach(a => a(r)) : s[0](r) | |
} | |
}; | |
Fr = e('__VUE_INSTANCE_SETTERS__', t => ot = t), | |
eo = e('__VUE_SSR_SETTERS__', t => $s = t) | |
} | |
const Hs = i => { | |
const e = ot; | |
return Fr(i), | |
i.scope.on(), | |
() => { | |
i.scope.off(), | |
Fr(e) | |
} | |
}, | |
tc = () => { | |
ot && | |
ot.scope.off(), | |
Fr(null) | |
}; | |
function Pf(i) { | |
return i.vnode.shapeFlag & 4 | |
} | |
let $s = !1; | |
function F0(i, e = !1, t = !1) { | |
e && | |
eo(e); | |
const { | |
props: n, | |
children: s | |
} | |
= i.vnode, | |
r = Pf(i); | |
h0(i, n, r, e), | |
m0(i, s, t); | |
const a = r ? A0(i, e) : void 0; | |
return e && | |
eo(!1), | |
a | |
} | |
function A0(i, e) { | |
const t = i.type; | |
i.accessCache = Object.create(null), | |
i.proxy = new Proxy(i.ctx, i0); | |
const { | |
setup: n | |
} | |
= t; | |
if (n) { | |
Gi(); | |
const s = i.setupContext = n.length > 1 ? z0(i) : null, | |
r = Hs(i), | |
a = js(n, i, 0, [ | |
i.props, | |
s | |
]), | |
l = bd(a); | |
if (Ki(), r(), (l || i.sp) && !In(i) && sf(i), l) { | |
if (a.then(tc, tc), e) return a.then(o => { | |
ic(i, o, e) | |
}).catch(o => { | |
la(o, i, 0) | |
}); | |
i.asyncDep = a | |
} else ic(i, a, e) | |
} else If(i, e) | |
} | |
function ic(i, e, t) { | |
_e(e) ? i.type.__ssrInlineRender ? i.ssrRender = e : i.render = e : De(e) && | |
(i.setupState = Hd(e)), | |
If(i, t) | |
} | |
let nc; | |
function If(i, e, t) { | |
const n = i.type; | |
if (!i.render) { | |
if (!e && nc && !n.render) { | |
const s = n.template || | |
ru(i).template; | |
if (s) { | |
const { | |
isCustomElement: r, | |
compilerOptions: a | |
} | |
= i.appContext.config, | |
{ | |
delimiters: l, | |
compilerOptions: o | |
} | |
= n, | |
u = et(et({ | |
isCustomElement: r, | |
delimiters: l | |
}, a), o); | |
n.render = nc(s, u) | |
} | |
} | |
i.render = n.render || | |
Qt | |
} | |
{ | |
const s = Hs(i); | |
Gi(); | |
try { | |
n0(i) | |
} finally { | |
Ki(), | |
s() | |
} | |
} | |
} | |
const V0 = { | |
get(i, e) { | |
return pt(i, 'get', ''), | |
i[e] | |
} | |
}; | |
function z0(i) { | |
const e = t => { | |
i.exposed = t || | |
{ | |
} | |
}; | |
return { | |
attrs: new Proxy(i.attrs, V0), | |
slots: i.slots, | |
emit: i.emit, | |
expose: e | |
} | |
} | |
function ma(i) { | |
return i.exposed ? i.exposeProxy || | |
( | |
i.exposeProxy = new Proxy( | |
Hd(aa(i.exposed)), | |
{ | |
get(e, t) { | |
if (t in e) return e[t]; | |
if (t in ds) return ds[t](i) | |
}, | |
has(e, t) { | |
return t in e || | |
t in ds | |
} | |
} | |
) | |
) : i.proxy | |
} | |
function W0(i, e = !0) { | |
return _e(i) ? i.displayName || | |
i.name : i.name || | |
e && | |
i.__name | |
} | |
function U0(i) { | |
return _e(i) && | |
'__vccOpts' in i | |
} | |
const q = (i, e) => Mg(i, e, $s); | |
function wt(i, e, t) { | |
const n = arguments.length; | |
return n === 2 ? De(e) && | |
!ve(e) ? Cs(e) ? V(i, null, [ | |
e | |
]) : V(i, e) : V(i, null, e) : ( | |
n > 3 ? t = Array.prototype.slice.call(arguments, 2) : n === 3 && | |
Cs(t) && | |
(t = [ | |
t | |
]), | |
V(i, e, t) | |
) | |
} | |
const j0 = '3.5.13'; /** | |
* @vue/runtime-dom v3.5.13 | |
* (c) 2018-present Yuxi (Evan) You and Vue contributors | |
* @license MIT | |
**/ | |
let to; | |
const sc = typeof window < 'u' && | |
window.trustedTypes; | |
if (sc) try { | |
to = sc.createPolicy('vue', { | |
createHTML: i => i | |
}) | |
} catch { | |
} | |
const Nf = to ? i => to.createHTML(i) : i => i, | |
H0 = 'http://www.w3.org/2000/svg', | |
q0 = 'http://www.w3.org/1998/Math/MathML', | |
vi = typeof document < 'u' ? document : null, | |
rc = vi && | |
vi.createElement('template'), | |
G0 = { | |
insert: (i, e, t) => { | |
e.insertBefore(i, t || null) | |
}, | |
remove: i => { | |
const e = i.parentNode; | |
e && | |
e.removeChild(i) | |
}, | |
createElement: (i, e, t, n) => { | |
const s = e === 'svg' ? vi.createElementNS(H0, i) : e === 'mathml' ? vi.createElementNS(q0, i) : t ? vi.createElement(i, { | |
is: t | |
}) : vi.createElement(i); | |
return i === 'select' && | |
n && | |
n.multiple != null && | |
s.setAttribute('multiple', n.multiple), | |
s | |
}, | |
createText: i => vi.createTextNode(i), | |
createComment: i => vi.createComment(i), | |
setText: (i, e) => { | |
i.nodeValue = e | |
}, | |
setElementText: (i, e) => { | |
i.textContent = e | |
}, | |
parentNode: i => i.parentNode, | |
nextSibling: i => i.nextSibling, | |
querySelector: i => vi.querySelector(i), | |
setScopeId(i, e) { | |
i.setAttribute(e, '') | |
}, | |
insertStaticContent(i, e, t, n, s, r) { | |
const a = t ? t.previousSibling : e.lastChild; | |
if (s && (s === r || s.nextSibling)) for ( | |
; | |
e.insertBefore(s.cloneNode(!0), t), | |
!(s === r || !(s = s.nextSibling)); | |
); | |
else { | |
rc.innerHTML = Nf( | |
n === 'svg' ? `<svg>${ i }</svg>` : n === 'mathml' ? `<math>${ i }</math>` : i | |
); | |
const l = rc.content; | |
if (n === 'svg' || n === 'mathml') { | |
const o = l.firstChild; | |
for (; o.firstChild; ) l.appendChild(o.firstChild); | |
l.removeChild(o) | |
} | |
e.insertBefore(l, t) | |
} | |
return [a ? a.nextSibling : e.firstChild, | |
t ? t.previousSibling : e.lastChild] | |
} | |
}, | |
Li = 'transition', | |
ns = 'animation', | |
zn = Symbol('_vtc'), | |
Mf = { | |
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 | |
}, | |
Rf = et({ | |
}, Zd, Mf), | |
K0 = i => (i.displayName = 'Transition', i.props = Rf, i), | |
ga = K0((i, { | |
slots: e | |
}) => wt(jg, Bf(i), e)), | |
Zi = (i, e = []) => { | |
ve(i) ? i.forEach(t => t(...e)) : i && | |
i(...e) | |
}, | |
ac = i => i ? ve(i) ? i.some(e => e.length > 1) : i.length > 1 : !1; | |
function Bf(i) { | |
const e = {}; | |
for (const N in i) N in Mf || | |
(e[N] = i[N]); | |
if (i.css === !1) return e; | |
const { | |
name: t = 'v', | |
type: n, | |
duration: s, | |
enterFromClass: r = `${ t }-enter-from`, | |
enterActiveClass: a = `${ t }-enter-active`, | |
enterToClass: l = `${ t }-enter-to`, | |
appearFromClass: o = r, | |
appearActiveClass: u = a, | |
appearToClass: c = l, | |
leaveFromClass: h = `${ t }-leave-from`, | |
leaveActiveClass: d = `${ t }-leave-active`, | |
leaveToClass: f = `${ t }-leave-to` | |
} | |
= i, | |
p = X0(s), | |
g = p && | |
p[0], | |
w = p && | |
p[1], | |
{ | |
onBeforeEnter: y, | |
onEnter: b, | |
onEnterCancelled: x, | |
onLeave: k, | |
onLeaveCancelled: S, | |
onBeforeAppear: B = y, | |
onAppear: z = b, | |
onAppearCancelled: I = x | |
} | |
= e, | |
$ = (N, O, se, G) => { | |
N._enterCancelled = G, | |
Ni(N, O ? c : l), | |
Ni(N, O ? u : a), | |
se && | |
se() | |
}, | |
L = (N, O) => { | |
N._isLeaving = !1, | |
Ni(N, h), | |
Ni(N, f), | |
Ni(N, d), | |
O && | |
O() | |
}, | |
A = N => (O, se) => { | |
const G = N ? z : b, | |
te = () => $(O, N, se); | |
Zi(G, [ | |
O, | |
te | |
]), | |
lc(() => { | |
Ni(O, N ? o : r), | |
ui(O, N ? c : l), | |
ac(G) || | |
oc(O, n, g, te) | |
}) | |
}; | |
return et( | |
e, | |
{ | |
onBeforeEnter(N) { | |
Zi(y, [ | |
N | |
]), | |
ui(N, r), | |
ui(N, a) | |
}, | |
onBeforeAppear(N) { | |
Zi(B, [ | |
N | |
]), | |
ui(N, o), | |
ui(N, u) | |
}, | |
onEnter: A(!1), | |
onAppear: A(!0), | |
onLeave(N, O) { | |
N._isLeaving = !0; | |
const se = () => L(N, O); | |
ui(N, h), | |
N._enterCancelled ? (ui(N, d), io()) : (io(), ui(N, d)), | |
lc(() => { | |
!N._isLeaving || | |
(Ni(N, h), ui(N, f), ac(k) || oc(N, n, w, se)) | |
}), | |
Zi(k, [ | |
N, | |
se | |
]) | |
}, | |
onEnterCancelled(N) { | |
$(N, !1, void 0, !0), | |
Zi(x, [ | |
N | |
]) | |
}, | |
onAppearCancelled(N) { | |
$(N, !0, void 0, !0), | |
Zi(I, [ | |
N | |
]) | |
}, | |
onLeaveCancelled(N) { | |
L(N), | |
Zi(S, [ | |
N | |
]) | |
} | |
} | |
) | |
} | |
function X0(i) { | |
if (i == null) return null; | |
if (De(i)) return [Fa(i.enter), | |
Fa(i.leave)]; | |
{ | |
const e = Fa(i); | |
return [e, | |
e] | |
} | |
} | |
function Fa(i) { | |
return Ym(i) | |
} | |
function ui(i, e) { | |
e.split(/\s+/).forEach(t => t && i.classList.add(t)), | |
(i[zn] || (i[zn] = new Set)).add(e) | |
} | |
function Ni(i, e) { | |
e.split(/\s+/).forEach(n => n && i.classList.remove(n)); | |
const t = i[zn]; | |
t && | |
(t.delete(e), t.size || (i[zn] = void 0)) | |
} | |
function lc(i) { | |
requestAnimationFrame(() => { | |
requestAnimationFrame(i) | |
}) | |
} | |
let J0 = 0; | |
function oc(i, e, t, n) { | |
const s = i._endId = ++J0, | |
r = () => { | |
s === i._endId && | |
n() | |
}; | |
if (t != null) return setTimeout(r, t); | |
const { | |
type: a, | |
timeout: l, | |
propCount: o | |
} | |
= Of(i, e); | |
if (!a) return n(); | |
const u = a + 'end'; | |
let c = 0; | |
const h = () => { | |
i.removeEventListener(u, d), | |
r() | |
}, | |
d = f => { | |
f.target === i && | |
++c >= o && | |
h() | |
}; | |
setTimeout(() => { | |
c < o && | |
h() | |
}, l + 1), | |
i.addEventListener(u, d) | |
} | |
function Of(i, e) { | |
const t = window.getComputedStyle(i), | |
n = p => (t[p] || '').split(', '), | |
s = n(`${ Li }Delay`), | |
r = n(`${ Li }Duration`), | |
a = uc(s, r), | |
l = n(`${ ns }Delay`), | |
o = n(`${ ns }Duration`), | |
u = uc(l, o); | |
let c = null, | |
h = 0, | |
d = 0; | |
e === Li ? a > 0 && | |
(c = Li, h = a, d = r.length) : e === ns ? u > 0 && | |
(c = ns, h = u, d = o.length) : ( | |
h = Math.max(a, u), | |
c = h > 0 ? a > u ? Li : ns : null, | |
d = c ? c === Li ? r.length : o.length : 0 | |
); | |
const f = c === Li && | |
/\b(transform|all)(,|$)/.test(n(`${ Li }Property`).toString()); | |
return { | |
type: c, | |
timeout: h, | |
propCount: d, | |
hasTransform: f | |
} | |
} | |
function uc(i, e) { | |
for (; i.length < e.length; ) i = i.concat(i); | |
return Math.max(...e.map((t, n) => cc(t) + cc(i[n]))) | |
} | |
function cc(i) { | |
return i === 'auto' ? 0 : Number(i.slice(0, - 1).replace(',', '.')) * 1000 | |
} | |
function io() { | |
return document.body.offsetHeight | |
} | |
function Y0(i, e, t) { | |
const n = i[zn]; | |
n && | |
(e = (e ? [ | |
e, | |
...n | |
] : [ | |
...n | |
]).join(' ')), | |
e == null ? i.removeAttribute('class') : t ? i.setAttribute('class', e) : i.className = e | |
} | |
const Ar = Symbol('_vod'), | |
Df = Symbol('_vsh'), | |
Ls = { | |
beforeMount(i, { | |
value: e | |
}, { | |
transition: t | |
}) { | |
i[Ar] = i.style.display === 'none' ? '' : i.style.display, | |
t && | |
e ? t.beforeEnter(i) : ss(i, e) | |
}, | |
mounted(i, { | |
value: e | |
}, { | |
transition: t | |
}) { | |
t && | |
e && | |
t.enter(i) | |
}, | |
updated(i, { | |
value: e, | |
oldValue: t | |
}, { | |
transition: n | |
}) { | |
!e != !t && | |
( | |
n ? e ? (n.beforeEnter(i), ss(i, !0), n.enter(i)) : n.leave(i, () => { | |
ss(i, !1) | |
}) : ss(i, e) | |
) | |
}, | |
beforeUnmount(i, { | |
value: e | |
}) { | |
ss(i, e) | |
} | |
}; | |
function ss(i, e) { | |
i.style.display = e ? i[Ar] : 'none', | |
i[Df] = !e | |
} | |
const Q0 = Symbol(''), | |
Z0 = /(^|;)\s*display\s*:/; | |
function ey(i, e, t) { | |
const n = i.style, | |
s = Qe(t); | |
let r = !1; | |
if (t && !s) { | |
if (e) if (Qe(e)) for (const a of e.split(';')) { | |
const l = a.slice(0, a.indexOf(':')).trim(); | |
t[l] == null && | |
Sr(n, l, '') | |
} else for (const a in e) t[a] == null && | |
Sr(n, a, ''); | |
for (const a in t) a === 'display' && | |
(r = !0), | |
Sr(n, a, t[a]) | |
} else if (s) { | |
if (e !== t) { | |
const a = n[Q0]; | |
a && | |
(t += ';' + a), | |
n.cssText = t, | |
r = Z0.test(t) | |
} | |
} else e && | |
i.removeAttribute('style'); | |
Ar in i && | |
(i[Ar] = r ? n.display : '', i[Df] && (n.display = 'none')) | |
} | |
const hc = /\s*!important$/; | |
function Sr(i, e, t) { | |
if (ve(t)) t.forEach(n => Sr(i, e, n)); | |
else if (t == null && (t = ''), e.startsWith('--')) i.setProperty(e, t); | |
else { | |
const n = ty(i, e); | |
hc.test(t) ? i.setProperty(mn(n), t.replace(hc, ''), 'important') : i[n] = t | |
} | |
} | |
const dc = [ | |
'Webkit', | |
'Moz', | |
'ms' | |
], | |
Aa = {}; | |
function ty(i, e) { | |
const t = Aa[e]; | |
if (t) return t; | |
let n = qt(e); | |
if (n !== 'filter' && n in i) return Aa[e] = n; | |
n = sa(n); | |
for (let s = 0; s < dc.length; s++) { | |
const r = dc[s] + n; | |
if (r in i) return Aa[e] = r | |
} | |
return e | |
} | |
const fc = 'http://www.w3.org/1999/xlink'; | |
function pc(i, e, t, n, s, r = ng(e)) { | |
n && | |
e.startsWith('xlink:') ? t == null ? i.removeAttributeNS(fc, e.slice(6, e.length)) : i.setAttributeNS(fc, e, t) : t == null || | |
r && | |
!xd(t) ? i.removeAttribute(e) : i.setAttribute(e, r ? '' : ei(t) ? String(t) : t) | |
} | |
function mc(i, e, t, n, s) { | |
if (e === 'innerHTML' || e === 'textContent') { | |
t != null && | |
(i[e] = e === 'innerHTML' ? Nf(t) : t); | |
return | |
} | |
const r = i.tagName; | |
if (e === 'value' && r !== 'PROGRESS' && !r.includes('-')) { | |
const l = r === 'OPTION' ? i.getAttribute('value') || | |
'' : i.value, | |
o = t == null ? i.type === 'checkbox' ? 'on' : '' : String(t); | |
(l !== o || !('_value' in i)) && | |
(i.value = o), | |
t == null && | |
i.removeAttribute(e), | |
i._value = t; | |
return | |
} | |
let a = !1; | |
if (t === '' || t == null) { | |
const l = typeof i[e]; | |
l === 'boolean' ? t = xd(t) : t == null && | |
l === 'string' ? (t = '', a = !0) : l === 'number' && | |
(t = 0, a = !0) | |
} | |
try { | |
i[e] = t | |
} catch { | |
} | |
a && | |
i.removeAttribute(s || e) | |
} | |
function Ai(i, e, t, n) { | |
i.addEventListener(e, t, n) | |
} | |
function iy(i, e, t, n) { | |
i.removeEventListener(e, t, n) | |
} | |
const gc = Symbol('_vei'); | |
function ny(i, e, t, n, s = null) { | |
const r = i[gc] || | |
(i[gc] = {}), | |
a = r[e]; | |
if (n && a) a.value = n; | |
else { | |
const [l, | |
o] = sy(e); | |
if (n) { | |
const u = r[e] = ly(n, s); | |
Ai(i, l, u, o) | |
} else a && | |
(iy(i, l, a, o), r[e] = void 0) | |
} | |
} | |
const yc = /(?:Once|Passive|Capture)$/; | |
function sy(i) { | |
let e; | |
if (yc.test(i)) { | |
e = {}; | |
let n; | |
for (; n = i.match(yc); ) i = i.slice(0, i.length - n[0].length), | |
e[n[0].toLowerCase()] = !0 | |
} | |
return [i[2] === ':' ? i.slice(3) : mn(i.slice(2)), | |
e] | |
} | |
let Va = 0; | |
const ry = Promise.resolve(), | |
ay = () => Va || | |
(ry.then(() => Va = 0), Va = Date.now()); | |
function ly(i, e) { | |
const t = n => { | |
if (!n._vts) n._vts = Date.now(); | |
else if (n._vts <= t.attached) return; | |
ti(oy(n, t.value), e, 5, [ | |
n | |
]) | |
}; | |
return t.value = i, | |
t.attached = ay(), | |
t | |
} | |
function oy(i, e) { | |
if (ve(e)) { | |
const t = i.stopImmediatePropagation; | |
return i.stopImmediatePropagation = () => { | |
t.call(i), | |
i._stopped = !0 | |
}, | |
e.map(n => s => !s._stopped && n && n(s)) | |
} else return e | |
} | |
const vc = i => i.charCodeAt(0) === 111 && | |
i.charCodeAt(1) === 110 && | |
i.charCodeAt(2) > 96 && | |
i.charCodeAt(2) < 123, | |
uy = (i, e, t, n, s, r) => { | |
const a = s === 'svg'; | |
e === 'class' ? Y0(i, n, a) : e === 'style' ? ey(i, t, n) : ta(e) ? jo(e) || | |
ny(i, e, t, n, r) : ( | |
e[0] === '.' ? (e = e.slice(1), !0) : e[0] === '^' ? (e = e.slice(1), !1) : cy(i, e, n, a) | |
) ? ( | |
mc(i, e, n), | |
!i.tagName.includes('-') && | |
(e === 'value' || e === 'checked' || e === 'selected') && | |
pc(i, e, n, a, r, e !== 'value') | |
) : i._isVueCE && | |
(/[A-Z]/.test(e) || !Qe(n)) ? mc(i, qt(e), n, r, e) : ( | |
e === 'true-value' ? i._trueValue = n : e === 'false-value' && | |
(i._falseValue = n), | |
pc(i, e, n, a) | |
) | |
}; | |
function cy(i, e, t, n) { | |
if (n) return !!(e === 'innerHTML' || e === 'textContent' || e in i && vc(e) && _e(t)); | |
if ( | |
e === 'spellcheck' || | |
e === 'draggable' || | |
e === 'translate' || | |
e === 'form' || | |
e === 'list' && | |
i.tagName === 'INPUT' || | |
e === 'type' && | |
i.tagName === 'TEXTAREA' | |
) return !1; | |
if (e === 'width' || e === 'height') { | |
const s = i.tagName; | |
if (s === 'IMG' || s === 'VIDEO' || s === 'CANVAS' || s === 'SOURCE') return !1 | |
} | |
return vc(e) && | |
Qe(t) ? !1 : e in i | |
} | |
const Ff = new WeakMap, | |
Af = new WeakMap, | |
Vr = Symbol('_moveCb'), | |
bc = Symbol('_enterCb'), | |
hy = i => (delete i.props.mode, i), | |
dy = hy({ | |
name: 'TransitionGroup', | |
props: et({ | |
}, Rf, { | |
tag: String, | |
moveClass: String | |
}), | |
setup(i, { | |
slots: e | |
}) { | |
const t = Lf(), | |
n = Qd(); | |
let s, | |
r; | |
return ha( | |
() => { | |
if (!s.length) return; | |
const a = i.moveClass || | |
`${ i.name || | |
'v' }-move`; | |
if (!gy(s[0].el, t.vnode.el, a)) return; | |
s.forEach(fy), | |
s.forEach(py); | |
const l = s.filter(my); | |
io(), | |
l.forEach( | |
o => { | |
const u = o.el, | |
c = u.style; | |
ui(u, a), | |
c.transform = c.webkitTransform = c.transitionDuration = ''; | |
const h = u[Vr] = d => { | |
d && | |
d.target !== u || | |
(!d || /transform$/.test(d.propertyName)) && | |
(u.removeEventListener('transitionend', h), u[Vr] = null, Ni(u, a)) | |
}; | |
u.addEventListener('transitionend', h) | |
} | |
) | |
} | |
), | |
() => { | |
const a = Pe(i), | |
l = Bf(a); | |
let o = a.tag || | |
D; | |
if (s = [], r) for (let u = 0; u < r.length; u++) { | |
const c = r[u]; | |
c.el && | |
c.el instanceof Element && | |
( | |
s.push(c), | |
on(c, Ss(c, l, n, t)), | |
Ff.set(c, c.el.getBoundingClientRect()) | |
) | |
} | |
r = e.default ? iu(e.default()) : []; | |
for (let u = 0; u < r.length; u++) { | |
const c = r[u]; | |
c.key != null && | |
on(c, Ss(c, l, n, t)) | |
} | |
return V(o, null, r) | |
} | |
} | |
}), | |
Vf = dy; | |
function fy(i) { | |
const e = i.el; | |
e[Vr] && | |
e[Vr](), | |
e[bc] && | |
e[bc]() | |
} | |
function py(i) { | |
Af.set(i, i.el.getBoundingClientRect()) | |
} | |
function my(i) { | |
const e = Ff.get(i), | |
t = Af.get(i), | |
n = e.left - t.left, | |
s = e.top - t.top; | |
if (n || s) { | |
const r = i.el.style; | |
return r.transform = r.webkitTransform = `translate(${ n }px,${ s }px)`, | |
r.transitionDuration = '0s', | |
i | |
} | |
} | |
function gy(i, e, t) { | |
const n = i.cloneNode(), | |
s = i[zn]; | |
s && | |
s.forEach(l => { | |
l.split(/\s+/).forEach(o => o && n.classList.remove(o)) | |
}), | |
t.split(/\s+/).forEach(l => l && n.classList.add(l)), | |
n.style.display = 'none'; | |
const r = e.nodeType === 1 ? e : e.parentNode; | |
r.appendChild(n); | |
const { | |
hasTransform: a | |
} | |
= Of(n); | |
return r.removeChild(n), | |
a | |
} | |
const Wn = i => { | |
const e = i.props['onUpdate:modelValue'] || | |
!1; | |
return ve(e) ? t => _r(e, t) : e | |
}; | |
function yy(i) { | |
i.target.composing = !0 | |
} | |
function wc(i) { | |
const e = i.target; | |
e.composing && | |
(e.composing = !1, e.dispatchEvent(new Event('input'))) | |
} | |
const Si = Symbol('_assign'), | |
zr = { | |
created(i, { | |
modifiers: { | |
lazy: e, | |
trim: t, | |
number: n | |
} | |
}, s) { | |
i[Si] = Wn(s); | |
const r = n || | |
s.props && | |
s.props.type === 'number'; | |
Ai( | |
i, | |
e ? 'change' : 'input', | |
a => { | |
if (a.target.composing) return; | |
let l = i.value; | |
t && | |
(l = l.trim()), | |
r && | |
(l = Ir(l)), | |
i[Si](l) | |
} | |
), | |
t && | |
Ai(i, 'change', () => { | |
i.value = i.value.trim() | |
}), | |
e || | |
( | |
Ai(i, 'compositionstart', yy), | |
Ai(i, 'compositionend', wc), | |
Ai(i, 'change', wc) | |
) | |
}, | |
mounted(i, { | |
value: e | |
}) { | |
i.value = e ?? '' | |
}, | |
beforeUpdate(i, { | |
value: e, | |
oldValue: t, | |
modifiers: { | |
lazy: n, | |
trim: s, | |
number: r | |
} | |
}, a) { | |
if (i[Si] = Wn(a), i.composing) return; | |
const l = (r || i.type === 'number') && | |
!/^0\d/.test(i.value) ? Ir(i.value) : i.value, | |
o = e ?? ''; | |
l !== o && | |
( | |
document.activeElement === i && | |
i.type !== 'range' && | |
(n && e === t || s && i.value.trim() === o) || | |
(i.value = o) | |
) | |
} | |
}, | |
vy = { | |
created(i, { | |
value: e | |
}, t) { | |
i.checked = Vn(e, t.props.value), | |
i[Si] = Wn(t), | |
Ai(i, 'change', () => { | |
i[Si](Ps(i)) | |
}) | |
}, | |
beforeUpdate(i, { | |
value: e, | |
oldValue: t | |
}, n) { | |
i[Si] = Wn(n), | |
e !== t && | |
(i.checked = Vn(e, n.props.value)) | |
} | |
}, | |
by = { | |
deep: !0, | |
created(i, { | |
value: e, | |
modifiers: { | |
number: t | |
} | |
}, n) { | |
const s = ia(e); | |
Ai( | |
i, | |
'change', | |
() => { | |
const r = Array.prototype.filter.call(i.options, a => a.selected).map(a => t ? Ir(Ps(a)) : Ps(a)); | |
i[Si](i.multiple ? s ? new Set(r) : r : r[0]), | |
i._assigning = !0, | |
pi(() => { | |
i._assigning = !1 | |
}) | |
} | |
), | |
i[Si] = Wn(n) | |
}, | |
mounted(i, { | |
value: e | |
}) { | |
kc(i, e) | |
}, | |
beforeUpdate(i, e, t) { | |
i[Si] = Wn(t) | |
}, | |
updated(i, { | |
value: e | |
}) { | |
i._assigning || | |
kc(i, e) | |
} | |
}; | |
function kc(i, e) { | |
const t = i.multiple, | |
n = ve(e); | |
if (!(t && !n && !ia(e))) { | |
for (let s = 0, r = i.options.length; s < r; s++) { | |
const a = i.options[s], | |
l = Ps(a); | |
if (t) if (n) { | |
const o = typeof l; | |
o === 'string' || | |
o === 'number' ? a.selected = e.some(u => String(u) === String(l)) : a.selected = rg(e, l) > - 1 | |
} else a.selected = e.has(l); | |
else if (Vn(Ps(a), e)) { | |
i.selectedIndex !== s && | |
(i.selectedIndex = s); | |
return | |
} | |
} | |
!t && | |
i.selectedIndex !== - 1 && | |
(i.selectedIndex = - 1) | |
} | |
} | |
function Ps(i) { | |
return '_value' in i ? i._value : i.value | |
} | |
const wy = [ | |
'ctrl', | |
'shift', | |
'alt', | |
'meta' | |
], | |
ky = { | |
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, e) => wy.some(t => i[`${ t }Key`] && !e.includes(t)) | |
}, | |
_y = (i, e) => { | |
const t = i._withMods || | |
(i._withMods = {}), | |
n = e.join('.'); | |
return t[n] || | |
( | |
t[n] = (s, ...r) => { | |
for (let a = 0; a < e.length; a++) { | |
const l = ky[e[a]]; | |
if (l && l(s, e)) return | |
} | |
return i(s, ...r) | |
} | |
) | |
}, | |
xy = et({ | |
patchProp: uy | |
}, G0); | |
let _c; | |
function Ty() { | |
return _c || | |
(_c = v0(xy)) | |
} | |
const zf = (...i) => { | |
const e = Ty().createApp(...i), | |
{ | |
mount: t | |
} | |
= e; | |
return e.mount = n => { | |
const s = Ey(n); | |
if (!s) return; | |
const r = e._component; | |
!_e(r) && | |
!r.render && | |
!r.template && | |
(r.template = s.innerHTML), | |
s.nodeType === 1 && | |
(s.textContent = ''); | |
const a = t(s, !1, Sy(s)); | |
return s instanceof Element && | |
(s.removeAttribute('v-cloak'), s.setAttribute('data-v-app', '')), | |
a | |
}, | |
e | |
}; | |
function Sy(i) { | |
if (i instanceof SVGElement) return 'svg'; | |
if (typeof MathMLElement == 'function' && i instanceof MathMLElement) return 'mathml' | |
} | |
function Ey(i) { | |
return Qe(i) ? document.querySelector(i) : i | |
} | |
var Cy = !1; /*! | |
* pinia v2.3.0 | |
* (c) 2024 Eduardo San Martin Morote | |
* @license MIT | |
*/ | |
let Wf; | |
const ya = i => Wf = i, | |
Uf = Symbol(); | |
function no(i) { | |
return i && | |
typeof i == 'object' && | |
Object.prototype.toString.call(i) === '[object Object]' && | |
typeof i.toJSON != 'function' | |
} | |
var ps; | |
( | |
function (i) { | |
i.direct = 'direct', | |
i.patchObject = 'patch object', | |
i.patchFunction = 'patch function' | |
} | |
) (ps || (ps = {})); | |
function $y() { | |
const i = Cd(!0), | |
e = i.run(() => M({ | |
})); | |
let t = [], | |
n = []; | |
const s = aa({ | |
install(r) { | |
ya(s), | |
s._a = r, | |
r.provide(Uf, s), | |
r.config.globalProperties.$pinia = s, | |
n.forEach(a => t.push(a)), | |
n = [] | |
}, | |
use(r) { | |
return !this._a && | |
!Cy ? n.push(r) : t.push(r), | |
this | |
}, | |
_p: t, | |
_a: null, | |
_e: i, | |
_s: new Map, | |
state: e | |
}); | |
return s | |
} | |
const jf = () => { | |
}; | |
function xc(i, e, t, n = jf) { | |
i.push(e); | |
const s = () => { | |
const r = i.indexOf(e); | |
r > - 1 && | |
(i.splice(r, 1), n()) | |
}; | |
return !t && | |
$d() && | |
ag(s), | |
s | |
} | |
function bn(i, ...e) { | |
i.slice().forEach(t => { | |
t(...e) | |
}) | |
} | |
const Ly = i => i(), | |
Tc = Symbol(), | |
za = Symbol(); | |
function so(i, e) { | |
i instanceof Map && | |
e instanceof Map ? e.forEach((t, n) => i.set(n, t)) : i instanceof Set && | |
e instanceof Set && | |
e.forEach(i.add, i); | |
for (const t in e) { | |
if (!e.hasOwnProperty(t)) continue; | |
const n = e[t], | |
s = i[t]; | |
no(s) && | |
no(n) && | |
i.hasOwnProperty(t) && | |
!Je(n) && | |
!Ui(n) ? i[t] = so(s, n) : i[t] = n | |
} | |
return i | |
} | |
const Py = Symbol(); | |
function Iy(i) { | |
return !no(i) || | |
!i.hasOwnProperty(Py) | |
} | |
const { | |
assign: Mi | |
} | |
= Object; | |
function Ny(i) { | |
return !!(Je(i) && i.effect) | |
} | |
function My(i, e, t, n) { | |
const { | |
state: s, | |
actions: r, | |
getters: a | |
} | |
= e, | |
l = t.state.value[i]; | |
let o; | |
function u() { | |
l || | |
(t.state.value[i] = s ? s() : { | |
}); | |
const c = Lg(t.state.value[i]); | |
return Mi( | |
c, | |
r, | |
Object.keys(a || { | |
}).reduce( | |
(h, d) => ( | |
h[d] = aa(q(() => { | |
ya(t); | |
const f = t._s.get(i); | |
return a[d].call(f, f) | |
})), | |
h | |
), | |
{ | |
} | |
) | |
) | |
} | |
return o = Hf(i, u, e, t, n, !0), | |
o | |
} | |
function Hf(i, e, t = {}, n, s, r) { | |
let a; | |
const l = Mi({ | |
actions: { | |
} | |
}, t), | |
o = { | |
deep: !0 | |
}; | |
let u, | |
c, | |
h = [], | |
d = [], | |
f; | |
const p = n.state.value[i]; | |
!r && | |
!p && | |
(n.state.value[i] = {}), | |
M({ | |
}); | |
let g; | |
function w(I) { | |
let $; | |
u = c = !1, | |
typeof I == 'function' ? ( | |
I(n.state.value[i]), | |
$ = { | |
type: ps.patchFunction, | |
storeId: i, | |
events: f | |
} | |
) : ( | |
so(n.state.value[i], I), | |
$ = { | |
type: ps.patchObject, | |
payload: I, | |
storeId: i, | |
events: f | |
} | |
); | |
const L = g = Symbol(); | |
pi().then(() => { | |
g === L && | |
(u = !0) | |
}), | |
c = !0, | |
bn(h, $, n.state.value[i]) | |
} | |
const y = r ? function () { | |
const { | |
state: $ | |
} | |
= t, | |
L = $ ? $() : { | |
}; | |
this.$patch(A => { | |
Mi(A, L) | |
}) | |
} | |
: jf; | |
function b() { | |
a.stop(), | |
h = [], | |
d = [], | |
n._s.delete(i) | |
} | |
const x = (I, $ = '') => { | |
if (Tc in I) return I[za] = $, | |
I; | |
const L = function () { | |
ya(n); | |
const A = Array.from(arguments), | |
N = [], | |
O = []; | |
function se(le) { | |
N.push(le) | |
} | |
function G(le) { | |
O.push(le) | |
} | |
bn(d, { | |
args: A, | |
name: L[za], | |
store: S, | |
after: se, | |
onError: G | |
}); | |
let te; | |
try { | |
te = I.apply(this && this.$id === i ? this : S, A) | |
} catch (le) { | |
throw bn(O, le), | |
le | |
} | |
return te instanceof Promise ? te.then(le => (bn(N, le), le)).catch(le => (bn(O, le), Promise.reject(le))) : (bn(N, te), te) | |
}; | |
return L[Tc] = !0, | |
L[za] = $, | |
L | |
}, | |
k = { | |
_p: n, | |
$id: i, | |
$onAction: xc.bind(null, d), | |
$patch: w, | |
$reset: y, | |
$subscribe(I, $ = {}) { | |
const L = xc(h, I, $.detached, () => A()), | |
A = a.run( | |
() => Ie( | |
() => n.state.value[i], | |
N => { | |
($.flush === 'sync' ? c : u) && | |
I({ | |
storeId: i, | |
type: ps.direct, | |
events: f | |
}, N) | |
}, | |
Mi({ | |
}, o, $) | |
) | |
); | |
return L | |
}, | |
$dispose: b | |
}, | |
S = Wi(k); | |
n._s.set(i, S); | |
const z = (n._a && n._a.runWithContext || Ly) (() => n._e.run(() => (a = Cd()).run(() => e({ | |
action: x | |
})))); | |
for (const I in z) { | |
const $ = z[I]; | |
if (Je($) && !Ny($) || Ui($)) r || | |
( | |
p && | |
Iy($) && | |
(Je($) ? $.value = p[I] : so($, p[I])), | |
n.state.value[i][I] = $ | |
); | |
else if (typeof $ == 'function') { | |
const L = x($, I); | |
z[I] = L, | |
l.actions[I] = $ | |
} | |
} | |
return Mi(S, z), | |
Mi(Pe(S), z), | |
Object.defineProperty( | |
S, | |
'$state', | |
{ | |
get: () => n.state.value[i], | |
set: I => { | |
w($ => { | |
Mi($, I) | |
}) | |
} | |
} | |
), | |
n._p.forEach( | |
I => { | |
Mi(S, a.run(() => I({ | |
store: S, | |
app: n._a, | |
pinia: n, | |
options: l | |
}))) | |
} | |
), | |
p && | |
r && | |
t.hydrate && | |
t.hydrate(S.$state, p), | |
u = !0, | |
c = !0, | |
S | |
} /*! #__NO_SIDE_EFFECTS__ */ function Xi(i, e, t) { | |
let n, | |
s; | |
const r = typeof e == 'function'; | |
typeof i == 'string' ? (n = i, s = r ? t : e) : (s = i, n = i.id); | |
function a(l, o) { | |
const u = c0(); | |
return l = l || | |
(u ? zt(Uf, null) : null), | |
l && | |
ya(l), | |
l = Wf, | |
l._s.has(n) || | |
(r ? Hf(n, e, s, l) : My(n, s, l)), | |
l._s.get(n) | |
} | |
return a.$id = n, | |
a | |
} | |
function ou(i) { | |
let e = typeof i; | |
if (e == 'object') { | |
if (Array.isArray(i)) return 'array'; | |
if (i === null) return 'null' | |
} | |
return e | |
} | |
function Ry(i) { | |
return i !== null && | |
typeof i == 'object' && | |
!Array.isArray(i) | |
} | |
let _i = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.split(''), | |
va = []; | |
for (let i = 0; i < _i.length; i++) va[_i[i].charCodeAt(0)] = i; | |
va['-'.charCodeAt(0)] = _i.indexOf('+'); | |
va['_'.charCodeAt(0)] = _i.indexOf('/'); | |
function qf(i) { | |
let e = i.length * 3 / 4; | |
i[i.length - 2] == '=' ? e -= 2 : i[i.length - 1] == '=' && | |
(e -= 1); | |
let t = new Uint8Array(e), | |
n = 0, | |
s = 0, | |
r, | |
a = 0; | |
for (let l = 0; l < i.length; l++) { | |
if (r = va[i.charCodeAt(l)], r === void 0) switch (i[l]) { | |
case '=': | |
s = 0; | |
case ` | |
`: | |
case '\r': | |
case '\t': | |
case ' ': | |
continue; | |
default: | |
throw Error('invalid base64 string.') | |
} | |
switch (s) { | |
case 0: | |
a = r, | |
s = 1; | |
break; | |
case 1: | |
t[n++] = a << 2 | (r & 48) >> 4, | |
a = r, | |
s = 2; | |
break; | |
case 2: | |
t[n++] = (a & 15) << 4 | (r & 60) >> 2, | |
a = r, | |
s = 3; | |
break; | |
case 3: | |
t[n++] = (a & 3) << 6 | r, | |
s = 0; | |
break | |
} | |
} | |
if (s == 1) throw Error('invalid base64 string.'); | |
return t.subarray(0, n) | |
} | |
function Gf(i) { | |
let e = '', | |
t = 0, | |
n, | |
s = 0; | |
for (let r = 0; r < i.length; r++) switch (n = i[r], t) { | |
case 0: | |
e += _i[n >> 2], | |
s = (n & 3) << 4, | |
t = 1; | |
break; | |
case 1: | |
e += _i[s | n >> 4], | |
s = (n & 15) << 2, | |
t = 2; | |
break; | |
case 2: | |
e += _i[s | n >> 6], | |
e += _i[n & 63], | |
t = 0; | |
break | |
} | |
return t && | |
(e += _i[s], e += '=', t == 1 && (e += '=')), | |
e | |
} | |
var P; | |
( | |
function (i) { | |
i.symbol = Symbol.for('protobuf-ts/unknown'), | |
i.onRead = (t, n, s, r, a) => { | |
(e(n) ? n[i.symbol] : n[i.symbol] = []).push({ | |
no: s, | |
wireType: r, | |
data: a | |
}) | |
}, | |
i.onWrite = (t, n, s) => { | |
for (let { | |
no: r, | |
wireType: a, | |
data: l | |
} | |
of i.list(n)) s.tag(r, a).raw(l) | |
}, | |
i.list = (t, n) => { | |
if (e(t)) { | |
let s = t[i.symbol]; | |
return n ? s.filter(r => r.no == n) : s | |
} | |
return [] | |
}, | |
i.last = (t, n) => i.list(t, n).slice( - 1) [0]; | |
const e = t => t && | |
Array.isArray(t[i.symbol]) | |
} | |
) (P || (P = {})); | |
function By(i, e) { | |
return Object.assign(Object.assign({ | |
}, i), e) | |
} | |
var v; | |
( | |
function (i) { | |
i[i.Varint = 0] = 'Varint', | |
i[i.Bit64 = 1] = 'Bit64', | |
i[i.LengthDelimited = 2] = 'LengthDelimited', | |
i[i.StartGroup = 3] = 'StartGroup', | |
i[i.EndGroup = 4] = 'EndGroup', | |
i[i.Bit32 = 5] = 'Bit32' | |
} | |
) (v || (v = {})); | |
function Oy() { | |
let i = 0, | |
e = 0; | |
for (let n = 0; n < 28; n += 7) { | |
let s = this.buf[this.pos++]; | |
if (i |= (s & 127) << n, (s & 128) == 0) return this.assertBounds(), | |
[ | |
i, | |
e | |
] | |
} | |
let t = this.buf[this.pos++]; | |
if (i |= (t & 15) << 28, e = (t & 112) >> 4, (t & 128) == 0) return this.assertBounds(), | |
[ | |
i, | |
e | |
]; | |
for (let n = 3; n <= 31; n += 7) { | |
let s = this.buf[this.pos++]; | |
if (e |= (s & 127) << n, (s & 128) == 0) return this.assertBounds(), | |
[ | |
i, | |
e | |
] | |
} | |
throw new Error('invalid varint') | |
} | |
function Wa(i, e, t) { | |
for (let r = 0; r < 28; r = r + 7) { | |
const a = i >>> r, | |
l = !(a >>> 7 == 0 && e == 0), | |
o = (l ? a | 128 : a) & 255; | |
if (t.push(o), !l) return | |
} | |
const n = i >>> 28 & 15 | (e & 7) << 4, | |
s = e >> 3 != 0; | |
if (t.push((s ? n | 128 : n) & 255), !!s) { | |
for (let r = 3; r < 31; r = r + 7) { | |
const a = e >>> r, | |
l = a >>> 7 != 0, | |
o = (l ? a | 128 : a) & 255; | |
if (t.push(o), !l) return | |
} | |
t.push(e >>> 31 & 1) | |
} | |
} | |
const Er = (1 << 16) * (1 << 16); | |
function Kf(i) { | |
let e = i[0] == '-'; | |
e && | |
(i = i.slice(1)); | |
const t = 1000000; | |
let n = 0, | |
s = 0; | |
function r(a, l) { | |
const o = Number(i.slice(a, l)); | |
s *= t, | |
n = n * t + o, | |
n >= Er && | |
(s = s + (n / Er | 0), n = n % Er) | |
} | |
return r( - 24, - 18), | |
r( - 18, - 12), | |
r( - 12, - 6), | |
r( - 6), | |
[ | |
e, | |
n, | |
s | |
] | |
} | |
function ro(i, e) { | |
if (e >>> 0 <= 2097151) return '' + (Er * e + (i >>> 0)); | |
let t = i & 16777215, | |
n = (i >>> 24 | e << 8) >>> 0 & 16777215, | |
s = e >> 16 & 65535, | |
r = t + n * 6777216 + s * 6710656, | |
a = n + s * 8147497, | |
l = s * 2, | |
o = 10000000; | |
r >= o && | |
(a += Math.floor(r / o), r %= o), | |
a >= o && | |
(l += Math.floor(a / o), a %= o); | |
function u(c, h) { | |
let d = c ? String(c) : ''; | |
return h ? '0000000'.slice(d.length) + d : d | |
} | |
return u(l, 0) + u(a, l) + u(r, 1) | |
} | |
function Sc(i, e) { | |
if (i >= 0) { | |
for (; i > 127; ) e.push(i & 127 | 128), | |
i = i >>> 7; | |
e.push(i) | |
} else { | |
for (let t = 0; t < 9; t++) e.push(i & 127 | 128), | |
i = i >> 7; | |
e.push(1) | |
} | |
} | |
function Dy() { | |
let i = this.buf[this.pos++], | |
e = i & 127; | |
if ((i & 128) == 0) return this.assertBounds(), | |
e; | |
if (i = this.buf[this.pos++], e |= (i & 127) << 7, (i & 128) == 0) return this.assertBounds(), | |
e; | |
if (i = this.buf[this.pos++], e |= (i & 127) << 14, (i & 128) == 0) return this.assertBounds(), | |
e; | |
if (i = this.buf[this.pos++], e |= (i & 127) << 21, (i & 128) == 0) return this.assertBounds(), | |
e; | |
i = this.buf[this.pos++], | |
e |= (i & 15) << 28; | |
for (let t = 5; (i & 128) !== 0 && t < 10; t++) i = this.buf[this.pos++]; | |
if ((i & 128) != 0) throw new Error('invalid varint'); | |
return this.assertBounds(), | |
e >>> 0 | |
} | |
let Ae; | |
function Fy() { | |
const i = new DataView(new ArrayBuffer(8)); | |
Ae = globalThis.BigInt !== void 0 && | |
typeof i.getBigInt64 == 'function' && | |
typeof i.getBigUint64 == 'function' && | |
typeof i.setBigInt64 == 'function' && | |
typeof i.setBigUint64 == 'function' ? { | |
MIN: BigInt('-9223372036854775808'), | |
MAX: BigInt('9223372036854775807'), | |
UMIN: BigInt('0'), | |
UMAX: BigInt('18446744073709551615'), | |
C: BigInt, | |
V: i | |
} | |
: void 0 | |
} | |
Fy(); | |
function Xf(i) { | |
if (!i) throw new Error( | |
'BigInt unavailable, see https://github.com/timostamm/protobuf-ts/blob/v1.0.8/MANUAL.md#bigint-support' | |
) | |
} | |
const Jf = /^-?[0-9]+$/, | |
Wr = 4294967296, | |
sr = 2147483648; | |
class Yf { | |
constructor(e, t) { | |
this.lo = e | 0, | |
this.hi = t | 0 | |
} | |
isZero() { | |
return this.lo == 0 && | |
this.hi == 0 | |
} | |
toNumber() { | |
let e = this.hi * Wr + (this.lo >>> 0); | |
if (!Number.isSafeInteger(e)) throw new Error('cannot convert to safe number'); | |
return e | |
} | |
} | |
class gt extends Yf { | |
static from(e) { | |
if (Ae) switch (typeof e) { | |
case 'string': | |
if (e == '0') return this.ZERO; | |
if (e == '') throw new Error('string is no integer'); | |
e = Ae.C(e); | |
case 'number': | |
if (e === 0) return this.ZERO; | |
e = Ae.C(e); | |
case 'bigint': | |
if (!e) return this.ZERO; | |
if (e < Ae.UMIN) throw new Error('signed value for ulong'); | |
if (e > Ae.UMAX) throw new Error('ulong too large'); | |
return Ae.V.setBigUint64(0, e, !0), | |
new gt(Ae.V.getInt32(0, !0), Ae.V.getInt32(4, !0)) | |
} else switch (typeof e) { | |
case 'string': | |
if (e == '0') return this.ZERO; | |
if (e = e.trim(), !Jf.test(e)) throw new Error('string is no integer'); | |
let[t, | |
n, | |
s] = Kf(e); | |
if (t) throw new Error('signed value for ulong'); | |
return new gt(n, s); | |
case 'number': | |
if (e == 0) return this.ZERO; | |
if (!Number.isSafeInteger(e)) throw new Error('number is no integer'); | |
if (e < 0) throw new Error('signed value for ulong'); | |
return new gt(e, e / Wr) | |
} | |
throw new Error('unknown value ' + typeof e) | |
} | |
toString() { | |
return Ae ? this.toBigInt().toString() : ro(this.lo, this.hi) | |
} | |
toBigInt() { | |
return Xf(Ae), | |
Ae.V.setInt32(0, this.lo, !0), | |
Ae.V.setInt32(4, this.hi, !0), | |
Ae.V.getBigUint64(0, !0) | |
} | |
} | |
gt.ZERO = new gt(0, 0); | |
class qe extends Yf { | |
static from(e) { | |
if (Ae) switch (typeof e) { | |
case 'string': | |
if (e == '0') return this.ZERO; | |
if (e == '') throw new Error('string is no integer'); | |
e = Ae.C(e); | |
case 'number': | |
if (e === 0) return this.ZERO; | |
e = Ae.C(e); | |
case 'bigint': | |
if (!e) return this.ZERO; | |
if (e < Ae.MIN) throw new Error('signed long too small'); | |
if (e > Ae.MAX) throw new Error('signed long too large'); | |
return Ae.V.setBigInt64(0, e, !0), | |
new qe(Ae.V.getInt32(0, !0), Ae.V.getInt32(4, !0)) | |
} else switch (typeof e) { | |
case 'string': | |
if (e == '0') return this.ZERO; | |
if (e = e.trim(), !Jf.test(e)) throw new Error('string is no integer'); | |
let[t, | |
n, | |
s] = Kf(e); | |
if (t) { | |
if (s > sr || s == sr && n != 0) throw new Error('signed long too small') | |
} else if (s >= sr) throw new Error('signed long too large'); | |
let r = new qe(n, s); | |
return t ? r.negate() : r; | |
case 'number': | |
if (e == 0) return this.ZERO; | |
if (!Number.isSafeInteger(e)) throw new Error('number is no integer'); | |
return e > 0 ? new qe(e, e / Wr) : new qe( - e, - e / Wr).negate() | |
} | |
throw new Error('unknown value ' + typeof e) | |
} | |
isNegative() { | |
return (this.hi & sr) !== 0 | |
} | |
negate() { | |
let e = ~this.hi, | |
t = this.lo; | |
return t ? t = ~t + 1 : e += 1, | |
new qe(t, e) | |
} | |
toString() { | |
if (Ae) return this.toBigInt().toString(); | |
if (this.isNegative()) { | |
let e = this.negate(); | |
return '-' + ro(e.lo, e.hi) | |
} | |
return ro(this.lo, this.hi) | |
} | |
toBigInt() { | |
return Xf(Ae), | |
Ae.V.setInt32(0, this.lo, !0), | |
Ae.V.setInt32(4, this.hi, !0), | |
Ae.V.getBigInt64(0, !0) | |
} | |
} | |
qe.ZERO = new qe(0, 0); | |
const Ec = { | |
readUnknownField: !0, | |
readerFactory: i => new Vy(i) | |
}; | |
function Ay(i) { | |
return i ? Object.assign(Object.assign({ | |
}, Ec), i) : Ec | |
} | |
class Vy { | |
constructor(e, t) { | |
this.varint64 = Oy, | |
this.uint32 = Dy, | |
this.buf = e, | |
this.len = e.length, | |
this.pos = 0, | |
this.view = new DataView(e.buffer, e.byteOffset, e.byteLength), | |
this.textDecoder = t ?? new TextDecoder('utf-8', { | |
fatal: !0, | |
ignoreBOM: !0 | |
}) | |
} | |
tag() { | |
let e = this.uint32(), | |
t = e >>> 3, | |
n = e & 7; | |
if (t <= 0 || n < 0 || n > 5) throw new Error('illegal tag: field no ' + t + ' wire type ' + n); | |
return [t, | |
n] | |
} | |
skip(e) { | |
let t = this.pos; | |
switch (e) { | |
case v.Varint: | |
for (; this.buf[this.pos++] & 128; ); | |
break; | |
case v.Bit64: | |
this.pos += 4; | |
case v.Bit32: | |
this.pos += 4; | |
break; | |
case v.LengthDelimited: | |
let n = this.uint32(); | |
this.pos += n; | |
break; | |
case v.StartGroup: | |
let s; | |
for (; (s = this.tag() [1]) !== v.EndGroup; ) this.skip(s); | |
break; | |
default: | |
throw new Error('cant skip wire type ' + e) | |
} | |
return this.assertBounds(), | |
this.buf.subarray(t, this.pos) | |
} | |
assertBounds() { | |
if (this.pos > this.len) throw new RangeError('premature EOF') | |
} | |
int32() { | |
return this.uint32() | 0 | |
} | |
sint32() { | |
let e = this.uint32(); | |
return e >>> 1 ^ - (e & 1) | |
} | |
int64() { | |
return new qe(...this.varint64()) | |
} | |
uint64() { | |
return new gt(...this.varint64()) | |
} | |
sint64() { | |
let[e, | |
t] = this.varint64(), | |
n = - (e & 1); | |
return e = (e >>> 1 | (t & 1) << 31) ^ n, | |
t = t >>> 1 ^ n, | |
new qe(e, t) | |
} | |
bool() { | |
let[e, | |
t] = this.varint64(); | |
return e !== 0 || | |
t !== 0 | |
} | |
fixed32() { | |
return this.view.getUint32((this.pos += 4) - 4, !0) | |
} | |
sfixed32() { | |
return this.view.getInt32((this.pos += 4) - 4, !0) | |
} | |
fixed64() { | |
return new gt(this.sfixed32(), this.sfixed32()) | |
} | |
sfixed64() { | |
return new qe(this.sfixed32(), this.sfixed32()) | |
} | |
float() { | |
return this.view.getFloat32((this.pos += 4) - 4, !0) | |
} | |
double() { | |
return this.view.getFloat64((this.pos += 8) - 8, !0) | |
} | |
bytes() { | |
let e = this.uint32(), | |
t = this.pos; | |
return this.pos += e, | |
this.assertBounds(), | |
this.buf.subarray(t, t + e) | |
} | |
string() { | |
return this.textDecoder.decode(this.bytes()) | |
} | |
} | |
function Se(i, e) { | |
if (!i) throw new Error(e) | |
} | |
function zy(i, e) { | |
throw new Error(e ?? 'Unexpected object: ' + i) | |
} | |
const Wy = 3.4028234663852886e+38, | |
Uy = - 3.4028234663852886e+38, | |
jy = 4294967295, | |
Hy = 2147483647, | |
qy = - 2147483648; | |
function ms(i) { | |
if (typeof i != 'number') throw new Error('invalid int 32: ' + typeof i); | |
if (!Number.isInteger(i) || i > Hy || i < qy) throw new Error('invalid int 32: ' + i) | |
} | |
function Ur(i) { | |
if (typeof i != 'number') throw new Error('invalid uint 32: ' + typeof i); | |
if (!Number.isInteger(i) || i > jy || i < 0) throw new Error('invalid uint 32: ' + i) | |
} | |
function uu(i) { | |
if (typeof i != 'number') throw new Error('invalid float 32: ' + typeof i); | |
if (!!Number.isFinite(i) && (i > Wy || i < Uy)) throw new Error('invalid float 32: ' + i) | |
} | |
const Cc = { | |
writeUnknownFields: !0, | |
writerFactory: () => new Ky | |
}; | |
function Gy(i) { | |
return i ? Object.assign(Object.assign({ | |
}, Cc), i) : Cc | |
} | |
class Ky { | |
constructor(e) { | |
this.stack = [], | |
this.textEncoder = e ?? new TextEncoder, | |
this.chunks = [], | |
this.buf = [] | |
} | |
finish() { | |
this.chunks.push(new Uint8Array(this.buf)); | |
let e = 0; | |
for (let s = 0; s < this.chunks.length; s++) e += this.chunks[s].length; | |
let t = new Uint8Array(e), | |
n = 0; | |
for (let s = 0; s < this.chunks.length; s++) t.set(this.chunks[s], n), | |
n += this.chunks[s].length; | |
return this.chunks = [], | |
t | |
} | |
fork() { | |
return this.stack.push({ | |
chunks: this.chunks, | |
buf: this.buf | |
}), | |
this.chunks = [], | |
this.buf = [], | |
this | |
} | |
join() { | |
let e = this.finish(), | |
t = this.stack.pop(); | |
if (!t) throw new Error('invalid state, fork stack empty'); | |
return this.chunks = t.chunks, | |
this.buf = t.buf, | |
this.uint32(e.byteLength), | |
this.raw(e) | |
} | |
tag(e, t) { | |
return this.uint32((e << 3 | t) >>> 0) | |
} | |
raw(e) { | |
return this.buf.length && | |
(this.chunks.push(new Uint8Array(this.buf)), this.buf = []), | |
this.chunks.push(e), | |
this | |
} | |
uint32(e) { | |
for (Ur(e); e > 127; ) this.buf.push(e & 127 | 128), | |
e = e >>> 7; | |
return this.buf.push(e), | |
this | |
} | |
int32(e) { | |
return ms(e), | |
Sc(e, this.buf), | |
this | |
} | |
bool(e) { | |
return this.buf.push(e ? 1 : 0), | |
this | |
} | |
bytes(e) { | |
return this.uint32(e.byteLength), | |
this.raw(e) | |
} | |
string(e) { | |
let t = this.textEncoder.encode(e); | |
return this.uint32(t.byteLength), | |
this.raw(t) | |
} | |
float(e) { | |
uu(e); | |
let t = new Uint8Array(4); | |
return new DataView(t.buffer).setFloat32(0, e, !0), | |
this.raw(t) | |
} | |
double(e) { | |
let t = new Uint8Array(8); | |
return new DataView(t.buffer).setFloat64(0, e, !0), | |
this.raw(t) | |
} | |
fixed32(e) { | |
Ur(e); | |
let t = new Uint8Array(4); | |
return new DataView(t.buffer).setUint32(0, e, !0), | |
this.raw(t) | |
} | |
sfixed32(e) { | |
ms(e); | |
let t = new Uint8Array(4); | |
return new DataView(t.buffer).setInt32(0, e, !0), | |
this.raw(t) | |
} | |
sint32(e) { | |
return ms(e), | |
e = (e << 1 ^ e >> 31) >>> 0, | |
Sc(e, this.buf), | |
this | |
} | |
sfixed64(e) { | |
let t = new Uint8Array(8), | |
n = new DataView(t.buffer), | |
s = qe.from(e); | |
return n.setInt32(0, s.lo, !0), | |
n.setInt32(4, s.hi, !0), | |
this.raw(t) | |
} | |
fixed64(e) { | |
let t = new Uint8Array(8), | |
n = new DataView(t.buffer), | |
s = gt.from(e); | |
return n.setInt32(0, s.lo, !0), | |
n.setInt32(4, s.hi, !0), | |
this.raw(t) | |
} | |
int64(e) { | |
let t = qe.from(e); | |
return Wa(t.lo, t.hi, this.buf), | |
this | |
} | |
sint64(e) { | |
let t = qe.from(e), | |
n = t.hi >> 31, | |
s = t.lo << 1 ^ n, | |
r = (t.hi << 1 | t.lo >>> 31) ^ n; | |
return Wa(s, r, this.buf), | |
this | |
} | |
uint64(e) { | |
let t = gt.from(e); | |
return Wa(t.lo, t.hi, this.buf), | |
this | |
} | |
} | |
const $c = { | |
emitDefaultValues: !1, | |
enumAsInteger: !1, | |
useProtoFieldName: !1, | |
prettySpaces: 0 | |
}, | |
Lc = { | |
ignoreUnknownFields: !1 | |
}; | |
function Xy(i) { | |
return i ? Object.assign(Object.assign({ | |
}, Lc), i) : Lc | |
} | |
function Jy(i) { | |
return i ? Object.assign(Object.assign({ | |
}, $c), i) : $c | |
} | |
function Yy(i, e) { | |
var t, | |
n; | |
let s = Object.assign(Object.assign({ | |
}, i), e); | |
return s.typeRegistry = [ | |
...(t = i?.typeRegistry) !== null && | |
t !== void 0 ? t : [], | |
...(n = e?.typeRegistry) !== null && | |
n !== void 0 ? n : [] | |
], | |
s | |
} | |
const J = Symbol.for('protobuf-ts/message-type'); | |
function ao(i) { | |
let e = !1; | |
const t = []; | |
for (let n = 0; n < i.length; n++) { | |
let s = i.charAt(n); | |
s == '_' ? e = !0 : /\d/.test(s) ? (t.push(s), e = !0) : e ? (t.push(s.toUpperCase()), e = !1) : n == 0 ? t.push(s.toLowerCase()) : t.push(s) | |
} | |
return t.join('') | |
} | |
var W; | |
( | |
function (i) { | |
i[i.DOUBLE = 1] = 'DOUBLE', | |
i[i.FLOAT = 2] = 'FLOAT', | |
i[i.INT64 = 3] = 'INT64', | |
i[i.UINT64 = 4] = 'UINT64', | |
i[i.INT32 = 5] = 'INT32', | |
i[i.FIXED64 = 6] = 'FIXED64', | |
i[i.FIXED32 = 7] = 'FIXED32', | |
i[i.BOOL = 8] = 'BOOL', | |
i[i.STRING = 9] = 'STRING', | |
i[i.BYTES = 12] = 'BYTES', | |
i[i.UINT32 = 13] = 'UINT32', | |
i[i.SFIXED32 = 15] = 'SFIXED32', | |
i[i.SFIXED64 = 16] = 'SFIXED64', | |
i[i.SINT32 = 17] = 'SINT32', | |
i[i.SINT64 = 18] = 'SINT64' | |
} | |
) (W || (W = {})); | |
var Wt; | |
( | |
function (i) { | |
i[i.BIGINT = 0] = 'BIGINT', | |
i[i.STRING = 1] = 'STRING', | |
i[i.NUMBER = 2] = 'NUMBER' | |
} | |
) (Wt || (Wt = {})); | |
var jr; | |
( | |
function (i) { | |
i[i.NO = 0] = 'NO', | |
i[i.PACKED = 1] = 'PACKED', | |
i[i.UNPACKED = 2] = 'UNPACKED' | |
} | |
) (jr || (jr = {})); | |
function Qy(i) { | |
var e, | |
t, | |
n, | |
s; | |
return i.localName = (e = i.localName) !== null && | |
e !== void 0 ? e : ao(i.name), | |
i.jsonName = (t = i.jsonName) !== null && | |
t !== void 0 ? t : ao(i.name), | |
i.repeat = (n = i.repeat) !== null && | |
n !== void 0 ? n : jr.NO, | |
i.opt = (s = i.opt) !== null && | |
s !== void 0 ? s : i.repeat || | |
i.oneof ? !1 : i.kind == 'message', | |
i | |
} | |
function Zy(i) { | |
if (typeof i != 'object' || i === null || !i.hasOwnProperty('oneofKind')) return !1; | |
switch (typeof i.oneofKind) { | |
case 'string': | |
return i[i.oneofKind] === void 0 ? !1 : Object.keys(i).length == 2; | |
case 'undefined': | |
return Object.keys(i).length == 1; | |
default: | |
return !1 | |
} | |
} | |
class ev { | |
constructor(e) { | |
var t; | |
this.fields = (t = e.fields) !== null && | |
t !== void 0 ? t : [] | |
} | |
prepare() { | |
if (this.data) return; | |
const e = [], | |
t = [], | |
n = []; | |
for (let s of this.fields) if (s.oneof) n.includes(s.oneof) || | |
(n.push(s.oneof), e.push(s.oneof), t.push(s.oneof)); | |
else switch (t.push(s.localName), s.kind) { | |
case 'scalar': | |
case 'enum': | |
(!s.opt || s.repeat) && | |
e.push(s.localName); | |
break; | |
case 'message': | |
s.repeat && | |
e.push(s.localName); | |
break; | |
case 'map': | |
e.push(s.localName); | |
break | |
} | |
this.data = { | |
req: e, | |
known: t, | |
oneofs: Object.values(n) | |
} | |
} | |
is(e, t, n = !1) { | |
if (t < 0) return !0; | |
if (e == null || typeof e != 'object') return !1; | |
this.prepare(); | |
let s = Object.keys(e), | |
r = this.data; | |
if ( | |
s.length < r.req.length || | |
r.req.some(a => !s.includes(a)) || | |
!n && | |
s.some(a => !r.known.includes(a)) | |
) return !1; | |
if (t < 1) return !0; | |
for (const a of r.oneofs) { | |
const l = e[a]; | |
if (!Zy(l)) return !1; | |
if (l.oneofKind === void 0) continue; | |
const o = this.fields.find(u => u.localName === l.oneofKind); | |
if (!o || !this.field(l[l.oneofKind], o, n, t)) return !1 | |
} | |
for (const a of this.fields) if (a.oneof === void 0 && !this.field(e[a.localName], a, n, t)) return !1; | |
return !0 | |
} | |
field(e, t, n, s) { | |
let r = t.repeat; | |
switch (t.kind) { | |
case 'scalar': | |
return e === void 0 ? t.opt : r ? this.scalars(e, t.T, s, t.L) : this.scalar(e, t.T, t.L); | |
case 'enum': | |
return e === void 0 ? t.opt : r ? this.scalars(e, W.INT32, s) : this.scalar(e, W.INT32); | |
case 'message': | |
return e === void 0 ? !0 : r ? this.messages(e, t.T(), n, s) : this.message(e, t.T(), n, s); | |
case 'map': | |
if (typeof e != 'object' || e === null) return !1; | |
if (s < 2) return !0; | |
if (!this.mapKeys(e, t.K, s)) return !1; | |
switch (t.V.kind) { | |
case 'scalar': | |
return this.scalars(Object.values(e), t.V.T, s, t.V.L); | |
case 'enum': | |
return this.scalars(Object.values(e), W.INT32, s); | |
case 'message': | |
return this.messages(Object.values(e), t.V.T(), n, s) | |
} | |
break | |
} | |
return !0 | |
} | |
message(e, t, n, s) { | |
return n ? t.isAssignable(e, s) : t.is(e, s) | |
} | |
messages(e, t, n, s) { | |
if (!Array.isArray(e)) return !1; | |
if (s < 2) return !0; | |
if (n) { | |
for (let r = 0; r < e.length && r < s; r++) if (!t.isAssignable(e[r], s - 1)) return !1 | |
} else for (let r = 0; r < e.length && r < s; r++) if (!t.is(e[r], s - 1)) return !1; | |
return !0 | |
} | |
scalar(e, t, n) { | |
let s = typeof e; | |
switch (t) { | |
case W.UINT64: | |
case W.FIXED64: | |
case W.INT64: | |
case W.SFIXED64: | |
case W.SINT64: | |
switch (n) { | |
case Wt.BIGINT: | |
return s == 'bigint'; | |
case Wt.NUMBER: | |
return s == 'number' && | |
!isNaN(e); | |
default: | |
return s == 'string' | |
} | |
case W.BOOL: | |
return s == 'boolean'; | |
case W.STRING: | |
return s == 'string'; | |
case W.BYTES: | |
return e instanceof Uint8Array; | |
case W.DOUBLE: | |
case W.FLOAT: | |
return s == 'number' && | |
!isNaN(e); | |
default: | |
return s == 'number' && | |
Number.isInteger(e) | |
} | |
} | |
scalars(e, t, n, s) { | |
if (!Array.isArray(e)) return !1; | |
if (n < 2) return !0; | |
if (Array.isArray(e)) { | |
for (let r = 0; r < e.length && r < n; r++) if (!this.scalar(e[r], t, s)) return !1 | |
} | |
return !0 | |
} | |
mapKeys(e, t, n) { | |
let s = Object.keys(e); | |
switch (t) { | |
case W.INT32: | |
case W.FIXED32: | |
case W.SFIXED32: | |
case W.SINT32: | |
case W.UINT32: | |
return this.scalars(s.slice(0, n).map(r => parseInt(r)), t, n); | |
case W.BOOL: | |
return this.scalars(s.slice(0, n).map(r => r == 'true' ? !0 : r == 'false' ? !1 : r), t, n); | |
default: | |
return this.scalars(s, t, n, Wt.STRING) | |
} | |
} | |
} | |
function Jt(i, e) { | |
switch (e) { | |
case Wt.BIGINT: | |
return i.toBigInt(); | |
case Wt.NUMBER: | |
return i.toNumber(); | |
default: | |
return i.toString() | |
} | |
} | |
class tv { | |
constructor(e) { | |
this.info = e | |
} | |
prepare() { | |
var e; | |
if (this.fMap === void 0) { | |
this.fMap = {}; | |
const t = (e = this.info.fields) !== null && | |
e !== void 0 ? e : []; | |
for (const n of t) this.fMap[n.name] = n, | |
this.fMap[n.jsonName] = n, | |
this.fMap[n.localName] = n | |
} | |
} | |
assert(e, t, n) { | |
if (!e) { | |
let s = ou(n); | |
throw (s == 'number' || s == 'boolean') && | |
(s = n.toString()), | |
new Error(`Cannot parse JSON ${ s } for ${ this.info.typeName }#${ t }`) | |
} | |
} | |
read(e, t, n) { | |
this.prepare(); | |
const s = []; | |
for (const [r, | |
a]of Object.entries(e)) { | |
const l = this.fMap[r]; | |
if (!l) { | |
if (!n.ignoreUnknownFields) throw new Error( | |
`Found unknown field while reading ${ this.info.typeName } from JSON format. JSON key: ${ r }` | |
); | |
continue | |
} | |
const o = l.localName; | |
let u; | |
if (l.oneof) { | |
if ( | |
a === null && | |
(l.kind !== 'enum' || l.T() [0] !== 'google.protobuf.NullValue') | |
) continue; | |
if (s.includes(l.oneof)) throw new Error( | |
`Multiple members of the oneof group "${ l.oneof }" of ${ this.info.typeName } are present in JSON.` | |
); | |
s.push(l.oneof), | |
u = t[l.oneof] = { | |
oneofKind: o | |
} | |
} else u = t; | |
if (l.kind == 'map') { | |
if (a === null) continue; | |
this.assert(Ry(a), l.name, a); | |
const c = u[o]; | |
for (const [h, | |
d]of Object.entries(a)) { | |
this.assert(d !== null, l.name + ' map value', null); | |
let f; | |
switch (l.V.kind) { | |
case 'message': | |
f = l.V.T().internalJsonRead(d, n); | |
break; | |
case 'enum': | |
if (f = this.enum(l.V.T(), d, l.name, n.ignoreUnknownFields), f === !1) continue; | |
break; | |
case 'scalar': | |
f = this.scalar(d, l.V.T, l.V.L, l.name); | |
break | |
} | |
this.assert(f !== void 0, l.name + ' map value', d); | |
let p = h; | |
l.K == W.BOOL && | |
(p = p == 'true' ? !0 : p == 'false' ? !1 : p), | |
p = this.scalar(p, l.K, Wt.STRING, l.name).toString(), | |
c[p] = f | |
} | |
} else if (l.repeat) { | |
if (a === null) continue; | |
this.assert(Array.isArray(a), l.name, a); | |
const c = u[o]; | |
for (const h of a) { | |
this.assert(h !== null, l.name, null); | |
let d; | |
switch (l.kind) { | |
case 'message': | |
d = l.T().internalJsonRead(h, n); | |
break; | |
case 'enum': | |
if (d = this.enum(l.T(), h, l.name, n.ignoreUnknownFields), d === !1) continue; | |
break; | |
case 'scalar': | |
d = this.scalar(h, l.T, l.L, l.name); | |
break | |
} | |
this.assert(d !== void 0, l.name, a), | |
c.push(d) | |
} | |
} else switch (l.kind) { | |
case 'message': | |
if (a === null && l.T().typeName != 'google.protobuf.Value') { | |
this.assert(l.oneof === void 0, l.name + ' (oneof member)', null); | |
continue | |
} | |
u[o] = l.T().internalJsonRead(a, n, u[o]); | |
break; | |
case 'enum': | |
let c = this.enum(l.T(), a, l.name, n.ignoreUnknownFields); | |
if (c === !1) continue; | |
u[o] = c; | |
break; | |
case 'scalar': | |
u[o] = this.scalar(a, l.T, l.L, l.name); | |
break | |
} | |
} | |
} | |
enum(e, t, n, s) { | |
if ( | |
e[0] == 'google.protobuf.NullValue' && | |
Se( | |
t === null || | |
t === 'NULL_VALUE', | |
`Unable to parse field ${ this.info.typeName }#${ n }, enum ${ e[0] } only accepts null.` | |
), | |
t === null | |
) return 0; | |
switch (typeof t) { | |
case 'number': | |
return Se( | |
Number.isInteger(t), | |
`Unable to parse field ${ this.info.typeName }#${ n }, enum can only be integral number, got ${ t }.` | |
), | |
t; | |
case 'string': | |
let r = t; | |
e[2] && | |
t.substring(0, e[2].length) === e[2] && | |
(r = t.substring(e[2].length)); | |
let a = e[1][r]; | |
return typeof a > 'u' && | |
s ? !1 : ( | |
Se( | |
typeof a == 'number', | |
`Unable to parse field ${ this.info.typeName }#${ n }, enum ${ e[0] } has no value for "${ t }".` | |
), | |
a | |
) | |
} | |
Se( | |
!1, | |
`Unable to parse field ${ this.info.typeName }#${ n }, cannot parse enum value from ${ typeof t }".` | |
) | |
} | |
scalar(e, t, n, s) { | |
let r; | |
try { | |
switch (t) { | |
case W.DOUBLE: | |
case W.FLOAT: | |
if (e === null) return 0; | |
if (e === 'NaN') return Number.NaN; | |
if (e === 'Infinity') return Number.POSITIVE_INFINITY; | |
if (e === '-Infinity') return Number.NEGATIVE_INFINITY; | |
if (e === '') { | |
r = 'empty string'; | |
break | |
} | |
if (typeof e == 'string' && e.trim().length !== e.length) { | |
r = 'extra whitespace'; | |
break | |
} | |
if (typeof e != 'string' && typeof e != 'number') break; | |
let a = Number(e); | |
if (Number.isNaN(a)) { | |
r = 'not a number'; | |
break | |
} | |
if (!Number.isFinite(a)) { | |
r = 'too large or small'; | |
break | |
} | |
return t == W.FLOAT && | |
uu(a), | |
a; | |
case W.INT32: | |
case W.FIXED32: | |
case W.SFIXED32: | |
case W.SINT32: | |
case W.UINT32: | |
if (e === null) return 0; | |
let l; | |
if ( | |
typeof e == 'number' ? l = e : e === '' ? r = 'empty string' : typeof e == 'string' && | |
(e.trim().length !== e.length ? r = 'extra whitespace' : l = Number(e)), | |
l === void 0 | |
) break; | |
return t == W.UINT32 ? Ur(l) : ms(l), | |
l; | |
case W.INT64: | |
case W.SFIXED64: | |
case W.SINT64: | |
if (e === null) return Jt(qe.ZERO, n); | |
if (typeof e != 'number' && typeof e != 'string') break; | |
return Jt(qe.from(e), n); | |
case W.FIXED64: | |
case W.UINT64: | |
if (e === null) return Jt(gt.ZERO, n); | |
if (typeof e != 'number' && typeof e != 'string') break; | |
return Jt(gt.from(e), n); | |
case W.BOOL: | |
if (e === null) return !1; | |
if (typeof e != 'boolean') break; | |
return e; | |
case W.STRING: | |
if (e === null) return ''; | |
if (typeof e != 'string') { | |
r = 'extra whitespace'; | |
break | |
} | |
try { | |
encodeURIComponent(e) | |
} catch (o) { | |
o = 'invalid UTF8'; | |
break | |
} | |
return e; | |
case W.BYTES: | |
if (e === null || e === '') return new Uint8Array(0); | |
if (typeof e != 'string') break; | |
return qf(e) | |
} | |
} catch (a) { | |
r = a.message | |
} | |
this.assert(!1, s + (r ? ' - ' + r : ''), e) | |
} | |
} | |
class iv { | |
constructor(e) { | |
var t; | |
this.fields = (t = e.fields) !== null && | |
t !== void 0 ? t : [] | |
} | |
write(e, t) { | |
const n = {}, | |
s = e; | |
for (const r of this.fields) { | |
if (!r.oneof) { | |
let u = this.field(r, s[r.localName], t); | |
u !== void 0 && | |
(n[t.useProtoFieldName ? r.name : r.jsonName] = u); | |
continue | |
} | |
const a = s[r.oneof]; | |
if (a.oneofKind !== r.localName) continue; | |
const l = r.kind == 'scalar' || | |
r.kind == 'enum' ? Object.assign(Object.assign({ | |
}, t), { | |
emitDefaultValues: !0 | |
}) : t; | |
let o = this.field(r, a[r.localName], l); | |
Se(o !== void 0), | |
n[t.useProtoFieldName ? r.name : r.jsonName] = o | |
} | |
return n | |
} | |
field(e, t, n) { | |
let s; | |
if (e.kind == 'map') { | |
Se(typeof t == 'object' && t !== null); | |
const r = {}; | |
switch (e.V.kind) { | |
case 'scalar': | |
for (const [o, | |
u]of Object.entries(t)) { | |
const c = this.scalar(e.V.T, u, e.name, !1, !0); | |
Se(c !== void 0), | |
r[o.toString()] = c | |
} | |
break; | |
case 'message': | |
const a = e.V.T(); | |
for (const [o, | |
u]of Object.entries(t)) { | |
const c = this.message(a, u, e.name, n); | |
Se(c !== void 0), | |
r[o.toString()] = c | |
} | |
break; | |
case 'enum': | |
const l = e.V.T(); | |
for (const [o, | |
u]of Object.entries(t)) { | |
Se(u === void 0 || typeof u == 'number'); | |
const c = this.enum(l, u, e.name, !1, !0, n.enumAsInteger); | |
Se(c !== void 0), | |
r[o.toString()] = c | |
} | |
break | |
}(n.emitDefaultValues || Object.keys(r).length > 0) && | |
(s = r) | |
} else if (e.repeat) { | |
Se(Array.isArray(t)); | |
const r = []; | |
switch (e.kind) { | |
case 'scalar': | |
for (let o = 0; o < t.length; o++) { | |
const u = this.scalar(e.T, t[o], e.name, e.opt, !0); | |
Se(u !== void 0), | |
r.push(u) | |
} | |
break; | |
case 'enum': | |
const a = e.T(); | |
for (let o = 0; o < t.length; o++) { | |
Se(t[o] === void 0 || typeof t[o] == 'number'); | |
const u = this.enum(a, t[o], e.name, e.opt, !0, n.enumAsInteger); | |
Se(u !== void 0), | |
r.push(u) | |
} | |
break; | |
case 'message': | |
const l = e.T(); | |
for (let o = 0; o < t.length; o++) { | |
const u = this.message(l, t[o], e.name, n); | |
Se(u !== void 0), | |
r.push(u) | |
} | |
break | |
}(n.emitDefaultValues || r.length > 0 || n.emitDefaultValues) && | |
(s = r) | |
} else switch (e.kind) { | |
case 'scalar': | |
s = this.scalar(e.T, t, e.name, e.opt, n.emitDefaultValues); | |
break; | |
case 'enum': | |
s = this.enum(e.T(), t, e.name, e.opt, n.emitDefaultValues, n.enumAsInteger); | |
break; | |
case 'message': | |
s = this.message(e.T(), t, e.name, n); | |
break | |
} | |
return s | |
} | |
enum(e, t, n, s, r, a) { | |
if (e[0] == 'google.protobuf.NullValue') return !r && | |
!s ? void 0 : null; | |
if (t === void 0) { | |
Se(s); | |
return | |
} | |
if (!(t === 0 && !r && !s)) return Se(typeof t == 'number'), | |
Se(Number.isInteger(t)), | |
a || | |
!e[1].hasOwnProperty(t) ? t : e[2] ? e[2] + e[1][t] : e[1][t] | |
} | |
message(e, t, n, s) { | |
return t === void 0 ? s.emitDefaultValues ? null : void 0 : e.internalJsonWrite(t, s) | |
} | |
scalar(e, t, n, s, r) { | |
if (t === void 0) { | |
Se(s); | |
return | |
} | |
const a = r || | |
s; | |
switch (e) { | |
case W.INT32: | |
case W.SFIXED32: | |
case W.SINT32: | |
return t === 0 ? a ? 0 : void 0 : (ms(t), t); | |
case W.FIXED32: | |
case W.UINT32: | |
return t === 0 ? a ? 0 : void 0 : (Ur(t), t); | |
case W.FLOAT: | |
uu(t); | |
case W.DOUBLE: | |
return t === 0 ? a ? 0 : void 0 : ( | |
Se(typeof t == 'number'), | |
Number.isNaN(t) ? 'NaN' : t === Number.POSITIVE_INFINITY ? 'Infinity' : t === Number.NEGATIVE_INFINITY ? '-Infinity' : t | |
); | |
case W.STRING: | |
return t === '' ? a ? '' : void 0 : (Se(typeof t == 'string'), t); | |
case W.BOOL: | |
return t === !1 ? a ? !1 : void 0 : (Se(typeof t == 'boolean'), t); | |
case W.UINT64: | |
case W.FIXED64: | |
Se(typeof t == 'number' || typeof t == 'string' || typeof t == 'bigint'); | |
let l = gt.from(t); | |
return l.isZero() && | |
!a ? void 0 : l.toString(); | |
case W.INT64: | |
case W.SFIXED64: | |
case W.SINT64: | |
Se(typeof t == 'number' || typeof t == 'string' || typeof t == 'bigint'); | |
let o = qe.from(t); | |
return o.isZero() && | |
!a ? void 0 : o.toString(); | |
case W.BYTES: | |
return Se(t instanceof Uint8Array), | |
t.byteLength ? Gf(t) : a ? '' : void 0 | |
} | |
} | |
} | |
function lo(i, e = Wt.STRING) { | |
switch (i) { | |
case W.BOOL: | |
return !1; | |
case W.UINT64: | |
case W.FIXED64: | |
return Jt(gt.ZERO, e); | |
case W.INT64: | |
case W.SFIXED64: | |
case W.SINT64: | |
return Jt(qe.ZERO, e); | |
case W.DOUBLE: | |
case W.FLOAT: | |
return 0; | |
case W.BYTES: | |
return new Uint8Array(0); | |
case W.STRING: | |
return ''; | |
default: | |
return 0 | |
} | |
} | |
class nv { | |
constructor(e) { | |
this.info = e | |
} | |
prepare() { | |
var e; | |
if (!this.fieldNoToField) { | |
const t = (e = this.info.fields) !== null && | |
e !== void 0 ? e : []; | |
this.fieldNoToField = new Map(t.map(n => [n.no, | |
n])) | |
} | |
} | |
read(e, t, n, s) { | |
this.prepare(); | |
const r = s === void 0 ? e.len : e.pos + s; | |
for (; e.pos < r; ) { | |
const [a, | |
l] = e.tag(), | |
o = this.fieldNoToField.get(a); | |
if (!o) { | |
let d = n.readUnknownField; | |
if (d == 'throw') throw new Error( | |
`Unknown field ${ a } (wire type ${ l }) for ${ this.info.typeName }` | |
); | |
let f = e.skip(l); | |
d !== !1 && | |
(d === !0 ? P.onRead : d) (this.info.typeName, t, a, l, f); | |
continue | |
} | |
let u = t, | |
c = o.repeat, | |
h = o.localName; | |
switch ( | |
o.oneof && | |
(u = u[o.oneof], u.oneofKind !== h && (u = t[o.oneof] = { | |
oneofKind: h | |
})), | |
o.kind | |
) { | |
case 'scalar': | |
case 'enum': | |
let d = o.kind == 'enum' ? W.INT32 : o.T, | |
f = o.kind == 'scalar' ? o.L : void 0; | |
if (c) { | |
let w = u[h]; | |
if (l == v.LengthDelimited && d != W.STRING && d != W.BYTES) { | |
let y = e.uint32() + e.pos; | |
for (; e.pos < y; ) w.push(this.scalar(e, d, f)) | |
} else w.push(this.scalar(e, d, f)) | |
} else u[h] = this.scalar(e, d, f); | |
break; | |
case 'message': | |
if (c) { | |
let w = u[h], | |
y = o.T().internalBinaryRead(e, e.uint32(), n); | |
w.push(y) | |
} else u[h] = o.T().internalBinaryRead(e, e.uint32(), n, u[h]); | |
break; | |
case 'map': | |
let[p, | |
g] = this.mapEntry(o, e, n); | |
u[h][p] = g; | |
break | |
} | |
} | |
} | |
mapEntry(e, t, n) { | |
let s = t.uint32(), | |
r = t.pos + s, | |
a, | |
l; | |
for (; t.pos < r; ) { | |
let[o, | |
u] = t.tag(); | |
switch (o) { | |
case 1: | |
e.K == W.BOOL ? a = t.bool().toString() : a = this.scalar(t, e.K, Wt.STRING); | |
break; | |
case 2: | |
switch (e.V.kind) { | |
case 'scalar': | |
l = this.scalar(t, e.V.T, e.V.L); | |
break; | |
case 'enum': | |
l = t.int32(); | |
break; | |
case 'message': | |
l = e.V.T().internalBinaryRead(t, t.uint32(), n); | |
break | |
} | |
break; | |
default: | |
throw new Error( | |
`Unknown field ${ o } (wire type ${ u }) in map entry for ${ this.info.typeName }#${ e.name }` | |
) | |
} | |
} | |
if (a === void 0) { | |
let o = lo(e.K); | |
a = e.K == W.BOOL ? o.toString() : o | |
} | |
if (l === void 0) switch (e.V.kind) { | |
case 'scalar': | |
l = lo(e.V.T, e.V.L); | |
break; | |
case 'enum': | |
l = 0; | |
break; | |
case 'message': | |
l = e.V.T().create(); | |
break | |
} | |
return [a, | |
l] | |
} | |
scalar(e, t, n) { | |
switch (t) { | |
case W.INT32: | |
return e.int32(); | |
case W.STRING: | |
return e.string(); | |
case W.BOOL: | |
return e.bool(); | |
case W.DOUBLE: | |
return e.double(); | |
case W.FLOAT: | |
return e.float(); | |
case W.INT64: | |
return Jt(e.int64(), n); | |
case W.UINT64: | |
return Jt(e.uint64(), n); | |
case W.FIXED64: | |
return Jt(e.fixed64(), n); | |
case W.FIXED32: | |
return e.fixed32(); | |
case W.BYTES: | |
return e.bytes(); | |
case W.UINT32: | |
return e.uint32(); | |
case W.SFIXED32: | |
return e.sfixed32(); | |
case W.SFIXED64: | |
return Jt(e.sfixed64(), n); | |
case W.SINT32: | |
return e.sint32(); | |
case W.SINT64: | |
return Jt(e.sint64(), n) | |
} | |
} | |
} | |
class sv { | |
constructor(e) { | |
this.info = e | |
} | |
prepare() { | |
if (!this.fields) { | |
const e = this.info.fields ? this.info.fields.concat() : []; | |
this.fields = e.sort((t, n) => t.no - n.no) | |
} | |
} | |
write(e, t, n) { | |
this.prepare(); | |
for (const r of this.fields) { | |
let a, | |
l, | |
o = r.repeat, | |
u = r.localName; | |
if (r.oneof) { | |
const c = e[r.oneof]; | |
if (c.oneofKind !== u) continue; | |
a = c[u], | |
l = !0 | |
} else a = e[u], | |
l = !1; | |
switch (r.kind) { | |
case 'scalar': | |
case 'enum': | |
let c = r.kind == 'enum' ? W.INT32 : r.T; | |
if (o) if (Se(Array.isArray(a)), o == jr.PACKED) this.packed(t, c, r.no, a); | |
else for (const h of a) this.scalar(t, c, r.no, h, !0); | |
else a === void 0 ? Se(r.opt) : this.scalar(t, c, r.no, a, l || r.opt); | |
break; | |
case 'message': | |
if (o) { | |
Se(Array.isArray(a)); | |
for (const h of a) this.message(t, n, r.T(), r.no, h) | |
} else this.message(t, n, r.T(), r.no, a); | |
break; | |
case 'map': | |
Se(typeof a == 'object' && a !== null); | |
for (const [h, | |
d]of Object.entries(a)) this.mapEntry(t, n, r, h, d); | |
break | |
} | |
} | |
let s = n.writeUnknownFields; | |
s !== !1 && | |
(s === !0 ? P.onWrite : s) (this.info.typeName, e, t) | |
} | |
mapEntry(e, t, n, s, r) { | |
e.tag(n.no, v.LengthDelimited), | |
e.fork(); | |
let a = s; | |
switch (n.K) { | |
case W.INT32: | |
case W.FIXED32: | |
case W.UINT32: | |
case W.SFIXED32: | |
case W.SINT32: | |
a = Number.parseInt(s); | |
break; | |
case W.BOOL: | |
Se(s == 'true' || s == 'false'), | |
a = s == 'true'; | |
break | |
} | |
switch (this.scalar(e, n.K, 1, a, !0), n.V.kind) { | |
case 'scalar': | |
this.scalar(e, n.V.T, 2, r, !0); | |
break; | |
case 'enum': | |
this.scalar(e, W.INT32, 2, r, !0); | |
break; | |
case 'message': | |
this.message(e, t, n.V.T(), 2, r); | |
break | |
} | |
e.join() | |
} | |
message(e, t, n, s, r) { | |
r !== void 0 && | |
( | |
n.internalBinaryWrite(r, e.tag(s, v.LengthDelimited).fork(), t), | |
e.join() | |
) | |
} | |
scalar(e, t, n, s, r) { | |
let[a, | |
l, | |
o] = this.scalarInfo(t, s); | |
(!o || r) && | |
(e.tag(n, a), e[l](s)) | |
} | |
packed(e, t, n, s) { | |
if (!s.length) return; | |
Se(t !== W.BYTES && t !== W.STRING), | |
e.tag(n, v.LengthDelimited), | |
e.fork(); | |
let[, | |
r] = this.scalarInfo(t); | |
for (let a = 0; a < s.length; a++) e[r](s[a]); | |
e.join() | |
} | |
scalarInfo(e, t) { | |
let n = v.Varint, | |
s, | |
r = t === void 0, | |
a = t === 0; | |
switch (e) { | |
case W.INT32: | |
s = 'int32'; | |
break; | |
case W.STRING: | |
a = r || | |
!t.length, | |
n = v.LengthDelimited, | |
s = 'string'; | |
break; | |
case W.BOOL: | |
a = t === !1, | |
s = 'bool'; | |
break; | |
case W.UINT32: | |
s = 'uint32'; | |
break; | |
case W.DOUBLE: | |
n = v.Bit64, | |
s = 'double'; | |
break; | |
case W.FLOAT: | |
n = v.Bit32, | |
s = 'float'; | |
break; | |
case W.INT64: | |
a = r || | |
qe.from(t).isZero(), | |
s = 'int64'; | |
break; | |
case W.UINT64: | |
a = r || | |
gt.from(t).isZero(), | |
s = 'uint64'; | |
break; | |
case W.FIXED64: | |
a = r || | |
gt.from(t).isZero(), | |
n = v.Bit64, | |
s = 'fixed64'; | |
break; | |
case W.BYTES: | |
a = r || | |
!t.byteLength, | |
n = v.LengthDelimited, | |
s = 'bytes'; | |
break; | |
case W.FIXED32: | |
n = v.Bit32, | |
s = 'fixed32'; | |
break; | |
case W.SFIXED32: | |
n = v.Bit32, | |
s = 'sfixed32'; | |
break; | |
case W.SFIXED64: | |
a = r || | |
qe.from(t).isZero(), | |
n = v.Bit64, | |
s = 'sfixed64'; | |
break; | |
case W.SINT32: | |
s = 'sint32'; | |
break; | |
case W.SINT64: | |
a = r || | |
qe.from(t).isZero(), | |
s = 'sint64'; | |
break | |
} | |
return [n, | |
s, | |
r || | |
a] | |
} | |
} | |
function rv(i) { | |
const e = i.messagePrototype ? Object.create(i.messagePrototype) : Object.defineProperty({ | |
}, J, { | |
value: i | |
}); | |
for (let t of i.fields) { | |
let n = t.localName; | |
if (!t.opt) if (t.oneof) e[t.oneof] = { | |
oneofKind: void 0 | |
}; | |
else if (t.repeat) e[n] = []; | |
else switch (t.kind) { | |
case 'scalar': | |
e[n] = lo(t.T, t.L); | |
break; | |
case 'enum': | |
e[n] = 0; | |
break; | |
case 'map': | |
e[n] = {}; | |
break | |
} | |
} | |
return e | |
} | |
function X(i, e, t) { | |
let n, | |
s = t, | |
r; | |
for (let a of i.fields) { | |
let l = a.localName; | |
if (a.oneof) { | |
const o = s[a.oneof]; | |
if (o?.oneofKind == null) continue; | |
if (n = o[l], r = e[a.oneof], r.oneofKind = o.oneofKind, n == null) { | |
delete r[l]; | |
continue | |
} | |
} else if (n = s[l], r = e, n == null) continue; | |
switch (a.repeat && (r[l].length = n.length), a.kind) { | |
case 'scalar': | |
case 'enum': | |
if (a.repeat) for (let u = 0; u < n.length; u++) r[l][u] = n[u]; | |
else r[l] = n; | |
break; | |
case 'message': | |
let o = a.T(); | |
if (a.repeat) for (let u = 0; u < n.length; u++) r[l][u] = o.create(n[u]); | |
else r[l] === void 0 ? r[l] = o.create(n) : o.mergePartial(r[l], n); | |
break; | |
case 'map': | |
switch (a.V.kind) { | |
case 'scalar': | |
case 'enum': | |
Object.assign(r[l], n); | |
break; | |
case 'message': | |
let u = a.V.T(); | |
for (let c of Object.keys(n)) r[l][c] = u.create(n[c]); | |
break | |
} | |
break | |
} | |
} | |
} | |
function av(i, e, t) { | |
if (e === t) return !0; | |
if (!e || !t) return !1; | |
for (let n of i.fields) { | |
let s = n.localName, | |
r = n.oneof ? e[n.oneof][s] : e[s], | |
a = n.oneof ? t[n.oneof][s] : t[s]; | |
switch (n.kind) { | |
case 'enum': | |
case 'scalar': | |
let l = n.kind == 'enum' ? W.INT32 : n.T; | |
if (!(n.repeat ? Pc(l, r, a) : Qf(l, r, a))) return !1; | |
break; | |
case 'map': | |
if ( | |
!( | |
n.V.kind == 'message' ? Ic(n.V.T(), rr(r), rr(a)) : Pc(n.V.kind == 'enum' ? W.INT32 : n.V.T, rr(r), rr(a)) | |
) | |
) return !1; | |
break; | |
case 'message': | |
let o = n.T(); | |
if (!(n.repeat ? Ic(o, r, a) : o.equals(r, a))) return !1; | |
break | |
} | |
} | |
return !0 | |
} | |
const rr = Object.values; | |
function Qf(i, e, t) { | |
if (e === t) return !0; | |
if (i !== W.BYTES) return !1; | |
let n = e, | |
s = t; | |
if (n.length !== s.length) return !1; | |
for (let r = 0; r < n.length; r++) if (n[r] != s[r]) return !1; | |
return !0 | |
} | |
function Pc(i, e, t) { | |
if (e.length !== t.length) return !1; | |
for (let n = 0; n < e.length; n++) if (!Qf(i, e[n], t[n])) return !1; | |
return !0 | |
} | |
function Ic(i, e, t) { | |
if (e.length !== t.length) return !1; | |
for (let n = 0; n < e.length; n++) if (!i.equals(e[n], t[n])) return !1; | |
return !0 | |
} | |
const lv = Object.getOwnPropertyDescriptors(Object.getPrototypeOf({ | |
})); | |
class Z { | |
constructor(e, t, n) { | |
this.defaultCheckDepth = 16, | |
this.typeName = e, | |
this.fields = t.map(Qy), | |
this.options = n ?? { | |
}, | |
this.messagePrototype = Object.create(null, Object.assign(Object.assign({ | |
}, lv), { | |
[ | |
J | |
]: { | |
value: this | |
} | |
})), | |
this.refTypeCheck = new ev(this), | |
this.refJsonReader = new tv(this), | |
this.refJsonWriter = new iv(this), | |
this.refBinReader = new nv(this), | |
this.refBinWriter = new sv(this) | |
} | |
create(e) { | |
let t = rv(this); | |
return e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
clone(e) { | |
let t = this.create(); | |
return X(this, t, e), | |
t | |
} | |
equals(e, t) { | |
return av(this, e, t) | |
} | |
is(e, t = this.defaultCheckDepth) { | |
return this.refTypeCheck.is(e, t, !1) | |
} | |
isAssignable(e, t = this.defaultCheckDepth) { | |
return this.refTypeCheck.is(e, t, !0) | |
} | |
mergePartial(e, t) { | |
X(this, e, t) | |
} | |
fromBinary(e, t) { | |
let n = Ay(t); | |
return this.internalBinaryRead(n.readerFactory(e), e.byteLength, n) | |
} | |
fromJson(e, t) { | |
return this.internalJsonRead(e, Xy(t)) | |
} | |
fromJsonString(e, t) { | |
let n = JSON.parse(e); | |
return this.fromJson(n, t) | |
} | |
toJson(e, t) { | |
return this.internalJsonWrite(e, Jy(t)) | |
} | |
toJsonString(e, t) { | |
var n; | |
let s = this.toJson(e, t); | |
return JSON.stringify(s, null, (n = t?.prettySpaces) !== null && n !== void 0 ? n : 0) | |
} | |
toBinary(e, t) { | |
let n = Gy(t); | |
return this.internalBinaryWrite(e, n.writerFactory(), n).finish() | |
} | |
internalJsonRead(e, t, n) { | |
if (e !== null && typeof e == 'object' && !Array.isArray(e)) { | |
let s = n ?? this.create(); | |
return this.refJsonReader.read(e, s, t), | |
s | |
} | |
throw new Error( | |
`Unable to parse message ${ this.typeName } from JSON ${ ou(e) }.` | |
) | |
} | |
internalJsonWrite(e, t) { | |
return this.refJsonWriter.write(e, t) | |
} | |
internalBinaryWrite(e, t, n) { | |
return this.refBinWriter.write(e, t, n), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(); | |
return this.refBinReader.read(e, r, n, t), | |
r | |
} | |
} | |
function ov(i, e) { | |
var t, | |
n, | |
s; | |
let r = i; | |
return r.service = e, | |
r.localName = (t = r.localName) !== null && | |
t !== void 0 ? t : ao(r.name), | |
r.serverStreaming = !!r.serverStreaming, | |
r.clientStreaming = !!r.clientStreaming, | |
r.options = (n = r.options) !== null && | |
n !== void 0 ? n : { | |
}, | |
r.idempotency = (s = r.idempotency) !== null && | |
s !== void 0 ? s : void 0, | |
r | |
} | |
class Zf { | |
constructor(e, t, n) { | |
this.typeName = e, | |
this.methods = t.map(s => ov(s, this)), | |
this.options = n ?? { | |
} | |
} | |
} | |
class Fe extends Error { | |
constructor(e, t = 'UNKNOWN', n) { | |
super (e), | |
this.name = 'RpcError', | |
Object.setPrototypeOf(this, new.target.prototype), | |
this.code = t, | |
this.meta = n ?? { | |
} | |
} | |
toString() { | |
const e = [ | |
this.name + ': ' + this.message | |
]; | |
this.code && | |
(e.push(''), e.push('Code: ' + this.code)), | |
this.serviceName && | |
this.methodName && | |
e.push('Method: ' + this.serviceName + '/' + this.methodName); | |
let t = Object.entries(this.meta); | |
if (t.length) { | |
e.push(''), | |
e.push('Meta:'); | |
for (let[n, | |
s]of t) e.push(` ${ n }: ${ s }`) | |
} | |
return e.join(` | |
`) | |
} | |
} | |
function uv(i, e) { | |
if (!e) return i; | |
let t = {}; | |
ar(i, t), | |
ar(e, t); | |
for (let n of Object.keys(e)) { | |
let s = e[n]; | |
switch (n) { | |
case 'jsonOptions': | |
t.jsonOptions = Yy(i.jsonOptions, t.jsonOptions); | |
break; | |
case 'binaryOptions': | |
t.binaryOptions = By(i.binaryOptions, t.binaryOptions); | |
break; | |
case 'meta': | |
t.meta = {}, | |
ar(i.meta, t.meta), | |
ar(e.meta, t.meta); | |
break; | |
case 'interceptors': | |
t.interceptors = i.interceptors ? i.interceptors.concat(s) : s.concat(); | |
break | |
} | |
} | |
return t | |
} | |
function ar(i, e) { | |
if (!i) return; | |
let t = e; | |
for (let[n, | |
s]of Object.entries(i)) s instanceof Date ? t[n] = new Date(s.getTime()) : Array.isArray(s) ? t[n] = s.concat() : t[n] = s | |
} | |
var Dt; | |
( | |
function (i) { | |
i[i.PENDING = 0] = 'PENDING', | |
i[i.REJECTED = 1] = 'REJECTED', | |
i[i.RESOLVED = 2] = 'RESOLVED' | |
} | |
) (Dt || (Dt = {})); | |
class Ri { | |
constructor(e = !0) { | |
this._state = Dt.PENDING, | |
this._promise = new Promise((t, n) => { | |
this._resolve = t, | |
this._reject = n | |
}), | |
e && | |
this._promise.catch(t => { | |
}) | |
} | |
get state() { | |
return this._state | |
} | |
get promise() { | |
return this._promise | |
} | |
resolve(e) { | |
if (this.state !== Dt.PENDING) throw new Error(`cannot resolve ${ Dt[this.state].toLowerCase() }`); | |
this._resolve(e), | |
this._state = Dt.RESOLVED | |
} | |
reject(e) { | |
if (this.state !== Dt.PENDING) throw new Error(`cannot reject ${ Dt[this.state].toLowerCase() }`); | |
this._reject(e), | |
this._state = Dt.REJECTED | |
} | |
resolvePending(e) { | |
this._state === Dt.PENDING && | |
this.resolve(e) | |
} | |
rejectPending(e) { | |
this._state === Dt.PENDING && | |
this.reject(e) | |
} | |
} | |
class cv { | |
constructor() { | |
this._lis = { | |
nxt: [], | |
msg: [], | |
err: [], | |
cmp: [] | |
}, | |
this._closed = !1 | |
} | |
onNext(e) { | |
return this.addLis(e, this._lis.nxt) | |
} | |
onMessage(e) { | |
return this.addLis(e, this._lis.msg) | |
} | |
onError(e) { | |
return this.addLis(e, this._lis.err) | |
} | |
onComplete(e) { | |
return this.addLis(e, this._lis.cmp) | |
} | |
addLis(e, t) { | |
return t.push(e), | |
() => { | |
let n = t.indexOf(e); | |
n >= 0 && | |
t.splice(n, 1) | |
} | |
} | |
clearLis() { | |
for (let e of Object.values(this._lis)) e.splice(0, e.length) | |
} | |
get closed() { | |
return this._closed !== !1 | |
} | |
notifyNext(e, t, n) { | |
Se((e ? 1 : 0) + (t ? 1 : 0) + (n ? 1 : 0) <= 1, 'only one emission at a time'), | |
e && | |
this.notifyMessage(e), | |
t && | |
this.notifyError(t), | |
n && | |
this.notifyComplete() | |
} | |
notifyMessage(e) { | |
Se(!this.closed, 'stream is closed'), | |
this.pushIt({ | |
value: e, | |
done: !1 | |
}), | |
this._lis.msg.forEach(t => t(e)), | |
this._lis.nxt.forEach(t => t(e, void 0, !1)) | |
} | |
notifyError(e) { | |
Se(!this.closed, 'stream is closed'), | |
this._closed = e, | |
this.pushIt(e), | |
this._lis.err.forEach(t => t(e)), | |
this._lis.nxt.forEach(t => t(void 0, e, !1)), | |
this.clearLis() | |
} | |
notifyComplete() { | |
Se(!this.closed, 'stream is closed'), | |
this._closed = !0, | |
this.pushIt({ | |
value: null, | |
done: !0 | |
}), | |
this._lis.cmp.forEach(e => e()), | |
this._lis.nxt.forEach(e => e(void 0, void 0, !0)), | |
this.clearLis() | |
} | |
[ | |
Symbol.asyncIterator | |
]() { | |
return this._itState || | |
(this._itState = { | |
q: [] | |
}), | |
this._closed === !0 ? this.pushIt({ | |
value: null, | |
done: !0 | |
}) : this._closed !== !1 && | |
this.pushIt(this._closed), | |
{ | |
next: () => { | |
let e = this._itState; | |
Se(e, 'bad state'), | |
Se(!e.p, 'iterator contract broken'); | |
let t = e.q.shift(); | |
return t ? 'value' in t ? Promise.resolve(t) : Promise.reject(t) : (e.p = new Ri, e.p.promise) | |
} | |
} | |
} | |
pushIt(e) { | |
let t = this._itState; | |
if (!!t) if (t.p) { | |
const n = t.p; | |
Se(n.state == Dt.PENDING, 'iterator contract broken'), | |
'value' in e ? n.resolve(e) : n.reject(e), | |
delete t.p | |
} else t.q.push(e) | |
} | |
} | |
var hv = globalThis && | |
globalThis.__awaiter || | |
function (i, e, t, n) { | |
function s(r) { | |
return r instanceof t ? r : new t(function (a) { | |
a(r) | |
}) | |
} | |
return new (t || (t = Promise)) ( | |
function (r, a) { | |
function l(c) { | |
try { | |
u(n.next(c)) | |
} catch (h) { | |
a(h) | |
} | |
} | |
function o(c) { | |
try { | |
u(n.throw(c)) | |
} catch (h) { | |
a(h) | |
} | |
} | |
function u(c) { | |
c.done ? r(c.value) : s(c.value).then(l, o) | |
} | |
u((n = n.apply(i, e || [])).next()) | |
} | |
) | |
}; | |
class dv { | |
constructor(e, t, n, s, r, a, l) { | |
this.method = e, | |
this.requestHeaders = t, | |
this.request = n, | |
this.headers = s, | |
this.response = r, | |
this.status = a, | |
this.trailers = l | |
} | |
then(e, t) { | |
return this.promiseFinished().then( | |
n => e ? Promise.resolve(e(n)) : n, | |
n => t ? Promise.resolve(t(n)) : Promise.reject(n) | |
) | |
} | |
promiseFinished() { | |
return hv( | |
this, | |
void 0, | |
void 0, | |
function * () { | |
let[e, | |
t, | |
n, | |
s] = yield Promise.all([this.headers, | |
this.response, | |
this.status, | |
this.trailers]); | |
return { | |
method: this.method, | |
requestHeaders: this.requestHeaders, | |
request: this.request, | |
headers: e, | |
response: t, | |
status: n, | |
trailers: s | |
} | |
} | |
) | |
} | |
} | |
var fv = globalThis && | |
globalThis.__awaiter || | |
function (i, e, t, n) { | |
function s(r) { | |
return r instanceof t ? r : new t(function (a) { | |
a(r) | |
}) | |
} | |
return new (t || (t = Promise)) ( | |
function (r, a) { | |
function l(c) { | |
try { | |
u(n.next(c)) | |
} catch (h) { | |
a(h) | |
} | |
} | |
function o(c) { | |
try { | |
u(n.throw(c)) | |
} catch (h) { | |
a(h) | |
} | |
} | |
function u(c) { | |
c.done ? r(c.value) : s(c.value).then(l, o) | |
} | |
u((n = n.apply(i, e || [])).next()) | |
} | |
) | |
}; | |
class pv { | |
constructor(e, t, n, s, r, a, l) { | |
this.method = e, | |
this.requestHeaders = t, | |
this.request = n, | |
this.headers = s, | |
this.responses = r, | |
this.status = a, | |
this.trailers = l | |
} | |
then(e, t) { | |
return this.promiseFinished().then( | |
n => e ? Promise.resolve(e(n)) : n, | |
n => t ? Promise.resolve(t(n)) : Promise.reject(n) | |
) | |
} | |
promiseFinished() { | |
return fv( | |
this, | |
void 0, | |
void 0, | |
function * () { | |
let[e, | |
t, | |
n] = yield Promise.all([this.headers, | |
this.status, | |
this.trailers]); | |
return { | |
method: this.method, | |
requestHeaders: this.requestHeaders, | |
request: this.request, | |
headers: e, | |
status: t, | |
trailers: n | |
} | |
} | |
) | |
} | |
} | |
function Ge(i, e, t, n, s) { | |
var r, | |
a, | |
l, | |
o; | |
if (i == 'unary') { | |
let u = (c, h, d) => e.unary(c, h, d); | |
for ( | |
const c of ((r = n.interceptors) !== null && r !== void 0 ? r : []).filter(h => h.interceptUnary).reverse() | |
) { | |
const h = u; | |
u = (d, f, p) => c.interceptUnary(h, d, f, p) | |
} | |
return u(t, s, n) | |
} | |
if (i == 'serverStreaming') { | |
let u = (c, h, d) => e.serverStreaming(c, h, d); | |
for ( | |
const c of ((a = n.interceptors) !== null && a !== void 0 ? a : []).filter(h => h.interceptServerStreaming).reverse() | |
) { | |
const h = u; | |
u = (d, f, p) => c.interceptServerStreaming(h, d, f, p) | |
} | |
return u(t, s, n) | |
} | |
if (i == 'clientStreaming') { | |
let u = (c, h) => e.clientStreaming(c, h); | |
for ( | |
const c of ((l = n.interceptors) !== null && l !== void 0 ? l : []).filter(h => h.interceptClientStreaming).reverse() | |
) { | |
const h = u; | |
u = (d, f) => c.interceptClientStreaming(h, d, f) | |
} | |
return u(t, n) | |
} | |
if (i == 'duplex') { | |
let u = (c, h) => e.duplex(c, h); | |
for ( | |
const c of ((o = n.interceptors) !== null && o !== void 0 ? o : []).filter(h => h.interceptDuplex).reverse() | |
) { | |
const h = u; | |
u = (d, f) => c.interceptDuplex(h, d, f) | |
} | |
return u(t, n) | |
} | |
zy(i) | |
} | |
class mv extends Z { | |
constructor() { | |
super ( | |
'google.protobuf.DoubleValue', | |
[ | |
{ | |
no: 1, | |
name: 'value', | |
kind: 'scalar', | |
T: 1 | |
} | |
] | |
) | |
} | |
internalJsonWrite(e, t) { | |
return this.refJsonWriter.scalar(2, e.value, 'value', !1, !0) | |
} | |
internalJsonRead(e, t, n) { | |
return n || | |
(n = this.create()), | |
n.value = this.refJsonReader.scalar(e, 1, void 0, 'value'), | |
n | |
} | |
create(e) { | |
const t = { | |
value: 0 | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.value = e.double(); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.value !== 0 && | |
t.tag(1, v.Bit64).double(e.value); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const wn = new mv; | |
class gv extends Z { | |
constructor() { | |
super ( | |
'google.protobuf.FloatValue', | |
[ | |
{ | |
no: 1, | |
name: 'value', | |
kind: 'scalar', | |
T: 2 | |
} | |
] | |
) | |
} | |
internalJsonWrite(e, t) { | |
return this.refJsonWriter.scalar(1, e.value, 'value', !1, !0) | |
} | |
internalJsonRead(e, t, n) { | |
return n || | |
(n = this.create()), | |
n.value = this.refJsonReader.scalar(e, 1, void 0, 'value'), | |
n | |
} | |
create(e) { | |
const t = { | |
value: 0 | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.value = e.float(); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.value !== 0 && | |
t.tag(1, v.Bit32).float(e.value); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
new gv; | |
class yv extends Z { | |
constructor() { | |
super ( | |
'google.protobuf.Int64Value', | |
[ | |
{ | |
no: 1, | |
name: 'value', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
} | |
] | |
) | |
} | |
internalJsonWrite(e, t) { | |
return this.refJsonWriter.scalar(W.INT64, e.value, 'value', !1, !0) | |
} | |
internalJsonRead(e, t, n) { | |
return n || | |
(n = this.create()), | |
n.value = this.refJsonReader.scalar(e, W.INT64, Wt.NUMBER, 'value'), | |
n | |
} | |
create(e) { | |
const t = { | |
value: 0 | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.value = e.int64().toNumber(); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.value !== 0 && | |
t.tag(1, v.Varint).int64(e.value); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const be = new yv; | |
class vv extends Z { | |
constructor() { | |
super ( | |
'google.protobuf.UInt64Value', | |
[ | |
{ | |
no: 1, | |
name: 'value', | |
kind: 'scalar', | |
T: 4, | |
L: 2 | |
} | |
] | |
) | |
} | |
internalJsonWrite(e, t) { | |
return this.refJsonWriter.scalar(W.UINT64, e.value, 'value', !1, !0) | |
} | |
internalJsonRead(e, t, n) { | |
return n || | |
(n = this.create()), | |
n.value = this.refJsonReader.scalar(e, W.UINT64, Wt.NUMBER, 'value'), | |
n | |
} | |
create(e) { | |
const t = { | |
value: 0 | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.value = e.uint64().toNumber(); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.value !== 0 && | |
t.tag(1, v.Varint).uint64(e.value); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
new vv; | |
class bv extends Z { | |
constructor() { | |
super ( | |
'google.protobuf.Int32Value', | |
[ | |
{ | |
no: 1, | |
name: 'value', | |
kind: 'scalar', | |
T: 5 | |
} | |
] | |
) | |
} | |
internalJsonWrite(e, t) { | |
return this.refJsonWriter.scalar(5, e.value, 'value', !1, !0) | |
} | |
internalJsonRead(e, t, n) { | |
return n || | |
(n = this.create()), | |
n.value = this.refJsonReader.scalar(e, 5, void 0, 'value'), | |
n | |
} | |
create(e) { | |
const t = { | |
value: 0 | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.value = e.int32(); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.value !== 0 && | |
t.tag(1, v.Varint).int32(e.value); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
new bv; | |
class wv extends Z { | |
constructor() { | |
super ( | |
'google.protobuf.UInt32Value', | |
[ | |
{ | |
no: 1, | |
name: 'value', | |
kind: 'scalar', | |
T: 13 | |
} | |
] | |
) | |
} | |
internalJsonWrite(e, t) { | |
return this.refJsonWriter.scalar(13, e.value, 'value', !1, !0) | |
} | |
internalJsonRead(e, t, n) { | |
return n || | |
(n = this.create()), | |
n.value = this.refJsonReader.scalar(e, 13, void 0, 'value'), | |
n | |
} | |
create(e) { | |
const t = { | |
value: 0 | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.value = e.uint32(); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.value !== 0 && | |
t.tag(1, v.Varint).uint32(e.value); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
new wv; | |
class kv extends Z { | |
constructor() { | |
super ( | |
'google.protobuf.BoolValue', | |
[ | |
{ | |
no: 1, | |
name: 'value', | |
kind: 'scalar', | |
T: 8 | |
} | |
] | |
) | |
} | |
internalJsonWrite(e, t) { | |
return e.value | |
} | |
internalJsonRead(e, t, n) { | |
return n || | |
(n = this.create()), | |
n.value = this.refJsonReader.scalar(e, 8, void 0, 'value'), | |
n | |
} | |
create(e) { | |
const t = { | |
value: !1 | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.value = e.bool(); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.value !== !1 && | |
t.tag(1, v.Varint).bool(e.value); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
new kv; | |
class _v extends Z { | |
constructor() { | |
super ( | |
'google.protobuf.StringValue', | |
[ | |
{ | |
no: 1, | |
name: 'value', | |
kind: 'scalar', | |
T: 9 | |
} | |
] | |
) | |
} | |
internalJsonWrite(e, t) { | |
return e.value | |
} | |
internalJsonRead(e, t, n) { | |
return n || | |
(n = this.create()), | |
n.value = this.refJsonReader.scalar(e, 9, void 0, 'value'), | |
n | |
} | |
create(e) { | |
const t = { | |
value: '' | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.value = e.string(); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.value !== '' && | |
t.tag(1, v.LengthDelimited).string(e.value); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const ut = new _v; | |
class xv extends Z { | |
constructor() { | |
super ( | |
'google.protobuf.BytesValue', | |
[ | |
{ | |
no: 1, | |
name: 'value', | |
kind: 'scalar', | |
T: 12 | |
} | |
] | |
) | |
} | |
internalJsonWrite(e, t) { | |
return this.refJsonWriter.scalar(12, e.value, 'value', !1, !0) | |
} | |
internalJsonRead(e, t, n) { | |
return n || | |
(n = this.create()), | |
n.value = this.refJsonReader.scalar(e, 12, void 0, 'value'), | |
n | |
} | |
create(e) { | |
const t = { | |
value: new Uint8Array(0) | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.value = e.bytes(); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.value.length && | |
t.tag(1, v.LengthDelimited).bytes(e.value); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
new xv; | |
var Gt = ( | |
i => ( | |
i[i.Quadratic = 0] = 'Quadratic', | |
i[i.QuadraticV2 = 1] = 'QuadraticV2', | |
i[i.Linear = 2] = 'Linear', | |
i[i.Fixed = 3] = 'Fixed', | |
i | |
) | |
) (Gt || { | |
}), | |
Hr = (i => (i[i.BUY = 0] = 'BUY', i[i.SELL = 1] = 'SELL', i)) (Hr || { | |
}); | |
class Tv extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidToken', | |
[ | |
{ | |
no: 1, | |
name: 'id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 2, | |
name: 'name', | |
kind: 'scalar', | |
T: 9 | |
}, | |
{ | |
no: 3, | |
name: 'index', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 4, | |
name: 'sz_decimals', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 5, | |
name: 'wei_decimals', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 6, | |
name: 'token_id', | |
kind: 'scalar', | |
T: 9 | |
}, | |
{ | |
no: 7, | |
name: 'circulating_supply', | |
kind: 'scalar', | |
T: 1 | |
}, | |
{ | |
no: 8, | |
name: 'deploy_info', | |
kind: 'message', | |
T: () => Ha | |
}, | |
{ | |
no: 9, | |
name: 'geneses', | |
kind: 'message', | |
repeat: 1, | |
T: () => qa | |
}, | |
{ | |
no: 10, | |
name: 'hlq_balance', | |
kind: 'scalar', | |
T: 1 | |
}, | |
{ | |
no: 11, | |
name: 'full_name', | |
kind: 'scalar', | |
T: 9 | |
}, | |
{ | |
no: 12, | |
name: 'statistics', | |
kind: 'message', | |
T: () => ja | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
id: 0, | |
name: '', | |
index: 0, | |
szDecimals: 0, | |
weiDecimals: 0, | |
tokenId: '', | |
circulatingSupply: 0, | |
geneses: [], | |
hlqBalance: 0, | |
fullName: '' | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.id = e.int64().toNumber(); | |
break; | |
case 2: | |
r.name = e.string(); | |
break; | |
case 3: | |
r.index = e.int64().toNumber(); | |
break; | |
case 4: | |
r.szDecimals = e.int64().toNumber(); | |
break; | |
case 5: | |
r.weiDecimals = e.int64().toNumber(); | |
break; | |
case 6: | |
r.tokenId = e.string(); | |
break; | |
case 7: | |
r.circulatingSupply = e.double(); | |
break; | |
case 8: | |
r.deployInfo = Ha.internalBinaryRead(e, e.uint32(), n, r.deployInfo); | |
break; | |
case 9: | |
r.geneses.push(qa.internalBinaryRead(e, e.uint32(), n)); | |
break; | |
case 10: | |
r.hlqBalance = e.double(); | |
break; | |
case 11: | |
r.fullName = e.string(); | |
break; | |
case 12: | |
r.statistics = ja.internalBinaryRead(e, e.uint32(), n, r.statistics); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.id !== 0 && | |
t.tag(1, v.Varint).int64(e.id), | |
e.name !== '' && | |
t.tag(2, v.LengthDelimited).string(e.name), | |
e.index !== 0 && | |
t.tag(3, v.Varint).int64(e.index), | |
e.szDecimals !== 0 && | |
t.tag(4, v.Varint).int64(e.szDecimals), | |
e.weiDecimals !== 0 && | |
t.tag(5, v.Varint).int64(e.weiDecimals), | |
e.tokenId !== '' && | |
t.tag(6, v.LengthDelimited).string(e.tokenId), | |
e.circulatingSupply !== 0 && | |
t.tag(7, v.Bit64).double(e.circulatingSupply), | |
e.deployInfo && | |
Ha.internalBinaryWrite(e.deployInfo, t.tag(8, v.LengthDelimited).fork(), n).join(); | |
for (let r = 0; r < e.geneses.length; r++) qa.internalBinaryWrite(e.geneses[r], t.tag(9, v.LengthDelimited).fork(), n).join(); | |
e.hlqBalance !== 0 && | |
t.tag(10, v.Bit64).double(e.hlqBalance), | |
e.fullName !== '' && | |
t.tag(11, v.LengthDelimited).string(e.fullName), | |
e.statistics && | |
ja.internalBinaryWrite(e.statistics, t.tag(12, v.LengthDelimited).fork(), n).join(); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const lt = new Tv; | |
class Sv extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidTokenHolder', | |
[ | |
{ | |
no: 1, | |
name: 'balance', | |
kind: 'scalar', | |
T: 1 | |
}, | |
{ | |
no: 2, | |
name: 'address', | |
kind: 'scalar', | |
T: 9 | |
}, | |
{ | |
no: 3, | |
name: 'type', | |
kind: 'scalar', | |
T: 9 | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
balance: 0, | |
address: '', | |
type: '' | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.balance = e.double(); | |
break; | |
case 2: | |
r.address = e.string(); | |
break; | |
case 3: | |
r.type = e.string(); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.balance !== 0 && | |
t.tag(1, v.Bit64).double(e.balance), | |
e.address !== '' && | |
t.tag(2, v.LengthDelimited).string(e.address), | |
e.type !== '' && | |
t.tag(3, v.LengthDelimited).string(e.type); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const Ua = new Sv; | |
class Ev extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidTokenHoldersRequest', | |
[ | |
{ | |
no: 1, | |
name: 'token_id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
tokenId: 0 | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.tokenId = e.int64().toNumber(); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.tokenId !== 0 && | |
t.tag(1, v.Varint).int64(e.tokenId); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const Cv = new Ev; | |
class $v extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidTokenHoldersResponse', | |
[ | |
{ | |
no: 1, | |
name: 'holders', | |
kind: 'message', | |
repeat: 1, | |
T: () => Ua | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
holders: [] | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.holders.push(Ua.internalBinaryRead(e, e.uint32(), n)); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
for (let r = 0; r < e.holders.length; r++) Ua.internalBinaryWrite(e.holders[r], t.tag(1, v.LengthDelimited).fork(), n).join(); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const Lv = new $v; | |
class Pv extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidTokenStatistics', | |
[ | |
{ | |
no: 1, | |
name: 'token_id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 2, | |
name: 'holder_count', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 3, | |
name: 'concentration_coefficient', | |
kind: 'scalar', | |
T: 1 | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
tokenId: 0, | |
holderCount: 0, | |
concentrationCoefficient: 0 | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.tokenId = e.int64().toNumber(); | |
break; | |
case 2: | |
r.holderCount = e.int64().toNumber(); | |
break; | |
case 3: | |
r.concentrationCoefficient = e.double(); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.tokenId !== 0 && | |
t.tag(1, v.Varint).int64(e.tokenId), | |
e.holderCount !== 0 && | |
t.tag(2, v.Varint).int64(e.holderCount), | |
e.concentrationCoefficient !== 0 && | |
t.tag(3, v.Bit64).double(e.concentrationCoefficient); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const ja = new Pv; | |
class Iv extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidTokenDeployInfo', | |
[ | |
{ | |
no: 1, | |
name: 'token_id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 2, | |
name: 'height', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 3, | |
name: 'deployer', | |
kind: 'scalar', | |
T: 9 | |
}, | |
{ | |
no: 4, | |
name: 'register_tx', | |
kind: 'scalar', | |
T: 9 | |
}, | |
{ | |
no: 5, | |
name: 'register_spot_tx', | |
kind: 'scalar', | |
T: 9 | |
}, | |
{ | |
no: 6, | |
name: 'genesis_tx', | |
kind: 'scalar', | |
T: 9 | |
}, | |
{ | |
no: 7, | |
name: 'hyperliquidity_tx', | |
kind: 'scalar', | |
T: 9 | |
}, | |
{ | |
no: 8, | |
name: 'hip2_price', | |
kind: 'scalar', | |
T: 1 | |
}, | |
{ | |
no: 9, | |
name: 'hip2_order_count', | |
kind: 'scalar', | |
T: 5 | |
}, | |
{ | |
no: 10, | |
name: 'hip2_order_size', | |
kind: 'scalar', | |
T: 1 | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
tokenId: 0, | |
height: 0, | |
deployer: '', | |
registerTx: '', | |
registerSpotTx: '', | |
genesisTx: '', | |
hyperliquidityTx: '', | |
hip2Price: 0, | |
hip2OrderCount: 0, | |
hip2OrderSize: 0 | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.tokenId = e.int64().toNumber(); | |
break; | |
case 2: | |
r.height = e.int64().toNumber(); | |
break; | |
case 3: | |
r.deployer = e.string(); | |
break; | |
case 4: | |
r.registerTx = e.string(); | |
break; | |
case 5: | |
r.registerSpotTx = e.string(); | |
break; | |
case 6: | |
r.genesisTx = e.string(); | |
break; | |
case 7: | |
r.hyperliquidityTx = e.string(); | |
break; | |
case 8: | |
r.hip2Price = e.double(); | |
break; | |
case 9: | |
r.hip2OrderCount = e.int32(); | |
break; | |
case 10: | |
r.hip2OrderSize = e.double(); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.tokenId !== 0 && | |
t.tag(1, v.Varint).int64(e.tokenId), | |
e.height !== 0 && | |
t.tag(2, v.Varint).int64(e.height), | |
e.deployer !== '' && | |
t.tag(3, v.LengthDelimited).string(e.deployer), | |
e.registerTx !== '' && | |
t.tag(4, v.LengthDelimited).string(e.registerTx), | |
e.registerSpotTx !== '' && | |
t.tag(5, v.LengthDelimited).string(e.registerSpotTx), | |
e.genesisTx !== '' && | |
t.tag(6, v.LengthDelimited).string(e.genesisTx), | |
e.hyperliquidityTx !== '' && | |
t.tag(7, v.LengthDelimited).string(e.hyperliquidityTx), | |
e.hip2Price !== 0 && | |
t.tag(8, v.Bit64).double(e.hip2Price), | |
e.hip2OrderCount !== 0 && | |
t.tag(9, v.Varint).int32(e.hip2OrderCount), | |
e.hip2OrderSize !== 0 && | |
t.tag(10, v.Bit64).double(e.hip2OrderSize); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const Ha = new Iv; | |
class Nv extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidTokenGenesis', | |
[ | |
{ | |
no: 1, | |
name: 'token_id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 2, | |
name: 'target', | |
kind: 'scalar', | |
T: 9 | |
}, | |
{ | |
no: 3, | |
name: 'amount', | |
kind: 'scalar', | |
T: 1 | |
}, | |
{ | |
no: 4, | |
name: 'type', | |
kind: 'scalar', | |
T: 9 | |
}, | |
{ | |
no: 5, | |
name: 'target_token_id', | |
kind: 'message', | |
T: () => be | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
tokenId: 0, | |
target: '', | |
amount: 0, | |
type: '' | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.tokenId = e.int64().toNumber(); | |
break; | |
case 2: | |
r.target = e.string(); | |
break; | |
case 3: | |
r.amount = e.double(); | |
break; | |
case 4: | |
r.type = e.string(); | |
break; | |
case 5: | |
r.targetTokenId = be.internalBinaryRead(e, e.uint32(), n, r.targetTokenId); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.tokenId !== 0 && | |
t.tag(1, v.Varint).int64(e.tokenId), | |
e.target !== '' && | |
t.tag(2, v.LengthDelimited).string(e.target), | |
e.amount !== 0 && | |
t.tag(3, v.Bit64).double(e.amount), | |
e.type !== '' && | |
t.tag(4, v.LengthDelimited).string(e.type), | |
e.targetTokenId && | |
be.internalBinaryWrite(e.targetTokenId, t.tag(5, v.LengthDelimited).fork(), n).join(); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const qa = new Nv; | |
class Mv extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidSpotPair', | |
[ | |
{ | |
no: 1, | |
name: 'id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 2, | |
name: 'name', | |
kind: 'scalar', | |
T: 9 | |
}, | |
{ | |
no: 3, | |
name: 'base_id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 4, | |
name: 'base', | |
kind: 'message', | |
T: () => lt | |
}, | |
{ | |
no: 5, | |
name: 'quote_id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 6, | |
name: 'quote', | |
kind: 'message', | |
T: () => lt | |
}, | |
{ | |
no: 7, | |
name: 'index', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 8, | |
name: 'mid_price', | |
kind: 'scalar', | |
T: 1 | |
}, | |
{ | |
no: 9, | |
name: 'mark_price', | |
kind: 'scalar', | |
T: 1 | |
}, | |
{ | |
no: 10, | |
name: 'daily_ntl_volume', | |
kind: 'scalar', | |
T: 1 | |
}, | |
{ | |
no: 11, | |
name: 'previous_day_px', | |
kind: 'scalar', | |
T: 1 | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
id: 0, | |
name: '', | |
baseId: 0, | |
quoteId: 0, | |
index: 0, | |
midPrice: 0, | |
markPrice: 0, | |
dailyNtlVolume: 0, | |
previousDayPx: 0 | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.id = e.int64().toNumber(); | |
break; | |
case 2: | |
r.name = e.string(); | |
break; | |
case 3: | |
r.baseId = e.int64().toNumber(); | |
break; | |
case 4: | |
r.base = lt.internalBinaryRead(e, e.uint32(), n, r.base); | |
break; | |
case 5: | |
r.quoteId = e.int64().toNumber(); | |
break; | |
case 6: | |
r.quote = lt.internalBinaryRead(e, e.uint32(), n, r.quote); | |
break; | |
case 7: | |
r.index = e.int64().toNumber(); | |
break; | |
case 8: | |
r.midPrice = e.double(); | |
break; | |
case 9: | |
r.markPrice = e.double(); | |
break; | |
case 10: | |
r.dailyNtlVolume = e.double(); | |
break; | |
case 11: | |
r.previousDayPx = e.double(); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.id !== 0 && | |
t.tag(1, v.Varint).int64(e.id), | |
e.name !== '' && | |
t.tag(2, v.LengthDelimited).string(e.name), | |
e.baseId !== 0 && | |
t.tag(3, v.Varint).int64(e.baseId), | |
e.base && | |
lt.internalBinaryWrite(e.base, t.tag(4, v.LengthDelimited).fork(), n).join(), | |
e.quoteId !== 0 && | |
t.tag(5, v.Varint).int64(e.quoteId), | |
e.quote && | |
lt.internalBinaryWrite(e.quote, t.tag(6, v.LengthDelimited).fork(), n).join(), | |
e.index !== 0 && | |
t.tag(7, v.Varint).int64(e.index), | |
e.midPrice !== 0 && | |
t.tag(8, v.Bit64).double(e.midPrice), | |
e.markPrice !== 0 && | |
t.tag(9, v.Bit64).double(e.markPrice), | |
e.dailyNtlVolume !== 0 && | |
t.tag(10, v.Bit64).double(e.dailyNtlVolume), | |
e.previousDayPx !== 0 && | |
t.tag(11, v.Bit64).double(e.previousDayPx); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const Mn = new Mv; | |
class Rv extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidPerpPair', | |
[ | |
{ | |
no: 1, | |
name: 'id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 2, | |
name: 'name', | |
kind: 'scalar', | |
T: 9 | |
}, | |
{ | |
no: 3, | |
name: 'index', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 4, | |
name: 'mid_price', | |
kind: 'scalar', | |
T: 1 | |
}, | |
{ | |
no: 5, | |
name: 'mark_price', | |
kind: 'scalar', | |
T: 1 | |
}, | |
{ | |
no: 6, | |
name: 'daily_ntl_volume', | |
kind: 'scalar', | |
T: 1 | |
}, | |
{ | |
no: 7, | |
name: 'previous_day_px', | |
kind: 'scalar', | |
T: 1 | |
}, | |
{ | |
no: 8, | |
name: 'funding', | |
kind: 'scalar', | |
T: 1 | |
}, | |
{ | |
no: 9, | |
name: 'open_interest', | |
kind: 'scalar', | |
T: 1 | |
}, | |
{ | |
no: 10, | |
name: 'premium', | |
kind: 'scalar', | |
T: 1 | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
id: 0, | |
name: '', | |
index: 0, | |
midPrice: 0, | |
markPrice: 0, | |
dailyNtlVolume: 0, | |
previousDayPx: 0, | |
funding: 0, | |
openInterest: 0, | |
premium: 0 | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.id = e.int64().toNumber(); | |
break; | |
case 2: | |
r.name = e.string(); | |
break; | |
case 3: | |
r.index = e.int64().toNumber(); | |
break; | |
case 4: | |
r.midPrice = e.double(); | |
break; | |
case 5: | |
r.markPrice = e.double(); | |
break; | |
case 6: | |
r.dailyNtlVolume = e.double(); | |
break; | |
case 7: | |
r.previousDayPx = e.double(); | |
break; | |
case 8: | |
r.funding = e.double(); | |
break; | |
case 9: | |
r.openInterest = e.double(); | |
break; | |
case 10: | |
r.premium = e.double(); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.id !== 0 && | |
t.tag(1, v.Varint).int64(e.id), | |
e.name !== '' && | |
t.tag(2, v.LengthDelimited).string(e.name), | |
e.index !== 0 && | |
t.tag(3, v.Varint).int64(e.index), | |
e.midPrice !== 0 && | |
t.tag(4, v.Bit64).double(e.midPrice), | |
e.markPrice !== 0 && | |
t.tag(5, v.Bit64).double(e.markPrice), | |
e.dailyNtlVolume !== 0 && | |
t.tag(6, v.Bit64).double(e.dailyNtlVolume), | |
e.previousDayPx !== 0 && | |
t.tag(7, v.Bit64).double(e.previousDayPx), | |
e.funding !== 0 && | |
t.tag(8, v.Bit64).double(e.funding), | |
e.openInterest !== 0 && | |
t.tag(9, v.Bit64).double(e.openInterest), | |
e.premium !== 0 && | |
t.tag(10, v.Bit64).double(e.premium); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const Ga = new Rv; | |
class Bv extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidWallet', | |
[ | |
{ | |
no: 1, | |
name: 'id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 2, | |
name: 'name', | |
kind: 'scalar', | |
T: 9 | |
}, | |
{ | |
no: 3, | |
name: 'telegram_id', | |
kind: 'message', | |
T: () => be | |
}, | |
{ | |
no: 4, | |
name: 'ethereum_address', | |
kind: 'scalar', | |
T: 9 | |
}, | |
{ | |
no: 5, | |
name: 'points', | |
kind: 'scalar', | |
T: 5 | |
}, | |
{ | |
no: 6, | |
name: 'movements', | |
kind: 'message', | |
repeat: 1, | |
T: () => Rn | |
}, | |
{ | |
no: 7, | |
name: 'spot_balances', | |
kind: 'message', | |
repeat: 1, | |
T: () => Bn | |
}, | |
{ | |
no: 8, | |
name: 'launch_balances', | |
kind: 'message', | |
repeat: 1, | |
T: () => Ka | |
}, | |
{ | |
no: 9, | |
name: 'is_agent', | |
kind: 'scalar', | |
T: 8 | |
}, | |
{ | |
no: 10, | |
name: 'is_read_only', | |
kind: 'scalar', | |
T: 8 | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
id: 0, | |
name: '', | |
ethereumAddress: '', | |
points: 0, | |
movements: [], | |
spotBalances: [], | |
launchBalances: [], | |
isAgent: !1, | |
isReadOnly: !1 | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.id = e.int64().toNumber(); | |
break; | |
case 2: | |
r.name = e.string(); | |
break; | |
case 3: | |
r.telegramId = be.internalBinaryRead(e, e.uint32(), n, r.telegramId); | |
break; | |
case 4: | |
r.ethereumAddress = e.string(); | |
break; | |
case 5: | |
r.points = e.int32(); | |
break; | |
case 6: | |
r.movements.push(Rn.internalBinaryRead(e, e.uint32(), n)); | |
break; | |
case 7: | |
r.spotBalances.push(Bn.internalBinaryRead(e, e.uint32(), n)); | |
break; | |
case 8: | |
r.launchBalances.push(Ka.internalBinaryRead(e, e.uint32(), n)); | |
break; | |
case 9: | |
r.isAgent = e.bool(); | |
break; | |
case 10: | |
r.isReadOnly = e.bool(); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.id !== 0 && | |
t.tag(1, v.Varint).int64(e.id), | |
e.name !== '' && | |
t.tag(2, v.LengthDelimited).string(e.name), | |
e.telegramId && | |
be.internalBinaryWrite(e.telegramId, t.tag(3, v.LengthDelimited).fork(), n).join(), | |
e.ethereumAddress !== '' && | |
t.tag(4, v.LengthDelimited).string(e.ethereumAddress), | |
e.points !== 0 && | |
t.tag(5, v.Varint).int32(e.points); | |
for (let r = 0; r < e.movements.length; r++) Rn.internalBinaryWrite(e.movements[r], t.tag(6, v.LengthDelimited).fork(), n).join(); | |
for (let r = 0; r < e.spotBalances.length; r++) Bn.internalBinaryWrite(e.spotBalances[r], t.tag(7, v.LengthDelimited).fork(), n).join(); | |
for (let r = 0; r < e.launchBalances.length; r++) Ka.internalBinaryWrite(e.launchBalances[r], t.tag(8, v.LengthDelimited).fork(), n).join(); | |
e.isAgent !== !1 && | |
t.tag(9, v.Varint).bool(e.isAgent), | |
e.isReadOnly !== !1 && | |
t.tag(10, v.Varint).bool(e.isReadOnly); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const Ve = new Bv; | |
class Ov extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidPublicWallet', | |
[ | |
{ | |
no: 1, | |
name: 'ethereum_address', | |
kind: 'scalar', | |
T: 9 | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
ethereumAddress: '' | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.ethereumAddress = e.string(); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.ethereumAddress !== '' && | |
t.tag(1, v.LengthDelimited).string(e.ethereumAddress); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const bi = new Ov; | |
class Dv extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidWalletMovement', | |
[ | |
{ | |
no: 1, | |
name: 'telegram_id', | |
kind: 'message', | |
T: () => be | |
}, | |
{ | |
no: 2, | |
name: 'wallet', | |
kind: 'message', | |
T: () => Ve | |
}, | |
{ | |
no: 3, | |
name: 'wallet_id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 4, | |
name: 'hash', | |
kind: 'scalar', | |
T: 9 | |
}, | |
{ | |
no: 5, | |
name: 'type', | |
kind: 'scalar', | |
T: 9 | |
}, | |
{ | |
no: 6, | |
name: 'token_id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 7, | |
name: 'token', | |
kind: 'message', | |
T: () => lt | |
}, | |
{ | |
no: 8, | |
name: 'amount', | |
kind: 'scalar', | |
T: 1 | |
}, | |
{ | |
no: 9, | |
name: 'usdc_value', | |
kind: 'scalar', | |
T: 1 | |
}, | |
{ | |
no: 10, | |
name: 'destination', | |
kind: 'scalar', | |
T: 9 | |
}, | |
{ | |
no: 11, | |
name: 'fee', | |
kind: 'scalar', | |
T: 1 | |
}, | |
{ | |
no: 12, | |
name: 'timestamp', | |
kind: 'message', | |
T: () => be | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
walletId: 0, | |
hash: '', | |
type: '', | |
tokenId: 0, | |
amount: 0, | |
usdcValue: 0, | |
destination: '', | |
fee: 0 | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.telegramId = be.internalBinaryRead(e, e.uint32(), n, r.telegramId); | |
break; | |
case 2: | |
r.wallet = Ve.internalBinaryRead(e, e.uint32(), n, r.wallet); | |
break; | |
case 3: | |
r.walletId = e.int64().toNumber(); | |
break; | |
case 4: | |
r.hash = e.string(); | |
break; | |
case 5: | |
r.type = e.string(); | |
break; | |
case 6: | |
r.tokenId = e.int64().toNumber(); | |
break; | |
case 7: | |
r.token = lt.internalBinaryRead(e, e.uint32(), n, r.token); | |
break; | |
case 8: | |
r.amount = e.double(); | |
break; | |
case 9: | |
r.usdcValue = e.double(); | |
break; | |
case 10: | |
r.destination = e.string(); | |
break; | |
case 11: | |
r.fee = e.double(); | |
break; | |
case 12: | |
r.timestamp = be.internalBinaryRead(e, e.uint32(), n, r.timestamp); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.telegramId && | |
be.internalBinaryWrite(e.telegramId, t.tag(1, v.LengthDelimited).fork(), n).join(), | |
e.wallet && | |
Ve.internalBinaryWrite(e.wallet, t.tag(2, v.LengthDelimited).fork(), n).join(), | |
e.walletId !== 0 && | |
t.tag(3, v.Varint).int64(e.walletId), | |
e.hash !== '' && | |
t.tag(4, v.LengthDelimited).string(e.hash), | |
e.type !== '' && | |
t.tag(5, v.LengthDelimited).string(e.type), | |
e.tokenId !== 0 && | |
t.tag(6, v.Varint).int64(e.tokenId), | |
e.token && | |
lt.internalBinaryWrite(e.token, t.tag(7, v.LengthDelimited).fork(), n).join(), | |
e.amount !== 0 && | |
t.tag(8, v.Bit64).double(e.amount), | |
e.usdcValue !== 0 && | |
t.tag(9, v.Bit64).double(e.usdcValue), | |
e.destination !== '' && | |
t.tag(10, v.LengthDelimited).string(e.destination), | |
e.fee !== 0 && | |
t.tag(11, v.Bit64).double(e.fee), | |
e.timestamp && | |
be.internalBinaryWrite(e.timestamp, t.tag(12, v.LengthDelimited).fork(), n).join(); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const Rn = new Dv; | |
class Fv extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidWalletBalance', | |
[ | |
{ | |
no: 1, | |
name: 'telegram_id', | |
kind: 'message', | |
T: () => be | |
}, | |
{ | |
no: 2, | |
name: 'wallet_id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 3, | |
name: 'token_id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 4, | |
name: 'balance', | |
kind: 'scalar', | |
T: 1 | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
walletId: 0, | |
tokenId: 0, | |
balance: 0 | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.telegramId = be.internalBinaryRead(e, e.uint32(), n, r.telegramId); | |
break; | |
case 2: | |
r.walletId = e.int64().toNumber(); | |
break; | |
case 3: | |
r.tokenId = e.int64().toNumber(); | |
break; | |
case 4: | |
r.balance = e.double(); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.telegramId && | |
be.internalBinaryWrite(e.telegramId, t.tag(1, v.LengthDelimited).fork(), n).join(), | |
e.walletId !== 0 && | |
t.tag(2, v.Varint).int64(e.walletId), | |
e.tokenId !== 0 && | |
t.tag(3, v.Varint).int64(e.tokenId), | |
e.balance !== 0 && | |
t.tag(4, v.Bit64).double(e.balance); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const Bn = new Fv; | |
class Av extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidLaunchBalance', | |
[ | |
{ | |
no: 1, | |
name: 'telegram_id', | |
kind: 'message', | |
T: () => be | |
}, | |
{ | |
no: 2, | |
name: 'wallet_id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 3, | |
name: 'launch_id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 4, | |
name: 'balance', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
walletId: 0, | |
launchId: 0, | |
balance: 0 | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.telegramId = be.internalBinaryRead(e, e.uint32(), n, r.telegramId); | |
break; | |
case 2: | |
r.walletId = e.int64().toNumber(); | |
break; | |
case 3: | |
r.launchId = e.int64().toNumber(); | |
break; | |
case 4: | |
r.balance = e.int64().toNumber(); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.telegramId && | |
be.internalBinaryWrite(e.telegramId, t.tag(1, v.LengthDelimited).fork(), n).join(), | |
e.walletId !== 0 && | |
t.tag(2, v.Varint).int64(e.walletId), | |
e.launchId !== 0 && | |
t.tag(3, v.Varint).int64(e.launchId), | |
e.balance !== 0 && | |
t.tag(4, v.Varint).int64(e.balance); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const Ka = new Av; | |
class Vv extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidWalletDeploySession', | |
[ | |
{ | |
no: 1, | |
name: 'id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 2, | |
name: 'telegram_id', | |
kind: 'message', | |
T: () => be | |
}, | |
{ | |
no: 3, | |
name: 'step', | |
kind: 'scalar', | |
T: 5 | |
}, | |
{ | |
no: 4, | |
name: 'token_name', | |
kind: 'scalar', | |
T: 9 | |
}, | |
{ | |
no: 5, | |
name: 'full_name', | |
kind: 'scalar', | |
T: 9 | |
}, | |
{ | |
no: 6, | |
name: 'token_decimals', | |
kind: 'scalar', | |
T: 5 | |
}, | |
{ | |
no: 7, | |
name: 'token_wei', | |
kind: 'scalar', | |
T: 5 | |
}, | |
{ | |
no: 8, | |
name: 'token_supply', | |
kind: 'scalar', | |
T: 1 | |
}, | |
{ | |
no: 9, | |
name: 'start_market_cap', | |
kind: 'scalar', | |
T: 5 | |
}, | |
{ | |
no: 10, | |
name: 'anchor1_token_id', | |
kind: 'message', | |
T: () => be | |
}, | |
{ | |
no: 11, | |
name: 'anchor1_token', | |
kind: 'message', | |
T: () => lt | |
}, | |
{ | |
no: 12, | |
name: 'anchor2_token_id', | |
kind: 'message', | |
T: () => be | |
}, | |
{ | |
no: 13, | |
name: 'anchor2_token', | |
kind: 'message', | |
T: () => lt | |
}, | |
{ | |
no: 14, | |
name: 'token_id', | |
kind: 'message', | |
T: () => be | |
}, | |
{ | |
no: 15, | |
name: 'spot_pair_id', | |
kind: 'scalar', | |
T: 5 | |
}, | |
{ | |
no: 16, | |
name: 'deploy_threshold', | |
kind: 'scalar', | |
T: 1 | |
}, | |
{ | |
no: 17, | |
name: 'geneses', | |
kind: 'map', | |
K: 9, | |
V: { | |
kind: 'message', | |
T: () => lr | |
} | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
id: 0, | |
step: 0, | |
tokenName: '', | |
fullName: '', | |
tokenDecimals: 0, | |
tokenWei: 0, | |
tokenSupply: 0, | |
startMarketCap: 0, | |
spotPairId: 0, | |
deployThreshold: 0, | |
geneses: { | |
} | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.id = e.int64().toNumber(); | |
break; | |
case 2: | |
r.telegramId = be.internalBinaryRead(e, e.uint32(), n, r.telegramId); | |
break; | |
case 3: | |
r.step = e.int32(); | |
break; | |
case 4: | |
r.tokenName = e.string(); | |
break; | |
case 5: | |
r.fullName = e.string(); | |
break; | |
case 6: | |
r.tokenDecimals = e.int32(); | |
break; | |
case 7: | |
r.tokenWei = e.int32(); | |
break; | |
case 8: | |
r.tokenSupply = e.double(); | |
break; | |
case 9: | |
r.startMarketCap = e.int32(); | |
break; | |
case 10: | |
r.anchor1TokenId = be.internalBinaryRead(e, e.uint32(), n, r.anchor1TokenId); | |
break; | |
case 11: | |
r.anchor1Token = lt.internalBinaryRead(e, e.uint32(), n, r.anchor1Token); | |
break; | |
case 12: | |
r.anchor2TokenId = be.internalBinaryRead(e, e.uint32(), n, r.anchor2TokenId); | |
break; | |
case 13: | |
r.anchor2Token = lt.internalBinaryRead(e, e.uint32(), n, r.anchor2Token); | |
break; | |
case 14: | |
r.tokenId = be.internalBinaryRead(e, e.uint32(), n, r.tokenId); | |
break; | |
case 15: | |
r.spotPairId = e.int32(); | |
break; | |
case 16: | |
r.deployThreshold = e.double(); | |
break; | |
case 17: | |
this.binaryReadMap17(r.geneses, e, n); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
binaryReadMap17(e, t, n) { | |
let s = t.uint32(), | |
r = t.pos + s, | |
a, | |
l; | |
for (; t.pos < r; ) { | |
let[o, | |
u] = t.tag(); | |
switch (o) { | |
case 1: | |
a = t.string(); | |
break; | |
case 2: | |
l = lr.internalBinaryRead(t, t.uint32(), n); | |
break; | |
default: | |
throw new globalThis.Error( | |
'unknown map entry field for field hypurr.HyperliquidWalletDeploySession.geneses' | |
) | |
} | |
} | |
e[a ?? ''] = l ?? lr.create() | |
} | |
internalBinaryWrite(e, t, n) { | |
e.id !== 0 && | |
t.tag(1, v.Varint).int64(e.id), | |
e.telegramId && | |
be.internalBinaryWrite(e.telegramId, t.tag(2, v.LengthDelimited).fork(), n).join(), | |
e.step !== 0 && | |
t.tag(3, v.Varint).int32(e.step), | |
e.tokenName !== '' && | |
t.tag(4, v.LengthDelimited).string(e.tokenName), | |
e.fullName !== '' && | |
t.tag(5, v.LengthDelimited).string(e.fullName), | |
e.tokenDecimals !== 0 && | |
t.tag(6, v.Varint).int32(e.tokenDecimals), | |
e.tokenWei !== 0 && | |
t.tag(7, v.Varint).int32(e.tokenWei), | |
e.tokenSupply !== 0 && | |
t.tag(8, v.Bit64).double(e.tokenSupply), | |
e.startMarketCap !== 0 && | |
t.tag(9, v.Varint).int32(e.startMarketCap), | |
e.anchor1TokenId && | |
be.internalBinaryWrite(e.anchor1TokenId, t.tag(10, v.LengthDelimited).fork(), n).join(), | |
e.anchor1Token && | |
lt.internalBinaryWrite(e.anchor1Token, t.tag(11, v.LengthDelimited).fork(), n).join(), | |
e.anchor2TokenId && | |
be.internalBinaryWrite(e.anchor2TokenId, t.tag(12, v.LengthDelimited).fork(), n).join(), | |
e.anchor2Token && | |
lt.internalBinaryWrite(e.anchor2Token, t.tag(13, v.LengthDelimited).fork(), n).join(), | |
e.tokenId && | |
be.internalBinaryWrite(e.tokenId, t.tag(14, v.LengthDelimited).fork(), n).join(), | |
e.spotPairId !== 0 && | |
t.tag(15, v.Varint).int32(e.spotPairId), | |
e.deployThreshold !== 0 && | |
t.tag(16, v.Bit64).double(e.deployThreshold); | |
for (let r of Object.keys(e.geneses)) t.tag(17, v.LengthDelimited).fork().tag(1, v.LengthDelimited).string(r), | |
t.tag(2, v.LengthDelimited).fork(), | |
lr.internalBinaryWrite(e.geneses[r], t, n), | |
t.join().join(); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const Ut = new Vv; | |
class zv extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidWalletDeploySessionGenesis', | |
[ | |
{ | |
no: 1, | |
name: 'target', | |
kind: 'scalar', | |
T: 9 | |
}, | |
{ | |
no: 2, | |
name: 'share', | |
kind: 'scalar', | |
T: 5 | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
target: '', | |
share: 0 | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.target = e.string(); | |
break; | |
case 2: | |
r.share = e.int32(); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.target !== '' && | |
t.tag(1, v.LengthDelimited).string(e.target), | |
e.share !== 0 && | |
t.tag(2, v.Varint).int32(e.share); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const lr = new zv; | |
class Wv extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidLaunch', | |
[ | |
{ | |
no: 1, | |
name: 'id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 2, | |
name: 'telegram_id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 3, | |
name: 'telegram_user', | |
kind: 'message', | |
T: () => Ht | |
}, | |
{ | |
no: 4, | |
name: 'description', | |
kind: 'scalar', | |
T: 9 | |
}, | |
{ | |
no: 5, | |
name: 'listed', | |
kind: 'scalar', | |
T: 8 | |
}, | |
{ | |
no: 6, | |
name: 'settled', | |
kind: 'scalar', | |
T: 8 | |
}, | |
{ | |
no: 7, | |
name: 'x0', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 8, | |
name: 'session_id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 9, | |
name: 'session', | |
kind: 'message', | |
T: () => Ut | |
}, | |
{ | |
no: 10, | |
name: 'media_file_id', | |
kind: 'scalar', | |
T: 9 | |
}, | |
{ | |
no: 11, | |
name: 'topic_id', | |
kind: 'message', | |
T: () => be | |
}, | |
{ | |
no: 12, | |
name: 'x', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 13, | |
name: 'y', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 14, | |
name: 'k', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 15, | |
name: 'fills', | |
kind: 'message', | |
repeat: 1, | |
T: () => Ei | |
}, | |
{ | |
no: 16, | |
name: 'daily_ntl_volume', | |
kind: 'scalar', | |
T: 1 | |
}, | |
{ | |
no: 17, | |
name: 'previous_day_px', | |
kind: 'scalar', | |
T: 1 | |
}, | |
{ | |
no: 18, | |
name: 'last_event_timestamp', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 19, | |
name: 'pool_type', | |
kind: 'enum', | |
T: () => ['hypurr.HyperliquidLaunchPoolType', | |
Gt] | |
}, | |
{ | |
no: 20, | |
name: 'decimals', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 21, | |
name: 'session_wallet', | |
kind: 'message', | |
T: () => bi | |
}, | |
{ | |
no: 22, | |
name: 'media_type', | |
kind: 'scalar', | |
T: 9 | |
}, | |
{ | |
no: 23, | |
name: 'listed_timestamp', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 24, | |
name: 'dev_wallet', | |
kind: 'message', | |
T: () => bi | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
id: 0, | |
telegramId: 0, | |
description: '', | |
listed: !1, | |
settled: !1, | |
x0: 0, | |
sessionId: 0, | |
mediaFileId: '', | |
x: 0, | |
y: 0, | |
k: 0, | |
fills: [], | |
dailyNtlVolume: 0, | |
previousDayPx: 0, | |
lastEventTimestamp: 0, | |
poolType: 0, | |
decimals: 0, | |
mediaType: '', | |
listedTimestamp: 0 | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.id = e.int64().toNumber(); | |
break; | |
case 2: | |
r.telegramId = e.int64().toNumber(); | |
break; | |
case 3: | |
r.telegramUser = Ht.internalBinaryRead(e, e.uint32(), n, r.telegramUser); | |
break; | |
case 4: | |
r.description = e.string(); | |
break; | |
case 5: | |
r.listed = e.bool(); | |
break; | |
case 6: | |
r.settled = e.bool(); | |
break; | |
case 7: | |
r.x0 = e.int64().toNumber(); | |
break; | |
case 8: | |
r.sessionId = e.int64().toNumber(); | |
break; | |
case 9: | |
r.session = Ut.internalBinaryRead(e, e.uint32(), n, r.session); | |
break; | |
case 10: | |
r.mediaFileId = e.string(); | |
break; | |
case 11: | |
r.topicId = be.internalBinaryRead(e, e.uint32(), n, r.topicId); | |
break; | |
case 12: | |
r.x = e.int64().toNumber(); | |
break; | |
case 13: | |
r.y = e.int64().toNumber(); | |
break; | |
case 14: | |
r.k = e.int64().toNumber(); | |
break; | |
case 15: | |
r.fills.push(Ei.internalBinaryRead(e, e.uint32(), n)); | |
break; | |
case 16: | |
r.dailyNtlVolume = e.double(); | |
break; | |
case 17: | |
r.previousDayPx = e.double(); | |
break; | |
case 18: | |
r.lastEventTimestamp = e.int64().toNumber(); | |
break; | |
case 19: | |
r.poolType = e.int32(); | |
break; | |
case 20: | |
r.decimals = e.int64().toNumber(); | |
break; | |
case 21: | |
r.sessionWallet = bi.internalBinaryRead(e, e.uint32(), n, r.sessionWallet); | |
break; | |
case 22: | |
r.mediaType = e.string(); | |
break; | |
case 23: | |
r.listedTimestamp = e.int64().toNumber(); | |
break; | |
case 24: | |
r.devWallet = bi.internalBinaryRead(e, e.uint32(), n, r.devWallet); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.id !== 0 && | |
t.tag(1, v.Varint).int64(e.id), | |
e.telegramId !== 0 && | |
t.tag(2, v.Varint).int64(e.telegramId), | |
e.telegramUser && | |
Ht.internalBinaryWrite(e.telegramUser, t.tag(3, v.LengthDelimited).fork(), n).join(), | |
e.description !== '' && | |
t.tag(4, v.LengthDelimited).string(e.description), | |
e.listed !== !1 && | |
t.tag(5, v.Varint).bool(e.listed), | |
e.settled !== !1 && | |
t.tag(6, v.Varint).bool(e.settled), | |
e.x0 !== 0 && | |
t.tag(7, v.Varint).int64(e.x0), | |
e.sessionId !== 0 && | |
t.tag(8, v.Varint).int64(e.sessionId), | |
e.session && | |
Ut.internalBinaryWrite(e.session, t.tag(9, v.LengthDelimited).fork(), n).join(), | |
e.mediaFileId !== '' && | |
t.tag(10, v.LengthDelimited).string(e.mediaFileId), | |
e.topicId && | |
be.internalBinaryWrite(e.topicId, t.tag(11, v.LengthDelimited).fork(), n).join(), | |
e.x !== 0 && | |
t.tag(12, v.Varint).int64(e.x), | |
e.y !== 0 && | |
t.tag(13, v.Varint).int64(e.y), | |
e.k !== 0 && | |
t.tag(14, v.Varint).int64(e.k); | |
for (let r = 0; r < e.fills.length; r++) Ei.internalBinaryWrite(e.fills[r], t.tag(15, v.LengthDelimited).fork(), n).join(); | |
e.dailyNtlVolume !== 0 && | |
t.tag(16, v.Bit64).double(e.dailyNtlVolume), | |
e.previousDayPx !== 0 && | |
t.tag(17, v.Bit64).double(e.previousDayPx), | |
e.lastEventTimestamp !== 0 && | |
t.tag(18, v.Varint).int64(e.lastEventTimestamp), | |
e.poolType !== 0 && | |
t.tag(19, v.Varint).int32(e.poolType), | |
e.decimals !== 0 && | |
t.tag(20, v.Varint).int64(e.decimals), | |
e.sessionWallet && | |
bi.internalBinaryWrite(e.sessionWallet, t.tag(21, v.LengthDelimited).fork(), n).join(), | |
e.mediaType !== '' && | |
t.tag(22, v.LengthDelimited).string(e.mediaType), | |
e.listedTimestamp !== 0 && | |
t.tag(23, v.Varint).int64(e.listedTimestamp), | |
e.devWallet && | |
bi.internalBinaryWrite(e.devWallet, t.tag(24, v.LengthDelimited).fork(), n).join(); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const jt = new Wv; | |
class Uv extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidLaunchFill', | |
[ | |
{ | |
no: 1, | |
name: 'launch_id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 2, | |
name: 'telegram_id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 3, | |
name: 'telegram', | |
kind: 'message', | |
T: () => Ht | |
}, | |
{ | |
no: 4, | |
name: 'wallet', | |
kind: 'message', | |
T: () => bi | |
}, | |
{ | |
no: 5, | |
name: 'usdc_delta', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 6, | |
name: 'launch_delta', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 7, | |
name: 'timestamp', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 8, | |
name: 'movement_hash', | |
kind: 'message', | |
T: () => ut | |
}, | |
{ | |
no: 9, | |
name: 'id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
launchId: 0, | |
telegramId: 0, | |
usdcDelta: 0, | |
launchDelta: 0, | |
timestamp: 0, | |
id: 0 | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.launchId = e.int64().toNumber(); | |
break; | |
case 2: | |
r.telegramId = e.int64().toNumber(); | |
break; | |
case 3: | |
r.telegram = Ht.internalBinaryRead(e, e.uint32(), n, r.telegram); | |
break; | |
case 4: | |
r.wallet = bi.internalBinaryRead(e, e.uint32(), n, r.wallet); | |
break; | |
case 5: | |
r.usdcDelta = e.int64().toNumber(); | |
break; | |
case 6: | |
r.launchDelta = e.int64().toNumber(); | |
break; | |
case 7: | |
r.timestamp = e.int64().toNumber(); | |
break; | |
case 8: | |
r.movementHash = ut.internalBinaryRead(e, e.uint32(), n, r.movementHash); | |
break; | |
case 9: | |
r.id = e.int64().toNumber(); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.launchId !== 0 && | |
t.tag(1, v.Varint).int64(e.launchId), | |
e.telegramId !== 0 && | |
t.tag(2, v.Varint).int64(e.telegramId), | |
e.telegram && | |
Ht.internalBinaryWrite(e.telegram, t.tag(3, v.LengthDelimited).fork(), n).join(), | |
e.wallet && | |
bi.internalBinaryWrite(e.wallet, t.tag(4, v.LengthDelimited).fork(), n).join(), | |
e.usdcDelta !== 0 && | |
t.tag(5, v.Varint).int64(e.usdcDelta), | |
e.launchDelta !== 0 && | |
t.tag(6, v.Varint).int64(e.launchDelta), | |
e.timestamp !== 0 && | |
t.tag(7, v.Varint).int64(e.timestamp), | |
e.movementHash && | |
ut.internalBinaryWrite(e.movementHash, t.tag(8, v.LengthDelimited).fork(), n).join(), | |
e.id !== 0 && | |
t.tag(9, v.Varint).int64(e.id); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const Ei = new Uv; | |
class jv extends Z { | |
constructor() { | |
super ( | |
'hypurr.TelegramUserPublic', | |
[ | |
{ | |
no: 1, | |
name: 'id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 2, | |
name: 'username', | |
kind: 'scalar', | |
T: 9 | |
}, | |
{ | |
no: 3, | |
name: 'picture_file_id', | |
kind: 'scalar', | |
T: 9 | |
}, | |
{ | |
no: 4, | |
name: 'reputation_score', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
id: 0, | |
username: '', | |
pictureFileId: '', | |
reputationScore: 0 | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.id = e.int64().toNumber(); | |
break; | |
case 2: | |
r.username = e.string(); | |
break; | |
case 3: | |
r.pictureFileId = e.string(); | |
break; | |
case 4: | |
r.reputationScore = e.int64().toNumber(); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.id !== 0 && | |
t.tag(1, v.Varint).int64(e.id), | |
e.username !== '' && | |
t.tag(2, v.LengthDelimited).string(e.username), | |
e.pictureFileId !== '' && | |
t.tag(3, v.LengthDelimited).string(e.pictureFileId), | |
e.reputationScore !== 0 && | |
t.tag(4, v.Varint).int64(e.reputationScore); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const Ht = new jv; | |
class Hv extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidDeployAuction', | |
[ | |
{ | |
no: 1, | |
name: 'start_time', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 2, | |
name: 'duration', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 3, | |
name: 'start_gas', | |
kind: 'scalar', | |
T: 1 | |
}, | |
{ | |
no: 4, | |
name: 'current_gas', | |
kind: 'message', | |
T: () => wn | |
}, | |
{ | |
no: 5, | |
name: 'end_gas', | |
kind: 'message', | |
T: () => wn | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
startTime: 0, | |
duration: 0, | |
startGas: 0 | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.startTime = e.int64().toNumber(); | |
break; | |
case 2: | |
r.duration = e.int64().toNumber(); | |
break; | |
case 3: | |
r.startGas = e.double(); | |
break; | |
case 4: | |
r.currentGas = wn.internalBinaryRead(e, e.uint32(), n, r.currentGas); | |
break; | |
case 5: | |
r.endGas = wn.internalBinaryRead(e, e.uint32(), n, r.endGas); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.startTime !== 0 && | |
t.tag(1, v.Varint).int64(e.startTime), | |
e.duration !== 0 && | |
t.tag(2, v.Varint).int64(e.duration), | |
e.startGas !== 0 && | |
t.tag(3, v.Bit64).double(e.startGas), | |
e.currentGas && | |
wn.internalBinaryWrite(e.currentGas, t.tag(4, v.LengthDelimited).fork(), n).join(), | |
e.endGas && | |
wn.internalBinaryWrite(e.endGas, t.tag(5, v.LengthDelimited).fork(), n).join(); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const Xa = new Hv; | |
class qv extends Z { | |
constructor() { | |
super ('hypurr.HyperliquidDeployAuctionRequest', []) | |
} | |
create(e) { | |
const t = {}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
return s ?? this.create() | |
} | |
internalBinaryWrite(e, t, n) { | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const Gv = new qv; | |
class Kv extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidDeployAuctionResponse', | |
[ | |
{ | |
no: 1, | |
name: 'auction', | |
kind: 'message', | |
T: () => Xa | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = {}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.auction = Xa.internalBinaryRead(e, e.uint32(), n, r.auction); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.auction && | |
Xa.internalBinaryWrite(e.auction, t.tag(1, v.LengthDelimited).fork(), n).join(); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const Xv = new Kv; | |
class Jv extends Z { | |
constructor() { | |
super ('hypurr.HyperliquidTokensRequest', []) | |
} | |
create(e) { | |
const t = {}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
return s ?? this.create() | |
} | |
internalBinaryWrite(e, t, n) { | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const Yv = new Jv; | |
class Qv extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidTokensResponse', | |
[ | |
{ | |
no: 1, | |
name: 'tokens', | |
kind: 'message', | |
repeat: 1, | |
T: () => lt | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
tokens: [] | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.tokens.push(lt.internalBinaryRead(e, e.uint32(), n)); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
for (let r = 0; r < e.tokens.length; r++) lt.internalBinaryWrite(e.tokens[r], t.tag(1, v.LengthDelimited).fork(), n).join(); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const Zv = new Qv; | |
class eb extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidTokenMessage', | |
[ | |
{ | |
no: 1, | |
name: 'id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 2, | |
name: 'timestamp', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 3, | |
name: 'token_id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 4, | |
name: 'telegram_id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 5, | |
name: 'author', | |
kind: 'message', | |
T: () => Ht | |
}, | |
{ | |
no: 6, | |
name: 'chat_id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 7, | |
name: 'topic_id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 8, | |
name: 'message', | |
kind: 'scalar', | |
T: 9 | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
id: 0, | |
timestamp: 0, | |
tokenId: 0, | |
telegramId: 0, | |
chatId: 0, | |
topicId: 0, | |
message: '' | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.id = e.int64().toNumber(); | |
break; | |
case 2: | |
r.timestamp = e.int64().toNumber(); | |
break; | |
case 3: | |
r.tokenId = e.int64().toNumber(); | |
break; | |
case 4: | |
r.telegramId = e.int64().toNumber(); | |
break; | |
case 5: | |
r.author = Ht.internalBinaryRead(e, e.uint32(), n, r.author); | |
break; | |
case 6: | |
r.chatId = e.int64().toNumber(); | |
break; | |
case 7: | |
r.topicId = e.int64().toNumber(); | |
break; | |
case 8: | |
r.message = e.string(); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.id !== 0 && | |
t.tag(1, v.Varint).int64(e.id), | |
e.timestamp !== 0 && | |
t.tag(2, v.Varint).int64(e.timestamp), | |
e.tokenId !== 0 && | |
t.tag(3, v.Varint).int64(e.tokenId), | |
e.telegramId !== 0 && | |
t.tag(4, v.Varint).int64(e.telegramId), | |
e.author && | |
Ht.internalBinaryWrite(e.author, t.tag(5, v.LengthDelimited).fork(), n).join(), | |
e.chatId !== 0 && | |
t.tag(6, v.Varint).int64(e.chatId), | |
e.topicId !== 0 && | |
t.tag(7, v.Varint).int64(e.topicId), | |
e.message !== '' && | |
t.tag(8, v.LengthDelimited).string(e.message); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const Ja = new eb; | |
class tb extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidTokenMessagesRequest', | |
[ | |
{ | |
no: 1, | |
name: 'token_id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
tokenId: 0 | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.tokenId = e.int64().toNumber(); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.tokenId !== 0 && | |
t.tag(1, v.Varint).int64(e.tokenId); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const ib = new tb; | |
class nb extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidTokenMessagesResponse', | |
[ | |
{ | |
no: 1, | |
name: 'messages', | |
kind: 'message', | |
repeat: 1, | |
T: () => Ja | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
messages: [] | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.messages.push(Ja.internalBinaryRead(e, e.uint32(), n)); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
for (let r = 0; r < e.messages.length; r++) Ja.internalBinaryWrite(e.messages[r], t.tag(1, v.LengthDelimited).fork(), n).join(); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const sb = new nb; | |
class rb extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidSpotPairRequest', | |
[ | |
{ | |
no: 1, | |
name: 'id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
id: 0 | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.id = e.int64().toNumber(); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.id !== 0 && | |
t.tag(1, v.Varint).int64(e.id); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const ab = new rb; | |
class lb extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidSpotPairResponse', | |
[ | |
{ | |
no: 1, | |
name: 'pair', | |
kind: 'message', | |
T: () => Mn | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = {}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.pair = Mn.internalBinaryRead(e, e.uint32(), n, r.pair); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.pair && | |
Mn.internalBinaryWrite(e.pair, t.tag(1, v.LengthDelimited).fork(), n).join(); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const ob = new lb; | |
class ub extends Z { | |
constructor() { | |
super ('hypurr.HyperliquidSpotPairsRequest', []) | |
} | |
create(e) { | |
const t = {}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
return s ?? this.create() | |
} | |
internalBinaryWrite(e, t, n) { | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const cb = new ub; | |
class hb extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidSpotPairsResponse', | |
[ | |
{ | |
no: 1, | |
name: 'pairs', | |
kind: 'message', | |
repeat: 1, | |
T: () => Mn | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
pairs: [] | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.pairs.push(Mn.internalBinaryRead(e, e.uint32(), n)); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
for (let r = 0; r < e.pairs.length; r++) Mn.internalBinaryWrite(e.pairs[r], t.tag(1, v.LengthDelimited).fork(), n).join(); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const db = new hb; | |
class fb extends Z { | |
constructor() { | |
super ('hypurr.HyperliquidPerpPairsRequest', []) | |
} | |
create(e) { | |
const t = {}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
return s ?? this.create() | |
} | |
internalBinaryWrite(e, t, n) { | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const pb = new fb; | |
class mb extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidPerpPairsResponse', | |
[ | |
{ | |
no: 1, | |
name: 'pairs', | |
kind: 'message', | |
repeat: 1, | |
T: () => Ga | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
pairs: [] | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.pairs.push(Ga.internalBinaryRead(e, e.uint32(), n)); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
for (let r = 0; r < e.pairs.length; r++) Ga.internalBinaryWrite(e.pairs[r], t.tag(1, v.LengthDelimited).fork(), n).join(); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const gb = new mb; | |
class yb extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidWalletRequest', | |
[ | |
{ | |
no: 1, | |
name: 'ethereum_address', | |
kind: 'message', | |
T: () => ut | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = {}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.ethereumAddress = ut.internalBinaryRead(e, e.uint32(), n, r.ethereumAddress); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.ethereumAddress && | |
ut.internalBinaryWrite(e.ethereumAddress, t.tag(1, v.LengthDelimited).fork(), n).join(); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const vb = new yb; | |
class bb extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidWalletResponse', | |
[ | |
{ | |
no: 1, | |
name: 'wallet', | |
kind: 'message', | |
T: () => Ve | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = {}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.wallet = Ve.internalBinaryRead(e, e.uint32(), n, r.wallet); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.wallet && | |
Ve.internalBinaryWrite(e.wallet, t.tag(1, v.LengthDelimited).fork(), n).join(); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const wb = new bb; | |
class kb extends Z { | |
constructor() { | |
super ('hypurr.HyperliquidLaunchesRequest', []) | |
} | |
create(e) { | |
const t = {}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
return s ?? this.create() | |
} | |
internalBinaryWrite(e, t, n) { | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const _b = new kb; | |
class xb extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidLaunchesResponse', | |
[ | |
{ | |
no: 1, | |
name: 'launches', | |
kind: 'message', | |
repeat: 1, | |
T: () => jt | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
launches: [] | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.launches.push(jt.internalBinaryRead(e, e.uint32(), n)); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
for (let r = 0; r < e.launches.length; r++) jt.internalBinaryWrite(e.launches[r], t.tag(1, v.LengthDelimited).fork(), n).join(); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const Tb = new xb; | |
class Sb extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidLaunchStreamRequest', | |
[ | |
{ | |
no: 1, | |
name: 'launch_id', | |
kind: 'message', | |
T: () => be | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = {}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.launchId = be.internalBinaryRead(e, e.uint32(), n, r.launchId); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.launchId && | |
be.internalBinaryWrite(e.launchId, t.tag(1, v.LengthDelimited).fork(), n).join(); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const Eb = new Sb; | |
class Cb extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidLaunchStreamResponse', | |
[ | |
{ | |
no: 1, | |
name: 'launches', | |
kind: 'message', | |
repeat: 1, | |
T: () => jt | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
launches: [] | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.launches.push(jt.internalBinaryRead(e, e.uint32(), n)); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
for (let r = 0; r < e.launches.length; r++) jt.internalBinaryWrite(e.launches[r], t.tag(1, v.LengthDelimited).fork(), n).join(); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const $b = new Cb; | |
class Lb extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidWalletDeploySessionsRequest', | |
[ | |
{ | |
no: 1, | |
name: 'telegram_id', | |
kind: 'message', | |
T: () => be | |
}, | |
{ | |
no: 2, | |
name: 'wallet_id', | |
kind: 'message', | |
T: () => be | |
}, | |
{ | |
no: 3, | |
name: 'session_id', | |
kind: 'message', | |
T: () => be | |
}, | |
{ | |
no: 4, | |
name: 'ethereum_address', | |
kind: 'message', | |
T: () => ut | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = {}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.telegramId = be.internalBinaryRead(e, e.uint32(), n, r.telegramId); | |
break; | |
case 2: | |
r.walletId = be.internalBinaryRead(e, e.uint32(), n, r.walletId); | |
break; | |
case 3: | |
r.sessionId = be.internalBinaryRead(e, e.uint32(), n, r.sessionId); | |
break; | |
case 4: | |
r.ethereumAddress = ut.internalBinaryRead(e, e.uint32(), n, r.ethereumAddress); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.telegramId && | |
be.internalBinaryWrite(e.telegramId, t.tag(1, v.LengthDelimited).fork(), n).join(), | |
e.walletId && | |
be.internalBinaryWrite(e.walletId, t.tag(2, v.LengthDelimited).fork(), n).join(), | |
e.sessionId && | |
be.internalBinaryWrite(e.sessionId, t.tag(3, v.LengthDelimited).fork(), n).join(), | |
e.ethereumAddress && | |
ut.internalBinaryWrite(e.ethereumAddress, t.tag(4, v.LengthDelimited).fork(), n).join(); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const Pb = new Lb; | |
class Ib extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidWalletDeploySessionsResponse', | |
[ | |
{ | |
no: 1, | |
name: 'sessions', | |
kind: 'message', | |
repeat: 1, | |
T: () => Ut | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
sessions: [] | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.sessions.push(Ut.internalBinaryRead(e, e.uint32(), n)); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
for (let r = 0; r < e.sessions.length; r++) Ut.internalBinaryWrite(e.sessions[r], t.tag(1, v.LengthDelimited).fork(), n).join(); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const Nb = new Ib; | |
class Mb extends Z { | |
constructor() { | |
super ( | |
'hypurr.SetHyperliquidWalletDeploySessionTargetRequest', | |
[ | |
{ | |
no: 1, | |
name: 'ethereum_address', | |
kind: 'message', | |
T: () => ut | |
}, | |
{ | |
no: 2, | |
name: 'session_id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 3, | |
name: 'name', | |
kind: 'scalar', | |
T: 9 | |
}, | |
{ | |
no: 4, | |
name: 'target', | |
kind: 'scalar', | |
T: 9 | |
}, | |
{ | |
no: 5, | |
name: 'share', | |
kind: 'scalar', | |
T: 5 | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
sessionId: 0, | |
name: '', | |
target: '', | |
share: 0 | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.ethereumAddress = ut.internalBinaryRead(e, e.uint32(), n, r.ethereumAddress); | |
break; | |
case 2: | |
r.sessionId = e.int64().toNumber(); | |
break; | |
case 3: | |
r.name = e.string(); | |
break; | |
case 4: | |
r.target = e.string(); | |
break; | |
case 5: | |
r.share = e.int32(); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.ethereumAddress && | |
ut.internalBinaryWrite(e.ethereumAddress, t.tag(1, v.LengthDelimited).fork(), n).join(), | |
e.sessionId !== 0 && | |
t.tag(2, v.Varint).int64(e.sessionId), | |
e.name !== '' && | |
t.tag(3, v.LengthDelimited).string(e.name), | |
e.target !== '' && | |
t.tag(4, v.LengthDelimited).string(e.target), | |
e.share !== 0 && | |
t.tag(5, v.Varint).int32(e.share); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const Rb = new Mb; | |
class Bb extends Z { | |
constructor() { | |
super ( | |
'hypurr.SetHyperliquidWalletDeploySessionTargetResponse', | |
[ | |
{ | |
no: 1, | |
name: 'session', | |
kind: 'message', | |
T: () => Ut | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = {}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.session = Ut.internalBinaryRead(e, e.uint32(), n, r.session); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.session && | |
Ut.internalBinaryWrite(e.session, t.tag(1, v.LengthDelimited).fork(), n).join(); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const Ob = new Bb; | |
class Db extends Z { | |
constructor() { | |
super ( | |
'hypurr.DeleteHyperliquidWalletDeploySessionTargetRequest', | |
[ | |
{ | |
no: 1, | |
name: 'ethereum_address', | |
kind: 'message', | |
T: () => ut | |
}, | |
{ | |
no: 2, | |
name: 'session_id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 3, | |
name: 'name', | |
kind: 'scalar', | |
T: 9 | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
sessionId: 0, | |
name: '' | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.ethereumAddress = ut.internalBinaryRead(e, e.uint32(), n, r.ethereumAddress); | |
break; | |
case 2: | |
r.sessionId = e.int64().toNumber(); | |
break; | |
case 3: | |
r.name = e.string(); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.ethereumAddress && | |
ut.internalBinaryWrite(e.ethereumAddress, t.tag(1, v.LengthDelimited).fork(), n).join(), | |
e.sessionId !== 0 && | |
t.tag(2, v.Varint).int64(e.sessionId), | |
e.name !== '' && | |
t.tag(3, v.LengthDelimited).string(e.name); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const Fb = new Db; | |
class Ab extends Z { | |
constructor() { | |
super ( | |
'hypurr.DeleteHyperliquidWalletDeploySessionTargetResponse', | |
[ | |
{ | |
no: 1, | |
name: 'session', | |
kind: 'message', | |
T: () => Ut | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = {}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.session = Ut.internalBinaryRead(e, e.uint32(), n, r.session); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.session && | |
Ut.internalBinaryWrite(e.session, t.tag(1, v.LengthDelimited).fork(), n).join(); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const Vb = new Ab; | |
class zb extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidLaunchFillsRequest', | |
[ | |
{ | |
no: 1, | |
name: 'launch_id', | |
kind: 'message', | |
T: () => be | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = {}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.launchId = be.internalBinaryRead(e, e.uint32(), n, r.launchId); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.launchId && | |
be.internalBinaryWrite(e.launchId, t.tag(1, v.LengthDelimited).fork(), n).join(); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const Wb = new zb; | |
class Ub extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidLaunchFillsResponse', | |
[ | |
{ | |
no: 1, | |
name: 'fills', | |
kind: 'message', | |
repeat: 1, | |
T: () => Ei | |
}, | |
{ | |
no: 2, | |
name: 'positions', | |
kind: 'message', | |
repeat: 1, | |
T: () => Ya | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
fills: [], | |
positions: [] | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.fills.push(Ei.internalBinaryRead(e, e.uint32(), n)); | |
break; | |
case 2: | |
r.positions.push(Ya.internalBinaryRead(e, e.uint32(), n)); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
for (let r = 0; r < e.fills.length; r++) Ei.internalBinaryWrite(e.fills[r], t.tag(1, v.LengthDelimited).fork(), n).join(); | |
for (let r = 0; r < e.positions.length; r++) Ya.internalBinaryWrite(e.positions[r], t.tag(2, v.LengthDelimited).fork(), n).join(); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const Nc = new Ub; | |
class jb extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidLaunchPosition', | |
[ | |
{ | |
no: 1, | |
name: 'address', | |
kind: 'scalar', | |
T: 9 | |
}, | |
{ | |
no: 2, | |
name: 'balance', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 3, | |
name: 'cost', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
address: '', | |
balance: 0, | |
cost: 0 | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.address = e.string(); | |
break; | |
case 2: | |
r.balance = e.int64().toNumber(); | |
break; | |
case 3: | |
r.cost = e.int64().toNumber(); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.address !== '' && | |
t.tag(1, v.LengthDelimited).string(e.address), | |
e.balance !== 0 && | |
t.tag(2, v.Varint).int64(e.balance), | |
e.cost !== 0 && | |
t.tag(3, v.Varint).int64(e.cost); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const Ya = new jb; | |
class Hb extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidLaunchCandlesRequest', | |
[ | |
{ | |
no: 1, | |
name: 'launch_id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 2, | |
name: 'interval', | |
kind: 'scalar', | |
T: 9 | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
launchId: 0, | |
interval: '' | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.launchId = e.int64().toNumber(); | |
break; | |
case 2: | |
r.interval = e.string(); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.launchId !== 0 && | |
t.tag(1, v.Varint).int64(e.launchId), | |
e.interval !== '' && | |
t.tag(2, v.LengthDelimited).string(e.interval); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const Mc = new Hb; | |
class qb extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidLaunchCandle', | |
[ | |
{ | |
no: 1, | |
name: 'time', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 2, | |
name: 'open', | |
kind: 'scalar', | |
T: 2 | |
}, | |
{ | |
no: 3, | |
name: 'high', | |
kind: 'scalar', | |
T: 2 | |
}, | |
{ | |
no: 4, | |
name: 'low', | |
kind: 'scalar', | |
T: 2 | |
}, | |
{ | |
no: 5, | |
name: 'close', | |
kind: 'scalar', | |
T: 2 | |
}, | |
{ | |
no: 6, | |
name: 'volume', | |
kind: 'scalar', | |
T: 2 | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
time: 0, | |
open: 0, | |
high: 0, | |
low: 0, | |
close: 0, | |
volume: 0 | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.time = e.int64().toNumber(); | |
break; | |
case 2: | |
r.open = e.float(); | |
break; | |
case 3: | |
r.high = e.float(); | |
break; | |
case 4: | |
r.low = e.float(); | |
break; | |
case 5: | |
r.close = e.float(); | |
break; | |
case 6: | |
r.volume = e.float(); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.time !== 0 && | |
t.tag(1, v.Varint).int64(e.time), | |
e.open !== 0 && | |
t.tag(2, v.Bit32).float(e.open), | |
e.high !== 0 && | |
t.tag(3, v.Bit32).float(e.high), | |
e.low !== 0 && | |
t.tag(4, v.Bit32).float(e.low), | |
e.close !== 0 && | |
t.tag(5, v.Bit32).float(e.close), | |
e.volume !== 0 && | |
t.tag(6, v.Bit32).float(e.volume); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const Qa = new qb; | |
class Gb extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidLaunchCandlesResponse', | |
[ | |
{ | |
no: 1, | |
name: 'candles', | |
kind: 'message', | |
repeat: 1, | |
T: () => Qa | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
candles: [] | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.candles.push(Qa.internalBinaryRead(e, e.uint32(), n)); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
for (let r = 0; r < e.candles.length; r++) Qa.internalBinaryWrite(e.candles[r], t.tag(1, v.LengthDelimited).fork(), n).join(); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const Rc = new Gb; | |
class Kb extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidLaunchRequest', | |
[ | |
{ | |
no: 1, | |
name: 'id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
id: 0 | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.id = e.int64().toNumber(); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.id !== 0 && | |
t.tag(1, v.Varint).int64(e.id); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const Xb = new Kb; | |
class Jb extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidLaunchResponse', | |
[ | |
{ | |
no: 1, | |
name: 'launch', | |
kind: 'message', | |
T: () => jt | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = {}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.launch = jt.internalBinaryRead(e, e.uint32(), n, r.launch); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.launch && | |
jt.internalBinaryWrite(e.launch, t.tag(1, v.LengthDelimited).fork(), n).join(); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const Yb = new Jb; | |
class Qb extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidLaunchMessage', | |
[ | |
{ | |
no: 1, | |
name: 'id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 2, | |
name: 'timestamp', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 3, | |
name: 'launch_id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 4, | |
name: 'telegram_id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 5, | |
name: 'author', | |
kind: 'message', | |
T: () => Ht | |
}, | |
{ | |
no: 6, | |
name: 'chat_id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 7, | |
name: 'topic_id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 8, | |
name: 'message', | |
kind: 'scalar', | |
T: 9 | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
id: 0, | |
timestamp: 0, | |
launchId: 0, | |
telegramId: 0, | |
chatId: 0, | |
topicId: 0, | |
message: '' | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.id = e.int64().toNumber(); | |
break; | |
case 2: | |
r.timestamp = e.int64().toNumber(); | |
break; | |
case 3: | |
r.launchId = e.int64().toNumber(); | |
break; | |
case 4: | |
r.telegramId = e.int64().toNumber(); | |
break; | |
case 5: | |
r.author = Ht.internalBinaryRead(e, e.uint32(), n, r.author); | |
break; | |
case 6: | |
r.chatId = e.int64().toNumber(); | |
break; | |
case 7: | |
r.topicId = e.int64().toNumber(); | |
break; | |
case 8: | |
r.message = e.string(); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.id !== 0 && | |
t.tag(1, v.Varint).int64(e.id), | |
e.timestamp !== 0 && | |
t.tag(2, v.Varint).int64(e.timestamp), | |
e.launchId !== 0 && | |
t.tag(3, v.Varint).int64(e.launchId), | |
e.telegramId !== 0 && | |
t.tag(4, v.Varint).int64(e.telegramId), | |
e.author && | |
Ht.internalBinaryWrite(e.author, t.tag(5, v.LengthDelimited).fork(), n).join(), | |
e.chatId !== 0 && | |
t.tag(6, v.Varint).int64(e.chatId), | |
e.topicId !== 0 && | |
t.tag(7, v.Varint).int64(e.topicId), | |
e.message !== '' && | |
t.tag(8, v.LengthDelimited).string(e.message); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const Za = new Qb; | |
class Zb extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidLaunchMessagesRequest', | |
[ | |
{ | |
no: 1, | |
name: 'launch_id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
launchId: 0 | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.launchId = e.int64().toNumber(); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.launchId !== 0 && | |
t.tag(1, v.Varint).int64(e.launchId); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const ew = new Zb; | |
class tw extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidLaunchMessagesResponse', | |
[ | |
{ | |
no: 1, | |
name: 'messages', | |
kind: 'message', | |
repeat: 1, | |
T: () => Za | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
messages: [] | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.messages.push(Za.internalBinaryRead(e, e.uint32(), n)); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
for (let r = 0; r < e.messages.length; r++) Za.internalBinaryWrite(e.messages[r], t.tag(1, v.LengthDelimited).fork(), n).join(); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const iw = new tw; | |
class nw extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidLaunchHolder', | |
[ | |
{ | |
no: 1, | |
name: 'balance', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 2, | |
name: 'address', | |
kind: 'scalar', | |
T: 9 | |
}, | |
{ | |
no: 3, | |
name: 'type', | |
kind: 'scalar', | |
T: 9 | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
balance: 0, | |
address: '', | |
type: '' | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.balance = e.int64().toNumber(); | |
break; | |
case 2: | |
r.address = e.string(); | |
break; | |
case 3: | |
r.type = e.string(); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.balance !== 0 && | |
t.tag(1, v.Varint).int64(e.balance), | |
e.address !== '' && | |
t.tag(2, v.LengthDelimited).string(e.address), | |
e.type !== '' && | |
t.tag(3, v.LengthDelimited).string(e.type); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const el = new nw; | |
class sw extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidLaunchHoldersRequest', | |
[ | |
{ | |
no: 1, | |
name: 'launch_id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
launchId: 0 | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.launchId = e.int64().toNumber(); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.launchId !== 0 && | |
t.tag(1, v.Varint).int64(e.launchId); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const rw = new sw; | |
class aw extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidLaunchHoldersResponse', | |
[ | |
{ | |
no: 1, | |
name: 'holders', | |
kind: 'message', | |
repeat: 1, | |
T: () => el | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
holders: [] | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.holders.push(el.internalBinaryRead(e, e.uint32(), n)); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
for (let r = 0; r < e.holders.length; r++) el.internalBinaryWrite(e.holders[r], t.tag(1, v.LengthDelimited).fork(), n).join(); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const lw = new aw; | |
class ow extends Z { | |
constructor() { | |
super ('hypurr.LatestHyperliquidLaunchFillsRequest', []) | |
} | |
create(e) { | |
const t = {}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
return s ?? this.create() | |
} | |
internalBinaryWrite(e, t, n) { | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const uw = new ow; | |
class cw extends Z { | |
constructor() { | |
super ( | |
'hypurr.TelegramUser', | |
[ | |
{ | |
no: 1, | |
name: 'telegram_id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 2, | |
name: 'telegram_username', | |
kind: 'scalar', | |
T: 9 | |
}, | |
{ | |
no: 3, | |
name: 'pending_fees', | |
kind: 'scalar', | |
T: 1 | |
}, | |
{ | |
no: 4, | |
name: 'referral_rewards', | |
kind: 'scalar', | |
T: 1 | |
}, | |
{ | |
no: 5, | |
name: 'referral_code', | |
kind: 'scalar', | |
T: 9 | |
}, | |
{ | |
no: 6, | |
name: 'referral_score', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 7, | |
name: 'referrer_id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 8, | |
name: 'settings', | |
kind: 'message', | |
T: () => il | |
}, | |
{ | |
no: 9, | |
name: 'wallet', | |
kind: 'message', | |
T: () => Ve | |
}, | |
{ | |
no: 10, | |
name: 'wallets', | |
kind: 'message', | |
repeat: 1, | |
T: () => Ve | |
}, | |
{ | |
no: 11, | |
name: 'wallet_id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 12, | |
name: 'sniper_wallet', | |
kind: 'message', | |
T: () => Ve | |
}, | |
{ | |
no: 13, | |
name: 'sniper_wallet_id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 14, | |
name: 'dumper_wallet', | |
kind: 'message', | |
T: () => Ve | |
}, | |
{ | |
no: 15, | |
name: 'dumper_wallet_id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 16, | |
name: 'reputation_id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 17, | |
name: 'reputation', | |
kind: 'message', | |
T: () => nl | |
}, | |
{ | |
no: 18, | |
name: 'launches', | |
kind: 'message', | |
repeat: 1, | |
T: () => jt | |
}, | |
{ | |
no: 19, | |
name: 'balances', | |
kind: 'message', | |
repeat: 1, | |
T: () => Bn | |
}, | |
{ | |
no: 20, | |
name: 'movements', | |
kind: 'message', | |
repeat: 1, | |
T: () => Rn | |
}, | |
{ | |
no: 21, | |
name: 'launch_fills', | |
kind: 'message', | |
repeat: 1, | |
T: () => Ei | |
}, | |
{ | |
no: 22, | |
name: 'labels', | |
kind: 'message', | |
repeat: 1, | |
T: () => sl | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
telegramId: 0, | |
telegramUsername: '', | |
pendingFees: 0, | |
referralRewards: 0, | |
referralCode: '', | |
referralScore: 0, | |
referrerId: 0, | |
wallets: [], | |
walletId: 0, | |
sniperWalletId: 0, | |
dumperWalletId: 0, | |
reputationId: 0, | |
launches: [], | |
balances: [], | |
movements: [], | |
launchFills: [], | |
labels: [] | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.telegramId = e.int64().toNumber(); | |
break; | |
case 2: | |
r.telegramUsername = e.string(); | |
break; | |
case 3: | |
r.pendingFees = e.double(); | |
break; | |
case 4: | |
r.referralRewards = e.double(); | |
break; | |
case 5: | |
r.referralCode = e.string(); | |
break; | |
case 6: | |
r.referralScore = e.int64().toNumber(); | |
break; | |
case 7: | |
r.referrerId = e.int64().toNumber(); | |
break; | |
case 8: | |
r.settings = il.internalBinaryRead(e, e.uint32(), n, r.settings); | |
break; | |
case 9: | |
r.wallet = Ve.internalBinaryRead(e, e.uint32(), n, r.wallet); | |
break; | |
case 10: | |
r.wallets.push(Ve.internalBinaryRead(e, e.uint32(), n)); | |
break; | |
case 11: | |
r.walletId = e.int64().toNumber(); | |
break; | |
case 12: | |
r.sniperWallet = Ve.internalBinaryRead(e, e.uint32(), n, r.sniperWallet); | |
break; | |
case 13: | |
r.sniperWalletId = e.int64().toNumber(); | |
break; | |
case 14: | |
r.dumperWallet = Ve.internalBinaryRead(e, e.uint32(), n, r.dumperWallet); | |
break; | |
case 15: | |
r.dumperWalletId = e.int64().toNumber(); | |
break; | |
case 16: | |
r.reputationId = e.int64().toNumber(); | |
break; | |
case 17: | |
r.reputation = nl.internalBinaryRead(e, e.uint32(), n, r.reputation); | |
break; | |
case 18: | |
r.launches.push(jt.internalBinaryRead(e, e.uint32(), n)); | |
break; | |
case 19: | |
r.balances.push(Bn.internalBinaryRead(e, e.uint32(), n)); | |
break; | |
case 20: | |
r.movements.push(Rn.internalBinaryRead(e, e.uint32(), n)); | |
break; | |
case 21: | |
r.launchFills.push(Ei.internalBinaryRead(e, e.uint32(), n)); | |
break; | |
case 22: | |
r.labels.push(sl.internalBinaryRead(e, e.uint32(), n)); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.telegramId !== 0 && | |
t.tag(1, v.Varint).int64(e.telegramId), | |
e.telegramUsername !== '' && | |
t.tag(2, v.LengthDelimited).string(e.telegramUsername), | |
e.pendingFees !== 0 && | |
t.tag(3, v.Bit64).double(e.pendingFees), | |
e.referralRewards !== 0 && | |
t.tag(4, v.Bit64).double(e.referralRewards), | |
e.referralCode !== '' && | |
t.tag(5, v.LengthDelimited).string(e.referralCode), | |
e.referralScore !== 0 && | |
t.tag(6, v.Varint).int64(e.referralScore), | |
e.referrerId !== 0 && | |
t.tag(7, v.Varint).int64(e.referrerId), | |
e.settings && | |
il.internalBinaryWrite(e.settings, t.tag(8, v.LengthDelimited).fork(), n).join(), | |
e.wallet && | |
Ve.internalBinaryWrite(e.wallet, t.tag(9, v.LengthDelimited).fork(), n).join(); | |
for (let r = 0; r < e.wallets.length; r++) Ve.internalBinaryWrite(e.wallets[r], t.tag(10, v.LengthDelimited).fork(), n).join(); | |
e.walletId !== 0 && | |
t.tag(11, v.Varint).int64(e.walletId), | |
e.sniperWallet && | |
Ve.internalBinaryWrite(e.sniperWallet, t.tag(12, v.LengthDelimited).fork(), n).join(), | |
e.sniperWalletId !== 0 && | |
t.tag(13, v.Varint).int64(e.sniperWalletId), | |
e.dumperWallet && | |
Ve.internalBinaryWrite(e.dumperWallet, t.tag(14, v.LengthDelimited).fork(), n).join(), | |
e.dumperWalletId !== 0 && | |
t.tag(15, v.Varint).int64(e.dumperWalletId), | |
e.reputationId !== 0 && | |
t.tag(16, v.Varint).int64(e.reputationId), | |
e.reputation && | |
nl.internalBinaryWrite(e.reputation, t.tag(17, v.LengthDelimited).fork(), n).join(); | |
for (let r = 0; r < e.launches.length; r++) jt.internalBinaryWrite(e.launches[r], t.tag(18, v.LengthDelimited).fork(), n).join(); | |
for (let r = 0; r < e.balances.length; r++) Bn.internalBinaryWrite(e.balances[r], t.tag(19, v.LengthDelimited).fork(), n).join(); | |
for (let r = 0; r < e.movements.length; r++) Rn.internalBinaryWrite(e.movements[r], t.tag(20, v.LengthDelimited).fork(), n).join(); | |
for (let r = 0; r < e.launchFills.length; r++) Ei.internalBinaryWrite(e.launchFills[r], t.tag(21, v.LengthDelimited).fork(), n).join(); | |
for (let r = 0; r < e.labels.length; r++) sl.internalBinaryWrite(e.labels[r], t.tag(22, v.LengthDelimited).fork(), n).join(); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const tl = new cw; | |
class hw extends Z { | |
constructor() { | |
super ('hypurr.TelegramUserSettings', []) | |
} | |
create(e) { | |
const t = {}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
return s ?? this.create() | |
} | |
internalBinaryWrite(e, t, n) { | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const il = new hw; | |
class dw extends Z { | |
constructor() { | |
super ('hypurr.TelegramUserReputation', []) | |
} | |
create(e) { | |
const t = {}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
return s ?? this.create() | |
} | |
internalBinaryWrite(e, t, n) { | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const nl = new dw; | |
class fw extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidWalletLabel', | |
[ | |
{ | |
no: 1, | |
name: 'ethereum_address', | |
kind: 'scalar', | |
T: 9 | |
}, | |
{ | |
no: 2, | |
name: 'label', | |
kind: 'scalar', | |
T: 9 | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
ethereumAddress: '', | |
label: '' | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.ethereumAddress = e.string(); | |
break; | |
case 2: | |
r.label = e.string(); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.ethereumAddress !== '' && | |
t.tag(1, v.LengthDelimited).string(e.ethereumAddress), | |
e.label !== '' && | |
t.tag(2, v.LengthDelimited).string(e.label); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const sl = new fw; | |
class pw extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidWalletPerformanceRequest', | |
[ | |
{ | |
no: 1, | |
name: 'ethereum_address', | |
kind: 'message', | |
T: () => ut | |
}, | |
{ | |
no: 2, | |
name: 'account_type', | |
kind: 'scalar', | |
T: 9 | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
accountType: '' | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.ethereumAddress = ut.internalBinaryRead(e, e.uint32(), n, r.ethereumAddress); | |
break; | |
case 2: | |
r.accountType = e.string(); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.ethereumAddress && | |
ut.internalBinaryWrite(e.ethereumAddress, t.tag(1, v.LengthDelimited).fork(), n).join(), | |
e.accountType !== '' && | |
t.tag(2, v.LengthDelimited).string(e.accountType); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const mw = new pw; | |
class gw extends Z { | |
constructor() { | |
super ( | |
'hypurr.PerformancePoint', | |
[ | |
{ | |
no: 1, | |
name: 'time', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 2, | |
name: 'notional', | |
kind: 'scalar', | |
T: 2 | |
}, | |
{ | |
no: 3, | |
name: 'pnl', | |
kind: 'scalar', | |
T: 2 | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
time: 0, | |
notional: 0, | |
pnl: 0 | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.time = e.int64().toNumber(); | |
break; | |
case 2: | |
r.notional = e.float(); | |
break; | |
case 3: | |
r.pnl = e.float(); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.time !== 0 && | |
t.tag(1, v.Varint).int64(e.time), | |
e.notional !== 0 && | |
t.tag(2, v.Bit32).float(e.notional), | |
e.pnl !== 0 && | |
t.tag(3, v.Bit32).float(e.pnl); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const rl = new gw; | |
class yw extends Z { | |
constructor() { | |
super ( | |
'hypurr.PerformanceReport', | |
[ | |
{ | |
no: 1, | |
name: 'token_id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 2, | |
name: 'total_pnl', | |
kind: 'scalar', | |
T: 2 | |
}, | |
{ | |
no: 3, | |
name: 'running_pnl', | |
kind: 'scalar', | |
T: 2 | |
}, | |
{ | |
no: 4, | |
name: 'size', | |
kind: 'scalar', | |
T: 2 | |
}, | |
{ | |
no: 5, | |
name: 'price', | |
kind: 'scalar', | |
T: 2 | |
}, | |
{ | |
no: 6, | |
name: 'entry_price', | |
kind: 'scalar', | |
T: 2 | |
}, | |
{ | |
no: 7, | |
name: 'total_cost', | |
kind: 'scalar', | |
T: 2 | |
}, | |
{ | |
no: 8, | |
name: 'running_cost', | |
kind: 'scalar', | |
T: 2 | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
tokenId: 0, | |
totalPnl: 0, | |
runningPnl: 0, | |
size: 0, | |
price: 0, | |
entryPrice: 0, | |
totalCost: 0, | |
runningCost: 0 | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.tokenId = e.int64().toNumber(); | |
break; | |
case 2: | |
r.totalPnl = e.float(); | |
break; | |
case 3: | |
r.runningPnl = e.float(); | |
break; | |
case 4: | |
r.size = e.float(); | |
break; | |
case 5: | |
r.price = e.float(); | |
break; | |
case 6: | |
r.entryPrice = e.float(); | |
break; | |
case 7: | |
r.totalCost = e.float(); | |
break; | |
case 8: | |
r.runningCost = e.float(); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.tokenId !== 0 && | |
t.tag(1, v.Varint).int64(e.tokenId), | |
e.totalPnl !== 0 && | |
t.tag(2, v.Bit32).float(e.totalPnl), | |
e.runningPnl !== 0 && | |
t.tag(3, v.Bit32).float(e.runningPnl), | |
e.size !== 0 && | |
t.tag(4, v.Bit32).float(e.size), | |
e.price !== 0 && | |
t.tag(5, v.Bit32).float(e.price), | |
e.entryPrice !== 0 && | |
t.tag(6, v.Bit32).float(e.entryPrice), | |
e.totalCost !== 0 && | |
t.tag(7, v.Bit32).float(e.totalCost), | |
e.runningCost !== 0 && | |
t.tag(8, v.Bit32).float(e.runningCost); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const al = new yw; | |
class vw extends Z { | |
constructor() { | |
super ( | |
'hypurr.Performance', | |
[ | |
{ | |
no: 1, | |
name: 'net_cash', | |
kind: 'scalar', | |
T: 2 | |
}, | |
{ | |
no: 2, | |
name: 'notional', | |
kind: 'scalar', | |
T: 2 | |
}, | |
{ | |
no: 3, | |
name: 'reports', | |
kind: 'message', | |
repeat: 1, | |
T: () => al | |
}, | |
{ | |
no: 4, | |
name: 'points', | |
kind: 'message', | |
repeat: 1, | |
T: () => rl | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
netCash: 0, | |
notional: 0, | |
reports: [], | |
points: [] | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.netCash = e.float(); | |
break; | |
case 2: | |
r.notional = e.float(); | |
break; | |
case 3: | |
r.reports.push(al.internalBinaryRead(e, e.uint32(), n)); | |
break; | |
case 4: | |
r.points.push(rl.internalBinaryRead(e, e.uint32(), n)); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.netCash !== 0 && | |
t.tag(1, v.Bit32).float(e.netCash), | |
e.notional !== 0 && | |
t.tag(2, v.Bit32).float(e.notional); | |
for (let r = 0; r < e.reports.length; r++) al.internalBinaryWrite(e.reports[r], t.tag(3, v.LengthDelimited).fork(), n).join(); | |
for (let r = 0; r < e.points.length; r++) rl.internalBinaryWrite(e.points[r], t.tag(4, v.LengthDelimited).fork(), n).join(); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const gi = new vw; | |
class bw extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidWalletPerformanceResponse', | |
[ | |
{ | |
no: 1, | |
name: 'spot', | |
kind: 'message', | |
T: () => gi | |
}, | |
{ | |
no: 2, | |
name: 'perp', | |
kind: 'message', | |
T: () => gi | |
}, | |
{ | |
no: 3, | |
name: 'launch', | |
kind: 'message', | |
T: () => gi | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = {}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.spot = gi.internalBinaryRead(e, e.uint32(), n, r.spot); | |
break; | |
case 2: | |
r.perp = gi.internalBinaryRead(e, e.uint32(), n, r.perp); | |
break; | |
case 3: | |
r.launch = gi.internalBinaryRead(e, e.uint32(), n, r.launch); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.spot && | |
gi.internalBinaryWrite(e.spot, t.tag(1, v.LengthDelimited).fork(), n).join(), | |
e.perp && | |
gi.internalBinaryWrite(e.perp, t.tag(2, v.LengthDelimited).fork(), n).join(), | |
e.launch && | |
gi.internalBinaryWrite(e.launch, t.tag(3, v.LengthDelimited).fork(), n).join(); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const ww = new bw; | |
class kw extends Z { | |
constructor() { | |
super ( | |
'hypurr.HypurrFunCabal', | |
[ | |
{ | |
no: 1, | |
name: 'telegram_chat_id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 2, | |
name: 'name', | |
kind: 'scalar', | |
T: 9 | |
}, | |
{ | |
no: 3, | |
name: 'picture_file_id', | |
kind: 'scalar', | |
T: 9 | |
}, | |
{ | |
no: 4, | |
name: 'users', | |
kind: 'message', | |
repeat: 1, | |
T: () => ol | |
}, | |
{ | |
no: 5, | |
name: 'tracked_wallets', | |
kind: 'message', | |
repeat: 1, | |
T: () => ul | |
}, | |
{ | |
no: 6, | |
name: 'user_seasons', | |
kind: 'message', | |
repeat: 1, | |
T: () => Dn | |
}, | |
{ | |
no: 7, | |
name: 'summary', | |
kind: 'message', | |
T: () => ll | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
telegramChatId: 0, | |
name: '', | |
pictureFileId: '', | |
users: [], | |
trackedWallets: [], | |
userSeasons: [] | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.telegramChatId = e.int64().toNumber(); | |
break; | |
case 2: | |
r.name = e.string(); | |
break; | |
case 3: | |
r.pictureFileId = e.string(); | |
break; | |
case 4: | |
r.users.push(ol.internalBinaryRead(e, e.uint32(), n)); | |
break; | |
case 5: | |
r.trackedWallets.push(ul.internalBinaryRead(e, e.uint32(), n)); | |
break; | |
case 6: | |
r.userSeasons.push(Dn.internalBinaryRead(e, e.uint32(), n)); | |
break; | |
case 7: | |
r.summary = ll.internalBinaryRead(e, e.uint32(), n, r.summary); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.telegramChatId !== 0 && | |
t.tag(1, v.Varint).int64(e.telegramChatId), | |
e.name !== '' && | |
t.tag(2, v.LengthDelimited).string(e.name), | |
e.pictureFileId !== '' && | |
t.tag(3, v.LengthDelimited).string(e.pictureFileId); | |
for (let r = 0; r < e.users.length; r++) ol.internalBinaryWrite(e.users[r], t.tag(4, v.LengthDelimited).fork(), n).join(); | |
for (let r = 0; r < e.trackedWallets.length; r++) ul.internalBinaryWrite(e.trackedWallets[r], t.tag(5, v.LengthDelimited).fork(), n).join(); | |
for (let r = 0; r < e.userSeasons.length; r++) Dn.internalBinaryWrite(e.userSeasons[r], t.tag(6, v.LengthDelimited).fork(), n).join(); | |
e.summary && | |
ll.internalBinaryWrite(e.summary, t.tag(7, v.LengthDelimited).fork(), n).join(); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const On = new kw; | |
class _w extends Z { | |
constructor() { | |
super ( | |
'hypurr.HypurrFunCabalSummary', | |
[ | |
{ | |
no: 1, | |
name: 'user_count', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 2, | |
name: 'season_spot_pnl', | |
kind: 'scalar', | |
T: 1 | |
}, | |
{ | |
no: 3, | |
name: 'season_perp_pnl', | |
kind: 'scalar', | |
T: 1 | |
}, | |
{ | |
no: 4, | |
name: 'season_launch_pnl', | |
kind: 'scalar', | |
T: 1 | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
userCount: 0, | |
seasonSpotPnl: 0, | |
seasonPerpPnl: 0, | |
seasonLaunchPnl: 0 | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.userCount = e.int64().toNumber(); | |
break; | |
case 2: | |
r.seasonSpotPnl = e.double(); | |
break; | |
case 3: | |
r.seasonPerpPnl = e.double(); | |
break; | |
case 4: | |
r.seasonLaunchPnl = e.double(); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.userCount !== 0 && | |
t.tag(1, v.Varint).int64(e.userCount), | |
e.seasonSpotPnl !== 0 && | |
t.tag(2, v.Bit64).double(e.seasonSpotPnl), | |
e.seasonPerpPnl !== 0 && | |
t.tag(3, v.Bit64).double(e.seasonPerpPnl), | |
e.seasonLaunchPnl !== 0 && | |
t.tag(4, v.Bit64).double(e.seasonLaunchPnl); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const ll = new _w; | |
class xw extends Z { | |
constructor() { | |
super ( | |
'hypurr.HypurrFunCabalUser', | |
[ | |
{ | |
no: 1, | |
name: 'telegram_chat_id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 2, | |
name: 'telegram_id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 3, | |
name: 'wallet', | |
kind: 'message', | |
T: () => Ve | |
}, | |
{ | |
no: 4, | |
name: 'wallet_id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 5, | |
name: 'name', | |
kind: 'scalar', | |
T: 9 | |
}, | |
{ | |
no: 6, | |
name: 'spot_pnl', | |
kind: 'scalar', | |
T: 1 | |
}, | |
{ | |
no: 7, | |
name: 'spot_equity', | |
kind: 'scalar', | |
T: 1 | |
}, | |
{ | |
no: 8, | |
name: 'launch_pnl', | |
kind: 'scalar', | |
T: 1 | |
}, | |
{ | |
no: 9, | |
name: 'launch_equity', | |
kind: 'scalar', | |
T: 1 | |
}, | |
{ | |
no: 10, | |
name: 'perp_pnl', | |
kind: 'scalar', | |
T: 1 | |
}, | |
{ | |
no: 11, | |
name: 'perp_equity', | |
kind: 'scalar', | |
T: 1 | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
telegramChatId: 0, | |
telegramId: 0, | |
walletId: 0, | |
name: '', | |
spotPnl: 0, | |
spotEquity: 0, | |
launchPnl: 0, | |
launchEquity: 0, | |
perpPnl: 0, | |
perpEquity: 0 | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.telegramChatId = e.int64().toNumber(); | |
break; | |
case 2: | |
r.telegramId = e.int64().toNumber(); | |
break; | |
case 3: | |
r.wallet = Ve.internalBinaryRead(e, e.uint32(), n, r.wallet); | |
break; | |
case 4: | |
r.walletId = e.int64().toNumber(); | |
break; | |
case 5: | |
r.name = e.string(); | |
break; | |
case 6: | |
r.spotPnl = e.double(); | |
break; | |
case 7: | |
r.spotEquity = e.double(); | |
break; | |
case 8: | |
r.launchPnl = e.double(); | |
break; | |
case 9: | |
r.launchEquity = e.double(); | |
break; | |
case 10: | |
r.perpPnl = e.double(); | |
break; | |
case 11: | |
r.perpEquity = e.double(); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.telegramChatId !== 0 && | |
t.tag(1, v.Varint).int64(e.telegramChatId), | |
e.telegramId !== 0 && | |
t.tag(2, v.Varint).int64(e.telegramId), | |
e.wallet && | |
Ve.internalBinaryWrite(e.wallet, t.tag(3, v.LengthDelimited).fork(), n).join(), | |
e.walletId !== 0 && | |
t.tag(4, v.Varint).int64(e.walletId), | |
e.name !== '' && | |
t.tag(5, v.LengthDelimited).string(e.name), | |
e.spotPnl !== 0 && | |
t.tag(6, v.Bit64).double(e.spotPnl), | |
e.spotEquity !== 0 && | |
t.tag(7, v.Bit64).double(e.spotEquity), | |
e.launchPnl !== 0 && | |
t.tag(8, v.Bit64).double(e.launchPnl), | |
e.launchEquity !== 0 && | |
t.tag(9, v.Bit64).double(e.launchEquity), | |
e.perpPnl !== 0 && | |
t.tag(10, v.Bit64).double(e.perpPnl), | |
e.perpEquity !== 0 && | |
t.tag(11, v.Bit64).double(e.perpEquity); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const ol = new xw; | |
class Tw extends Z { | |
constructor() { | |
super ( | |
'hypurr.HypurrFunCabalTrackedWallet', | |
[ | |
{ | |
no: 1, | |
name: 'telegram_chat_id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 2, | |
name: 'wallet_id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 3, | |
name: 'wallet', | |
kind: 'message', | |
T: () => Ve | |
}, | |
{ | |
no: 4, | |
name: 'label', | |
kind: 'scalar', | |
T: 9 | |
}, | |
{ | |
no: 5, | |
name: 'alert_spot', | |
kind: 'scalar', | |
T: 8 | |
}, | |
{ | |
no: 6, | |
name: 'alert_perp', | |
kind: 'scalar', | |
T: 8 | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
telegramChatId: 0, | |
walletId: 0, | |
label: '', | |
alertSpot: !1, | |
alertPerp: !1 | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.telegramChatId = e.int64().toNumber(); | |
break; | |
case 2: | |
r.walletId = e.int64().toNumber(); | |
break; | |
case 3: | |
r.wallet = Ve.internalBinaryRead(e, e.uint32(), n, r.wallet); | |
break; | |
case 4: | |
r.label = e.string(); | |
break; | |
case 5: | |
r.alertSpot = e.bool(); | |
break; | |
case 6: | |
r.alertPerp = e.bool(); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.telegramChatId !== 0 && | |
t.tag(1, v.Varint).int64(e.telegramChatId), | |
e.walletId !== 0 && | |
t.tag(2, v.Varint).int64(e.walletId), | |
e.wallet && | |
Ve.internalBinaryWrite(e.wallet, t.tag(3, v.LengthDelimited).fork(), n).join(), | |
e.label !== '' && | |
t.tag(4, v.LengthDelimited).string(e.label), | |
e.alertSpot !== !1 && | |
t.tag(5, v.Varint).bool(e.alertSpot), | |
e.alertPerp !== !1 && | |
t.tag(6, v.Varint).bool(e.alertPerp); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const ul = new Tw; | |
class Sw extends Z { | |
constructor() { | |
super ( | |
'hypurr.HypurrFunCabalSeason', | |
[ | |
{ | |
no: 1, | |
name: 'id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 2, | |
name: 'start_time', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 3, | |
name: 'end_time', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 4, | |
name: 'name', | |
kind: 'scalar', | |
T: 9 | |
}, | |
{ | |
no: 5, | |
name: 'user_seasons', | |
kind: 'message', | |
repeat: 1, | |
T: () => Dn | |
}, | |
{ | |
no: 6, | |
name: 'winner_id', | |
kind: 'message', | |
T: () => be | |
}, | |
{ | |
no: 7, | |
name: 'winner', | |
kind: 'message', | |
T: () => On | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
id: 0, | |
startTime: 0, | |
endTime: 0, | |
name: '', | |
userSeasons: [] | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.id = e.int64().toNumber(); | |
break; | |
case 2: | |
r.startTime = e.int64().toNumber(); | |
break; | |
case 3: | |
r.endTime = e.int64().toNumber(); | |
break; | |
case 4: | |
r.name = e.string(); | |
break; | |
case 5: | |
r.userSeasons.push(Dn.internalBinaryRead(e, e.uint32(), n)); | |
break; | |
case 6: | |
r.winnerId = be.internalBinaryRead(e, e.uint32(), n, r.winnerId); | |
break; | |
case 7: | |
r.winner = On.internalBinaryRead(e, e.uint32(), n, r.winner); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.id !== 0 && | |
t.tag(1, v.Varint).int64(e.id), | |
e.startTime !== 0 && | |
t.tag(2, v.Varint).int64(e.startTime), | |
e.endTime !== 0 && | |
t.tag(3, v.Varint).int64(e.endTime), | |
e.name !== '' && | |
t.tag(4, v.LengthDelimited).string(e.name); | |
for (let r = 0; r < e.userSeasons.length; r++) Dn.internalBinaryWrite(e.userSeasons[r], t.tag(5, v.LengthDelimited).fork(), n).join(); | |
e.winnerId && | |
be.internalBinaryWrite(e.winnerId, t.tag(6, v.LengthDelimited).fork(), n).join(), | |
e.winner && | |
On.internalBinaryWrite(e.winner, t.tag(7, v.LengthDelimited).fork(), n).join(); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
new Sw; | |
class Ew extends Z { | |
constructor() { | |
super ( | |
'hypurr.HypurrFunCabalUserSeason', | |
[ | |
{ | |
no: 1, | |
name: 'cabal_season_id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 2, | |
name: 'telegram_id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 3, | |
name: 'wallet_id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 4, | |
name: 'telegram_chat_id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 5, | |
name: 'spot_pnl', | |
kind: 'scalar', | |
T: 1 | |
}, | |
{ | |
no: 6, | |
name: 'launch_pnl', | |
kind: 'scalar', | |
T: 1 | |
}, | |
{ | |
no: 7, | |
name: 'perp_pnl', | |
kind: 'scalar', | |
T: 1 | |
}, | |
{ | |
no: 8, | |
name: 'last_spot_pnl', | |
kind: 'scalar', | |
T: 1 | |
}, | |
{ | |
no: 9, | |
name: 'last_launch_pnl', | |
kind: 'scalar', | |
T: 1 | |
}, | |
{ | |
no: 10, | |
name: 'last_perp_pnl', | |
kind: 'scalar', | |
T: 1 | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
cabalSeasonId: 0, | |
telegramId: 0, | |
walletId: 0, | |
telegramChatId: 0, | |
spotPnl: 0, | |
launchPnl: 0, | |
perpPnl: 0, | |
lastSpotPnl: 0, | |
lastLaunchPnl: 0, | |
lastPerpPnl: 0 | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.cabalSeasonId = e.int64().toNumber(); | |
break; | |
case 2: | |
r.telegramId = e.int64().toNumber(); | |
break; | |
case 3: | |
r.walletId = e.int64().toNumber(); | |
break; | |
case 4: | |
r.telegramChatId = e.int64().toNumber(); | |
break; | |
case 5: | |
r.spotPnl = e.double(); | |
break; | |
case 6: | |
r.launchPnl = e.double(); | |
break; | |
case 7: | |
r.perpPnl = e.double(); | |
break; | |
case 8: | |
r.lastSpotPnl = e.double(); | |
break; | |
case 9: | |
r.lastLaunchPnl = e.double(); | |
break; | |
case 10: | |
r.lastPerpPnl = e.double(); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.cabalSeasonId !== 0 && | |
t.tag(1, v.Varint).int64(e.cabalSeasonId), | |
e.telegramId !== 0 && | |
t.tag(2, v.Varint).int64(e.telegramId), | |
e.walletId !== 0 && | |
t.tag(3, v.Varint).int64(e.walletId), | |
e.telegramChatId !== 0 && | |
t.tag(4, v.Varint).int64(e.telegramChatId), | |
e.spotPnl !== 0 && | |
t.tag(5, v.Bit64).double(e.spotPnl), | |
e.launchPnl !== 0 && | |
t.tag(6, v.Bit64).double(e.launchPnl), | |
e.perpPnl !== 0 && | |
t.tag(7, v.Bit64).double(e.perpPnl), | |
e.lastSpotPnl !== 0 && | |
t.tag(8, v.Bit64).double(e.lastSpotPnl), | |
e.lastLaunchPnl !== 0 && | |
t.tag(9, v.Bit64).double(e.lastLaunchPnl), | |
e.lastPerpPnl !== 0 && | |
t.tag(10, v.Bit64).double(e.lastPerpPnl); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const Dn = new Ew; | |
class Cw extends Z { | |
constructor() { | |
super ('hypurr.HypurrFunCabalsRequest', []) | |
} | |
create(e) { | |
const t = {}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
return s ?? this.create() | |
} | |
internalBinaryWrite(e, t, n) { | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const $w = new Cw; | |
class Lw extends Z { | |
constructor() { | |
super ( | |
'hypurr.HypurrFunCabalsResponse', | |
[ | |
{ | |
no: 1, | |
name: 'cabals', | |
kind: 'message', | |
repeat: 1, | |
T: () => On | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
cabals: [] | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.cabals.push(On.internalBinaryRead(e, e.uint32(), n)); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
for (let r = 0; r < e.cabals.length; r++) On.internalBinaryWrite(e.cabals[r], t.tag(1, v.LengthDelimited).fork(), n).join(); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const Pw = new Lw; | |
class Iw extends Z { | |
constructor() { | |
super ( | |
'hypurr.TelegramUserRequest', | |
[ | |
{ | |
no: 1, | |
name: 'auth_data', | |
kind: 'map', | |
K: 9, | |
V: { | |
kind: 'scalar', | |
T: 9 | |
} | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
authData: { | |
} | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
this.binaryReadMap1(r.authData, e, n); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
binaryReadMap1(e, t, n) { | |
let s = t.uint32(), | |
r = t.pos + s, | |
a, | |
l; | |
for (; t.pos < r; ) { | |
let[o, | |
u] = t.tag(); | |
switch (o) { | |
case 1: | |
a = t.string(); | |
break; | |
case 2: | |
l = t.string(); | |
break; | |
default: | |
throw new globalThis.Error( | |
'unknown map entry field for field hypurr.TelegramUserRequest.auth_data' | |
) | |
} | |
} | |
e[a ?? ''] = l ?? '' | |
} | |
internalBinaryWrite(e, t, n) { | |
for (let r of Object.keys(e.authData)) t.tag(1, v.LengthDelimited).fork().tag(1, v.LengthDelimited).string(r).tag(2, v.LengthDelimited).string(e.authData[r]).join(); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const Nw = new Iw; | |
class Mw extends Z { | |
constructor() { | |
super ( | |
'hypurr.TelegramUserResponse', | |
[ | |
{ | |
no: 1, | |
name: 'user', | |
kind: 'message', | |
T: () => tl | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = {}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.user = tl.internalBinaryRead(e, e.uint32(), n, r.user); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.user && | |
tl.internalBinaryWrite(e.user, t.tag(1, v.LengthDelimited).fork(), n).join(); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const Rw = new Mw; | |
class Bw extends Z { | |
constructor() { | |
super ( | |
'hypurr.TelegramUserWalletsRequest', | |
[ | |
{ | |
no: 1, | |
name: 'auth_data', | |
kind: 'map', | |
K: 9, | |
V: { | |
kind: 'scalar', | |
T: 9 | |
} | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
authData: { | |
} | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
this.binaryReadMap1(r.authData, e, n); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
binaryReadMap1(e, t, n) { | |
let s = t.uint32(), | |
r = t.pos + s, | |
a, | |
l; | |
for (; t.pos < r; ) { | |
let[o, | |
u] = t.tag(); | |
switch (o) { | |
case 1: | |
a = t.string(); | |
break; | |
case 2: | |
l = t.string(); | |
break; | |
default: | |
throw new globalThis.Error( | |
'unknown map entry field for field hypurr.TelegramUserWalletsRequest.auth_data' | |
) | |
} | |
} | |
e[a ?? ''] = l ?? '' | |
} | |
internalBinaryWrite(e, t, n) { | |
for (let r of Object.keys(e.authData)) t.tag(1, v.LengthDelimited).fork().tag(1, v.LengthDelimited).string(r).tag(2, v.LengthDelimited).string(e.authData[r]).join(); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const Ow = new Bw; | |
class Dw extends Z { | |
constructor() { | |
super ( | |
'hypurr.TelegramUserWalletsResponse', | |
[ | |
{ | |
no: 1, | |
name: 'wallets', | |
kind: 'message', | |
repeat: 1, | |
T: () => Ve | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
wallets: [] | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.wallets.push(Ve.internalBinaryRead(e, e.uint32(), n)); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
for (let r = 0; r < e.wallets.length; r++) Ve.internalBinaryWrite(e.wallets[r], t.tag(1, v.LengthDelimited).fork(), n).join(); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const Fw = new Dw; | |
class Aw extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidLaunchTradeRequest', | |
[ | |
{ | |
no: 1, | |
name: 'auth_data', | |
kind: 'map', | |
K: 9, | |
V: { | |
kind: 'scalar', | |
T: 9 | |
} | |
}, | |
{ | |
no: 2, | |
name: 'launch_id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 3, | |
name: 'wallet_id', | |
kind: 'scalar', | |
T: 3, | |
L: 2 | |
}, | |
{ | |
no: 4, | |
name: 'direction', | |
kind: 'enum', | |
T: () => ['hypurr.HyperliquidLaunchTradeDirection', | |
Hr] | |
}, | |
{ | |
no: 5, | |
name: 'amount', | |
kind: 'scalar', | |
T: 1 | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
authData: { | |
}, | |
launchId: 0, | |
walletId: 0, | |
direction: 0, | |
amount: 0 | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
this.binaryReadMap1(r.authData, e, n); | |
break; | |
case 2: | |
r.launchId = e.int64().toNumber(); | |
break; | |
case 3: | |
r.walletId = e.int64().toNumber(); | |
break; | |
case 4: | |
r.direction = e.int32(); | |
break; | |
case 5: | |
r.amount = e.double(); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
binaryReadMap1(e, t, n) { | |
let s = t.uint32(), | |
r = t.pos + s, | |
a, | |
l; | |
for (; t.pos < r; ) { | |
let[o, | |
u] = t.tag(); | |
switch (o) { | |
case 1: | |
a = t.string(); | |
break; | |
case 2: | |
l = t.string(); | |
break; | |
default: | |
throw new globalThis.Error( | |
'unknown map entry field for field hypurr.HyperliquidLaunchTradeRequest.auth_data' | |
) | |
} | |
} | |
e[a ?? ''] = l ?? '' | |
} | |
internalBinaryWrite(e, t, n) { | |
for (let r of Object.keys(e.authData)) t.tag(1, v.LengthDelimited).fork().tag(1, v.LengthDelimited).string(r).tag(2, v.LengthDelimited).string(e.authData[r]).join(); | |
e.launchId !== 0 && | |
t.tag(2, v.Varint).int64(e.launchId), | |
e.walletId !== 0 && | |
t.tag(3, v.Varint).int64(e.walletId), | |
e.direction !== 0 && | |
t.tag(4, v.Varint).int32(e.direction), | |
e.amount !== 0 && | |
t.tag(5, v.Bit64).double(e.amount); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const Vw = new Aw; | |
class zw extends Z { | |
constructor() { | |
super ( | |
'hypurr.HyperliquidLaunchTradeResponse', | |
[ | |
{ | |
no: 1, | |
name: 'base_amount', | |
kind: 'scalar', | |
T: 1 | |
}, | |
{ | |
no: 2, | |
name: 'quote_amount', | |
kind: 'scalar', | |
T: 1 | |
}, | |
{ | |
no: 3, | |
name: 'message', | |
kind: 'scalar', | |
T: 9 | |
}, | |
{ | |
no: 4, | |
name: 'success', | |
kind: 'scalar', | |
T: 8 | |
} | |
] | |
) | |
} | |
create(e) { | |
const t = { | |
baseAmount: 0, | |
quoteAmount: 0, | |
message: '', | |
success: !1 | |
}; | |
return globalThis.Object.defineProperty(t, J, { | |
enumerable: !1, | |
value: this | |
}), | |
e !== void 0 && | |
X(this, t, e), | |
t | |
} | |
internalBinaryRead(e, t, n, s) { | |
let r = s ?? this.create(), | |
a = e.pos + t; | |
for (; e.pos < a; ) { | |
let[l, | |
o] = e.tag(); | |
switch (l) { | |
case 1: | |
r.baseAmount = e.double(); | |
break; | |
case 2: | |
r.quoteAmount = e.double(); | |
break; | |
case 3: | |
r.message = e.string(); | |
break; | |
case 4: | |
r.success = e.bool(); | |
break; | |
default: | |
let u = n.readUnknownField; | |
if (u === 'throw') throw new globalThis.Error(`Unknown field ${ l } (wire type ${ o }) for ${ this.typeName }`); | |
let c = e.skip(o); | |
u !== !1 && | |
(u === !0 ? P.onRead : u) (this.typeName, r, l, o, c) | |
} | |
} | |
return r | |
} | |
internalBinaryWrite(e, t, n) { | |
e.baseAmount !== 0 && | |
t.tag(1, v.Bit64).double(e.baseAmount), | |
e.quoteAmount !== 0 && | |
t.tag(2, v.Bit64).double(e.quoteAmount), | |
e.message !== '' && | |
t.tag(3, v.LengthDelimited).string(e.message), | |
e.success !== !1 && | |
t.tag(4, v.Varint).bool(e.success); | |
let s = n.writeUnknownFields; | |
return s !== !1 && | |
(s == !0 ? P.onWrite : s) (this.typeName, e, t), | |
t | |
} | |
} | |
const Ww = new zw, | |
cl = new Zf( | |
'hypurr.Telegram', | |
[ | |
{ | |
name: 'TelegramUser', | |
options: { | |
}, | |
I: Nw, | |
O: Rw | |
}, | |
{ | |
name: 'TelegramUserWallets', | |
options: { | |
}, | |
I: Ow, | |
O: Fw | |
}, | |
{ | |
name: 'HyperliquidLaunchTrade', | |
options: { | |
}, | |
I: Vw, | |
O: Ww | |
} | |
] | |
), | |
hl = new Zf( | |
'hypurr.Static', | |
[ | |
{ | |
name: 'HyperliquidDeployAuction', | |
options: { | |
}, | |
I: Gv, | |
O: Xv | |
}, | |
{ | |
name: 'HyperliquidTokens', | |
options: { | |
}, | |
I: Yv, | |
O: Zv | |
}, | |
{ | |
name: 'HyperliquidTokenHolders', | |
options: { | |
}, | |
I: Cv, | |
O: Lv | |
}, | |
{ | |
name: 'HyperliquidTokenMessages', | |
serverStreaming: !0, | |
options: { | |
}, | |
I: ib, | |
O: sb | |
}, | |
{ | |
name: 'HyperliquidSpotPair', | |
options: { | |
}, | |
I: ab, | |
O: ob | |
}, | |
{ | |
name: 'HyperliquidSpotPairs', | |
options: { | |
}, | |
I: cb, | |
O: db | |
}, | |
{ | |
name: 'HyperliquidPerpPairs', | |
options: { | |
}, | |
I: pb, | |
O: gb | |
}, | |
{ | |
name: 'HyperliquidWallet', | |
options: { | |
}, | |
I: vb, | |
O: wb | |
}, | |
{ | |
name: 'HyperliquidWalletDeploySessions', | |
options: { | |
}, | |
I: Pb, | |
O: Nb | |
}, | |
{ | |
name: 'HyperliquidWalletPerformance', | |
options: { | |
}, | |
I: mw, | |
O: ww | |
}, | |
{ | |
name: 'HyperliquidLaunch', | |
options: { | |
}, | |
I: Xb, | |
O: Yb | |
}, | |
{ | |
name: 'HyperliquidLaunches', | |
options: { | |
}, | |
I: _b, | |
O: Tb | |
}, | |
{ | |
name: 'HyperliquidLaunchStream', | |
serverStreaming: !0, | |
options: { | |
}, | |
I: Eb, | |
O: $b | |
}, | |
{ | |
name: 'HyperliquidLaunchFills', | |
serverStreaming: !0, | |
options: { | |
}, | |
I: Wb, | |
O: Nc | |
}, | |
{ | |
name: 'HyperliquidLaunchCandles', | |
options: { | |
}, | |
I: Mc, | |
O: Rc | |
}, | |
{ | |
name: 'HyperliquidLaunchCandleStream', | |
serverStreaming: !0, | |
options: { | |
}, | |
I: Mc, | |
O: Rc | |
}, | |
{ | |
name: 'HyperliquidLaunchMessages', | |
serverStreaming: !0, | |
options: { | |
}, | |
I: ew, | |
O: iw | |
}, | |
{ | |
name: 'LatestHyperliquidLaunchFills', | |
serverStreaming: !0, | |
options: { | |
}, | |
I: uw, | |
O: Nc | |
}, | |
{ | |
name: 'HyperliquidLaunchHolders', | |
options: { | |
}, | |
I: rw, | |
O: lw | |
}, | |
{ | |
name: 'HypurrFunCabals', | |
options: { | |
}, | |
I: $w, | |
O: Pw | |
}, | |
{ | |
name: 'SetHyperliquidWalletDeploySessionTarget', | |
options: { | |
}, | |
I: Rb, | |
O: Ob | |
}, | |
{ | |
name: 'DeleteHyperliquidWalletDeploySessionTarget', | |
options: { | |
}, | |
I: Fb, | |
O: Vb | |
} | |
] | |
); | |
class Uw { | |
constructor(e) { | |
this._transport = e | |
} | |
typeName = cl.typeName; | |
methods = cl.methods; | |
options = cl.options; | |
telegramUser(e, t) { | |
const n = this.methods[0], | |
s = this._transport.mergeOptions(t); | |
return Ge('unary', this._transport, n, s, e) | |
} | |
telegramUserWallets(e, t) { | |
const n = this.methods[1], | |
s = this._transport.mergeOptions(t); | |
return Ge('unary', this._transport, n, s, e) | |
} | |
hyperliquidLaunchTrade(e, t) { | |
const n = this.methods[2], | |
s = this._transport.mergeOptions(t); | |
return Ge('unary', this._transport, n, s, e) | |
} | |
} | |
class ep { | |
constructor(e) { | |
this._transport = e | |
} | |
typeName = hl.typeName; | |
methods = hl.methods; | |
options = hl.options; | |
hyperliquidDeployAuction(e, t) { | |
const n = this.methods[0], | |
s = this._transport.mergeOptions(t); | |
return Ge('unary', this._transport, n, s, e) | |
} | |
hyperliquidTokens(e, t) { | |
const n = this.methods[1], | |
s = this._transport.mergeOptions(t); | |
return Ge('unary', this._transport, n, s, e) | |
} | |
hyperliquidTokenHolders(e, t) { | |
const n = this.methods[2], | |
s = this._transport.mergeOptions(t); | |
return Ge('unary', this._transport, n, s, e) | |
} | |
hyperliquidTokenMessages(e, t) { | |
const n = this.methods[3], | |
s = this._transport.mergeOptions(t); | |
return Ge('serverStreaming', this._transport, n, s, e) | |
} | |
hyperliquidSpotPair(e, t) { | |
const n = this.methods[4], | |
s = this._transport.mergeOptions(t); | |
return Ge('unary', this._transport, n, s, e) | |
} | |
hyperliquidSpotPairs(e, t) { | |
const n = this.methods[5], | |
s = this._transport.mergeOptions(t); | |
return Ge('unary', this._transport, n, s, e) | |
} | |
hyperliquidPerpPairs(e, t) { | |
const n = this.methods[6], | |
s = this._transport.mergeOptions(t); | |
return Ge('unary', this._transport, n, s, e) | |
} | |
hyperliquidWallet(e, t) { | |
const n = this.methods[7], | |
s = this._transport.mergeOptions(t); | |
return Ge('unary', this._transport, n, s, e) | |
} | |
hyperliquidWalletDeploySessions(e, t) { | |
const n = this.methods[8], | |
s = this._transport.mergeOptions(t); | |
return Ge('unary', this._transport, n, s, e) | |
} | |
hyperliquidWalletPerformance(e, t) { | |
const n = this.methods[9], | |
s = this._transport.mergeOptions(t); | |
return Ge('unary', this._transport, n, s, e) | |
} | |
hyperliquidLaunch(e, t) { | |
const n = this.methods[10], | |
s = this._transport.mergeOptions(t); | |
return Ge('unary', this._transport, n, s, e) | |
} | |
hyperliquidLaunches(e, t) { | |
const n = this.methods[11], | |
s = this._transport.mergeOptions(t); | |
return Ge('unary', this._transport, n, s, e) | |
} | |
hyperliquidLaunchStream(e, t) { | |
const n = this.methods[12], | |
s = this._transport.mergeOptions(t); | |
return Ge('serverStreaming', this._transport, n, s, e) | |
} | |
hyperliquidLaunchFills(e, t) { | |
const n = this.methods[13], | |
s = this._transport.mergeOptions(t); | |
return Ge('serverStreaming', this._transport, n, s, e) | |
} | |
hyperliquidLaunchCandles(e, t) { | |
const n = this.methods[14], | |
s = this._transport.mergeOptions(t); | |
return Ge('unary', this._transport, n, s, e) | |
} | |
hyperliquidLaunchCandleStream(e, t) { | |
const n = this.methods[15], | |
s = this._transport.mergeOptions(t); | |
return Ge('serverStreaming', this._transport, n, s, e) | |
} | |
hyperliquidLaunchMessages(e, t) { | |
const n = this.methods[16], | |
s = this._transport.mergeOptions(t); | |
return Ge('serverStreaming', this._transport, n, s, e) | |
} | |
latestHyperliquidLaunchFills(e, t) { | |
const n = this.methods[17], | |
s = this._transport.mergeOptions(t); | |
return Ge('serverStreaming', this._transport, n, s, e) | |
} | |
hyperliquidLaunchHolders(e, t) { | |
const n = this.methods[18], | |
s = this._transport.mergeOptions(t); | |
return Ge('unary', this._transport, n, s, e) | |
} | |
hypurrFunCabals(e, t) { | |
const n = this.methods[19], | |
s = this._transport.mergeOptions(t); | |
return Ge('unary', this._transport, n, s, e) | |
} | |
setHyperliquidWalletDeploySessionTarget(e, t) { | |
const n = this.methods[20], | |
s = this._transport.mergeOptions(t); | |
return Ge('unary', this._transport, n, s, e) | |
} | |
deleteHyperliquidWalletDeploySessionTarget(e, t) { | |
const n = this.methods[21], | |
s = this._transport.mergeOptions(t); | |
return Ge('unary', this._transport, n, s, e) | |
} | |
} | |
var oe; | |
( | |
function (i) { | |
i[i.OK = 0] = 'OK', | |
i[i.CANCELLED = 1] = 'CANCELLED', | |
i[i.UNKNOWN = 2] = 'UNKNOWN', | |
i[i.INVALID_ARGUMENT = 3] = 'INVALID_ARGUMENT', | |
i[i.DEADLINE_EXCEEDED = 4] = 'DEADLINE_EXCEEDED', | |
i[i.NOT_FOUND = 5] = 'NOT_FOUND', | |
i[i.ALREADY_EXISTS = 6] = 'ALREADY_EXISTS', | |
i[i.PERMISSION_DENIED = 7] = 'PERMISSION_DENIED', | |
i[i.UNAUTHENTICATED = 16] = 'UNAUTHENTICATED', | |
i[i.RESOURCE_EXHAUSTED = 8] = 'RESOURCE_EXHAUSTED', | |
i[i.FAILED_PRECONDITION = 9] = 'FAILED_PRECONDITION', | |
i[i.ABORTED = 10] = 'ABORTED', | |
i[i.OUT_OF_RANGE = 11] = 'OUT_OF_RANGE', | |
i[i.UNIMPLEMENTED = 12] = 'UNIMPLEMENTED', | |
i[i.INTERNAL = 13] = 'INTERNAL', | |
i[i.UNAVAILABLE = 14] = 'UNAVAILABLE', | |
i[i.DATA_LOSS = 15] = 'DATA_LOSS' | |
} | |
) (oe || (oe = {})); | |
var jw = globalThis && | |
globalThis.__awaiter || | |
function (i, e, t, n) { | |
function s(r) { | |
return r instanceof t ? r : new t(function (a) { | |
a(r) | |
}) | |
} | |
return new (t || (t = Promise)) ( | |
function (r, a) { | |
function l(c) { | |
try { | |
u(n.next(c)) | |
} catch (h) { | |
a(h) | |
} | |
} | |
function o(c) { | |
try { | |
u(n.throw(c)) | |
} catch (h) { | |
a(h) | |
} | |
} | |
function u(c) { | |
c.done ? r(c.value) : s(c.value).then(l, o) | |
} | |
u((n = n.apply(i, e || [])).next()) | |
} | |
) | |
}; | |
function Bc(i, e, t, n, s) { | |
if (n) for (let[r, | |
a]of Object.entries(n)) if (typeof a == 'string') i.append(r, a); | |
else for (let l of a) i.append(r, l); | |
if ( | |
i.set( | |
'Content-Type', | |
e === 'text' ? 'application/grpc-web-text' : 'application/grpc-web+proto' | |
), | |
e == 'text' && | |
i.set('Accept', 'application/grpc-web-text'), | |
i.set('X-Grpc-Web', '1'), | |
s && | |
i.set('X-User-Agent', s), | |
typeof t == 'number' | |
) { | |
if (t <= 0) throw new Fe(`timeout ${ t } ms exceeded`, oe[oe.DEADLINE_EXCEEDED]); | |
i.set('grpc-timeout', `${ t }m`) | |
} else if (t) { | |
const r = t.getTime(), | |
a = Date.now(); | |
if (r <= a) throw new Fe(`deadline ${ t } exceeded`, oe[oe.DEADLINE_EXCEEDED]); | |
i.set('grpc-timeout', `${ r - a }m`) | |
} | |
return i | |
} | |
function Oc(i, e) { | |
let t = new Uint8Array(5 + i.length); | |
t[0] = Yt.DATA; | |
for (let n = i.length, s = 4; s > 0; s--) t[s] = n % 256, | |
n >>>= 8; | |
return t.set(i, 5), | |
e === 'binary' ? t : Gf(t) | |
} | |
function oo(i, e, t) { | |
if (arguments.length === 1) { | |
let o = i, | |
u; | |
try { | |
u = o.type | |
} catch { | |
} | |
switch (u) { | |
case 'error': | |
case 'opaque': | |
case 'opaqueredirect': | |
throw new Fe(`fetch response type ${ o.type }`, oe[oe.UNKNOWN]) | |
} | |
return oo(Kw(o.headers), o.status, o.statusText) | |
} | |
let n = i, | |
s = e >= 200 && | |
e < 300, | |
r = ip(n), | |
[ | |
a, | |
l | |
] = tp(n); | |
return (a === void 0 || a === oe.OK) && | |
!s && | |
(a = Xw(e), l = t), | |
[ | |
a, | |
l, | |
r | |
] | |
} | |
function Dc(i) { | |
let e = Gw(i), | |
[ | |
t, | |
n | |
] = tp(e), | |
s = ip(e); | |
return [t ?? oe.OK, | |
n, | |
s] | |
} | |
var Yt; | |
(function (i) { | |
i[i.DATA = 0] = 'DATA', | |
i[i.TRAILER = 128] = 'TRAILER' | |
}) (Yt || (Yt = {})); | |
function Fc(i, e, t) { | |
return jw( | |
this, | |
void 0, | |
void 0, | |
function * () { | |
let n, | |
s = '', | |
r = new Uint8Array(0), | |
a = qw(e); | |
if (Hw(i)) { | |
let l = i.getReader(); | |
n = { | |
next: () => l.read() | |
} | |
} else n = i[Symbol.asyncIterator](); | |
for (; ; ) { | |
let l = yield n.next(); | |
if (l.value !== void 0) { | |
if (a === 'text') { | |
for (let u = 0; u < l.value.length; u++) s += String.fromCharCode(l.value[u]); | |
let o = s.length - s.length % 4; | |
if (o === 0) continue; | |
r = Ac(r, qf(s.substring(0, o))), | |
s = s.substring(o) | |
} else r = Ac(r, l.value); | |
for (; r.length >= 5 && r[0] === Yt.DATA; ) { | |
let o = 0; | |
for (let u = 1; u < 5; u++) o = (o << 8) + r[u]; | |
if (r.length - 5 >= o) t(Yt.DATA, r.subarray(5, 5 + o)), | |
r = r.subarray(5 + o); | |
else break | |
} | |
} | |
if (l.done) { | |
if (r.length === 0) break; | |
if (r[0] !== Yt.TRAILER || r.length < 5) throw new Fe('premature EOF', oe[oe.DATA_LOSS]); | |
t(Yt.TRAILER, r.subarray(5)); | |
break | |
} | |
} | |
} | |
) | |
} | |
const Hw = i => typeof i.getReader == 'function'; | |
function Ac(i, e) { | |
let t = new Uint8Array(i.length + e.length); | |
return t.set(i), | |
t.set(e, i.length), | |
t | |
} | |
function qw(i) { | |
switch (i) { | |
case 'application/grpc-web-text': | |
case 'application/grpc-web-text+proto': | |
return 'text'; | |
case 'application/grpc-web': | |
case 'application/grpc-web+proto': | |
return 'binary'; | |
case void 0: | |
case null: | |
throw new Fe('missing response content type', oe[oe.INTERNAL]); | |
default: | |
throw new Fe('unexpected response content type: ' + i, oe[oe.INTERNAL]) | |
} | |
} | |
function tp(i) { | |
let e, | |
t, | |
n = i['grpc-message']; | |
if (n !== void 0) { | |
if (Array.isArray(n)) return [oe.INTERNAL, | |
'invalid grpc-web message']; | |
t = n | |
} | |
let s = i['grpc-status']; | |
if (s !== void 0) { | |
if (Array.isArray(s)) return [oe.INTERNAL, | |
'invalid grpc-web status']; | |
if (e = parseInt(s, 10), oe[e] === void 0) return [oe.INTERNAL, | |
'invalid grpc-web status'] | |
} | |
return [e, | |
t] | |
} | |
function ip(i) { | |
let e = {}; | |
for (let[t, | |
n]of Object.entries(i)) switch (t) { | |
case 'grpc-message': | |
case 'grpc-status': | |
case 'content-type': | |
break; | |
default: | |
e[t] = n | |
} | |
return e | |
} | |
function Gw(i) { | |
let e = {}; | |
for ( | |
let t of String.fromCharCode.apply(String, i).trim().split(`\r | |
`) | |
) { | |
if (t == '') continue; | |
let[n, | |
...s] = t.split(':'); | |
const r = s.join(':').trim(); | |
n = n.trim(); | |
let a = e[n]; | |
typeof a == 'string' ? e[n] = [ | |
a, | |
r | |
] : Array.isArray(a) ? a.push(r) : e[n] = r | |
} | |
return e | |
} | |
function Kw(i) { | |
let e = {}; | |
return i.forEach( | |
(t, n) => { | |
let s = e[n]; | |
typeof s == 'string' ? e[n] = [ | |
s, | |
t | |
] : Array.isArray(s) ? s.push(t) : e[n] = t | |
} | |
), | |
e | |
} | |
function Xw(i) { | |
switch (i) { | |
case 200: | |
return oe.OK; | |
case 400: | |
return oe.INVALID_ARGUMENT; | |
case 401: | |
return oe.UNAUTHENTICATED; | |
case 403: | |
return oe.PERMISSION_DENIED; | |
case 404: | |
return oe.NOT_FOUND; | |
case 409: | |
return oe.ABORTED; | |
case 412: | |
return oe.FAILED_PRECONDITION; | |
case 429: | |
return oe.RESOURCE_EXHAUSTED; | |
case 499: | |
return oe.CANCELLED; | |
case 500: | |
return oe.UNKNOWN; | |
case 501: | |
return oe.UNIMPLEMENTED; | |
case 503: | |
return oe.UNAVAILABLE; | |
case 504: | |
return oe.DEADLINE_EXCEEDED; | |
default: | |
return oe.UNKNOWN | |
} | |
} | |
class cu { | |
constructor(e) { | |
this.defaultOptions = e | |
} | |
mergeOptions(e) { | |
return uv(this.defaultOptions, e) | |
} | |
makeUrl(e, t) { | |
let n = t.baseUrl; | |
return n.endsWith('/') && | |
(n = n.substring(0, n.length - 1)), | |
`${ n }/${ e.service.typeName }/${ e.name }` | |
} | |
clientStreaming(e) { | |
const t = new Fe( | |
'Client streaming is not supported by grpc-web', | |
oe[oe.UNIMPLEMENTED] | |
); | |
throw t.methodName = e.name, | |
t.serviceName = e.service.typeName, | |
t | |
} | |
duplex(e) { | |
const t = new Fe( | |
'Duplex streaming is not supported by grpc-web', | |
oe[oe.UNIMPLEMENTED] | |
); | |
throw t.methodName = e.name, | |
t.serviceName = e.service.typeName, | |
t | |
} | |
serverStreaming(e, t, n) { | |
var s, | |
r, | |
a, | |
l; | |
let o = n, | |
u = (s = o.format) !== null && | |
s !== void 0 ? s : 'text', | |
c = (r = o.fetchInit) !== null && | |
r !== void 0 ? r : { | |
}, | |
h = this.makeUrl(e, o), | |
d = e.I.toBinary(t, o.binaryOptions), | |
f = new Ri, | |
p = new cv, | |
g = !0, | |
w, | |
y = new Ri, | |
b, | |
x = new Ri; | |
return globalThis.fetch( | |
h, | |
Object.assign( | |
Object.assign({ | |
}, c), | |
{ | |
method: 'POST', | |
headers: Bc(new globalThis.Headers, u, o.timeout, o.meta), | |
body: Oc(d, u), | |
signal: (a = n.abort) !== null && | |
a !== void 0 ? a : null | |
} | |
) | |
).then( | |
k => { | |
let[S, | |
B, | |
z] = oo(k); | |
if (f.resolve(z), S != null && S !== oe.OK) throw new Fe(B ?? oe[S], oe[S], z); | |
return S != null && | |
(w = { | |
code: oe[S], | |
detail: B ?? oe[S] | |
}), | |
k | |
} | |
).then( | |
k => { | |
if (!k.body) throw new Fe('missing response body', oe[oe.INTERNAL]); | |
return Fc( | |
k.body, | |
k.headers.get('content-type'), | |
(S, B) => { | |
switch (S) { | |
case Yt.DATA: | |
p.notifyMessage(e.O.fromBinary(B, o.binaryOptions)), | |
g = !1; | |
break; | |
case Yt.TRAILER: | |
let z, | |
I; | |
[ | |
z, | |
I, | |
b | |
] = Dc(B), | |
w = { | |
code: oe[z], | |
detail: I ?? oe[z] | |
}; | |
break | |
} | |
} | |
) | |
} | |
).then( | |
() => { | |
if (!b && !g) throw new Fe('missing trailers', oe[oe.DATA_LOSS]); | |
if (!w) throw new Fe('missing status', oe[oe.INTERNAL]); | |
if (w.code !== 'OK') throw new Fe(w.detail, w.code, b); | |
p.notifyComplete(), | |
y.resolve(w), | |
x.resolve(b || { | |
}) | |
} | |
).catch( | |
k => { | |
let S; | |
k instanceof Fe ? S = k : k instanceof Error && | |
k.name === 'AbortError' ? S = new Fe(k.message, oe[oe.CANCELLED]) : S = new Fe(k instanceof Error ? k.message : '' + k, oe[oe.INTERNAL]), | |
S.methodName = e.name, | |
S.serviceName = e.service.typeName, | |
f.rejectPending(S), | |
p.notifyError(S), | |
y.rejectPending(S), | |
x.rejectPending(S) | |
} | |
), | |
new pv( | |
e, | |
(l = o.meta) !== null && | |
l !== void 0 ? l : { | |
}, | |
t, | |
f.promise, | |
p, | |
y.promise, | |
x.promise | |
) | |
} | |
unary(e, t, n) { | |
var s, | |
r, | |
a, | |
l; | |
let o = n, | |
u = (s = o.format) !== null && | |
s !== void 0 ? s : 'text', | |
c = (r = o.fetchInit) !== null && | |
r !== void 0 ? r : { | |
}, | |
h = this.makeUrl(e, o), | |
d = e.I.toBinary(t, o.binaryOptions), | |
f = new Ri, | |
p, | |
g = new Ri, | |
w, | |
y = new Ri, | |
b, | |
x = new Ri; | |
return globalThis.fetch( | |
h, | |
Object.assign( | |
Object.assign({ | |
}, c), | |
{ | |
method: 'POST', | |
headers: Bc(new globalThis.Headers, u, o.timeout, o.meta), | |
body: Oc(d, u), | |
signal: (a = n.abort) !== null && | |
a !== void 0 ? a : null | |
} | |
) | |
).then( | |
k => { | |
let[S, | |
B, | |
z] = oo(k); | |
if (f.resolve(z), S != null && S !== oe.OK) throw new Fe(B ?? oe[S], oe[S], z); | |
return S != null && | |
(w = { | |
code: oe[S], | |
detail: B ?? oe[S] | |
}), | |
k | |
} | |
).then( | |
k => { | |
if (!k.body) throw new Fe('missing response body', oe[oe.INTERNAL]); | |
return Fc( | |
k.body, | |
k.headers.get('content-type'), | |
(S, B) => { | |
switch (S) { | |
case Yt.DATA: | |
if (p) throw new Fe('unary call received 2nd message', oe[oe.DATA_LOSS]); | |
p = e.O.fromBinary(B, o.binaryOptions); | |
break; | |
case Yt.TRAILER: | |
let z, | |
I; | |
[ | |
z, | |
I, | |
b | |
] = Dc(B), | |
w = { | |
code: oe[z], | |
detail: I ?? oe[z] | |
}; | |
break | |
} | |
} | |
) | |
} | |
).then( | |
() => { | |
if (!b && p) throw new Fe('missing trailers', oe[oe.DATA_LOSS]); | |
if (!w) throw new Fe('missing status', oe[oe.INTERNAL]); | |
if (!p && w.code === 'OK') throw new Fe('expected error status', oe[oe.DATA_LOSS]); | |
if (!p) throw new Fe(w.detail, w.code, b); | |
if (g.resolve(p), w.code !== 'OK') throw new Fe(w.detail, w.code, b); | |
y.resolve(w), | |
x.resolve(b || { | |
}) | |
} | |
).catch( | |
k => { | |
let S; | |
k instanceof Fe ? S = k : k instanceof Error && | |
k.name === 'AbortError' ? S = new Fe(k.message, oe[oe.CANCELLED]) : S = new Fe(k instanceof Error ? k.message : '' + k, oe[oe.INTERNAL]), | |
S.methodName = e.name, | |
S.serviceName = e.service.typeName, | |
f.rejectPending(S), | |
g.rejectPending(S), | |
y.rejectPending(S), | |
x.rejectPending(S) | |
} | |
), | |
new dv( | |
e, | |
(l = o.meta) !== null && | |
l !== void 0 ? l : { | |
}, | |
t, | |
f.promise, | |
g.promise, | |
y.promise, | |
x.promise | |
) | |
} | |
} | |
let np, | |
hu; | |
np = 'https://grpc.hypurr.fun', | |
hu = 'https://telegram.hypurr.fun'; | |
const dt = new ep(new cu({ | |
baseUrl: np | |
})), | |
dl = new Uw(new cu({ | |
baseUrl: hu | |
})), | |
Jw = new ep(new cu({ | |
baseUrl: hu | |
})); | |
class xn { | |
stream = null; | |
abortController = null; | |
input = null; | |
retryCount = 0; | |
retryTimeout = null; | |
config; | |
constructor(e) { | |
this.config = { | |
maxRetries: 10, | |
retryDelay: 2000, | |
onError: function (t) { | |
console.error('Stream error:', t) | |
}, | |
...e | |
} | |
} | |
async start(e) { | |
this.stop(), | |
this.input = e, | |
this.retryCount = 0, | |
await this.connect() | |
} | |
async connect() { | |
try { | |
this.abortController = new AbortController, | |
this.stream = this.config.startStream(this.input, this.abortController), | |
this.listen() | |
} catch (e) { | |
this.config.onError(e), | |
await this.handleError() | |
} | |
} | |
async listen() { | |
if (!!this.stream) try { | |
for await(const e of this.stream.responses) this.retryCount = 0, | |
this.config.onMessage(e) | |
} catch (e) { | |
this.config.onError(e), | |
await this.handleError(e) | |
} | |
} | |
async handleError(e) { | |
e.name === 'RpcError' && | |
e.message.includes('BodyStreamBuffer was aborted') || | |
( | |
this.retryTimeout && | |
clearTimeout(this.retryTimeout), | |
this.retryCount++, | |
this.input && | |
( | |
this.retryCount < this.config.maxRetries ? ( | |
console.log(`Attempting to reconnect (attempt ${ this.retryCount })...`), | |
this.retryTimeout = setTimeout( | |
async() => { | |
this.input && | |
await this.connect() | |
}, | |
this.config.retryDelay | |
) | |
) : ( | |
console.error('Max reconnection attempts reached'), | |
this.stop() | |
) | |
) | |
) | |
} | |
stop() { | |
this.stream = null, | |
this.input = null, | |
this.retryCount = 0, | |
this.abortController && | |
(this.abortController.abort(), this.abortController = null), | |
this.retryTimeout && | |
(clearTimeout(this.retryTimeout), this.retryTimeout = null) | |
} | |
} | |
const St = Xi( | |
'launch', | |
() => { | |
const i = M(new Map), | |
e = M([]), | |
t = M(new Map), | |
n = M([]), | |
s = M([]), | |
r = M([]), | |
a = M([]), | |
l = M([]), | |
o = M(), | |
u = M(Date.now() / 1000); | |
setInterval(() => { | |
u.value = Date.now() / 1000 | |
}, 1000); | |
const c = q( | |
() => { | |
if (!o.value) return 0; | |
if (o.value.endGas) return o.value.endGas.value * 2; | |
let G = o.value.startTime, | |
te = o.value.startTime + o.value.duration, | |
le = u.value; | |
return le > te ? 0 : le < G ? 10000 : (o.value.startGas - 10000) * (te - le) / (te - G) | |
} | |
), | |
h = new xn({ | |
startStream: (G, te) => ( | |
i.value = new Map, | |
e.value = [], | |
dt.hyperliquidLaunchStream(G, { | |
abort: te.signal | |
}) | |
), | |
onMessage: G => { | |
let te = !1; | |
G.launches.forEach( | |
le => { | |
const ae = e.value.findIndex($e => $e.id === le.id); | |
if (ae >= 0) { | |
let $e = e.value[ae]; | |
Object.assign($e, le), | |
i.value.set(le.id, $e) | |
} else e.value.push(le), | |
i.value.set(le.id, le), | |
te = !0 | |
} | |
), | |
te && | |
( | |
e.value = [ | |
...e.value | |
].sort((le, ae) => ae.lastEventTimestamp - le.lastEventTimestamp) | |
) | |
}, | |
onError: G => { | |
console.log(G) | |
} | |
}), | |
d = new xn({ | |
startStream: (G, te) => (n.value = [], dt.hyperliquidLaunchMessages(G, { | |
abort: te.signal | |
})), | |
onMessage: G => { | |
n.value.push(...G.messages) | |
}, | |
onError: G => { | |
console.error('Error in message stream:', G), | |
n.value = [] | |
} | |
}), | |
f = new xn({ | |
startStream: (G, te) => ( | |
s.value = [], | |
dt.hyperliquidLaunchCandleStream(G, { | |
abort: te.signal | |
}) | |
), | |
onMessage: G => { | |
s.value.push(...G.candles) | |
}, | |
onError: G => { | |
console.error('Error in candle stream:', G), | |
s.value = [] | |
} | |
}), | |
p = new xn({ | |
startStream: (G, te) => ( | |
r.value = [], | |
a.value = [], | |
dt.hyperliquidLaunchFills(G, { | |
abort: te.signal | |
}) | |
), | |
onMessage: G => { | |
r.value.push(...G.fills), | |
G.positions.forEach( | |
te => { | |
const le = a.value.findIndex(ae => ae.address === te.address); | |
le >= 0 ? a.value[le] = te : a.value.push(te) | |
} | |
) | |
}, | |
onError: G => { | |
console.error('Error in candle stream:', G), | |
r.value = [], | |
a.value = [] | |
} | |
}), | |
g = new xn({ | |
startStream: (G, te) => ( | |
l.value = [], | |
dt.latestHyperliquidLaunchFills(G, { | |
abort: te.signal | |
}) | |
), | |
onMessage: G => { | |
l.value.push(...G.fills) | |
}, | |
onError: G => { | |
console.error('Error in candle stream:', G), | |
l.value = [] | |
} | |
}); | |
return { | |
fills: r, | |
positions: a, | |
candles: s, | |
messages: n, | |
launches: e, | |
launchMap: i, | |
launchFills: t, | |
auction: o, | |
auctionPrice: c, | |
fetchLaunches: async() => null, | |
fetchLaunchCandles: async(G, te) => { | |
try { | |
return ( | |
await dt.hyperliquidLaunchCandles({ | |
launchId: G, | |
interval: te | |
}, { | |
}) | |
).response.candles.map($e => ({ | |
...$e, | |
time: $e.time / 1000 | |
})) | |
} catch (le) { | |
return console.error(le), | |
[] | |
} | |
}, | |
fetchLaunchHolders: async G => { | |
try { | |
return (await dt.hyperliquidLaunchHolders({ | |
launchId: G | |
}, { | |
})).response.holders | |
} catch (te) { | |
return console.log(te), | |
null | |
} | |
}, | |
fetchLaunch: async G => { | |
if (G && i.value.has(G)) return i.value.get(G); | |
try { | |
console.log('fetching launch', G); | |
let le = (await dt.hyperliquidLaunch({ | |
id: G | |
}, { | |
})).response.launch; | |
return i.value.set(le.id, le), | |
console.log('fetched launch', le.id), | |
i.value.get(le.id) | |
} catch (te) { | |
return console.log(te), | |
null | |
} | |
}, | |
fetchAuction: async() => { | |
try { | |
const G = await dt.hyperliquidDeployAuction({ | |
}, { | |
}); | |
o.value = G.response.auction | |
} catch (G) { | |
console.error(G) | |
} | |
}, | |
startCandleStream: async(G, te) => { | |
await f.start({ | |
launchId: G, | |
interval: te | |
}) | |
}, | |
stopCandleStream: () => { | |
f.stop(), | |
s.value = [] | |
}, | |
startMessageStream: async G => { | |
await d.start({ | |
launchId: G | |
}) | |
}, | |
stopMessageStream: () => { | |
d.stop(), | |
n.value = [] | |
}, | |
startFillStream: async G => { | |
await p.start({ | |
launchId: { | |
value: G | |
} | |
}) | |
}, | |
stopFillStream: () => { | |
p.stop(), | |
r.value = [] | |
}, | |
startLatestFillStream: async() => { | |
await g.start({ | |
}) | |
}, | |
stopLatestFillStream: () => { | |
g.stop(), | |
l.value = [] | |
}, | |
startLaunchStream: async() => { | |
await h.start({ | |
}) | |
}, | |
stopLaunchStream: () => { | |
h.stop(), | |
i.value = new Map, | |
e.value = [] | |
} | |
} | |
} | |
), | |
Is = '/assets/purrbot.246840f0.png'; | |
class Yw { | |
auth; | |
user; | |
constructor(e, t) { | |
this.auth = e, | |
this.user = t | |
} | |
getAddress() { | |
return this.user.wallet.ethereumAddress | |
} | |
getProfilePicture() { | |
return this.auth.photo_url | |
} | |
getDisplayName() { | |
return this.auth.first_name | |
} | |
} | |
const Ji = Xi( | |
'user', | |
() => { | |
const i = M(null), | |
e = new Map, | |
t = M(null); | |
M([]); | |
const n = M(null), | |
s = M(!1), | |
r = M(!0), | |
a = localStorage.getItem('animationsEnabled'); | |
a !== null && | |
(r.value = a !== 'false'); | |
function l() { | |
r.value = !r.value, | |
localStorage.setItem('animationsEnabled', r.value.toString()) | |
} | |
const o = q( | |
() => { | |
let p = {}; | |
if (!i.value || !i.value?.auth) return p; | |
for (const [g, | |
w]of Object.entries(i.value?.auth)) p[g] = w; | |
return p | |
} | |
); | |
e.set( | |
'0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF', | |
'Hyperliquidity' | |
); | |
async function u(p) { | |
let g = {}; | |
for (const [w, | |
y]of Object.entries(p)) g[w] = y; | |
try { | |
s.value = !0; | |
const w = await dl.telegramUser({ | |
authData: g | |
}); | |
i.value = new Yw(p, w.response.user), | |
console.log('user', i.value), | |
s.value = !1, | |
localStorage.setItem('telegramAuth', JSON.stringify(p)); | |
for (let y of w.response.user.labels) e.set(y.ethereumAddress, y.label) | |
} catch (w) { | |
throw console.error('Error authenticating with Telegram:', w), | |
localStorage.removeItem('telegramAuth'), | |
i.value = null, | |
s.value = !1, | |
w | |
} | |
} | |
async function c(p, g, w, y, b) { | |
if (!i.value || !i.value.auth) throw 'Error'; | |
const x = i.value.user.wallets.find(z => z.id === w); | |
if (!x) throw 'Error'; | |
const k = await dl.hyperliquidLaunchTrade({ | |
authData: o.value, | |
launchId: p, | |
walletId: w, | |
direction: y, | |
amount: b | |
}); | |
console.log('res', k.response); | |
let S = x.launchBalances.find(z => z.launchId === p); | |
S ? S.balance = k.response.baseAmount * Math.pow(10, g) : (S = { | |
walletId: w, | |
launchId: p, | |
balance: 0 | |
}, x.launchBalances.push(S)); | |
let B = x.spotBalances.find(z => z.tokenId === 10000); | |
return B ? B.balance = k.response.quoteAmount : (B = { | |
walletId: w, | |
tokenId: 10000, | |
balance: 0 | |
}, x.spotBalances.push(B)), | |
k.response | |
} | |
async function h(p) { | |
const g = {}; | |
for (const [y, | |
b]of Object.entries(p)) g[y] = b; | |
return (await dl.telegramUserWallets({ | |
authData: g | |
})).response.wallets | |
} | |
function d() { | |
const p = localStorage.getItem('telegramAuth'); | |
if (p) { | |
console.log('loading stored auth'); | |
try { | |
const g = JSON.parse(p); | |
u(g).catch( | |
w => { | |
console.error('Failed to authenticate stored credentials:', w) | |
} | |
) | |
} catch (g) { | |
console.error('Error parsing stored auth data:', g), | |
localStorage.removeItem('telegramAuth') | |
} | |
} | |
} | |
function f() { | |
i.value = null, | |
localStorage.removeItem('telegramAuth') | |
} | |
return d(), | |
{ | |
user: i, | |
userWallet: t, | |
walletLabels: e, | |
onTelegramLogin: u, | |
onLaunchTrade: c, | |
fetchUserWallets: h, | |
pendingDeploySession: n, | |
logout: f, | |
userLoading: s, | |
animationsEnabled: r, | |
toggleAnimations: l | |
} | |
} | |
); /*! | |
* vue-router v4.5.0 | |
* (c) 2024 Eduardo San Martin Morote | |
* @license MIT | |
*/ | |
const Tn = typeof document < 'u'; | |
function sp(i) { | |
return typeof i == 'object' || | |
'displayName' in i || | |
'props' in i || | |
'__vccOpts' in i | |
} | |
function Qw(i) { | |
return i.__esModule || | |
i[Symbol.toStringTag] === 'Module' || | |
i.default && | |
sp(i.default) | |
} | |
const Me = Object.assign; | |
function fl(i, e) { | |
const t = {}; | |
for (const n in e) { | |
const s = e[n]; | |
t[n] = ii(s) ? s.map(i) : i(s) | |
} | |
return t | |
} | |
const gs = () => { | |
}, | |
ii = Array.isArray, | |
rp = /#/g, | |
Zw = /&/g, | |
e1 = /\//g, | |
t1 = /=/g, | |
i1 = /\?/g, | |
ap = /\+/g, | |
n1 = /%5B/g, | |
s1 = /%5D/g, | |
lp = /%5E/g, | |
r1 = /%60/g, | |
op = /%7B/g, | |
a1 = /%7C/g, | |
up = /%7D/g, | |
l1 = /%20/g; | |
function du(i) { | |
return encodeURI('' + i).replace(a1, '|').replace(n1, '[').replace(s1, ']') | |
} | |
function o1(i) { | |
return du(i).replace(op, '{').replace(up, '}').replace(lp, '^') | |
} | |
function uo(i) { | |
return du(i).replace(ap, '%2B').replace(l1, '+').replace(rp, '%23').replace(Zw, '%26').replace(r1, '`').replace(op, '{').replace(up, '}').replace(lp, '^') | |
} | |
function u1(i) { | |
return uo(i).replace(t1, '%3D') | |
} | |
function c1(i) { | |
return du(i).replace(rp, '%23').replace(i1, '%3F') | |
} | |
function h1(i) { | |
return i == null ? '' : c1(i).replace(e1, '%2F') | |
} | |
function Ns(i) { | |
try { | |
return decodeURIComponent('' + i) | |
} catch { | |
} | |
return '' + i | |
} | |
const d1 = /\/$/, | |
f1 = i => i.replace(d1, ''); | |
function pl(i, e, t = '/') { | |
let n, | |
s = {}, | |
r = '', | |
a = ''; | |
const l = e.indexOf('#'); | |
let o = e.indexOf('?'); | |
return l < o && | |
l >= 0 && | |
(o = - 1), | |
o > - 1 && | |
(n = e.slice(0, o), r = e.slice(o + 1, l > - 1 ? l : e.length), s = i(r)), | |
l > - 1 && | |
(n = n || e.slice(0, l), a = e.slice(l, e.length)), | |
n = y1(n ?? e, t), | |
{ | |
fullPath: n + (r && '?') + r + a, | |
path: n, | |
query: s, | |
hash: Ns(a) | |
} | |
} | |
function p1(i, e) { | |
const t = e.query ? i(e.query) : ''; | |
return e.path + (t && '?') + t + (e.hash || '') | |
} | |
function Vc(i, e) { | |
return !e || | |
!i.toLowerCase().startsWith(e.toLowerCase()) ? i : i.slice(e.length) || | |
'/' | |
} | |
function m1(i, e, t) { | |
const n = e.matched.length - 1, | |
s = t.matched.length - 1; | |
return n > - 1 && | |
n === s && | |
Un(e.matched[n], t.matched[s]) && | |
cp(e.params, t.params) && | |
i(e.query) === i(t.query) && | |
e.hash === t.hash | |
} | |
function Un(i, e) { | |
return (i.aliasOf || i) === (e.aliasOf || e) | |
} | |
function cp(i, e) { | |
if (Object.keys(i).length !== Object.keys(e).length) return !1; | |
for (const t in i) if (!g1(i[t], e[t])) return !1; | |
return !0 | |
} | |
function g1(i, e) { | |
return ii(i) ? zc(i, e) : ii(e) ? zc(e, i) : i === e | |
} | |
function zc(i, e) { | |
return ii(e) ? i.length === e.length && | |
i.every((t, n) => t === e[n]) : i.length === 1 && | |
i[0] === e | |
} | |
function y1(i, e) { | |
if (i.startsWith('/')) return i; | |
if (!i) return e; | |
const t = e.split('/'), | |
n = i.split('/'), | |
s = n[n.length - 1]; | |
(s === '..' || s === '.') && | |
n.push(''); | |
let r = t.length - 1, | |
a, | |
l; | |
for (a = 0; a < n.length; a++) if (l = n[a], l !== '.') if (l === '..') r > 1 && | |
r--; | |
else break; | |
return t.slice(0, r).join('/') + '/' + n.slice(a).join('/') | |
} | |
const Pi = { | |
path: '/', | |
name: void 0, | |
params: { | |
}, | |
query: { | |
}, | |
hash: '', | |
fullPath: '/', | |
matched: [], | |
meta: { | |
}, | |
redirectedFrom: void 0 | |
}; | |
var Ms; | |
(function (i) { | |
i.pop = 'pop', | |
i.push = 'push' | |
}) (Ms || (Ms = {})); | |
var ys; | |
(function (i) { | |
i.back = 'back', | |
i.forward = 'forward', | |
i.unknown = '' | |
}) (ys || (ys = {})); | |
function v1(i) { | |
if (!i) if (Tn) { | |
const e = document.querySelector('base'); | |
i = e && | |
e.getAttribute('href') || | |
'/', | |
i = i.replace(/^\w+:\/\/[^\/]+/, '') | |
} else i = '/'; | |
return i[0] !== '/' && | |
i[0] !== '#' && | |
(i = '/' + i), | |
f1(i) | |
} | |
const b1 = /^[^#]+#/; | |
function w1(i, e) { | |
return i.replace(b1, '#') + e | |
} | |
function k1(i, e) { | |
const t = document.documentElement.getBoundingClientRect(), | |
n = i.getBoundingClientRect(); | |
return { | |
behavior: e.behavior, | |
left: n.left - t.left - (e.left || 0), | |
top: n.top - t.top - (e.top || 0) | |
} | |
} | |
const ba = () => ({ | |
left: window.scrollX, | |
top: window.scrollY | |
}); | |
function _1(i) { | |
let e; | |
if ('el' in i) { | |
const t = i.el, | |
n = typeof t == 'string' && | |
t.startsWith('#'), | |
s = typeof t == 'string' ? n ? document.getElementById(t.slice(1)) : document.querySelector(t) : t; | |
if (!s) return; | |
e = k1(s, i) | |
} else e = i; | |
'scrollBehavior' in document.documentElement.style ? window.scrollTo(e) : window.scrollTo( | |
e.left != null ? e.left : window.scrollX, | |
e.top != null ? e.top : window.scrollY | |
) | |
} | |
function Wc(i, e) { | |
return (history.state ? history.state.position - e : - 1) + i | |
} | |
const co = new Map; | |
function x1(i, e) { | |
co.set(i, e) | |
} | |
function T1(i) { | |
const e = co.get(i); | |
return co.delete(i), | |
e | |
} | |
let S1 = () => location.protocol + '//' + location.host; | |
function hp(i, e) { | |
const { | |
pathname: t, | |
search: n, | |
hash: s | |
} | |
= e, | |
r = i.indexOf('#'); | |
if (r > - 1) { | |
let l = s.includes(i.slice(r)) ? i.slice(r).length : 1, | |
o = s.slice(l); | |
return o[0] !== '/' && | |
(o = '/' + o), | |
Vc(o, '') | |
} | |
return Vc(t, i) + n + s | |
} | |
function E1(i, e, t, n) { | |
let s = [], | |
r = [], | |
a = null; | |
const l = ({ | |
state: d | |
}) => { | |
const f = hp(i, location), | |
p = t.value, | |
g = e.value; | |
let w = 0; | |
if (d) { | |
if (t.value = f, e.value = d, a && a === p) { | |
a = null; | |
return | |
} | |
w = g ? d.position - g.position : 0 | |
} else n(f); | |
s.forEach( | |
y => { | |
y( | |
t.value, | |
p, | |
{ | |
delta: w, | |
type: Ms.pop, | |
direction: w ? w > 0 ? ys.forward : ys.back : ys.unknown | |
} | |
) | |
} | |
) | |
}; | |
function o() { | |
a = t.value | |
} | |
function u(d) { | |
s.push(d); | |
const f = () => { | |
const p = s.indexOf(d); | |
p > - 1 && | |
s.splice(p, 1) | |
}; | |
return r.push(f), | |
f | |
} | |
function c() { | |
const { | |
history: d | |
} | |
= window; | |
!d.state || | |
d.replaceState(Me({ | |
}, d.state, { | |
scroll: ba() | |
}), '') | |
} | |
function h() { | |
for (const d of r) d(); | |
r = [], | |
window.removeEventListener('popstate', l), | |
window.removeEventListener('beforeunload', c) | |
} | |
return window.addEventListener('popstate', l), | |
window.addEventListener('beforeunload', c, { | |
passive: !0 | |
}), | |
{ | |
pauseListeners: o, | |
listen: u, | |
destroy: h | |
} | |
} | |
function Uc(i, e, t, n = !1, s = !1) { | |
return { | |
back: i, | |
current: e, | |
forward: t, | |
replaced: n, | |
position: window.history.length, | |
scroll: s ? ba() : null | |
} | |
} | |
function C1(i) { | |
const { | |
history: e, | |
location: t | |
} | |
= window, | |
n = { | |
value: hp(i, t) | |
}, | |
s = { | |
value: e.state | |
}; | |
s.value || | |
r( | |
n.value, | |
{ | |
back: null, | |
current: n.value, | |
forward: null, | |
position: e.length - 1, | |
replaced: !0, | |
scroll: null | |
}, | |
!0 | |
); | |
function r(o, u, c) { | |
const h = i.indexOf('#'), | |
d = h > - 1 ? (t.host && document.querySelector('base') ? i : i.slice(h)) + o : S1() + i + o; | |
try { | |
e[c ? 'replaceState' : 'pushState'](u, '', d), | |
s.value = u | |
} catch (f) { | |
console.error(f), | |
t[c ? 'replace' : 'assign'](d) | |
} | |
} | |
function a(o, u) { | |
const c = Me({ | |
}, e.state, Uc(s.value.back, o, s.value.forward, !0), u, { | |
position: s.value.position | |
}); | |
r(o, c, !0), | |
n.value = o | |
} | |
function l(o, u) { | |
const c = Me({ | |
}, s.value, e.state, { | |
forward: o, | |
scroll: ba() | |
}); | |
r(c.current, c, !0); | |
const h = Me({ | |
}, Uc(n.value, o, null), { | |
position: c.position + 1 | |
}, u); | |
r(o, h, !1), | |
n.value = o | |
} | |
return { | |
location: n, | |
state: s, | |
push: l, | |
replace: a | |
} | |
} | |
function $1(i) { | |
i = v1(i); | |
const e = C1(i), | |
t = E1(i, e.state, e.location, e.replace); | |
function n(r, a = !0) { | |
a || | |
t.pauseListeners(), | |
history.go(r) | |
} | |
const s = Me({ | |
location: '', | |
base: i, | |
go: n, | |
createHref: w1.bind(null, i) | |
}, e, t); | |
return Object.defineProperty(s, 'location', { | |
enumerable: !0, | |
get: () => e.location.value | |
}), | |
Object.defineProperty(s, 'state', { | |
enumerable: !0, | |
get: () => e.state.value | |
}), | |
s | |
} | |
function L1(i) { | |
return typeof i == 'string' || | |
i && | |
typeof i == 'object' | |
} | |
function dp(i) { | |
return typeof i == 'string' || | |
typeof i == 'symbol' | |
} | |
const fp = Symbol(''); | |
var jc; | |
( | |
function (i) { | |
i[i.aborted = 4] = 'aborted', | |
i[i.cancelled = 8] = 'cancelled', | |
i[i.duplicated = 16] = 'duplicated' | |
} | |
) (jc || (jc = {})); | |
function jn(i, e) { | |
return Me(new Error, { | |
type: i, | |
[ | |
fp | |
]: !0 | |
}, e) | |
} | |
function yi(i, e) { | |
return i instanceof Error && | |
fp in i && | |
(e == null || !!(i.type & e)) | |
} | |
const Hc = '[^/]+?', | |
P1 = { | |
sensitive: !1, | |
strict: !1, | |
start: !0, | |
end: !0 | |
}, | |
I1 = /[.+*?^${}()[\]/\\]/g; | |
function N1(i, e) { | |
const t = Me({ | |
}, P1, e), | |
n = []; | |
let s = t.start ? '^' : ''; | |
const r = []; | |
for (const u of i) { | |
const c = u.length ? [] : [ | |
90 | |
]; | |
t.strict && | |
!u.length && | |
(s += '/'); | |
for (let h = 0; h < u.length; h++) { | |
const d = u[h]; | |
let f = 40 + (t.sensitive ? 0.25 : 0); | |
if (d.type === 0) h || | |
(s += '/'), | |
s += d.value.replace(I1, '\\$&'), | |
f += 40; | |
else if (d.type === 1) { | |
const { | |
value: p, | |
repeatable: g, | |
optional: w, | |
regexp: y | |
} | |
= d; | |
r.push({ | |
name: p, | |
repeatable: g, | |
optional: w | |
}); | |
const b = y || | |
Hc; | |
if (b !== Hc) { | |
f += 10; | |
try { | |
new RegExp(`(${ b })`) | |
} catch (k) { | |
throw new Error(`Invalid custom RegExp for param "${ p }" (${ b }): ` + k.message) | |
} | |
} | |
let x = g ? `((?:${ b })(?:/(?:${ b }))*)` : `(${ b })`; | |
h || | |
(x = w && u.length < 2 ? `(?:/${ x })` : '/' + x), | |
w && | |
(x += '?'), | |
s += x, | |
f += 20, | |
w && | |
(f += - 8), | |
g && | |
(f += - 20), | |
b === '.*' && | |
(f += - 50) | |
} | |
c.push(f) | |
} | |
n.push(c) | |
} | |
if (t.strict && t.end) { | |
const u = n.length - 1; | |
n[u][n[u].length - 1] += 0.7000000000000001 | |
} | |
t.strict || | |
(s += '/?'), | |
t.end ? s += '$' : t.strict && | |
!s.endsWith('/') && | |
(s += '(?:/|$)'); | |
const a = new RegExp(s, t.sensitive ? '' : 'i'); | |
function l(u) { | |
const c = u.match(a), | |
h = {}; | |
if (!c) return null; | |
for (let d = 1; d < c.length; d++) { | |
const f = c[d] || | |
'', | |
p = r[d - 1]; | |
h[p.name] = f && | |
p.repeatable ? f.split('/') : f | |
} | |
return h | |
} | |
function o(u) { | |
let c = '', | |
h = !1; | |
for (const d of i) { | |
(!h || !c.endsWith('/')) && | |
(c += '/'), | |
h = !1; | |
for (const f of d) if (f.type === 0) c += f.value; | |
else if (f.type === 1) { | |
const { | |
value: p, | |
repeatable: g, | |
optional: w | |
} | |
= f, | |
y = p in u ? u[p] : ''; | |
if (ii(y) && !g) throw new Error( | |
`Provided param "${ p }" is an array but it is not repeatable (* or + modifiers)` | |
); | |
const b = ii(y) ? y.join('/') : y; | |
if (!b) if (w) d.length < 2 && | |
(c.endsWith('/') ? c = c.slice(0, - 1) : h = !0); | |
else throw new Error(`Missing required param "${ p }"`); | |
c += b | |
} | |
} | |
return c || | |
'/' | |
} | |
return { | |
re: a, | |
score: n, | |
keys: r, | |
parse: l, | |
stringify: o | |
} | |
} | |
function M1(i, e) { | |
let t = 0; | |
for (; t < i.length && t < e.length; ) { | |
const n = e[t] - i[t]; | |
if (n) return n; | |
t++ | |
} | |
return i.length < e.length ? i.length === 1 && | |
i[0] === 40 + 40 ? - 1 : 1 : i.length > e.length ? e.length === 1 && | |
e[0] === 40 + 40 ? 1 : - 1 : 0 | |
} | |
function pp(i, e) { | |
let t = 0; | |
const n = i.score, | |
s = e.score; | |
for (; t < n.length && t < s.length; ) { | |
const r = M1(n[t], s[t]); | |
if (r) return r; | |
t++ | |
} | |
if (Math.abs(s.length - n.length) === 1) { | |
if (qc(n)) return 1; | |
if (qc(s)) return - 1 | |
} | |
return s.length - n.length | |
} | |
function qc(i) { | |
const e = i[i.length - 1]; | |
return i.length > 0 && | |
e[e.length - 1] < 0 | |
} | |
const R1 = { | |
type: 0, | |
value: '' | |
}, | |
B1 = /[a-zA-Z0-9_]/; | |
function O1(i) { | |
if (!i) return [[]]; | |
if (i === '/') return [[R1]]; | |
if (!i.startsWith('/')) throw new Error(`Invalid path "${ i }"`); | |
function e(f) { | |
throw new Error(`ERR (${ t })/"${ u }": ${ f }`) | |
} | |
let t = 0, | |
n = t; | |
const s = []; | |
let r; | |
function a() { | |
r && | |
s.push(r), | |
r = [] | |
} | |
let l = 0, | |
o, | |
u = '', | |
c = ''; | |
function h() { | |
!u || | |
( | |
t === 0 ? r.push({ | |
type: 0, | |
value: u | |
}) : t === 1 || | |
t === 2 || | |
t === 3 ? ( | |
r.length > 1 && | |
(o === '*' || o === '+') && | |
e( | |
`A repeatable param (${ u }) must be alone in its segment. eg: '/:ids+.` | |
), | |
r.push({ | |
type: 1, | |
value: u, | |
regexp: c, | |
repeatable: o === '*' || | |
o === '+', | |
optional: o === '*' || | |
o === '?' | |
}) | |
) : e('Invalid state to consume buffer'), | |
u = '' | |
) | |
} | |
function d() { | |
u += o | |
} | |
for (; l < i.length; ) { | |
if (o = i[l++], o === '\\' && t !== 2) { | |
n = t, | |
t = 4; | |
continue | |
} | |
switch (t) { | |
case 0: | |
o === '/' ? (u && h(), a()) : o === ':' ? (h(), t = 1) : d(); | |
break; | |
case 4: | |
d(), | |
t = n; | |
break; | |
case 1: | |
o === '(' ? t = 2 : B1.test(o) ? d() : (h(), t = 0, o !== '*' && o !== '?' && o !== '+' && l--); | |
break; | |
case 2: | |
o === ')' ? c[c.length - 1] == '\\' ? c = c.slice(0, - 1) + o : t = 3 : c += o; | |
break; | |
case 3: | |
h(), | |
t = 0, | |
o !== '*' && | |
o !== '?' && | |
o !== '+' && | |
l--, | |
c = ''; | |
break; | |
default: | |
e('Unknown state'); | |
break | |
} | |
} | |
return t === 2 && | |
e(`Unfinished custom RegExp for param "${ u }"`), | |
h(), | |
a(), | |
s | |
} | |
function D1(i, e, t) { | |
const n = N1(O1(i.path), t), | |
s = Me(n, { | |
record: i, | |
parent: e, | |
children: [], | |
alias: [] | |
}); | |
return e && | |
!s.record.aliasOf == !e.record.aliasOf && | |
e.children.push(s), | |
s | |
} | |
function F1(i, e) { | |
const t = [], | |
n = new Map; | |
e = Jc({ | |
strict: !1, | |
end: !0, | |
sensitive: !1 | |
}, e); | |
function s(h) { | |
return n.get(h) | |
} | |
function r(h, d, f) { | |
const p = !f, | |
g = Kc(h); | |
g.aliasOf = f && | |
f.record; | |
const w = Jc(e, h), | |
y = [ | |
g | |
]; | |
if ('alias' in h) { | |
const k = typeof h.alias == 'string' ? [ | |
h.alias | |
] : h.alias; | |
for (const S of k) y.push( | |
Kc( | |
Me({ | |
}, g, { | |
components: f ? f.record.components : g.components, | |
path: S, | |
aliasOf: f ? f.record : g | |
}) | |
) | |
) | |
} | |
let b, | |
x; | |
for (const k of y) { | |
const { | |
path: S | |
} | |
= k; | |
if (d && S[0] !== '/') { | |
const B = d.record.path, | |
z = B[B.length - 1] === '/' ? '' : '/'; | |
k.path = d.record.path + (S && z + S) | |
} | |
if ( | |
b = D1(k, d, w), | |
f ? f.alias.push(b) : (x = x || b, x !== b && x.alias.push(b), p && h.name && !Xc(b) && a(h.name)), | |
mp(b) && | |
o(b), | |
g.children | |
) { | |
const B = g.children; | |
for (let z = 0; z < B.length; z++) r(B[z], b, f && f.children[z]) | |
} | |
f = f || | |
b | |
} | |
return x ? () => { | |
a(x) | |
} | |
: gs | |
} | |
function a(h) { | |
if (dp(h)) { | |
const d = n.get(h); | |
d && | |
( | |
n.delete(h), | |
t.splice(t.indexOf(d), 1), | |
d.children.forEach(a), | |
d.alias.forEach(a) | |
) | |
} else { | |
const d = t.indexOf(h); | |
d > - 1 && | |
( | |
t.splice(d, 1), | |
h.record.name && | |
n.delete(h.record.name), | |
h.children.forEach(a), | |
h.alias.forEach(a) | |
) | |
} | |
} | |
function l() { | |
return t | |
} | |
function o(h) { | |
const d = z1(h, t); | |
t.splice(d, 0, h), | |
h.record.name && | |
!Xc(h) && | |
n.set(h.record.name, h) | |
} | |
function u(h, d) { | |
let f, | |
p = {}, | |
g, | |
w; | |
if ('name' in h && h.name) { | |
if (f = n.get(h.name), !f) throw jn(1, { | |
location: h | |
}); | |
w = f.record.name, | |
p = Me( | |
Gc( | |
d.params, | |
f.keys.filter(x => !x.optional).concat(f.parent ? f.parent.keys.filter(x => x.optional) : []).map(x => x.name) | |
), | |
h.params && | |
Gc(h.params, f.keys.map(x => x.name)) | |
), | |
g = f.stringify(p) | |
} else if (h.path != null) g = h.path, | |
f = t.find(x => x.re.test(g)), | |
f && | |
(p = f.parse(g), w = f.record.name); | |
else { | |
if (f = d.name ? n.get(d.name) : t.find(x => x.re.test(d.path)), !f) throw jn(1, { | |
location: h, | |
currentLocation: d | |
}); | |
w = f.record.name, | |
p = Me({ | |
}, d.params, h.params), | |
g = f.stringify(p) | |
} | |
const y = []; | |
let b = f; | |
for (; b; ) y.unshift(b.record), | |
b = b.parent; | |
return { | |
name: w, | |
path: g, | |
params: p, | |
matched: y, | |
meta: V1(y) | |
} | |
} | |
i.forEach(h => r(h)); | |
function c() { | |
t.length = 0, | |
n.clear() | |
} | |
return { | |
addRoute: r, | |
resolve: u, | |
removeRoute: a, | |
clearRoutes: c, | |
getRoutes: l, | |
getRecordMatcher: s | |
} | |
} | |
function Gc(i, e) { | |
const t = {}; | |
for (const n of e) n in i && | |
(t[n] = i[n]); | |
return t | |
} | |
function Kc(i) { | |
const e = { | |
path: i.path, | |
redirect: i.redirect, | |
name: i.name, | |
meta: i.meta || | |
{ | |
}, | |
aliasOf: i.aliasOf, | |
beforeEnter: i.beforeEnter, | |
props: A1(i), | |
children: i.children || | |
[], | |
instances: { | |
}, | |
leaveGuards: new Set, | |
updateGuards: new Set, | |
enterCallbacks: { | |
}, | |
components: 'components' in i ? i.components || | |
null : i.component && | |
{ | |
default: | |
i.component | |
} | |
}; | |
return Object.defineProperty(e, 'mods', { | |
value: { | |
} | |
}), | |
e | |
} | |
function A1(i) { | |
const e = {}, | |
t = i.props || | |
!1; | |
if ('component' in i) e.default = t; | |
else for (const n in i.components) e[n] = typeof t == 'object' ? t[n] : t; | |
return e | |
} | |
function Xc(i) { | |
for (; i; ) { | |
if (i.record.aliasOf) return !0; | |
i = i.parent | |
} | |
return !1 | |
} | |
function V1(i) { | |
return i.reduce((e, t) => Me(e, t.meta), { | |
}) | |
} | |
function Jc(i, e) { | |
const t = {}; | |
for (const n in i) t[n] = n in e ? e[n] : i[n]; | |
return t | |
} | |
function z1(i, e) { | |
let t = 0, | |
n = e.length; | |
for (; t !== n; ) { | |
const r = t + n >> 1; | |
pp(i, e[r]) < 0 ? n = r : t = r + 1 | |
} | |
const s = W1(i); | |
return s && | |
(n = e.lastIndexOf(s, n - 1)), | |
n | |
} | |
function W1(i) { | |
let e = i; | |
for (; e = e.parent; ) if (mp(e) && pp(i, e) === 0) return e | |
} | |
function mp({ | |
record: i | |
}) { | |
return !!( | |
i.name || | |
i.components && | |
Object.keys(i.components).length || | |
i.redirect | |
) | |
} | |
function U1(i) { | |
const e = {}; | |
if (i === '' || i === '?') return e; | |
const n = (i[0] === '?' ? i.slice(1) : i).split('&'); | |
for (let s = 0; s < n.length; ++s) { | |
const r = n[s].replace(ap, ' '), | |
a = r.indexOf('='), | |
l = Ns(a < 0 ? r : r.slice(0, a)), | |
o = a < 0 ? null : Ns(r.slice(a + 1)); | |
if (l in e) { | |
let u = e[l]; | |
ii(u) || | |
(u = e[l] = [ | |
u | |
]), | |
u.push(o) | |
} else e[l] = o | |
} | |
return e | |
} | |
function Yc(i) { | |
let e = ''; | |
for (let t in i) { | |
const n = i[t]; | |
if (t = u1(t), n == null) { | |
n !== void 0 && | |
(e += (e.length ? '&' : '') + t); | |
continue | |
}(ii(n) ? n.map(r => r && uo(r)) : [ | |
n && | |
uo(n) | |
]).forEach(r => { | |
r !== void 0 && | |
(e += (e.length ? '&' : '') + t, r != null && (e += '=' + r)) | |
}) | |
} | |
return e | |
} | |
function j1(i) { | |
const e = {}; | |
for (const t in i) { | |
const n = i[t]; | |
n !== void 0 && | |
(e[t] = ii(n) ? n.map(s => s == null ? null : '' + s) : n == null ? n : '' + n) | |
} | |
return e | |
} | |
const H1 = Symbol(''), | |
Qc = Symbol(''), | |
wa = Symbol(''), | |
fu = Symbol(''), | |
ho = Symbol(''); | |
function rs() { | |
let i = []; | |
function e(n) { | |
return i.push(n), | |
() => { | |
const s = i.indexOf(n); | |
s > - 1 && | |
i.splice(s, 1) | |
} | |
} | |
function t() { | |
i = [] | |
} | |
return { | |
add: e, | |
list: () => i.slice(), | |
reset: t | |
} | |
} | |
function Fi(i, e, t, n, s, r = a => a()) { | |
const a = n && | |
(n.enterCallbacks[s] = n.enterCallbacks[s] || []); | |
return () => new Promise( | |
(l, o) => { | |
const u = d => { | |
d === !1 ? o(jn(4, { | |
from: t, | |
to: e | |
})) : d instanceof Error ? o(d) : L1(d) ? o(jn(2, { | |
from: e, | |
to: d | |
})) : ( | |
a && | |
n.enterCallbacks[s] === a && | |
typeof d == 'function' && | |
a.push(d), | |
l() | |
) | |
}, | |
c = r(() => i.call(n && n.instances[s], e, t, u)); | |
let h = Promise.resolve(c); | |
i.length < 3 && | |
(h = h.then(u)), | |
h.catch(d => o(d)) | |
} | |
) | |
} | |
function ml(i, e, t, n, s = r => r()) { | |
const r = []; | |
for (const a of i) for (const l in a.components) { | |
let o = a.components[l]; | |
if (!(e !== 'beforeRouteEnter' && !a.instances[l])) if (sp(o)) { | |
const c = (o.__vccOpts || o) [e]; | |
c && | |
r.push(Fi(c, t, n, a, l, s)) | |
} else { | |
let u = o(); | |
r.push( | |
() => u.then( | |
c => { | |
if (!c) throw new Error(`Couldn't resolve component "${ l }" at "${ a.path }"`); | |
const h = Qw(c) ? c.default : c; | |
a.mods[l] = c, | |
a.components[l] = h; | |
const f = (h.__vccOpts || h) [e]; | |
return f && | |
Fi(f, t, n, a, l, s) () | |
} | |
) | |
) | |
} | |
} | |
return r | |
} | |
function Zc(i) { | |
const e = zt(wa), | |
t = zt(fu), | |
n = q(() => { | |
const o = pe(i.to); | |
return e.resolve(o) | |
}), | |
s = q( | |
() => { | |
const { | |
matched: o | |
} | |
= n.value, | |
{ | |
length: u | |
} | |
= o, | |
c = o[u - 1], | |
h = t.matched; | |
if (!c || !h.length) return - 1; | |
const d = h.findIndex(Un.bind(null, c)); | |
if (d > - 1) return d; | |
const f = eh(o[u - 2]); | |
return u > 1 && | |
eh(c) === f && | |
h[h.length - 1].path !== f ? h.findIndex(Un.bind(null, o[u - 2])) : d | |
} | |
), | |
r = q(() => s.value > - 1 && J1(t.params, n.value.params)), | |
a = q( | |
() => s.value > - 1 && | |
s.value === t.matched.length - 1 && | |
cp(t.params, n.value.params) | |
); | |
function l(o = {}) { | |
if (X1(o)) { | |
const u = e[pe(i.replace) ? 'replace' : 'push'](pe(i.to)).catch(gs); | |
return i.viewTransition && | |
typeof document < 'u' && | |
'startViewTransition' in document && | |
document.startViewTransition(() => u), | |
u | |
} | |
return Promise.resolve() | |
} | |
return { | |
route: n, | |
href: q(() => n.value.href), | |
isActive: r, | |
isExactActive: a, | |
navigate: l | |
} | |
} | |
function q1(i) { | |
return i.length === 1 ? i[0] : i | |
} | |
const G1 = U({ | |
name: 'RouterLink', | |
compatConfig: { | |
MODE: 3 | |
}, | |
props: { | |
to: { | |
type: [ | |
String, | |
Object | |
], | |
required: !0 | |
}, | |
replace: Boolean, | |
activeClass: String, | |
exactActiveClass: String, | |
custom: Boolean, | |
ariaCurrentValue: { | |
type: String, | |
default: | |
'page' | |
} | |
}, | |
useLink: Zc, | |
setup(i, { | |
slots: e | |
}) { | |
const t = Wi(Zc(i)), | |
{ | |
options: n | |
} | |
= zt(wa), | |
s = q( | |
() => ({ | |
[ | |
th(i.activeClass, n.linkActiveClass, 'router-link-active') | |
]: t.isActive, | |
[ | |
th( | |
i.exactActiveClass, | |
n.linkExactActiveClass, | |
'router-link-exact-active' | |
) | |
]: t.isExactActive | |
}) | |
); | |
return () => { | |
const r = e.default && | |
q1(e.default(t)); | |
return i.custom ? r : wt( | |
'a', | |
{ | |
'aria-current': t.isExactActive ? i.ariaCurrentValue : null, | |
href: t.href, | |
onClick: t.navigate, | |
class : s.value | |
}, | |
r | |
) | |
} | |
} | |
}), | |
K1 = G1; | |
function X1(i) { | |
if ( | |
!(i.metaKey || i.altKey || i.ctrlKey || i.shiftKey) && | |
!i.defaultPrevented && | |
!(i.button !== void 0 && i.button !== 0) | |
) { | |
if (i.currentTarget && i.currentTarget.getAttribute) { | |
const e = i.currentTarget.getAttribute('target'); | |
if (/\b_blank\b/i.test(e)) return | |
} | |
return i.preventDefault && | |
i.preventDefault(), | |
!0 | |
} | |
} | |
function J1(i, e) { | |
for (const t in e) { | |
const n = e[t], | |
s = i[t]; | |
if (typeof n == 'string') { | |
if (n !== s) return !1 | |
} else if (!ii(s) || s.length !== n.length || n.some((r, a) => r !== s[a])) return !1 | |
} | |
return !0 | |
} | |
function eh(i) { | |
return i ? i.aliasOf ? i.aliasOf.path : i.path : '' | |
} | |
const th = (i, e, t) => i ?? e ?? t, | |
Y1 = U({ | |
name: 'RouterView', | |
inheritAttrs: !1, | |
props: { | |
name: { | |
type: String, | |
default: | |
'default' | |
}, | |
route: Object | |
}, | |
compatConfig: { | |
MODE: 3 | |
}, | |
setup(i, { | |
attrs: e, | |
slots: t | |
}) { | |
const n = zt(ho), | |
s = q(() => i.route || n.value), | |
r = zt(Qc, 0), | |
a = q( | |
() => { | |
let u = pe(r); | |
const { | |
matched: c | |
} | |
= s.value; | |
let h; | |
for (; (h = c[u]) && !h.components; ) u++; | |
return u | |
} | |
), | |
l = q(() => s.value.matched[a.value]); | |
Nn(Qc, q(() => a.value + 1)), | |
Nn(H1, l), | |
Nn(ho, s); | |
const o = M(); | |
return Ie( | |
() => [o.value, | |
l.value, | |
i.name], | |
([u, | |
c, | |
h], [ | |
d, | |
f, | |
p | |
]) => { | |
c && | |
( | |
c.instances[h] = u, | |
f && | |
f !== c && | |
u && | |
u === d && | |
( | |
c.leaveGuards.size || | |
(c.leaveGuards = f.leaveGuards), | |
c.updateGuards.size || | |
(c.updateGuards = f.updateGuards) | |
) | |
), | |
u && | |
c && | |
(!f || !Un(c, f) || !d) && | |
(c.enterCallbacks[h] || []).forEach(g => g(u)) | |
}, | |
{ | |
flush: 'post' | |
} | |
), | |
() => { | |
const u = s.value, | |
c = i.name, | |
h = l.value, | |
d = h && | |
h.components[c]; | |
if (!d) return ih(t.default, { | |
Component: d, | |
route: u | |
}); | |
const f = h.props[c], | |
p = f ? f === !0 ? u.params : typeof f == 'function' ? f(u) : f : null, | |
w = wt( | |
d, | |
Me({ | |
}, p, e, { | |
onVnodeUnmounted: y => { | |
y.component.isUnmounted && | |
(h.instances[c] = null) | |
}, | |
ref: o | |
}) | |
); | |
return ih(t.default, { | |
Component: w, | |
route: u | |
}) || | |
w | |
} | |
} | |
}); | |
function ih(i, e) { | |
if (!i) return null; | |
const t = i(e); | |
return t.length === 1 ? t[0] : t | |
} | |
const Q1 = Y1; | |
function Z1(i) { | |
const e = F1(i.routes, i), | |
t = i.parseQuery || | |
U1, | |
n = i.stringifyQuery || | |
Yc, | |
s = i.history, | |
r = rs(), | |
a = rs(), | |
l = rs(), | |
o = Eg(Pi); | |
let u = Pi; | |
Tn && | |
i.scrollBehavior && | |
'scrollRestoration' in history && | |
(history.scrollRestoration = 'manual'); | |
const c = fl.bind(null, H => '' + H), | |
h = fl.bind(null, h1), | |
d = fl.bind(null, Ns); | |
function f(H, fe) { | |
let he, | |
me; | |
return dp(H) ? (he = e.getRecordMatcher(H), me = fe) : me = H, | |
e.addRoute(me, he) | |
} | |
function p(H) { | |
const fe = e.getRecordMatcher(H); | |
fe && | |
e.removeRoute(fe) | |
} | |
function g() { | |
return e.getRoutes().map(H => H.record) | |
} | |
function w(H) { | |
return !!e.getRecordMatcher(H) | |
} | |
function y(H, fe) { | |
if (fe = Me({ | |
}, fe || o.value), typeof H == 'string') { | |
const C = pl(t, H, fe.path), | |
R = e.resolve({ | |
path: C.path | |
}, fe), | |
K = s.createHref(C.fullPath); | |
return Me( | |
C, | |
R, | |
{ | |
params: d(R.params), | |
hash: Ns(C.hash), | |
redirectedFrom: void 0, | |
href: K | |
} | |
) | |
} | |
let he; | |
if (H.path != null) he = Me({ | |
}, H, { | |
path: pl(t, H.path, fe.path).path | |
}); | |
else { | |
const C = Me({ | |
}, H.params); | |
for (const R in C) C[R] == null && | |
delete C[R]; | |
he = Me({ | |
}, H, { | |
params: h(C) | |
}), | |
fe.params = h(fe.params) | |
} | |
const me = e.resolve(he, fe), | |
Ne = H.hash || | |
''; | |
me.params = c(d(me.params)); | |
const Xe = p1(n, Me({ | |
}, H, { | |
hash: o1(Ne), | |
path: me.path | |
})), | |
E = s.createHref(Xe); | |
return Me({ | |
fullPath: Xe, | |
hash: Ne, | |
query: n === Yc ? j1(H.query) : H.query || | |
{ | |
} | |
}, me, { | |
redirectedFrom: void 0, | |
href: E | |
}) | |
} | |
function b(H) { | |
return typeof H == 'string' ? pl(t, H, o.value.path) : Me({ | |
}, H) | |
} | |
function x(H, fe) { | |
if (u !== H) return jn(8, { | |
from: fe, | |
to: H | |
}) | |
} | |
function k(H) { | |
return z(H) | |
} | |
function S(H) { | |
return k(Me(b(H), { | |
replace: !0 | |
})) | |
} | |
function B(H) { | |
const fe = H.matched[H.matched.length - 1]; | |
if (fe && fe.redirect) { | |
const { | |
redirect: he | |
} | |
= fe; | |
let me = typeof he == 'function' ? he(H) : he; | |
return typeof me == 'string' && | |
( | |
me = me.includes('?') || | |
me.includes('#') ? me = b(me) : { | |
path: me | |
}, | |
me.params = {} | |
), | |
Me({ | |
query: H.query, | |
hash: H.hash, | |
params: me.path != null ? { | |
} | |
: H.params | |
}, me) | |
} | |
} | |
function z(H, fe) { | |
const he = u = y(H), | |
me = o.value, | |
Ne = H.state, | |
Xe = H.force, | |
E = H.replace === !0, | |
C = B(he); | |
if (C) return z( | |
Me( | |
b(C), | |
{ | |
state: typeof C == 'object' ? Me({ | |
}, Ne, C.state) : Ne, | |
force: Xe, | |
replace: E | |
} | |
), | |
fe || | |
he | |
); | |
const R = he; | |
R.redirectedFrom = fe; | |
let K; | |
return !Xe && | |
m1(n, me, he) && | |
(K = jn(16, { | |
to: R, | |
from: me | |
}), Ye(me, me, !0, !1)), | |
(K ? Promise.resolve(K) : L(R, me)).catch(j => yi(j) ? yi(j, 2) ? j : Oe(j) : ae(j, R, me)).then( | |
j => { | |
if (j) { | |
if (yi(j, 2)) return z( | |
Me({ | |
replace: E | |
}, b(j.to), { | |
state: typeof j.to == 'object' ? Me({ | |
}, Ne, j.to.state) : Ne, | |
force: Xe | |
}), | |
fe || | |
R | |
) | |
} else j = N(R, me, !0, E, Ne); | |
return A(R, me, j), | |
j | |
} | |
) | |
} | |
function I(H, fe) { | |
const he = x(H, fe); | |
return he ? Promise.reject(he) : Promise.resolve() | |
} | |
function $(H) { | |
const fe = yn.values().next().value; | |
return fe && | |
typeof fe.runWithContext == 'function' ? fe.runWithContext(H) : H() | |
} | |
function L(H, fe) { | |
let he; | |
const [me, | |
Ne, | |
Xe] = ek(H, fe); | |
he = ml(me.reverse(), 'beforeRouteLeave', H, fe); | |
for (const C of me) C.leaveGuards.forEach(R => { | |
he.push(Fi(R, H, fe)) | |
}); | |
const E = I.bind(null, H, fe); | |
return he.push(E), | |
Bt(he).then( | |
() => { | |
he = []; | |
for (const C of r.list()) he.push(Fi(C, H, fe)); | |
return he.push(E), | |
Bt(he) | |
} | |
).then( | |
() => { | |
he = ml(Ne, 'beforeRouteUpdate', H, fe); | |
for (const C of Ne) C.updateGuards.forEach(R => { | |
he.push(Fi(R, H, fe)) | |
}); | |
return he.push(E), | |
Bt(he) | |
} | |
).then( | |
() => { | |
he = []; | |
for (const C of Xe) if (C.beforeEnter) if (ii(C.beforeEnter)) for (const R of C.beforeEnter) he.push(Fi(R, H, fe)); | |
else he.push(Fi(C.beforeEnter, H, fe)); | |
return he.push(E), | |
Bt(he) | |
} | |
).then( | |
() => ( | |
H.matched.forEach(C => C.enterCallbacks = {}), | |
he = ml(Xe, 'beforeRouteEnter', H, fe, $), | |
he.push(E), | |
Bt(he) | |
) | |
).then( | |
() => { | |
he = []; | |
for (const C of a.list()) he.push(Fi(C, H, fe)); | |
return he.push(E), | |
Bt(he) | |
} | |
).catch(C => yi(C, 8) ? C : Promise.reject(C)) | |
} | |
function A(H, fe, he) { | |
l.list().forEach(me => $(() => me(H, fe, he))) | |
} | |
function N(H, fe, he, me, Ne) { | |
const Xe = x(H, fe); | |
if (Xe) return Xe; | |
const E = fe === Pi, | |
C = Tn ? history.state : { | |
}; | |
he && | |
( | |
me || | |
E ? s.replace(H.fullPath, Me({ | |
scroll: E && | |
C && | |
C.scroll | |
}, Ne)) : s.push(H.fullPath, Ne) | |
), | |
o.value = H, | |
Ye(H, fe, he, E), | |
Oe() | |
} | |
let O; | |
function se() { | |
O || | |
( | |
O = s.listen( | |
(H, fe, he) => { | |
if (!Qs.listening) return; | |
const me = y(H), | |
Ne = B(me); | |
if (Ne) { | |
z(Me(Ne, { | |
replace: !0, | |
force: !0 | |
}), me).catch(gs); | |
return | |
} | |
u = me; | |
const Xe = o.value; | |
Tn && | |
x1(Wc(Xe.fullPath, he.delta), ba()), | |
L(me, Xe).catch( | |
E => yi(E, 12) ? E : yi(E, 2) ? ( | |
z(Me(b(E.to), { | |
force: !0 | |
}), me).then(C => { | |
yi(C, 20) && | |
!he.delta && | |
he.type === Ms.pop && | |
s.go( - 1, !1) | |
}).catch(gs), | |
Promise.reject() | |
) : (he.delta && s.go( - he.delta, !1), ae(E, me, Xe)) | |
).then( | |
E => { | |
E = E || | |
N(me, Xe, !1), | |
E && | |
( | |
he.delta && | |
!yi(E, 8) ? s.go( - he.delta, !1) : he.type === Ms.pop && | |
yi(E, 20) && | |
s.go( - 1, !1) | |
), | |
A(me, Xe, E) | |
} | |
).catch(gs) | |
} | |
) | |
) | |
} | |
let G = rs(), | |
te = rs(), | |
le; | |
function ae(H, fe, he) { | |
Oe(H); | |
const me = te.list(); | |
return me.length ? me.forEach(Ne => Ne(H, fe, he)) : console.error(H), | |
Promise.reject(H) | |
} | |
function $e() { | |
return le && | |
o.value !== Pi ? Promise.resolve() : new Promise((H, fe) => { | |
G.add([H, | |
fe]) | |
}) | |
} | |
function Oe(H) { | |
return le || | |
( | |
le = !H, | |
se(), | |
G.list().forEach(([fe, | |
he]) => H ? he(H) : fe()), | |
G.reset() | |
), | |
H | |
} | |
function Ye(H, fe, he, me) { | |
const { | |
scrollBehavior: Ne | |
} | |
= i; | |
if (!Tn || !Ne) return Promise.resolve(); | |
const Xe = !he && | |
T1(Wc(H.fullPath, 0)) || | |
(me || !he) && | |
history.state && | |
history.state.scroll || | |
null; | |
return pi().then(() => Ne(H, fe, Xe)).then(E => E && _1(E)).catch(E => ae(E, H, fe)) | |
} | |
const it = H => s.go(H); | |
let gn; | |
const yn = new Set, | |
Qs = { | |
currentRoute: o, | |
listening: !0, | |
addRoute: f, | |
removeRoute: p, | |
clearRoutes: e.clearRoutes, | |
hasRoute: w, | |
getRoutes: g, | |
resolve: y, | |
options: i, | |
push: k, | |
replace: S, | |
go: it, | |
back: () => it( - 1), | |
forward: () => it(1), | |
beforeEach: r.add, | |
beforeResolve: a.add, | |
afterEach: l.add, | |
onError: te.add, | |
isReady: $e, | |
install(H) { | |
const fe = this; | |
H.component('RouterLink', K1), | |
H.component('RouterView', Q1), | |
H.config.globalProperties.$router = fe, | |
Object.defineProperty( | |
H.config.globalProperties, | |
'$route', | |
{ | |
enumerable: !0, | |
get: () => pe(o) | |
} | |
), | |
Tn && | |
!gn && | |
o.value === Pi && | |
(gn = !0, k(s.location).catch(Ne => { | |
})); | |
const he = {}; | |
for (const Ne in Pi) Object.defineProperty(he, Ne, { | |
get: () => o.value[Ne], | |
enumerable: !0 | |
}); | |
H.provide(wa, fe), | |
H.provide(fu, Qo(he)), | |
H.provide(ho, o); | |
const me = H.unmount; | |
yn.add(H), | |
H.unmount = function () { | |
yn.delete(H), | |
yn.size < 1 && | |
(u = Pi, O && O(), O = null, o.value = Pi, gn = !1, le = !1), | |
me() | |
} | |
} | |
}; | |
function Bt(H) { | |
return H.reduce((fe, he) => fe.then(() => $(he)), Promise.resolve()) | |
} | |
return Qs | |
} | |
function ek(i, e) { | |
const t = [], | |
n = [], | |
s = [], | |
r = Math.max(e.matched.length, i.matched.length); | |
for (let a = 0; a < r; a++) { | |
const l = e.matched[a]; | |
l && | |
(i.matched.find(u => Un(u, l)) ? n.push(l) : t.push(l)); | |
const o = i.matched[a]; | |
o && | |
(e.matched.find(u => Un(u, o)) || s.push(o)) | |
} | |
return [t, | |
n, | |
s] | |
} | |
function gp() { | |
return zt(wa) | |
} | |
function Zn(i) { | |
return zt(fu) | |
} | |
async function tk(i, e, t, n) { | |
const s = Date.now(), | |
r = { | |
req: { | |
coin: `@${ i }`, | |
endTime: n || | |
s, | |
interval: e, | |
startTime: t || | |
s - 24 * 60 * 60 * 1000 | |
}, | |
type: 'candleSnapshot' | |
}, | |
a = await fetch( | |
'https://api-ui.hyperliquid.xyz/info', | |
{ | |
method: 'POST', | |
headers: { | |
'Content-Type': 'application/json' | |
}, | |
body: JSON.stringify(r) | |
} | |
); | |
if (!a.ok) throw new Error(`HTTP error! status: ${ a.status }`); | |
return await a.json() | |
} | |
const si = Xi( | |
'pair', | |
() => { | |
const i = M([]), | |
e = Wi(new Map), | |
t = Wi(new Map), | |
n = M([]), | |
s = Wi(new Map), | |
r = M([]), | |
a = M([]), | |
l = M('1h'), | |
o = new xn({ | |
startStream: (y, b) => (r.value = [], dt.hyperliquidTokenMessages(y, { | |
abort: b.signal | |
})), | |
onMessage: y => { | |
r.value.push(...y.messages) | |
}, | |
onError: y => { | |
console.error('Error in message stream:', y), | |
r.value = [] | |
} | |
}); | |
return { | |
tokens: i, | |
spotPairs: e, | |
spotPairByBaseId: t, | |
perpPairs: n, | |
perpPairById: s, | |
messages: r, | |
fetchTokens: async() => { | |
const y = {}; | |
try { | |
const b = await dt.hyperliquidTokens(y, { | |
}); | |
return i.value = b.response.tokens, | |
b | |
} catch (b) { | |
return console.log(b), | |
b.code, | |
null | |
} | |
}, | |
fetchTokenHolders: async y => { | |
try { | |
return (await dt.hyperliquidTokenHolders({ | |
tokenId: y | |
}, { | |
})).response.holders | |
} catch (b) { | |
return console.log(b), | |
b.code, | |
null | |
} | |
}, | |
fetchSpotPair: async y => { | |
if (y && e.has(y)) return e.get(y); | |
try { | |
const x = (await dt.hyperliquidSpotPair({ | |
id: y | |
}, { | |
})).response.pair; | |
return e.set(x.id, x), | |
t.set(x.base.id, x), | |
e.get(x.id) | |
} catch (b) { | |
return console.log(b), | |
null | |
} | |
}, | |
fetchSpotPairs: async() => { | |
const y = {}; | |
try { | |
const b = await dt.hyperliquidSpotPairs(y, { | |
}); | |
for (const x of b.response.pairs) e.set(x.id, x), | |
t.set(x.base.id, x); | |
return b | |
} catch (b) { | |
return console.log(b), | |
b.code, | |
null | |
} | |
}, | |
fetchPerpPairs: async() => { | |
const y = {}; | |
try { | |
const b = await dt.hyperliquidPerpPairs(y, { | |
}); | |
n.value = b.response.pairs; | |
for (const x of b.response.pairs) s.set(x.id, x); | |
return b | |
} catch (b) { | |
return console.log(b), | |
b.code, | |
null | |
} | |
}, | |
startMessageStream: async y => { | |
await o.start({ | |
tokenId: y | |
}) | |
}, | |
stopMessageStream: () => { | |
o.stop(), | |
r.value = [] | |
}, | |
candles: a, | |
currentInterval: l, | |
fetchCandleData: async(y, b) => { | |
try { | |
b && | |
(l.value = b); | |
const x = await tk(y, l.value); | |
a.value = x.map( | |
k => ({ | |
time: k.t / 1000, | |
open: parseFloat(k.o), | |
high: parseFloat(k.h), | |
low: parseFloat(k.l), | |
close: parseFloat(k.c) | |
}) | |
) | |
} catch (x) { | |
console.error('Error fetching candle data:', x), | |
a.value = [] | |
} | |
} | |
} | |
} | |
); | |
const Hn = i => new Intl.NumberFormat('en-US', { | |
minimumFractionDigits: 2 | |
}).format(i), | |
Nt = i => new Intl.NumberFormat( | |
'en-US', | |
{ | |
style: 'currency', | |
currency: 'USD', | |
minimumFractionDigits: 2, | |
maximumFractionDigits: 2 | |
} | |
).format(i), | |
rt = i => i >= 1000000 ? new Intl.NumberFormat( | |
'en-US', | |
{ | |
style: 'currency', | |
currency: 'USD', | |
minimumFractionDigits: 2, | |
maximumFractionDigits: 2 | |
} | |
).format(i / 1000000) + 'M' : i >= 1000 ? new Intl.NumberFormat( | |
'en-US', | |
{ | |
style: 'currency', | |
currency: 'USD', | |
minimumFractionDigits: 2, | |
maximumFractionDigits: 2 | |
} | |
).format(i / 1000) + 'K' : new Intl.NumberFormat( | |
'en-US', | |
{ | |
style: 'currency', | |
currency: 'USD', | |
minimumFractionDigits: 2, | |
maximumFractionDigits: 2 | |
} | |
).format(i), | |
ik = { | |
class : 'bg-white dark:bg-slate-800 dark:text-white shadow-lg rounded-lg p-6 w-full max-w-sm border border-gray-300 dark:border-gray-700' | |
}, | |
nk = { | |
class : 'flex justify-between items-center mb-6' | |
}, | |
sk = { | |
class : 'text-xl font-bold text-black dark:text-white' | |
}, | |
rk = { | |
class : 'grid grid-cols-2 gap-2' | |
}, | |
ak = { | |
class : 'text-sm text-black dark:text-white mb-1 pl-1' | |
}, | |
lk = { | |
class : 'font-semibold text-gray-700 dark:text-gray-400 pl-1' | |
}, | |
ok = U({ | |
name: 'Card' | |
}), | |
fo = U({ | |
...ok, | |
props: { | |
pair: Object | |
}, | |
setup(i) { | |
const e = i, | |
t = q( | |
() => e.pair ? ( | |
(e.pair.markPrice - e.pair.previousDayPx) / e.pair.previousDayPx * 100 | |
).toFixed(2) : '0' | |
), | |
n = q( | |
() => e.pair ? parseFloat(t.value) >= 0 ? 'text-green-500' : 'text-red-500' : '' | |
), | |
s = a => new Intl.NumberFormat('en-US', { | |
notation: 'compact' | |
}).format(a), | |
r = q( | |
() => [{ | |
label: 'Mark Price', | |
value: e.pair?.markPrice.toFixed(4) | |
}, | |
{ | |
label: '24h Volume', | |
value: rt(e.pair?.dailyNtlVolume) | |
}, | |
{ | |
label: 'Circulating Supply', | |
value: s(e.pair?.base.circulatingSupply) | |
}, | |
{ | |
label: 'HLQ Balance', | |
value: s(e.pair?.base.hlqBalance) | |
} | |
] | |
); | |
return (a, l) => ( | |
_(), | |
T( | |
'div', | |
ik, | |
[ | |
m( | |
'div', | |
nk, | |
[ | |
m('h2', sk, F(i.pair.base.name) + '/' + F(i.pair.quote.name), 1), | |
m( | |
'span', | |
{ | |
class : ie([n.value, | |
'text-lg font-semibold']) | |
}, | |
F(t.value) + '%', | |
3 | |
) | |
] | |
), | |
m( | |
'div', | |
rk, | |
[ | |
( | |
_(!0), | |
T( | |
D, | |
null, | |
ue( | |
r.value, | |
(o, u) => ( | |
_(), | |
T( | |
'div', | |
{ | |
key: u | |
}, | |
[ | |
m('p', ak, F(o.label), 1), | |
m('p', lk, F(o.value), 1) | |
] | |
) | |
) | |
), | |
128 | |
) | |
) | |
] | |
) | |
] | |
) | |
) | |
} | |
}), | |
uk = U({ | |
name: 'CardLoading' | |
}), | |
Ee = (i, e) => { | |
const t = i.__vccOpts || | |
i; | |
for (const [n, | |
s]of e) t[n] = s; | |
return t | |
}, | |
ck = { | |
class : 'bg-white dark:bg-slate-800 shadow-lg rounded-lg p-6 w-full max-w-sm border border-gray-700' | |
}, | |
hk = { | |
class : 'animate-pulse space-y-4' | |
}, | |
dk = { | |
class : 'grid grid-cols-2 gap-4' | |
}; | |
function fk(i, e, t, n, s, r) { | |
return _(), | |
T( | |
'div', | |
ck, | |
[ | |
m( | |
'div', | |
hk, | |
[ | |
e[1] || | |
( | |