2053 lines
75 KiB
JavaScript
2053 lines
75 KiB
JavaScript
// Author Maasea Build: 2023/12/14 22:12:09
|
|
(() => {
|
|
(function (i) {
|
|
function e() {
|
|
}
|
|
|
|
function t() {
|
|
}
|
|
|
|
var r = String.fromCharCode, n = {}.toString, s = n.call(i.SharedArrayBuffer), o = n(), a = i.Uint8Array,
|
|
f = a || Array, l = a ? ArrayBuffer : f, h = l.isView || function (b) {
|
|
return b && "length" in b
|
|
}, y = n.call(l.prototype);
|
|
l = t.prototype;
|
|
var p = i.TextEncoder, c = new (a ? Uint16Array : f)(32);
|
|
e.prototype.decode = function (b) {
|
|
if (!h(b)) {
|
|
var A = n.call(b);
|
|
if (A !== y && A !== s && A !== o) throw TypeError("Failed to execute 'decode' on 'TextDecoder': The provided value is not of type '(ArrayBuffer or ArrayBufferView)'");
|
|
b = a ? new f(b) : b || []
|
|
}
|
|
for (var N = A = "", d = 0, I = b.length | 0, G = I - 32 | 0, B, x, E = 0, J = 0, V, U = 0, D = -1; d < I;) {
|
|
for (B = d <= G ? 32 : I - d | 0; U < B; d = d + 1 | 0, U = U + 1 | 0) {
|
|
switch (x = b[d] & 255, x >> 4) {
|
|
case 15:
|
|
if (V = b[d = d + 1 | 0] & 255, V >> 6 !== 2 || 247 < x) {
|
|
d = d - 1 | 0;
|
|
break
|
|
}
|
|
E = (x & 7) << 6 | V & 63, J = 5, x = 256;
|
|
case 14:
|
|
V = b[d = d + 1 | 0] & 255, E <<= 6, E |= (x & 15) << 6 | V & 63, J = V >> 6 === 2 ? J + 4 | 0 : 24, x = x + 256 & 768;
|
|
case 13:
|
|
case 12:
|
|
V = b[d = d + 1 | 0] & 255, E <<= 6, E |= (x & 31) << 6 | V & 63, J = J + 7 | 0, d < I && V >> 6 === 2 && E >> J && 1114112 > E ? (x = E, E = E - 65536 | 0, 0 <= E && (D = (E >> 10) + 55296 | 0, x = (E & 1023) + 56320 | 0, 31 > U ? (c[U] = D, U = U + 1 | 0, D = -1) : (V = D, D = x, x = V))) : (x >>= 8, d = d - x - 1 | 0, x = 65533), E = J = 0, B = d <= G ? 32 : I - d | 0;
|
|
default:
|
|
c[U] = x;
|
|
continue;
|
|
case 11:
|
|
case 10:
|
|
case 9:
|
|
case 8:
|
|
}
|
|
c[U] = 65533
|
|
}
|
|
if (N += r(c[0], c[1], c[2], c[3], c[4], c[5], c[6], c[7], c[8], c[9], c[10], c[11], c[12], c[13], c[14], c[15], c[16], c[17], c[18], c[19], c[20], c[21], c[22], c[23], c[24], c[25], c[26], c[27], c[28], c[29], c[30], c[31]), 32 > U && (N = N.slice(0, U - 32 | 0)), d < I) {
|
|
if (c[0] = D, U = ~D >>> 31, D = -1, N.length < A.length) continue
|
|
} else D !== -1 && (N += r(D));
|
|
A += N, N = ""
|
|
}
|
|
return A
|
|
}, l.encode = function (b) {
|
|
b = b === void 0 ? "" : "" + b;
|
|
var A = b.length | 0, N = new f((A << 1) + 8 | 0), d, I = 0, G = !a;
|
|
for (d = 0; d < A; d = d + 1 | 0, I = I + 1 | 0) {
|
|
var B = b.charCodeAt(d) | 0;
|
|
if (127 >= B) N[I] = B; else {
|
|
if (2047 >= B) N[I] = 192 | B >> 6; else {
|
|
e:{
|
|
if (55296 <= B) if (56319 >= B) {
|
|
var x = b.charCodeAt(d = d + 1 | 0) | 0;
|
|
if (56320 <= x && 57343 >= x) {
|
|
if (B = (B << 10) + x - 56613888 | 0, 65535 < B) {
|
|
N[I] = 240 | B >> 18, N[I = I + 1 | 0] = 128 | B >> 12 & 63, N[I = I + 1 | 0] = 128 | B >> 6 & 63, N[I = I + 1 | 0] = 128 | B & 63;
|
|
continue
|
|
}
|
|
break e
|
|
}
|
|
B = 65533
|
|
} else 57343 >= B && (B = 65533);
|
|
!G && d << 1 < I && d << 1 < (I - 7 | 0) && (G = !0, x = new f(3 * A), x.set(N), N = x)
|
|
}
|
|
N[I] = 224 | B >> 12, N[I = I + 1 | 0] = 128 | B >> 6 & 63
|
|
}
|
|
N[I = I + 1 | 0] = 128 | B & 63
|
|
}
|
|
}
|
|
return a ? N.subarray(0, I) : N.slice(0, I)
|
|
}, p || (i.TextDecoder = e, i.TextEncoder = t)
|
|
})(globalThis);
|
|
|
|
function Z(i) {
|
|
let e = typeof i;
|
|
if (e == "object") {
|
|
if (Array.isArray(i)) return "array";
|
|
if (i === null) return "null"
|
|
}
|
|
return e
|
|
}
|
|
|
|
function Be(i) {
|
|
return i !== null && typeof i == "object" && !Array.isArray(i)
|
|
}
|
|
|
|
var L = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split(""), z = [];
|
|
for (let i = 0; i < L.length; i++) z[L[i].charCodeAt(0)] = i;
|
|
z["-".charCodeAt(0)] = L.indexOf("+");
|
|
z["_".charCodeAt(0)] = L.indexOf("/");
|
|
|
|
function Oe(i) {
|
|
let e = i.length * 3 / 4;
|
|
i[i.length - 2] == "=" ? e -= 2 : i[i.length - 1] == "=" && (e -= 1);
|
|
let t = new Uint8Array(e), r = 0, n = 0, s, o = 0;
|
|
for (let a = 0; a < i.length; a++) {
|
|
if (s = z[i.charCodeAt(a)], s === void 0) switch (i[a]) {
|
|
case"=":
|
|
n = 0;
|
|
case`
|
|
`:
|
|
case"\r":
|
|
case" ":
|
|
case" ":
|
|
continue;
|
|
default:
|
|
throw Error("invalid base64 string.")
|
|
}
|
|
switch (n) {
|
|
case 0:
|
|
o = s, n = 1;
|
|
break;
|
|
case 1:
|
|
t[r++] = o << 2 | (s & 48) >> 4, o = s, n = 2;
|
|
break;
|
|
case 2:
|
|
t[r++] = (o & 15) << 4 | (s & 60) >> 2, o = s, n = 3;
|
|
break;
|
|
case 3:
|
|
t[r++] = (o & 3) << 6 | s, n = 0;
|
|
break
|
|
}
|
|
}
|
|
if (n == 1) throw Error("invalid base64 string.");
|
|
return t.subarray(0, r)
|
|
}
|
|
|
|
function Fe(i) {
|
|
let e = "", t = 0, r, n = 0;
|
|
for (let s = 0; s < i.length; s++) switch (r = i[s], t) {
|
|
case 0:
|
|
e += L[r >> 2], n = (r & 3) << 4, t = 1;
|
|
break;
|
|
case 1:
|
|
e += L[n | r >> 4], n = (r & 15) << 2, t = 2;
|
|
break;
|
|
case 2:
|
|
e += L[n | r >> 6], e += L[r & 63], t = 0;
|
|
break
|
|
}
|
|
return t && (e += L[n], e += "=", t == 1 && (e += "=")), e
|
|
}
|
|
|
|
var O;
|
|
(function (i) {
|
|
i.symbol = Symbol.for("protobuf-ts/unknown"), i.onRead = (t, r, n, s, o) => {
|
|
(e(r) ? r[i.symbol] : r[i.symbol] = []).push({no: n, wireType: s, data: o})
|
|
}, i.onWrite = (t, r, n) => {
|
|
for (let {no: s, wireType: o, data: a} of i.list(r)) n.tag(s, o).raw(a)
|
|
}, i.list = (t, r) => {
|
|
if (e(t)) {
|
|
let n = t[i.symbol];
|
|
return r ? n.filter(s => s.no == r) : n
|
|
}
|
|
return []
|
|
}, i.last = (t, r) => i.list(t, r).slice(-1)[0];
|
|
let e = t => t && Array.isArray(t[i.symbol])
|
|
})(O || (O = {}));
|
|
var g;
|
|
(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"
|
|
})(g || (g = {}));
|
|
|
|
function Ee() {
|
|
let i = 0, e = 0;
|
|
for (let r = 0; r < 28; r += 7) {
|
|
let n = this.buf[this.pos++];
|
|
if (i |= (n & 127) << r, !(n & 128)) return this.assertBounds(), [i, e]
|
|
}
|
|
let t = this.buf[this.pos++];
|
|
if (i |= (t & 15) << 28, e = (t & 112) >> 4, !(t & 128)) return this.assertBounds(), [i, e];
|
|
for (let r = 3; r <= 31; r += 7) {
|
|
let n = this.buf[this.pos++];
|
|
if (e |= (n & 127) << r, !(n & 128)) return this.assertBounds(), [i, e]
|
|
}
|
|
throw new Error("invalid varint")
|
|
}
|
|
|
|
function H(i, e, t) {
|
|
for (let s = 0; s < 28; s = s + 7) {
|
|
let o = i >>> s, a = !(!(o >>> 7) && e == 0), f = (a ? o | 128 : o) & 255;
|
|
if (t.push(f), !a) return
|
|
}
|
|
let r = i >>> 28 & 15 | (e & 7) << 4, n = !!(e >> 3);
|
|
if (t.push((n ? r | 128 : r) & 255), !!n) {
|
|
for (let s = 3; s < 31; s = s + 7) {
|
|
let o = e >>> s, a = !!(o >>> 7), f = (a ? o | 128 : o) & 255;
|
|
if (t.push(f), !a) return
|
|
}
|
|
t.push(e >>> 31 & 1)
|
|
}
|
|
}
|
|
|
|
var Q = (1 << 16) * (1 << 16);
|
|
|
|
function de(i) {
|
|
let e = i[0] == "-";
|
|
e && (i = i.slice(1));
|
|
let t = 1e6, r = 0, n = 0;
|
|
|
|
function s(o, a) {
|
|
let f = Number(i.slice(o, a));
|
|
n *= t, r = r * t + f, r >= Q && (n = n + (r / Q | 0), r = r % Q)
|
|
}
|
|
|
|
return s(-24, -18), s(-18, -12), s(-12, -6), s(-6), [e, r, n]
|
|
}
|
|
|
|
function ee(i, e) {
|
|
if (e <= 2097151) return "" + (Q * e + (i >>> 0));
|
|
let t = i & 16777215, r = (i >>> 24 | e << 8) >>> 0 & 16777215, n = e >> 16 & 65535,
|
|
s = t + r * 6777216 + n * 6710656, o = r + n * 8147497, a = n * 2, f = 1e7;
|
|
s >= f && (o += Math.floor(s / f), s %= f), o >= f && (a += Math.floor(o / f), o %= f);
|
|
|
|
function l(h, y) {
|
|
let p = h ? String(h) : "";
|
|
return y ? "0000000".slice(p.length) + p : p
|
|
}
|
|
|
|
return l(a, 0) + l(o, a) + l(s, 1)
|
|
}
|
|
|
|
function me(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 Re() {
|
|
let i = this.buf[this.pos++], e = i & 127;
|
|
if (!(i & 128)) return this.assertBounds(), e;
|
|
if (i = this.buf[this.pos++], e |= (i & 127) << 7, !(i & 128)) return this.assertBounds(), e;
|
|
if (i = this.buf[this.pos++], e |= (i & 127) << 14, !(i & 128)) return this.assertBounds(), e;
|
|
if (i = this.buf[this.pos++], e |= (i & 127) << 21, !(i & 128)) return this.assertBounds(), e;
|
|
i = this.buf[this.pos++], e |= (i & 15) << 28;
|
|
for (let t = 5; i & 128 && t < 10; t++) i = this.buf[this.pos++];
|
|
if (i & 128) throw new Error("invalid varint");
|
|
return this.assertBounds(), e >>> 0
|
|
}
|
|
|
|
function _e() {
|
|
let i = new DataView(new ArrayBuffer(8));
|
|
return 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
|
|
}
|
|
|
|
var k = _e();
|
|
|
|
function Ae(i) {
|
|
if (!i) throw new Error("BigInt unavailable, see https://github.com/timostamm/protobuf-ts/blob/v1.0.8/MANUAL.md#bigint-support")
|
|
}
|
|
|
|
var Se = /^-?[0-9]+$/, te = (1 << 16) * (1 << 16), re = class {
|
|
constructor(e, t) {
|
|
this.lo = e | 0, this.hi = t | 0
|
|
}
|
|
|
|
isZero() {
|
|
return this.lo == 0 && this.hi == 0
|
|
}
|
|
|
|
toNumber() {
|
|
let e = this.hi * te + (this.lo >>> 0);
|
|
if (!Number.isSafeInteger(e)) throw new Error("cannot convert to safe number");
|
|
return e
|
|
}
|
|
}, T = class extends re {
|
|
static from(e) {
|
|
if (k) switch (typeof e) {
|
|
case"string":
|
|
if (e == "0") return this.ZERO;
|
|
if (e == "") throw new Error("string is no integer");
|
|
e = k.C(e);
|
|
case"number":
|
|
if (e === 0) return this.ZERO;
|
|
e = k.C(e);
|
|
case"bigint":
|
|
if (!e) return this.ZERO;
|
|
if (e < k.UMIN) throw new Error("signed value for ulong");
|
|
if (e > k.UMAX) throw new Error("ulong too large");
|
|
return k.V.setBigUint64(0, e, !0), new T(k.V.getInt32(0, !0), k.V.getInt32(4, !0))
|
|
} else switch (typeof e) {
|
|
case"string":
|
|
if (e == "0") return this.ZERO;
|
|
if (e = e.trim(), !Se.test(e)) throw new Error("string is no integer");
|
|
let [t, r, n] = de(e);
|
|
if (t) throw new Error("signed value");
|
|
return new T(r, n);
|
|
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 T(e, e / te)
|
|
}
|
|
throw new Error("unknown value " + typeof e)
|
|
}
|
|
|
|
toString() {
|
|
return k ? this.toBigInt().toString() : ee(this.lo, this.hi)
|
|
}
|
|
|
|
toBigInt() {
|
|
return Ae(k), k.V.setInt32(0, this.lo, !0), k.V.setInt32(4, this.hi, !0), k.V.getBigUint64(0, !0)
|
|
}
|
|
};
|
|
T.ZERO = new T(0, 0);
|
|
var w = class extends re {
|
|
static from(e) {
|
|
if (k) switch (typeof e) {
|
|
case"string":
|
|
if (e == "0") return this.ZERO;
|
|
if (e == "") throw new Error("string is no integer");
|
|
e = k.C(e);
|
|
case"number":
|
|
if (e === 0) return this.ZERO;
|
|
e = k.C(e);
|
|
case"bigint":
|
|
if (!e) return this.ZERO;
|
|
if (e < k.MIN) throw new Error("ulong too small");
|
|
if (e > k.MAX) throw new Error("ulong too large");
|
|
return k.V.setBigInt64(0, e, !0), new w(k.V.getInt32(0, !0), k.V.getInt32(4, !0))
|
|
} else switch (typeof e) {
|
|
case"string":
|
|
if (e == "0") return this.ZERO;
|
|
if (e = e.trim(), !Se.test(e)) throw new Error("string is no integer");
|
|
let [t, r, n] = de(e), s = new w(r, n);
|
|
return t ? s.negate() : s;
|
|
case"number":
|
|
if (e == 0) return this.ZERO;
|
|
if (!Number.isSafeInteger(e)) throw new Error("number is no integer");
|
|
return e > 0 ? new w(e, e / te) : new w(-e, -e / te).negate()
|
|
}
|
|
throw new Error("unknown value " + typeof e)
|
|
}
|
|
|
|
isNegative() {
|
|
return (this.hi & 2147483648) !== 0
|
|
}
|
|
|
|
negate() {
|
|
let e = ~this.hi, t = this.lo;
|
|
return t ? t = ~t + 1 : e += 1, new w(t, e)
|
|
}
|
|
|
|
toString() {
|
|
if (k) return this.toBigInt().toString();
|
|
if (this.isNegative()) {
|
|
let e = this.negate();
|
|
return "-" + ee(e.lo, e.hi)
|
|
}
|
|
return ee(this.lo, this.hi)
|
|
}
|
|
|
|
toBigInt() {
|
|
return Ae(k), k.V.setInt32(0, this.lo, !0), k.V.setInt32(4, this.hi, !0), k.V.getBigInt64(0, !0)
|
|
}
|
|
};
|
|
w.ZERO = new w(0, 0);
|
|
var Ue = {readUnknownField: !0, readerFactory: i => new pe(i)};
|
|
|
|
function Ve(i) {
|
|
return i ? Object.assign(Object.assign({}, Ue), i) : Ue
|
|
}
|
|
|
|
var pe = class {
|
|
constructor(e, t) {
|
|
this.varint64 = Ee, this.uint32 = Re, 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, r = e & 7;
|
|
if (t <= 0 || r < 0 || r > 5) throw new Error("illegal tag: field no " + t + " wire type " + r);
|
|
return [t, r]
|
|
}
|
|
|
|
skip(e) {
|
|
let t = this.pos;
|
|
switch (e) {
|
|
case g.Varint:
|
|
for (; this.buf[this.pos++] & 128;) ;
|
|
break;
|
|
case g.Bit64:
|
|
this.pos += 4;
|
|
case g.Bit32:
|
|
this.pos += 4;
|
|
break;
|
|
case g.LengthDelimited:
|
|
let r = this.uint32();
|
|
this.pos += r;
|
|
break;
|
|
case g.StartGroup:
|
|
let n;
|
|
for (; (n = this.tag()[1]) !== g.EndGroup;) this.skip(n);
|
|
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 w(...this.varint64())
|
|
}
|
|
|
|
uint64() {
|
|
return new T(...this.varint64())
|
|
}
|
|
|
|
sint64() {
|
|
let [e, t] = this.varint64(), r = -(e & 1);
|
|
return e = (e >>> 1 | (t & 1) << 31) ^ r, t = t >>> 1 ^ r, new w(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 T(this.sfixed32(), this.sfixed32())
|
|
}
|
|
|
|
sfixed64() {
|
|
return new w(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 m(i, e) {
|
|
if (!i) throw new Error(e)
|
|
}
|
|
|
|
var Ye = 34028234663852886e22, Ze = -34028234663852886e22, ze = 4294967295, Qe = 2147483647, He = -2147483648;
|
|
|
|
function M(i) {
|
|
if (typeof i != "number") throw new Error("invalid int 32: " + typeof i);
|
|
if (!Number.isInteger(i) || i > Qe || i < He) throw new Error("invalid int 32: " + i)
|
|
}
|
|
|
|
function W(i) {
|
|
if (typeof i != "number") throw new Error("invalid uint 32: " + typeof i);
|
|
if (!Number.isInteger(i) || i > ze || i < 0) throw new Error("invalid uint 32: " + i)
|
|
}
|
|
|
|
function j(i) {
|
|
if (typeof i != "number") throw new Error("invalid float 32: " + typeof i);
|
|
if (Number.isFinite(i) && (i > Ye || i < Ze)) throw new Error("invalid float 32: " + i)
|
|
}
|
|
|
|
var De = {writeUnknownFields: !0, writerFactory: () => new ge};
|
|
|
|
function Ce(i) {
|
|
return i ? Object.assign(Object.assign({}, De), i) : De
|
|
}
|
|
|
|
var ge = class {
|
|
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 n = 0; n < this.chunks.length; n++) e += this.chunks[n].length;
|
|
let t = new Uint8Array(e), r = 0;
|
|
for (let n = 0; n < this.chunks.length; n++) t.set(this.chunks[n], r), r += this.chunks[n].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 (W(e); e > 127;) this.buf.push(e & 127 | 128), e = e >>> 7;
|
|
return this.buf.push(e), this
|
|
}
|
|
|
|
int32(e) {
|
|
return M(e), me(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) {
|
|
j(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) {
|
|
W(e);
|
|
let t = new Uint8Array(4);
|
|
return new DataView(t.buffer).setUint32(0, e, !0), this.raw(t)
|
|
}
|
|
|
|
sfixed32(e) {
|
|
M(e);
|
|
let t = new Uint8Array(4);
|
|
return new DataView(t.buffer).setInt32(0, e, !0), this.raw(t)
|
|
}
|
|
|
|
sint32(e) {
|
|
return M(e), e = (e << 1 ^ e >> 31) >>> 0, me(e, this.buf), this
|
|
}
|
|
|
|
sfixed64(e) {
|
|
let t = new Uint8Array(8), r = new DataView(t.buffer), n = w.from(e);
|
|
return r.setInt32(0, n.lo, !0), r.setInt32(4, n.hi, !0), this.raw(t)
|
|
}
|
|
|
|
fixed64(e) {
|
|
let t = new Uint8Array(8), r = new DataView(t.buffer), n = T.from(e);
|
|
return r.setInt32(0, n.lo, !0), r.setInt32(4, n.hi, !0), this.raw(t)
|
|
}
|
|
|
|
int64(e) {
|
|
let t = w.from(e);
|
|
return H(t.lo, t.hi, this.buf), this
|
|
}
|
|
|
|
sint64(e) {
|
|
let t = w.from(e), r = t.hi >> 31, n = t.lo << 1 ^ r, s = (t.hi << 1 | t.lo >>> 31) ^ r;
|
|
return H(n, s, this.buf), this
|
|
}
|
|
|
|
uint64(e) {
|
|
let t = T.from(e);
|
|
return H(t.lo, t.hi, this.buf), this
|
|
}
|
|
};
|
|
var Le = {emitDefaultValues: !1, enumAsInteger: !1, useProtoFieldName: !1, prettySpaces: 0},
|
|
Pe = {ignoreUnknownFields: !1};
|
|
|
|
function $e(i) {
|
|
return i ? Object.assign(Object.assign({}, Pe), i) : Pe
|
|
}
|
|
|
|
function Me(i) {
|
|
return i ? Object.assign(Object.assign({}, Le), i) : Le
|
|
}
|
|
|
|
var K = Symbol.for("protobuf-ts/message-type");
|
|
|
|
function be(i) {
|
|
let e = !1, t = [];
|
|
for (let r = 0; r < i.length; r++) {
|
|
let n = i.charAt(r);
|
|
n == "_" ? e = !0 : /\d/.test(n) ? (t.push(n), e = !0) : e ? (t.push(n.toUpperCase()), e = !1) : r == 0 ? t.push(n.toLowerCase()) : t.push(n)
|
|
}
|
|
return t.join("")
|
|
}
|
|
|
|
var u;
|
|
(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"
|
|
})(u || (u = {}));
|
|
var F;
|
|
(function (i) {
|
|
i[i.BIGINT = 0] = "BIGINT", i[i.STRING = 1] = "STRING", i[i.NUMBER = 2] = "NUMBER"
|
|
})(F || (F = {}));
|
|
var v;
|
|
(function (i) {
|
|
i[i.NO = 0] = "NO", i[i.PACKED = 1] = "PACKED", i[i.UNPACKED = 2] = "UNPACKED"
|
|
})(v || (v = {}));
|
|
|
|
function Ke(i) {
|
|
var e, t, r, n;
|
|
return i.localName = (e = i.localName) !== null && e !== void 0 ? e : be(i.name), i.jsonName = (t = i.jsonName) !== null && t !== void 0 ? t : be(i.name), i.repeat = (r = i.repeat) !== null && r !== void 0 ? r : v.NO, i.opt = (n = i.opt) !== null && n !== void 0 ? n : i.repeat || i.oneof ? !1 : i.kind == "message", i
|
|
}
|
|
|
|
function qe(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
|
|
}
|
|
}
|
|
|
|
var ne = class {
|
|
constructor(e) {
|
|
var t;
|
|
this.fields = (t = e.fields) !== null && t !== void 0 ? t : []
|
|
}
|
|
|
|
prepare() {
|
|
if (this.data) return;
|
|
let e = [], t = [], r = [];
|
|
for (let n of this.fields) if (n.oneof) r.includes(n.oneof) || (r.push(n.oneof), e.push(n.oneof), t.push(n.oneof)); else switch (t.push(n.localName), n.kind) {
|
|
case"scalar":
|
|
case"enum":
|
|
(!n.opt || n.repeat) && e.push(n.localName);
|
|
break;
|
|
case"message":
|
|
n.repeat && e.push(n.localName);
|
|
break;
|
|
case"map":
|
|
e.push(n.localName);
|
|
break
|
|
}
|
|
this.data = {req: e, known: t, oneofs: Object.values(r)}
|
|
}
|
|
|
|
is(e, t, r = !1) {
|
|
if (t < 0) return !0;
|
|
if (e == null || typeof e != "object") return !1;
|
|
this.prepare();
|
|
let n = Object.keys(e), s = this.data;
|
|
if (n.length < s.req.length || s.req.some(o => !n.includes(o)) || !r && n.some(o => !s.known.includes(o))) return !1;
|
|
if (t < 1) return !0;
|
|
for (let o of s.oneofs) {
|
|
let a = e[o];
|
|
if (!qe(a)) return !1;
|
|
if (a.oneofKind === void 0) continue;
|
|
let f = this.fields.find(l => l.localName === a.oneofKind);
|
|
if (!f || !this.field(a[a.oneofKind], f, r, t)) return !1
|
|
}
|
|
for (let o of this.fields) if (o.oneof === void 0 && !this.field(e[o.localName], o, r, t)) return !1;
|
|
return !0
|
|
}
|
|
|
|
field(e, t, r, n) {
|
|
let s = t.repeat;
|
|
switch (t.kind) {
|
|
case"scalar":
|
|
return e === void 0 ? t.opt : s ? this.scalars(e, t.T, n, t.L) : this.scalar(e, t.T, t.L);
|
|
case"enum":
|
|
return e === void 0 ? t.opt : s ? this.scalars(e, u.INT32, n) : this.scalar(e, u.INT32);
|
|
case"message":
|
|
return e === void 0 ? !0 : s ? this.messages(e, t.T(), r, n) : this.message(e, t.T(), r, n);
|
|
case"map":
|
|
if (typeof e != "object" || e === null) return !1;
|
|
if (n < 2) return !0;
|
|
if (!this.mapKeys(e, t.K, n)) return !1;
|
|
switch (t.V.kind) {
|
|
case"scalar":
|
|
return this.scalars(Object.values(e), t.V.T, n, t.V.L);
|
|
case"enum":
|
|
return this.scalars(Object.values(e), u.INT32, n);
|
|
case"message":
|
|
return this.messages(Object.values(e), t.V.T(), r, n)
|
|
}
|
|
break
|
|
}
|
|
return !0
|
|
}
|
|
|
|
message(e, t, r, n) {
|
|
return r ? t.isAssignable(e, n) : t.is(e, n)
|
|
}
|
|
|
|
messages(e, t, r, n) {
|
|
if (!Array.isArray(e)) return !1;
|
|
if (n < 2) return !0;
|
|
if (r) {
|
|
for (let s = 0; s < e.length && s < n; s++) if (!t.isAssignable(e[s], n - 1)) return !1
|
|
} else for (let s = 0; s < e.length && s < n; s++) if (!t.is(e[s], n - 1)) return !1;
|
|
return !0
|
|
}
|
|
|
|
scalar(e, t, r) {
|
|
let n = typeof e;
|
|
switch (t) {
|
|
case u.UINT64:
|
|
case u.FIXED64:
|
|
case u.INT64:
|
|
case u.SFIXED64:
|
|
case u.SINT64:
|
|
switch (r) {
|
|
case F.BIGINT:
|
|
return n == "bigint";
|
|
case F.NUMBER:
|
|
return n == "number" && !isNaN(e);
|
|
default:
|
|
return n == "string"
|
|
}
|
|
case u.BOOL:
|
|
return n == "boolean";
|
|
case u.STRING:
|
|
return n == "string";
|
|
case u.BYTES:
|
|
return e instanceof Uint8Array;
|
|
case u.DOUBLE:
|
|
case u.FLOAT:
|
|
return n == "number" && !isNaN(e);
|
|
default:
|
|
return n == "number" && Number.isInteger(e)
|
|
}
|
|
}
|
|
|
|
scalars(e, t, r, n) {
|
|
if (!Array.isArray(e)) return !1;
|
|
if (r < 2) return !0;
|
|
if (Array.isArray(e)) {
|
|
for (let s = 0; s < e.length && s < r; s++) if (!this.scalar(e[s], t, n)) return !1
|
|
}
|
|
return !0
|
|
}
|
|
|
|
mapKeys(e, t, r) {
|
|
let n = Object.keys(e);
|
|
switch (t) {
|
|
case u.INT32:
|
|
case u.FIXED32:
|
|
case u.SFIXED32:
|
|
case u.SINT32:
|
|
case u.UINT32:
|
|
return this.scalars(n.slice(0, r).map(s => parseInt(s)), t, r);
|
|
case u.BOOL:
|
|
return this.scalars(n.slice(0, r).map(s => s == "true" ? !0 : s == "false" ? !1 : s), t, r);
|
|
default:
|
|
return this.scalars(n, t, r, F.STRING)
|
|
}
|
|
}
|
|
};
|
|
|
|
function R(i, e) {
|
|
switch (e) {
|
|
case F.BIGINT:
|
|
return i.toBigInt();
|
|
case F.NUMBER:
|
|
return i.toNumber();
|
|
default:
|
|
return i.toString()
|
|
}
|
|
}
|
|
|
|
var ie = class {
|
|
constructor(e) {
|
|
this.info = e
|
|
}
|
|
|
|
prepare() {
|
|
var e;
|
|
if (this.fMap === void 0) {
|
|
this.fMap = {};
|
|
let t = (e = this.info.fields) !== null && e !== void 0 ? e : [];
|
|
for (let r of t) this.fMap[r.name] = r, this.fMap[r.jsonName] = r, this.fMap[r.localName] = r
|
|
}
|
|
}
|
|
|
|
assert(e, t, r) {
|
|
if (!e) {
|
|
let n = Z(r);
|
|
throw (n == "number" || n == "boolean") && (n = r.toString()), new Error(`Cannot parse JSON ${n} for ${this.info.typeName}#${t}`)
|
|
}
|
|
}
|
|
|
|
read(e, t, r) {
|
|
this.prepare();
|
|
let n = [];
|
|
for (let [s, o] of Object.entries(e)) {
|
|
let a = this.fMap[s];
|
|
if (!a) {
|
|
if (!r.ignoreUnknownFields) throw new Error(`Found unknown field while reading ${this.info.typeName} from JSON format. JSON key: ${s}`);
|
|
continue
|
|
}
|
|
let f = a.localName, l;
|
|
if (a.oneof) {
|
|
if (n.includes(a.oneof)) throw new Error(`Multiple members of the oneof group "${a.oneof}" of ${this.info.typeName} are present in JSON.`);
|
|
n.push(a.oneof), l = t[a.oneof] = {oneofKind: f}
|
|
} else l = t;
|
|
if (a.kind == "map") {
|
|
if (o === null) continue;
|
|
this.assert(Be(o), a.name, o);
|
|
let h = l[f];
|
|
for (let [y, p] of Object.entries(o)) {
|
|
this.assert(p !== null, a.name + " map value", null);
|
|
let c;
|
|
switch (a.V.kind) {
|
|
case"message":
|
|
c = a.V.T().internalJsonRead(p, r);
|
|
break;
|
|
case"enum":
|
|
if (c = this.enum(a.V.T(), p, a.name, r.ignoreUnknownFields), c === !1) continue;
|
|
break;
|
|
case"scalar":
|
|
c = this.scalar(p, a.V.T, a.V.L, a.name);
|
|
break
|
|
}
|
|
this.assert(c !== void 0, a.name + " map value", p);
|
|
let b = y;
|
|
a.K == u.BOOL && (b = b == "true" ? !0 : b == "false" ? !1 : b), b = this.scalar(b, a.K, F.STRING, a.name).toString(), h[b] = c
|
|
}
|
|
} else if (a.repeat) {
|
|
if (o === null) continue;
|
|
this.assert(Array.isArray(o), a.name, o);
|
|
let h = l[f];
|
|
for (let y of o) {
|
|
this.assert(y !== null, a.name, null);
|
|
let p;
|
|
switch (a.kind) {
|
|
case"message":
|
|
p = a.T().internalJsonRead(y, r);
|
|
break;
|
|
case"enum":
|
|
if (p = this.enum(a.T(), y, a.name, r.ignoreUnknownFields), p === !1) continue;
|
|
break;
|
|
case"scalar":
|
|
p = this.scalar(y, a.T, a.L, a.name);
|
|
break
|
|
}
|
|
this.assert(p !== void 0, a.name, o), h.push(p)
|
|
}
|
|
} else switch (a.kind) {
|
|
case"message":
|
|
if (o === null && a.T().typeName != "google.protobuf.Value") {
|
|
this.assert(a.oneof === void 0, a.name + " (oneof member)", null);
|
|
continue
|
|
}
|
|
l[f] = a.T().internalJsonRead(o, r, l[f]);
|
|
break;
|
|
case"enum":
|
|
let h = this.enum(a.T(), o, a.name, r.ignoreUnknownFields);
|
|
if (h === !1) continue;
|
|
l[f] = h;
|
|
break;
|
|
case"scalar":
|
|
l[f] = this.scalar(o, a.T, a.L, a.name);
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
enum(e, t, r, n) {
|
|
if (e[0] == "google.protobuf.NullValue" && m(t === null, `Unable to parse field ${this.info.typeName}#${r}, enum ${e[0]} only accepts null.`), t === null) return 0;
|
|
switch (typeof t) {
|
|
case"number":
|
|
return m(Number.isInteger(t), `Unable to parse field ${this.info.typeName}#${r}, enum can only be integral number, got ${t}.`), t;
|
|
case"string":
|
|
let s = t;
|
|
e[2] && t.substring(0, e[2].length) === e[2] && (s = t.substring(e[2].length));
|
|
let o = e[1][s];
|
|
return typeof o > "u" && n ? !1 : (m(typeof o == "number", `Unable to parse field ${this.info.typeName}#${r}, enum ${e[0]} has no value for "${t}".`), o)
|
|
}
|
|
m(!1, `Unable to parse field ${this.info.typeName}#${r}, cannot parse enum value from ${typeof t}".`)
|
|
}
|
|
|
|
scalar(e, t, r, n) {
|
|
let s;
|
|
try {
|
|
switch (t) {
|
|
case u.DOUBLE:
|
|
case u.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 === "") {
|
|
s = "empty string";
|
|
break
|
|
}
|
|
if (typeof e == "string" && e.trim().length !== e.length) {
|
|
s = "extra whitespace";
|
|
break
|
|
}
|
|
if (typeof e != "string" && typeof e != "number") break;
|
|
let o = Number(e);
|
|
if (Number.isNaN(o)) {
|
|
s = "not a number";
|
|
break
|
|
}
|
|
if (!Number.isFinite(o)) {
|
|
s = "too large or small";
|
|
break
|
|
}
|
|
return t == u.FLOAT && j(o), o;
|
|
case u.INT32:
|
|
case u.FIXED32:
|
|
case u.SFIXED32:
|
|
case u.SINT32:
|
|
case u.UINT32:
|
|
if (e === null) return 0;
|
|
let a;
|
|
if (typeof e == "number" ? a = e : e === "" ? s = "empty string" : typeof e == "string" && (e.trim().length !== e.length ? s = "extra whitespace" : a = Number(e)), a === void 0) break;
|
|
return t == u.UINT32 ? W(a) : M(a), a;
|
|
case u.INT64:
|
|
case u.SFIXED64:
|
|
case u.SINT64:
|
|
if (e === null) return R(w.ZERO, r);
|
|
if (typeof e != "number" && typeof e != "string") break;
|
|
return R(w.from(e), r);
|
|
case u.FIXED64:
|
|
case u.UINT64:
|
|
if (e === null) return R(T.ZERO, r);
|
|
if (typeof e != "number" && typeof e != "string") break;
|
|
return R(T.from(e), r);
|
|
case u.BOOL:
|
|
if (e === null) return !1;
|
|
if (typeof e != "boolean") break;
|
|
return e;
|
|
case u.STRING:
|
|
if (e === null) return "";
|
|
if (typeof e != "string") {
|
|
s = "extra whitespace";
|
|
break
|
|
}
|
|
try {
|
|
encodeURIComponent(e)
|
|
} catch (f) {
|
|
f = "invalid UTF8";
|
|
break
|
|
}
|
|
return e;
|
|
case u.BYTES:
|
|
if (e === null || e === "") return new Uint8Array(0);
|
|
if (typeof e != "string") break;
|
|
return Oe(e)
|
|
}
|
|
} catch (o) {
|
|
s = o.message
|
|
}
|
|
this.assert(!1, n + (s ? " - " + s : ""), e)
|
|
}
|
|
};
|
|
var se = class {
|
|
constructor(e) {
|
|
var t;
|
|
this.fields = (t = e.fields) !== null && t !== void 0 ? t : []
|
|
}
|
|
|
|
write(e, t) {
|
|
let r = {}, n = e;
|
|
for (let s of this.fields) {
|
|
if (!s.oneof) {
|
|
let l = this.field(s, n[s.localName], t);
|
|
l !== void 0 && (r[t.useProtoFieldName ? s.name : s.jsonName] = l);
|
|
continue
|
|
}
|
|
let o = n[s.oneof];
|
|
if (o.oneofKind !== s.localName) continue;
|
|
let a = s.kind == "scalar" || s.kind == "enum" ? Object.assign(Object.assign({}, t), {emitDefaultValues: !0}) : t,
|
|
f = this.field(s, o[s.localName], a);
|
|
m(f !== void 0), r[t.useProtoFieldName ? s.name : s.jsonName] = f
|
|
}
|
|
return r
|
|
}
|
|
|
|
field(e, t, r) {
|
|
let n;
|
|
if (e.kind == "map") {
|
|
m(typeof t == "object" && t !== null);
|
|
let s = {};
|
|
switch (e.V.kind) {
|
|
case"scalar":
|
|
for (let [f, l] of Object.entries(t)) {
|
|
let h = this.scalar(e.V.T, l, e.name, !1, !0);
|
|
m(h !== void 0), s[f.toString()] = h
|
|
}
|
|
break;
|
|
case"message":
|
|
let o = e.V.T();
|
|
for (let [f, l] of Object.entries(t)) {
|
|
let h = this.message(o, l, e.name, r);
|
|
m(h !== void 0), s[f.toString()] = h
|
|
}
|
|
break;
|
|
case"enum":
|
|
let a = e.V.T();
|
|
for (let [f, l] of Object.entries(t)) {
|
|
m(l === void 0 || typeof l == "number");
|
|
let h = this.enum(a, l, e.name, !1, !0, r.enumAsInteger);
|
|
m(h !== void 0), s[f.toString()] = h
|
|
}
|
|
break
|
|
}
|
|
(r.emitDefaultValues || Object.keys(s).length > 0) && (n = s)
|
|
} else if (e.repeat) {
|
|
m(Array.isArray(t));
|
|
let s = [];
|
|
switch (e.kind) {
|
|
case"scalar":
|
|
for (let f = 0; f < t.length; f++) {
|
|
let l = this.scalar(e.T, t[f], e.name, e.opt, !0);
|
|
m(l !== void 0), s.push(l)
|
|
}
|
|
break;
|
|
case"enum":
|
|
let o = e.T();
|
|
for (let f = 0; f < t.length; f++) {
|
|
m(t[f] === void 0 || typeof t[f] == "number");
|
|
let l = this.enum(o, t[f], e.name, e.opt, !0, r.enumAsInteger);
|
|
m(l !== void 0), s.push(l)
|
|
}
|
|
break;
|
|
case"message":
|
|
let a = e.T();
|
|
for (let f = 0; f < t.length; f++) {
|
|
let l = this.message(a, t[f], e.name, r);
|
|
m(l !== void 0), s.push(l)
|
|
}
|
|
break
|
|
}
|
|
(r.emitDefaultValues || s.length > 0 || r.emitDefaultValues) && (n = s)
|
|
} else switch (e.kind) {
|
|
case"scalar":
|
|
n = this.scalar(e.T, t, e.name, e.opt, r.emitDefaultValues);
|
|
break;
|
|
case"enum":
|
|
n = this.enum(e.T(), t, e.name, e.opt, r.emitDefaultValues, r.enumAsInteger);
|
|
break;
|
|
case"message":
|
|
n = this.message(e.T(), t, e.name, r);
|
|
break
|
|
}
|
|
return n
|
|
}
|
|
|
|
enum(e, t, r, n, s, o) {
|
|
if (e[0] == "google.protobuf.NullValue") return null;
|
|
if (t === void 0) {
|
|
m(n);
|
|
return
|
|
}
|
|
if (!(t === 0 && !s && !n)) return m(typeof t == "number"), m(Number.isInteger(t)), o || !e[1].hasOwnProperty(t) ? t : e[2] ? e[2] + e[1][t] : e[1][t]
|
|
}
|
|
|
|
message(e, t, r, n) {
|
|
return t === void 0 ? n.emitDefaultValues ? null : void 0 : e.internalJsonWrite(t, n)
|
|
}
|
|
|
|
scalar(e, t, r, n, s) {
|
|
if (t === void 0) {
|
|
m(n);
|
|
return
|
|
}
|
|
let o = s || n;
|
|
switch (e) {
|
|
case u.INT32:
|
|
case u.SFIXED32:
|
|
case u.SINT32:
|
|
return t === 0 ? o ? 0 : void 0 : (M(t), t);
|
|
case u.FIXED32:
|
|
case u.UINT32:
|
|
return t === 0 ? o ? 0 : void 0 : (W(t), t);
|
|
case u.FLOAT:
|
|
j(t);
|
|
case u.DOUBLE:
|
|
return t === 0 ? o ? 0 : void 0 : (m(typeof t == "number"), Number.isNaN(t) ? "NaN" : t === Number.POSITIVE_INFINITY ? "Infinity" : t === Number.NEGATIVE_INFINITY ? "-Infinity" : t);
|
|
case u.STRING:
|
|
return t === "" ? o ? "" : void 0 : (m(typeof t == "string"), t);
|
|
case u.BOOL:
|
|
return t === !1 ? o ? !1 : void 0 : (m(typeof t == "boolean"), t);
|
|
case u.UINT64:
|
|
case u.FIXED64:
|
|
m(typeof t == "number" || typeof t == "string" || typeof t == "bigint");
|
|
let a = T.from(t);
|
|
return a.isZero() && !o ? void 0 : a.toString();
|
|
case u.INT64:
|
|
case u.SFIXED64:
|
|
case u.SINT64:
|
|
m(typeof t == "number" || typeof t == "string" || typeof t == "bigint");
|
|
let f = w.from(t);
|
|
return f.isZero() && !o ? void 0 : f.toString();
|
|
case u.BYTES:
|
|
return m(t instanceof Uint8Array), t.byteLength ? Fe(t) : o ? "" : void 0
|
|
}
|
|
}
|
|
};
|
|
|
|
function _(i, e = F.STRING) {
|
|
switch (i) {
|
|
case u.BOOL:
|
|
return !1;
|
|
case u.UINT64:
|
|
case u.FIXED64:
|
|
return R(T.ZERO, e);
|
|
case u.INT64:
|
|
case u.SFIXED64:
|
|
case u.SINT64:
|
|
return R(w.ZERO, e);
|
|
case u.DOUBLE:
|
|
case u.FLOAT:
|
|
return 0;
|
|
case u.BYTES:
|
|
return new Uint8Array(0);
|
|
case u.STRING:
|
|
return "";
|
|
default:
|
|
return 0
|
|
}
|
|
}
|
|
|
|
var oe = class {
|
|
constructor(e) {
|
|
this.info = e
|
|
}
|
|
|
|
prepare() {
|
|
var e;
|
|
if (!this.fieldNoToField) {
|
|
let t = (e = this.info.fields) !== null && e !== void 0 ? e : [];
|
|
this.fieldNoToField = new Map(t.map(r => [r.no, r]))
|
|
}
|
|
}
|
|
|
|
read(e, t, r, n) {
|
|
this.prepare();
|
|
let s = n === void 0 ? e.len : e.pos + n;
|
|
for (; e.pos < s;) {
|
|
let [o, a] = e.tag(), f = this.fieldNoToField.get(o);
|
|
if (!f) {
|
|
let p = r.readUnknownField;
|
|
if (p == "throw") throw new Error(`Unknown field ${o} (wire type ${a}) for ${this.info.typeName}`);
|
|
let c = e.skip(a);
|
|
p !== !1 && (p === !0 ? O.onRead : p)(this.info.typeName, t, o, a, c);
|
|
continue
|
|
}
|
|
let l = t, h = f.repeat, y = f.localName;
|
|
switch (f.oneof && (l = l[f.oneof], l.oneofKind !== y && (l = t[f.oneof] = {oneofKind: y})), f.kind) {
|
|
case"scalar":
|
|
case"enum":
|
|
let p = f.kind == "enum" ? u.INT32 : f.T, c = f.kind == "scalar" ? f.L : void 0;
|
|
if (h) {
|
|
let N = l[y];
|
|
if (a == g.LengthDelimited && p != u.STRING && p != u.BYTES) {
|
|
let d = e.uint32() + e.pos;
|
|
for (; e.pos < d;) N.push(this.scalar(e, p, c))
|
|
} else N.push(this.scalar(e, p, c))
|
|
} else l[y] = this.scalar(e, p, c);
|
|
break;
|
|
case"message":
|
|
if (h) {
|
|
let N = l[y], d = f.T().internalBinaryRead(e, e.uint32(), r);
|
|
N.push(d)
|
|
} else l[y] = f.T().internalBinaryRead(e, e.uint32(), r, l[y]);
|
|
break;
|
|
case"map":
|
|
let [b, A] = this.mapEntry(f, e, r);
|
|
l[y][b] = A;
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
mapEntry(e, t, r) {
|
|
let n = t.uint32(), s = t.pos + n, o, a;
|
|
for (; t.pos < s;) {
|
|
let [f, l] = t.tag();
|
|
switch (f) {
|
|
case 1:
|
|
e.K == u.BOOL ? o = t.bool().toString() : o = this.scalar(t, e.K, F.STRING);
|
|
break;
|
|
case 2:
|
|
switch (e.V.kind) {
|
|
case"scalar":
|
|
a = this.scalar(t, e.V.T, e.V.L);
|
|
break;
|
|
case"enum":
|
|
a = t.int32();
|
|
break;
|
|
case"message":
|
|
a = e.V.T().internalBinaryRead(t, t.uint32(), r);
|
|
break
|
|
}
|
|
break;
|
|
default:
|
|
throw new Error(`Unknown field ${f} (wire type ${l}) in map entry for ${this.info.typeName}#${e.name}`)
|
|
}
|
|
}
|
|
if (o === void 0) {
|
|
let f = _(e.K);
|
|
o = e.K == u.BOOL ? f.toString() : f
|
|
}
|
|
if (a === void 0) switch (e.V.kind) {
|
|
case"scalar":
|
|
a = _(e.V.T, e.V.L);
|
|
break;
|
|
case"enum":
|
|
a = 0;
|
|
break;
|
|
case"message":
|
|
a = e.V.T().create();
|
|
break
|
|
}
|
|
return [o, a]
|
|
}
|
|
|
|
scalar(e, t, r) {
|
|
switch (t) {
|
|
case u.INT32:
|
|
return e.int32();
|
|
case u.STRING:
|
|
return e.string();
|
|
case u.BOOL:
|
|
return e.bool();
|
|
case u.DOUBLE:
|
|
return e.double();
|
|
case u.FLOAT:
|
|
return e.float();
|
|
case u.INT64:
|
|
return R(e.int64(), r);
|
|
case u.UINT64:
|
|
return R(e.uint64(), r);
|
|
case u.FIXED64:
|
|
return R(e.fixed64(), r);
|
|
case u.FIXED32:
|
|
return e.fixed32();
|
|
case u.BYTES:
|
|
return e.bytes();
|
|
case u.UINT32:
|
|
return e.uint32();
|
|
case u.SFIXED32:
|
|
return e.sfixed32();
|
|
case u.SFIXED64:
|
|
return R(e.sfixed64(), r);
|
|
case u.SINT32:
|
|
return e.sint32();
|
|
case u.SINT64:
|
|
return R(e.sint64(), r)
|
|
}
|
|
}
|
|
};
|
|
var ae = class {
|
|
constructor(e) {
|
|
this.info = e
|
|
}
|
|
|
|
prepare() {
|
|
if (!this.fields) {
|
|
let e = this.info.fields ? this.info.fields.concat() : [];
|
|
this.fields = e.sort((t, r) => t.no - r.no)
|
|
}
|
|
}
|
|
|
|
write(e, t, r) {
|
|
this.prepare();
|
|
for (let s of this.fields) {
|
|
let o, a, f = s.repeat, l = s.localName;
|
|
if (s.oneof) {
|
|
let h = e[s.oneof];
|
|
if (h.oneofKind !== l) continue;
|
|
o = h[l], a = !0
|
|
} else o = e[l], a = !1;
|
|
switch (s.kind) {
|
|
case"scalar":
|
|
case"enum":
|
|
let h = s.kind == "enum" ? u.INT32 : s.T;
|
|
if (f) if (m(Array.isArray(o)), f == v.PACKED) this.packed(t, h, s.no, o); else for (let y of o) this.scalar(t, h, s.no, y, !0); else o === void 0 ? m(s.opt) : this.scalar(t, h, s.no, o, a || s.opt);
|
|
break;
|
|
case"message":
|
|
if (f) {
|
|
m(Array.isArray(o));
|
|
for (let y of o) this.message(t, r, s.T(), s.no, y)
|
|
} else this.message(t, r, s.T(), s.no, o);
|
|
break;
|
|
case"map":
|
|
m(typeof o == "object" && o !== null);
|
|
for (let [y, p] of Object.entries(o)) this.mapEntry(t, r, s, y, p);
|
|
break
|
|
}
|
|
}
|
|
let n = r.writeUnknownFields;
|
|
n !== !1 && (n === !0 ? O.onWrite : n)(this.info.typeName, e, t)
|
|
}
|
|
|
|
mapEntry(e, t, r, n, s) {
|
|
e.tag(r.no, g.LengthDelimited), e.fork();
|
|
let o = n;
|
|
switch (r.K) {
|
|
case u.INT32:
|
|
case u.FIXED32:
|
|
case u.UINT32:
|
|
case u.SFIXED32:
|
|
case u.SINT32:
|
|
o = Number.parseInt(n);
|
|
break;
|
|
case u.BOOL:
|
|
m(n == "true" || n == "false"), o = n == "true";
|
|
break
|
|
}
|
|
switch (this.scalar(e, r.K, 1, o, !0), r.V.kind) {
|
|
case"scalar":
|
|
this.scalar(e, r.V.T, 2, s, !0);
|
|
break;
|
|
case"enum":
|
|
this.scalar(e, u.INT32, 2, s, !0);
|
|
break;
|
|
case"message":
|
|
this.message(e, t, r.V.T(), 2, s);
|
|
break
|
|
}
|
|
e.join()
|
|
}
|
|
|
|
message(e, t, r, n, s) {
|
|
s !== void 0 && (r.internalBinaryWrite(s, e.tag(n, g.LengthDelimited).fork(), t), e.join())
|
|
}
|
|
|
|
scalar(e, t, r, n, s) {
|
|
let [o, a, f] = this.scalarInfo(t, n);
|
|
(!f || s) && (e.tag(r, o), e[a](n))
|
|
}
|
|
|
|
packed(e, t, r, n) {
|
|
if (!n.length) return;
|
|
m(t !== u.BYTES && t !== u.STRING), e.tag(r, g.LengthDelimited), e.fork();
|
|
let [, s] = this.scalarInfo(t);
|
|
for (let o = 0; o < n.length; o++) e[s](n[o]);
|
|
e.join()
|
|
}
|
|
|
|
scalarInfo(e, t) {
|
|
let r = g.Varint, n, s = t === void 0, o = t === 0;
|
|
switch (e) {
|
|
case u.INT32:
|
|
n = "int32";
|
|
break;
|
|
case u.STRING:
|
|
o = s || !t.length, r = g.LengthDelimited, n = "string";
|
|
break;
|
|
case u.BOOL:
|
|
o = t === !1, n = "bool";
|
|
break;
|
|
case u.UINT32:
|
|
n = "uint32";
|
|
break;
|
|
case u.DOUBLE:
|
|
r = g.Bit64, n = "double";
|
|
break;
|
|
case u.FLOAT:
|
|
r = g.Bit32, n = "float";
|
|
break;
|
|
case u.INT64:
|
|
o = s || w.from(t).isZero(), n = "int64";
|
|
break;
|
|
case u.UINT64:
|
|
o = s || T.from(t).isZero(), n = "uint64";
|
|
break;
|
|
case u.FIXED64:
|
|
o = s || T.from(t).isZero(), r = g.Bit64, n = "fixed64";
|
|
break;
|
|
case u.BYTES:
|
|
o = s || !t.byteLength, r = g.LengthDelimited, n = "bytes";
|
|
break;
|
|
case u.FIXED32:
|
|
r = g.Bit32, n = "fixed32";
|
|
break;
|
|
case u.SFIXED32:
|
|
r = g.Bit32, n = "sfixed32";
|
|
break;
|
|
case u.SFIXED64:
|
|
o = s || w.from(t).isZero(), r = g.Bit64, n = "sfixed64";
|
|
break;
|
|
case u.SINT32:
|
|
n = "sint32";
|
|
break;
|
|
case u.SINT64:
|
|
o = s || w.from(t).isZero(), n = "sint64";
|
|
break
|
|
}
|
|
return [r, n, s || o]
|
|
}
|
|
};
|
|
|
|
function Je(i) {
|
|
let e = {};
|
|
Object.defineProperty(e, K, {enumerable: !1, value: i});
|
|
for (let t of i.fields) {
|
|
let r = t.localName;
|
|
if (!t.opt) if (t.oneof) e[t.oneof] = {oneofKind: void 0}; else if (t.repeat) e[r] = []; else switch (t.kind) {
|
|
case"scalar":
|
|
e[r] = _(t.T, t.L);
|
|
break;
|
|
case"enum":
|
|
e[r] = 0;
|
|
break;
|
|
case"map":
|
|
e[r] = {};
|
|
break
|
|
}
|
|
}
|
|
return e
|
|
}
|
|
|
|
function C(i, e, t) {
|
|
let r, n = t, s;
|
|
for (let o of i.fields) {
|
|
let a = o.localName;
|
|
if (o.oneof) {
|
|
let f = n[o.oneof];
|
|
if (f?.oneofKind == null) continue;
|
|
if (r = f[a], s = e[o.oneof], s.oneofKind = f.oneofKind, r == null) {
|
|
delete s[a];
|
|
continue
|
|
}
|
|
} else if (r = n[a], s = e, r == null) continue;
|
|
switch (o.repeat && (s[a].length = r.length), o.kind) {
|
|
case"scalar":
|
|
case"enum":
|
|
if (o.repeat) for (let l = 0; l < r.length; l++) s[a][l] = r[l]; else s[a] = r;
|
|
break;
|
|
case"message":
|
|
let f = o.T();
|
|
if (o.repeat) for (let l = 0; l < r.length; l++) s[a][l] = f.create(r[l]); else s[a] === void 0 ? s[a] = f.create(r) : f.mergePartial(s[a], r);
|
|
break;
|
|
case"map":
|
|
switch (o.V.kind) {
|
|
case"scalar":
|
|
case"enum":
|
|
Object.assign(s[a], r);
|
|
break;
|
|
case"message":
|
|
let l = o.V.T();
|
|
for (let h of Object.keys(r)) s[a][h] = l.create(r[h]);
|
|
break
|
|
}
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
function Xe(i, e, t) {
|
|
if (e === t) return !0;
|
|
if (!e || !t) return !1;
|
|
for (let r of i.fields) {
|
|
let n = r.localName, s = r.oneof ? e[r.oneof][n] : e[n], o = r.oneof ? t[r.oneof][n] : t[n];
|
|
switch (r.kind) {
|
|
case"enum":
|
|
case"scalar":
|
|
let a = r.kind == "enum" ? u.INT32 : r.T;
|
|
if (!(r.repeat ? We(a, s, o) : Ge(a, s, o))) return !1;
|
|
break;
|
|
case"map":
|
|
if (!(r.V.kind == "message" ? je(r.V.T(), fe(s), fe(o)) : We(r.V.kind == "enum" ? u.INT32 : r.V.T, fe(s), fe(o)))) return !1;
|
|
break;
|
|
case"message":
|
|
let f = r.T();
|
|
if (!(r.repeat ? je(f, s, o) : f.equals(s, o))) return !1;
|
|
break
|
|
}
|
|
}
|
|
return !0
|
|
}
|
|
|
|
var fe = Object.values;
|
|
|
|
function Ge(i, e, t) {
|
|
if (e === t) return !0;
|
|
if (i !== u.BYTES) return !1;
|
|
let r = e, n = t;
|
|
if (r.length !== n.length) return !1;
|
|
for (let s = 0; s < r.length; s++) if (r[s] != n[s]) return !1;
|
|
return !0
|
|
}
|
|
|
|
function We(i, e, t) {
|
|
if (e.length !== t.length) return !1;
|
|
for (let r = 0; r < e.length; r++) if (!Ge(i, e[r], t[r])) return !1;
|
|
return !0
|
|
}
|
|
|
|
function je(i, e, t) {
|
|
if (e.length !== t.length) return !1;
|
|
for (let r = 0; r < e.length; r++) if (!i.equals(e[r], t[r])) return !1;
|
|
return !0
|
|
}
|
|
|
|
var q = class {
|
|
constructor(e, t, r) {
|
|
this.defaultCheckDepth = 16, this.typeName = e, this.fields = t.map(Ke), this.options = r ?? {}, this.refTypeCheck = new ne(this), this.refJsonReader = new ie(this), this.refJsonWriter = new se(this), this.refBinReader = new oe(this), this.refBinWriter = new ae(this)
|
|
}
|
|
|
|
create(e) {
|
|
let t = Je(this);
|
|
return e !== void 0 && C(this, t, e), t
|
|
}
|
|
|
|
clone(e) {
|
|
let t = this.create();
|
|
return C(this, t, e), t
|
|
}
|
|
|
|
equals(e, t) {
|
|
return Xe(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) {
|
|
C(this, e, t)
|
|
}
|
|
|
|
fromBinary(e, t) {
|
|
let r = Ve(t);
|
|
return this.internalBinaryRead(r.readerFactory(e), e.byteLength, r)
|
|
}
|
|
|
|
fromJson(e, t) {
|
|
return this.internalJsonRead(e, $e(t))
|
|
}
|
|
|
|
fromJsonString(e, t) {
|
|
let r = JSON.parse(e);
|
|
return this.fromJson(r, t)
|
|
}
|
|
|
|
toJson(e, t) {
|
|
return this.internalJsonWrite(e, Me(t))
|
|
}
|
|
|
|
toJsonString(e, t) {
|
|
var r;
|
|
let n = this.toJson(e, t);
|
|
return JSON.stringify(n, null, (r = t?.prettySpaces) !== null && r !== void 0 ? r : 0)
|
|
}
|
|
|
|
toBinary(e, t) {
|
|
let r = Ce(t);
|
|
return this.internalBinaryWrite(e, r.writerFactory(), r).finish()
|
|
}
|
|
|
|
internalJsonRead(e, t, r) {
|
|
if (e !== null && typeof e == "object" && !Array.isArray(e)) {
|
|
let n = r ?? this.create();
|
|
return this.refJsonReader.read(e, n, t), n
|
|
}
|
|
throw new Error(`Unable to parse message ${this.typeName} from JSON ${Z(e)}.`)
|
|
}
|
|
|
|
internalJsonWrite(e, t) {
|
|
return this.refJsonWriter.write(e, t)
|
|
}
|
|
|
|
internalBinaryWrite(e, t, r) {
|
|
return this.refBinWriter.write(e, t, r), t
|
|
}
|
|
|
|
internalBinaryRead(e, t, r, n) {
|
|
let s = n ?? this.create();
|
|
return this.refBinReader.read(e, s, r, t), s
|
|
}
|
|
};
|
|
var Ne = class extends q {
|
|
constructor() {
|
|
super("Request", [{no: 1, name: "context", kind: "message", T: () => ye}, {
|
|
no: 2,
|
|
name: "browseId",
|
|
kind: "scalar",
|
|
T: 9
|
|
}])
|
|
}
|
|
|
|
create(e) {
|
|
let t = {browseId: ""};
|
|
return globalThis.Object.defineProperty(t, K, {
|
|
enumerable: !1,
|
|
value: this
|
|
}), e !== void 0 && C(this, t, e), t
|
|
}
|
|
|
|
internalBinaryRead(e, t, r, n) {
|
|
let s = n ?? this.create(), o = e.pos + t;
|
|
for (; e.pos < o;) {
|
|
let [a, f] = e.tag();
|
|
switch (a) {
|
|
case 1:
|
|
s.context = ye.internalBinaryRead(e, e.uint32(), r, s.context);
|
|
break;
|
|
case 2:
|
|
s.browseId = e.string();
|
|
break;
|
|
default:
|
|
let l = r.readUnknownField;
|
|
if (l === "throw") throw new globalThis.Error(`Unknown field ${a} (wire type ${f}) for ${this.typeName}`);
|
|
let h = e.skip(f);
|
|
l !== !1 && (l === !0 ? O.onRead : l)(this.typeName, s, a, f, h)
|
|
}
|
|
}
|
|
return s
|
|
}
|
|
|
|
internalBinaryWrite(e, t, r) {
|
|
e.context && ye.internalBinaryWrite(e.context, t.tag(1, g.LengthDelimited).fork(), r).join(), e.browseId !== "" && t.tag(2, g.LengthDelimited).string(e.browseId);
|
|
let n = r.writeUnknownFields;
|
|
return n !== !1 && (n == !0 ? O.onWrite : n)(this.typeName, e, t), t
|
|
}
|
|
}, ve = new Ne, ke = class extends q {
|
|
constructor() {
|
|
super("Context", [{no: 9, name: "adSignalsInfo", kind: "message", T: () => we}])
|
|
}
|
|
|
|
create(e) {
|
|
let t = {};
|
|
return globalThis.Object.defineProperty(t, K, {
|
|
enumerable: !1,
|
|
value: this
|
|
}), e !== void 0 && C(this, t, e), t
|
|
}
|
|
|
|
internalBinaryRead(e, t, r, n) {
|
|
let s = n ?? this.create(), o = e.pos + t;
|
|
for (; e.pos < o;) {
|
|
let [a, f] = e.tag();
|
|
switch (a) {
|
|
case 9:
|
|
s.adSignalsInfo = we.internalBinaryRead(e, e.uint32(), r, s.adSignalsInfo);
|
|
break;
|
|
default:
|
|
let l = r.readUnknownField;
|
|
if (l === "throw") throw new globalThis.Error(`Unknown field ${a} (wire type ${f}) for ${this.typeName}`);
|
|
let h = e.skip(f);
|
|
l !== !1 && (l === !0 ? O.onRead : l)(this.typeName, s, a, f, h)
|
|
}
|
|
}
|
|
return s
|
|
}
|
|
|
|
internalBinaryWrite(e, t, r) {
|
|
e.adSignalsInfo && we.internalBinaryWrite(e.adSignalsInfo, t.tag(9, g.LengthDelimited).fork(), r).join();
|
|
let n = r.writeUnknownFields;
|
|
return n !== !1 && (n == !0 ? O.onWrite : n)(this.typeName, e, t), t
|
|
}
|
|
}, ye = new ke, xe = class extends q {
|
|
constructor() {
|
|
super("AdSignalsInfo", [{no: 1, name: "params", kind: "message", repeat: 1, T: () => Ie}])
|
|
}
|
|
|
|
create(e) {
|
|
let t = {params: []};
|
|
return globalThis.Object.defineProperty(t, K, {
|
|
enumerable: !1,
|
|
value: this
|
|
}), e !== void 0 && C(this, t, e), t
|
|
}
|
|
|
|
internalBinaryRead(e, t, r, n) {
|
|
let s = n ?? this.create(), o = e.pos + t;
|
|
for (; e.pos < o;) {
|
|
let [a, f] = e.tag();
|
|
switch (a) {
|
|
case 1:
|
|
s.params.push(Ie.internalBinaryRead(e, e.uint32(), r));
|
|
break;
|
|
default:
|
|
let l = r.readUnknownField;
|
|
if (l === "throw") throw new globalThis.Error(`Unknown field ${a} (wire type ${f}) for ${this.typeName}`);
|
|
let h = e.skip(f);
|
|
l !== !1 && (l === !0 ? O.onRead : l)(this.typeName, s, a, f, h)
|
|
}
|
|
}
|
|
return s
|
|
}
|
|
|
|
internalBinaryWrite(e, t, r) {
|
|
for (let s = 0; s < e.params.length; s++) Ie.internalBinaryWrite(e.params[s], t.tag(1, g.LengthDelimited).fork(), r).join();
|
|
let n = r.writeUnknownFields;
|
|
return n !== !1 && (n == !0 ? O.onWrite : n)(this.typeName, e, t), t
|
|
}
|
|
}, we = new xe, Te = class extends q {
|
|
constructor() {
|
|
super("Params", [{no: 1, name: "key", kind: "scalar", T: 9}, {no: 2, name: "value", kind: "scalar", T: 9}])
|
|
}
|
|
|
|
create(e) {
|
|
let t = {key: "", value: ""};
|
|
return globalThis.Object.defineProperty(t, K, {
|
|
enumerable: !1,
|
|
value: this
|
|
}), e !== void 0 && C(this, t, e), t
|
|
}
|
|
|
|
internalBinaryRead(e, t, r, n) {
|
|
let s = n ?? this.create(), o = e.pos + t;
|
|
for (; e.pos < o;) {
|
|
let [a, f] = e.tag();
|
|
switch (a) {
|
|
case 1:
|
|
s.key = e.string();
|
|
break;
|
|
case 2:
|
|
s.value = e.string();
|
|
break;
|
|
default:
|
|
let l = r.readUnknownField;
|
|
if (l === "throw") throw new globalThis.Error(`Unknown field ${a} (wire type ${f}) for ${this.typeName}`);
|
|
let h = e.skip(f);
|
|
l !== !1 && (l === !0 ? O.onRead : l)(this.typeName, s, a, f, h)
|
|
}
|
|
}
|
|
return s
|
|
}
|
|
|
|
internalBinaryWrite(e, t, r) {
|
|
e.key !== "" && t.tag(1, g.LengthDelimited).string(e.key), e.value !== "" && t.tag(2, g.LengthDelimited).string(e.value);
|
|
let n = r.writeUnknownFields;
|
|
return n !== !1 && (n == !0 ? O.onWrite : n)(this.typeName, e, t), t
|
|
}
|
|
}, Ie = new Te;
|
|
var X = class {
|
|
constructor(e, t, r) {
|
|
this._times = new Map;
|
|
this.name = e ?? "", this.debug = r?.debug ?? !1, e && this.log(`${e} Start`), this.className = t ?? "", this.init()
|
|
}
|
|
|
|
static getInstance(e, t) {
|
|
let r = typeof $task < "u" ? "QuanX" : "Surge";
|
|
return X.instances[r] || (X.instances[r] = X.classNames[r](e, r, t)), X.instances[r]
|
|
}
|
|
|
|
createProxy(e) {
|
|
return new Proxy(e, {get: this.getFn, set: this.setFn})
|
|
}
|
|
|
|
getFn(e, t, r) {
|
|
return e[t]
|
|
}
|
|
|
|
setFn(e, t, r, n) {
|
|
return e[t] = r, !0
|
|
}
|
|
|
|
getJSON(e, t = {}) {
|
|
let r = this.getVal(e);
|
|
return r ? JSON.parse(r) : t
|
|
}
|
|
|
|
setJSON(e, t) {
|
|
this.setVal(JSON.stringify(e), t)
|
|
}
|
|
|
|
msg(e = this.name, t = "", r = "", n) {
|
|
}
|
|
|
|
log(e) {
|
|
this.debug && (typeof e == "object" && (e = JSON.stringify(e)), console.log(e))
|
|
}
|
|
|
|
timeStart(e) {
|
|
this._times = this._times || {}, this._times[e] = Date.now()
|
|
}
|
|
|
|
timeEnd(e) {
|
|
if (this._times?.has(e)) {
|
|
let t = Date.now() - this._times[e];
|
|
this.log(`${e}: ${t}ms`), this._times.delete(e)
|
|
} else this.log(`Timer with label ${e} does not exist.`)
|
|
}
|
|
|
|
exit() {
|
|
$done({})
|
|
}
|
|
|
|
reject() {
|
|
$done()
|
|
}
|
|
}, $ = X;
|
|
$.instances = {}, $.classNames = {QuanX: (e, t, r) => new le(e, t, r), Surge: (e, t, r) => new ue(e, t, r)};
|
|
var ce = class extends ${getFn(e,t,r){let n=ce.clientAdapter[t]||t;return super.getFn(e,n,r)}setFn(e, t, r, n) {
|
|
let
|
|
s = ce.clientAdapter[t] || t;
|
|
return
|
|
super
|
|
.
|
|
|
|
setFn(e, s, r, n)
|
|
}
|
|
init()
|
|
{
|
|
try {
|
|
this.request = this.createProxy($request), this.response = this.createProxy($response)
|
|
} catch (e) {
|
|
this.log(e.toString())
|
|
}
|
|
}
|
|
getVal(e)
|
|
{
|
|
return $persistentStore.read(e)
|
|
}
|
|
setVal(e, t)
|
|
{
|
|
$persistentStore.write(e, t)
|
|
}
|
|
msg(e = this.name, t = "", r = "", n)
|
|
{
|
|
$notification.post(e, t, r, {url: n ?? ""})
|
|
}
|
|
async
|
|
fetch(e)
|
|
{
|
|
return await new Promise((t, r) => {
|
|
let {method: n, body: s, bodyBytes: o, ...a} = e, f = o ?? s, l = f instanceof Uint8Array;
|
|
$httpClient[n.toLowerCase()]({...a, body: f, "binary-mode": l}, (h, y, p) => {
|
|
h && r(h);
|
|
let c = l ? "bodyBytes" : "body";
|
|
t({status: y.status || y.statusCode, headers: y.headers, [c]: p})
|
|
})
|
|
})
|
|
}
|
|
done(e)
|
|
{
|
|
let t = e.response ?? e, r, n;
|
|
t.bodyBytes ? (r = t.bodyBytes, delete t.bodyBytes, n = {...e}, n.response ? n.response.body = r : n.body = r) : n = e, $done(n)
|
|
}
|
|
}, ue = ce;
|
|
ue.clientAdapter = {bodyBytes: "body"};
|
|
var P = class extends ${static transferBodyBytes(e,t){return e instanceof ArrayBuffer?t==="Uint8Array"?new Uint8Array(e):e:e instanceof Uint8Array&&t==="ArrayBuffer"?e.buffer.slice(e.byteOffset,e.byteLength+e.byteOffset):e}init() {
|
|
try {
|
|
this
|
|
.
|
|
request = this.createProxy($request)
|
|
,
|
|
this
|
|
.
|
|
response = this.createProxy($response)
|
|
}
|
|
catch
|
|
(e)
|
|
{
|
|
this.log(e.toString())
|
|
}
|
|
}
|
|
getFn(e, t, r)
|
|
{
|
|
let n = P.clientAdapter[t] || t, s = super.getFn(e, n, r);
|
|
return t === "bodyBytes" && (s = P.transferBodyBytes(s, "Uint8Array")), s
|
|
}
|
|
setFn(e, t, r, n)
|
|
{
|
|
let s = P.clientAdapter[t] || t, o = r;
|
|
return t === "bodyBytes" && (o = P.transferBodyBytes(o, "Uint8Array")), super.setFn(e, s, o, n)
|
|
}
|
|
getVal(e)
|
|
{
|
|
return $prefs.valueForKey(e)?.replace(/\0/g, "")
|
|
}
|
|
setVal(e, t)
|
|
{
|
|
$prefs.setValueForKey(e, t)
|
|
}
|
|
msg(e = this.name, t = "", r = "", n)
|
|
{
|
|
$notify(e, t, r, {"open-url": n ?? ""})
|
|
}
|
|
async
|
|
fetch(e)
|
|
{
|
|
return await new Promise(t => {
|
|
let r = {url: "", method: "GET"};
|
|
for (let [n, s] of Object.entries(e)) n === "id" ? r.sessionIndex = s : n === "bodyBytes" ? r.bodyBytes = P.transferBodyBytes(s, "ArrayBuffer") : r[n] = s;
|
|
e.bodyBytes && delete r.body, $task.fetch(r).then(n => {
|
|
let s = {status: 200, headers: {}};
|
|
for (let [o, a] of Object.entries(n)) o === "sessionIndex" ? s.id = a : o === "bodyBytes" ? s.bodyBytes = P.transferBodyBytes(a, "Uint8Array") : o === "statusCode" ? s.status = a : s[o] = a;
|
|
t(s)
|
|
})
|
|
})
|
|
}
|
|
done(e)
|
|
{
|
|
let t = e.response ?? e, r = {};
|
|
for (let [n, s] of Object.entries(t)) n === "status" ? r.status = `HTTP/1.1 ${s}` : n === "bodyBytes" ? r.bodyBytes = P.transferBodyBytes(s, "ArrayBuffer") : r[n] = s;
|
|
$done(r)
|
|
}
|
|
},
|
|
le = P;
|
|
le.clientAdapter = {id: "sessionIndex", status: "statusCode"};
|
|
var S = $.getInstance("YouTube", {debug: !1});
|
|
var he = class {
|
|
constructor(e, t) {
|
|
this.decoder = new TextDecoder("utf-8", {fatal: !1, ignoreBOM: !0});
|
|
S.log(t), this.msgType = e, Object.assign(this, S.getJSON("YouTubeAdvertiseInfo", {
|
|
whiteNo: [],
|
|
blackNo: [],
|
|
whiteEml: [],
|
|
blackEml: ["cell_divider.eml"]
|
|
}))
|
|
}
|
|
|
|
fromBinary(e) {
|
|
return this.message = this.msgType.fromBinary(e), this
|
|
}
|
|
|
|
toBinary() {
|
|
return this.msgType.toBinary(this.message)
|
|
}
|
|
|
|
save() {
|
|
if (this.needSave) {
|
|
S.log("Update Config");
|
|
let e = {whiteNo: this.whiteNo, blackNo: this.blackNo, whiteEml: this.whiteEml, blackEml: this.blackEml};
|
|
S.setJSON(e, "YouTubeAdvertiseInfo")
|
|
}
|
|
}
|
|
|
|
done(e) {
|
|
this.save();
|
|
let t = e.bodyBytes;
|
|
this.needProcess && (t = this.toBinary()), e.headers["Content-Encoding"] = "identity", e.headers["Content-Length"] = (t?.length ?? 0)?.toString(), S.done({
|
|
response: {
|
|
...e,
|
|
bodyBytes: t
|
|
}
|
|
})
|
|
}
|
|
|
|
doneResponse() {
|
|
this.save(), this.needProcess && S.done({bodyBytes: this.toBinary()}), S.exit()
|
|
}
|
|
|
|
iterate(e = {}, t, r, n) {
|
|
let s = [];
|
|
for (s.push(e); s.length;) {
|
|
let o = s.pop(), a = Object.keys(o);
|
|
for (; a.length;) {
|
|
let f = a.pop();
|
|
f === t ? r(o, s) : typeof o[f] == "object" && (s.push(o[f]), typeof n == "function" && n(o, s))
|
|
}
|
|
}
|
|
}
|
|
|
|
isAdvertise(e) {
|
|
let t = O.list(e)[0], r = t ? this.handleFieldNo(t) : this.handleFieldEml(e);
|
|
return r && (this.needProcess = !0), r
|
|
}
|
|
|
|
handleFieldNo(e) {
|
|
let t = e.no;
|
|
if (this.whiteNo.includes(t)) return !1;
|
|
if (this.blackNo.includes(t)) return !0;
|
|
let n = this.decoder.decode(e.data).includes("pagead");
|
|
return n ? this.blackNo.push(t) : this.whiteNo.push(t), this.needSave = !0, n
|
|
}
|
|
|
|
handleFieldEml(e) {
|
|
let t = !1, r = !0, n = "";
|
|
return this.iterate(e, "type", (s, o) => {
|
|
n = s.type.split("|")[0], this.whiteEml.includes(n) ? t = !1 : this.blackEml.includes(n) || /shorts(?!_pivot_item)/.test(n) ? t = !0 : r = !1, r && (o.length = 0)
|
|
}), r || (this.iterate(e, "type", () => {
|
|
}, (s, o) => {
|
|
let a = O.list(s);
|
|
for (let f of a) if (f.data.length > 1e3 && (t = this.decoder.decode(f.data).includes("pagead"), t)) {
|
|
o.length = 0;
|
|
break
|
|
}
|
|
}), t ? this.blackEml.push(n) : this.whiteEml.push(n), this.needSave = !0), t
|
|
}
|
|
};
|
|
var Y = class extends he {
|
|
constructor(e = ve, t = "Request") {
|
|
super(e, t)
|
|
}
|
|
|
|
pure() {
|
|
return this.message.context.adSignalsInfo.params.length = 0, this.needProcess = !0, this
|
|
}
|
|
};
|
|
var et = new Y;
|
|
try {
|
|
let i = et.fromBinary(S.request.bodyBytes).pure().toBinary();
|
|
S.done({bodyBytes: i})
|
|
} catch (i) {
|
|
S.log(i.toString()), S.exit()
|
|
}
|
|
})
|
|
(); |