453 lines
9.6 KiB
Plaintext
453 lines
9.6 KiB
Plaintext
var A = Object.defineProperty;
|
|
var j = (r, e, t) => e in r ? A(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t;
|
|
var W = (r, e, t) => j(r, typeof e != "symbol" ? e + "" : e, t);
|
|
import { ScalarType as o, RepeatType as y, MessageType as I, BinaryReader as C, WireType as d } from "@protobuf-ts/runtime";
|
|
class s {
|
|
constructor(e, t, a, p) {
|
|
W(this, "_value");
|
|
W(this, "_fieldId");
|
|
W(this, "_opt");
|
|
W(this, "_callback");
|
|
this._value = t, this._fieldId = e, this._opt = a, this._callback = p;
|
|
}
|
|
get value() {
|
|
return this._value;
|
|
}
|
|
set value(e) {
|
|
this._value = e;
|
|
}
|
|
getTypeName() {
|
|
return this.constructor.name;
|
|
}
|
|
getFieldId() {
|
|
return this._fieldId;
|
|
}
|
|
getField(e) {
|
|
return L(e, this);
|
|
}
|
|
}
|
|
class F extends s {
|
|
getTypeName() {
|
|
return "DoubleWrapper";
|
|
}
|
|
}
|
|
class B extends s {
|
|
getTypeName() {
|
|
return "FloatWrapper";
|
|
}
|
|
}
|
|
class T extends s {
|
|
getTypeName() {
|
|
return "StringWrapper";
|
|
}
|
|
}
|
|
class S extends s {
|
|
getTypeName() {
|
|
return "UInt32Wrapper";
|
|
}
|
|
}
|
|
class w extends s {
|
|
getTypeName() {
|
|
return "Int32Wrapper";
|
|
}
|
|
}
|
|
class h extends s {
|
|
getTypeName() {
|
|
return "Int64Wrapper";
|
|
}
|
|
}
|
|
class m extends s {
|
|
getTypeName() {
|
|
return "UInt64Wrapper";
|
|
}
|
|
}
|
|
class b extends s {
|
|
getTypeName() {
|
|
return "ArrayWrapper";
|
|
}
|
|
}
|
|
class N extends s {
|
|
getTypeName() {
|
|
return "BoolWrapper";
|
|
}
|
|
}
|
|
class U extends s {
|
|
getTypeName() {
|
|
return "BytesWrapper";
|
|
}
|
|
}
|
|
class P extends s {
|
|
getTypeName() {
|
|
return "Fixed64Wrapper";
|
|
}
|
|
}
|
|
class k extends s {
|
|
getTypeName() {
|
|
return "Fixed32Wrapper";
|
|
}
|
|
}
|
|
class D extends s {
|
|
getTypeName() {
|
|
return "SFixed32Wrapper";
|
|
}
|
|
}
|
|
class _ extends s {
|
|
getTypeName() {
|
|
return "SFixed64Wrapper";
|
|
}
|
|
}
|
|
class O extends s {
|
|
getTypeName() {
|
|
return "SInt32Wrapper";
|
|
}
|
|
}
|
|
class v extends s {
|
|
getTypeName() {
|
|
return "SInt64Wrapper";
|
|
}
|
|
}
|
|
class E extends s {
|
|
getTypeName() {
|
|
return "UnknownWrapper";
|
|
}
|
|
}
|
|
const n = {
|
|
UInt32Wrapper: "UInt32Wrapper",
|
|
Int32Wrapper: "Int32Wrapper",
|
|
Int64Wrapper: "Int64Wrapper",
|
|
UInt64Wrapper: "UInt64Wrapper",
|
|
StringWrapper: "StringWrapper",
|
|
ArrayWrapper: "ArrayWrapper",
|
|
BoolWrapper: "BoolWrapper",
|
|
BytesWrapper: "BytesWrapper",
|
|
DoubleWrapper: "DoubleWrapper",
|
|
FloatWrapper: "FloatWrapper",
|
|
Fixed64Wrapper: "Fixed64Wrapper",
|
|
Fixed32Wrapper: "Fixed32Wrapper",
|
|
SFixed32Wrapper: "SFixed32Wrapper",
|
|
SFixed64Wrapper: "SFixed64Wrapper",
|
|
SInt32Wrapper: "SInt32Wrapper",
|
|
SInt64Wrapper: "SInt64Wrapper",
|
|
UnknownWrapper: "UnknownWrapper"
|
|
}, K = {
|
|
[n.UInt32Wrapper]: S,
|
|
[n.Int32Wrapper]: w,
|
|
[n.Int64Wrapper]: h,
|
|
[n.UInt64Wrapper]: m,
|
|
[n.StringWrapper]: T,
|
|
[n.ArrayWrapper]: b,
|
|
[n.BoolWrapper]: N,
|
|
[n.BytesWrapper]: U,
|
|
[n.DoubleWrapper]: F,
|
|
[n.FloatWrapper]: B,
|
|
[n.Fixed64Wrapper]: P,
|
|
[n.Fixed32Wrapper]: k,
|
|
[n.SFixed32Wrapper]: D,
|
|
[n.SFixed64Wrapper]: _,
|
|
[n.SInt32Wrapper]: O,
|
|
[n.SInt64Wrapper]: v,
|
|
[n.UnknownWrapper]: E
|
|
}, M = {
|
|
[n.UInt32Wrapper]: o.UINT32,
|
|
[n.Int32Wrapper]: o.INT32,
|
|
[n.Int64Wrapper]: o.INT64,
|
|
[n.UInt64Wrapper]: o.UINT64,
|
|
[n.StringWrapper]: o.STRING,
|
|
[n.BytesWrapper]: o.BYTES,
|
|
[n.BoolWrapper]: o.BOOL,
|
|
[n.DoubleWrapper]: o.DOUBLE,
|
|
[n.FloatWrapper]: o.FLOAT,
|
|
[n.Fixed64Wrapper]: o.FIXED64,
|
|
[n.Fixed32Wrapper]: o.FIXED32,
|
|
[n.SFixed32Wrapper]: o.SFIXED32,
|
|
[n.SFixed64Wrapper]: o.SFIXED64,
|
|
[n.SInt32Wrapper]: o.SINT32,
|
|
[n.SInt64Wrapper]: o.SINT64,
|
|
[n.UnknownWrapper]: o.BYTES
|
|
};
|
|
function $(r) {
|
|
return K[r] || E;
|
|
}
|
|
function x(r) {
|
|
return M[r] || o.BYTES;
|
|
}
|
|
function z(r = 0, e, t = !1, a = []) {
|
|
return new b(r, a, t, () => e);
|
|
}
|
|
function H(r = 0, e = !1, t = 0) {
|
|
return new F(r, t, e);
|
|
}
|
|
function J(r = 0, e = !1, t = 0) {
|
|
return new B(r, t, e);
|
|
}
|
|
function Z(r = 0, e = !1, t = "") {
|
|
return new T(r, t, e);
|
|
}
|
|
function ee(r = 0, e = !1, t = 0) {
|
|
return new S(r, t, e);
|
|
}
|
|
function re(r = 0, e = !1, t = 0) {
|
|
return new w(r, t, e);
|
|
}
|
|
function te(r = 0, e = !1, t = BigInt(0)) {
|
|
return new h(r, t, e);
|
|
}
|
|
function ne(r = 0, e = !1, t = BigInt(0)) {
|
|
return new m(r, t, e);
|
|
}
|
|
function ae(r = 0, e = !1, t = !1) {
|
|
return new N(r, t, e);
|
|
}
|
|
function pe(r = 0, e = !1, t = new Uint8Array()) {
|
|
return new U(r, t, e);
|
|
}
|
|
function se(r = 0, e = !1, t = BigInt(0)) {
|
|
return new P(r, t, e);
|
|
}
|
|
function ie(r = 0, e = !1, t = 0) {
|
|
return new k(r, t, e);
|
|
}
|
|
function oe(r = 0, e = !1, t = 0) {
|
|
return new D(r, t, e);
|
|
}
|
|
function ce(r = 0, e = !1, t = BigInt(0)) {
|
|
return new _(r, t, e);
|
|
}
|
|
function ue(r = 0, e = !1, t = 0) {
|
|
return new O(r, t, e);
|
|
}
|
|
function le(r = 0, e = !1, t = BigInt(0)) {
|
|
return new v(r, t, e);
|
|
}
|
|
function L(r, e) {
|
|
var c;
|
|
const t = e.getTypeName(), a = e.getFieldId(), p = e._opt;
|
|
if (t === n.ArrayWrapper) {
|
|
const i = (c = e._callback) == null ? void 0 : c.call(e);
|
|
if (i instanceof l)
|
|
return {
|
|
no: a,
|
|
name: r,
|
|
kind: "message",
|
|
T: () => new I(r, i.generateFields()),
|
|
opt: p || !1,
|
|
repeat: y.PACKED
|
|
};
|
|
if (i instanceof s) {
|
|
const u = i.getTypeName();
|
|
return {
|
|
no: a,
|
|
name: r,
|
|
kind: "scalar",
|
|
T: x(u),
|
|
opt: p || !1,
|
|
repeat: u === n.StringWrapper || u === n.BytesWrapper ? y.UNPACKED : y.PACKED
|
|
};
|
|
}
|
|
throw new Error("ArrayWrapper item type error");
|
|
}
|
|
return {
|
|
no: a,
|
|
name: r,
|
|
kind: "scalar",
|
|
T: x(t),
|
|
opt: p || !1,
|
|
repeat: y.NO
|
|
};
|
|
}
|
|
class l {
|
|
constructor() {
|
|
W(this, "_fieldId", 0);
|
|
}
|
|
//默认标记类
|
|
generateFields() {
|
|
const e = [];
|
|
for (const t of Object.keys(this)) {
|
|
const a = "_" + t, p = this[a];
|
|
p instanceof s && e.push(p.getField(t)), p instanceof l && e.push({
|
|
no: p._fieldId,
|
|
name: t,
|
|
kind: "message",
|
|
T: () => new I(a, p.generateFields()),
|
|
repeat: y.NO,
|
|
opt: !1
|
|
});
|
|
}
|
|
return e;
|
|
}
|
|
assignFields(e) {
|
|
for (const t of Object.keys(this)) {
|
|
const a = "_" + t;
|
|
let p = this[a];
|
|
if (p instanceof s) {
|
|
const c = e[t];
|
|
c !== void 0 && (p.value = c);
|
|
} else if (p instanceof l) {
|
|
const c = e[t];
|
|
c !== void 0 && p.assignFields(c);
|
|
} else {
|
|
const c = e[t];
|
|
c !== void 0 && (this[a] = c);
|
|
}
|
|
}
|
|
}
|
|
toObject() {
|
|
const e = {};
|
|
for (const t of Object.keys(this)) {
|
|
const a = "_" + t, p = this[a];
|
|
p && (p instanceof s && (e[t] = p.value), p instanceof l && (e[t] = p.toObject()));
|
|
}
|
|
return e;
|
|
}
|
|
encode() {
|
|
return new I("message", this.generateFields()).toBinary(this.toObject());
|
|
}
|
|
decode(e) {
|
|
const t = new I("message", this.generateFields()).fromBinary(e);
|
|
return this.assignFields(t), this;
|
|
}
|
|
then(e) {
|
|
e(this);
|
|
}
|
|
}
|
|
function g(r) {
|
|
return new Proxy(r, {
|
|
set(e, t, a) {
|
|
return e[t] instanceof s ? (e[t].value = a, !0) : (e[t] = a, !0);
|
|
},
|
|
get(e, t) {
|
|
if (typeof t == "string" && t.startsWith("_")) {
|
|
const p = t.slice(1);
|
|
if (e[p])
|
|
return e[p];
|
|
}
|
|
const a = e[t];
|
|
return a instanceof s ? a.value : a;
|
|
}
|
|
});
|
|
}
|
|
function X(r, e) {
|
|
const t = g(e ? new e() : new r());
|
|
return t._fieldId = typeof r == "number" ? r : 0, t;
|
|
}
|
|
function fe(r, e) {
|
|
const t = g(new r());
|
|
return e && t.assignFields(e), t;
|
|
}
|
|
function We(r, e) {
|
|
const a = X(class extends l {
|
|
});
|
|
return Object.assign(a, r), a.assignFields(e), a;
|
|
}
|
|
function de(r, e) {
|
|
if (typeof r == "number") {
|
|
let t = new class extends l {
|
|
constructor() {
|
|
super(), Object.assign(this, e);
|
|
}
|
|
}();
|
|
return t._fieldId = r, g(t);
|
|
}
|
|
return g(new class extends l {
|
|
constructor() {
|
|
super(), Object.assign(this, r);
|
|
}
|
|
}());
|
|
}
|
|
function ye(r) {
|
|
return r.value;
|
|
}
|
|
function G(r, e, t, a, p, c) {
|
|
let i;
|
|
const u = new C(p);
|
|
switch (a) {
|
|
case d.Varint:
|
|
i = u.uint64(), i = i.hi > 0 ? i.toBigInt() : Number(i.lo);
|
|
break;
|
|
case d.Bit64:
|
|
i = u.fixed64();
|
|
break;
|
|
case d.LengthDelimited:
|
|
let f = u.bytes();
|
|
try {
|
|
i = R(f);
|
|
} catch {
|
|
try {
|
|
if (i = new TextDecoder().decode(f), i.indexOf("�") !== -1)
|
|
throw new Error("Invalid UTF-8 sequence in input");
|
|
} catch {
|
|
c ? i = c(f) : i = f;
|
|
}
|
|
}
|
|
break;
|
|
case d.StartGroup:
|
|
case d.EndGroup:
|
|
break;
|
|
case d.Bit32:
|
|
i = u.fixed32();
|
|
break;
|
|
default:
|
|
throw new Error(`Unknown wire type: ${a}`);
|
|
}
|
|
e[t] ? e[t] instanceof Array ? e[t].push(i) : e[t] = [e[t], i] : e[t] = i;
|
|
}
|
|
function R(r, e) {
|
|
return new I("message", []).fromBinary(r, {
|
|
readUnknownField: (p, c, i, u, f) => G(p, c, i, u, f, e)
|
|
});
|
|
}
|
|
class Ie extends l {
|
|
push(e) {
|
|
return Object.assign(this, e), this;
|
|
}
|
|
}
|
|
export {
|
|
b as ArrayWrapper,
|
|
N as BoolWrapper,
|
|
U as BytesWrapper,
|
|
Ie as ChainProto,
|
|
F as DoubleWrapper,
|
|
k as Fixed32Wrapper,
|
|
P as Fixed64Wrapper,
|
|
B as FloatWrapper,
|
|
w as Int32Wrapper,
|
|
h as Int64Wrapper,
|
|
z as PBArray,
|
|
ae as PBBool,
|
|
pe as PBBytes,
|
|
H as PBDouble,
|
|
ie as PBFixed32,
|
|
se as PBFixed64,
|
|
J as PBFloat,
|
|
re as PBInt32,
|
|
te as PBInt64,
|
|
oe as PBSFixed32,
|
|
ce as PBSFixed64,
|
|
ue as PBSInt32,
|
|
le as PBSInt64,
|
|
Z as PBString,
|
|
ee as PBUint32,
|
|
ne as PBUint64,
|
|
X as ProtoBuf,
|
|
l as ProtoBufBase,
|
|
R as ProtoBufDecode,
|
|
fe as ProtoBufEx,
|
|
de as ProtoBufIn,
|
|
We as ProtoBufQuick,
|
|
D as SFixed32Wrapper,
|
|
_ as SFixed64Wrapper,
|
|
O as SInt32Wrapper,
|
|
v as SInt64Wrapper,
|
|
T as StringWrapper,
|
|
S as UInt32Wrapper,
|
|
m as UInt64Wrapper,
|
|
ye as UnWrap,
|
|
E as UnknownWrapper,
|
|
s as ValueWrapper,
|
|
$ as autoTypeToClass,
|
|
L as autoTypeToField,
|
|
G as decodeProtoBuf,
|
|
g as proxyClassProtobuf
|
|
};
|
|
//# sourceMappingURL=protobuf.js.map
|