Created
April 15, 2023 00:57
-
-
Save manan19/172e8207a0ee48a2c6600edacb4fc838 to your computer and use it in GitHub Desktop.
hub web's distribution
This file contains 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
"use strict"; | |
var __create = Object.create; | |
var __defProp = Object.defineProperty; | |
var __getOwnPropDesc = Object.getOwnPropertyDescriptor; | |
var __getOwnPropNames = Object.getOwnPropertyNames; | |
var __getProtoOf = Object.getPrototypeOf; | |
var __hasOwnProp = Object.prototype.hasOwnProperty; | |
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; | |
var __esm = (fn, res) => function __init() { | |
return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res; | |
}; | |
var __commonJS = (cb, mod2) => function __require() { | |
return mod2 || (0, cb[__getOwnPropNames(cb)[0]])((mod2 = { exports: {} }).exports, mod2), mod2.exports; | |
}; | |
var __export = (target, all) => { | |
for (var name in all) | |
__defProp(target, name, { get: all[name], enumerable: true }); | |
}; | |
var __copyProps = (to, from, except, desc) => { | |
if (from && typeof from === "object" || typeof from === "function") { | |
for (let key of __getOwnPropNames(from)) | |
if (!__hasOwnProp.call(to, key) && key !== except) | |
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); | |
} | |
return to; | |
}; | |
var __reExport = (target, mod2, secondTarget) => (__copyProps(target, mod2, "default"), secondTarget && __copyProps(secondTarget, mod2, "default")); | |
var __toESM = (mod2, isNodeMode, target) => (target = mod2 != null ? __create(__getProtoOf(mod2)) : {}, __copyProps( | |
// If the importer is in node compatibility mode or this is not an ESM | |
// file that has been converted to a CommonJS file using a Babel- | |
// compatible transform (i.e. "__esModule" has not been set), then set | |
// "default" to the CommonJS "module.exports" for node compatibility. | |
isNodeMode || !mod2 || !mod2.__esModule ? __defProp(target, "default", { value: mod2, enumerable: true }) : target, | |
mod2 | |
)); | |
var __toCommonJS = (mod2) => __copyProps(__defProp({}, "__esModule", { value: true }), mod2); | |
var __publicField = (obj, key, value) => { | |
__defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value); | |
return value; | |
}; | |
// ../../node_modules/tsup/assets/cjs_shims.js | |
var init_cjs_shims = __esm({ | |
"../../node_modules/tsup/assets/cjs_shims.js"() { | |
} | |
}); | |
// ../../node_modules/browser-headers/dist/browser-headers.js | |
var require_browser_headers = __commonJS({ | |
"../../node_modules/browser-headers/dist/browser-headers.js"(exports2) { | |
init_cjs_shims(); | |
(function(e, a) { | |
for (var i in a) | |
e[i] = a[i]; | |
})( | |
exports2, | |
/******/ | |
function(modules) { | |
var installedModules = {}; | |
function __webpack_require__(moduleId) { | |
if (installedModules[moduleId]) { | |
return installedModules[moduleId].exports; | |
} | |
var module3 = installedModules[moduleId] = { | |
/******/ | |
i: moduleId, | |
/******/ | |
l: false, | |
/******/ | |
exports: {} | |
/******/ | |
}; | |
modules[moduleId].call(module3.exports, module3, module3.exports, __webpack_require__); | |
module3.l = true; | |
return module3.exports; | |
} | |
__webpack_require__.m = modules; | |
__webpack_require__.c = installedModules; | |
__webpack_require__.i = function(value) { | |
return value; | |
}; | |
__webpack_require__.d = function(exports3, name, getter) { | |
if (!__webpack_require__.o(exports3, name)) { | |
Object.defineProperty(exports3, name, { | |
/******/ | |
configurable: false, | |
/******/ | |
enumerable: true, | |
/******/ | |
get: getter | |
/******/ | |
}); | |
} | |
}; | |
__webpack_require__.n = function(module3) { | |
var getter = module3 && module3.__esModule ? ( | |
/******/ | |
function getDefault() { | |
return module3["default"]; | |
} | |
) : ( | |
/******/ | |
function getModuleExports() { | |
return module3; | |
} | |
); | |
__webpack_require__.d(getter, "a", getter); | |
return getter; | |
}; | |
__webpack_require__.o = function(object, property) { | |
return Object.prototype.hasOwnProperty.call(object, property); | |
}; | |
__webpack_require__.p = ""; | |
return __webpack_require__(__webpack_require__.s = 1); | |
}([ | |
/* 0 */ | |
/***/ | |
function(module3, exports3, __webpack_require__) { | |
"use strict"; | |
Object.defineProperty(exports3, "__esModule", { value: true }); | |
var util_1 = __webpack_require__(3); | |
function isBrowserHeaders(arg) { | |
return typeof arg === "object" && typeof arg.headersMap === "object" && typeof arg.forEach === "function"; | |
} | |
var BrowserHeaders2 = function() { | |
function BrowserHeaders3(init, options) { | |
if (init === void 0) { | |
init = {}; | |
} | |
if (options === void 0) { | |
options = { splitValues: false }; | |
} | |
var _this = this; | |
this.headersMap = {}; | |
if (init) { | |
if (typeof Headers !== "undefined" && init instanceof Headers) { | |
var keys = util_1.getHeaderKeys(init); | |
keys.forEach(function(key) { | |
var values = util_1.getHeaderValues(init, key); | |
values.forEach(function(value) { | |
if (options.splitValues) { | |
_this.append(key, util_1.splitHeaderValue(value)); | |
} else { | |
_this.append(key, value); | |
} | |
}); | |
}); | |
} else if (isBrowserHeaders(init)) { | |
init.forEach(function(key, values) { | |
_this.append(key, values); | |
}); | |
} else if (typeof Map !== "undefined" && init instanceof Map) { | |
var asMap = init; | |
asMap.forEach(function(value, key) { | |
_this.append(key, value); | |
}); | |
} else if (typeof init === "string") { | |
this.appendFromString(init); | |
} else if (typeof init === "object") { | |
Object.getOwnPropertyNames(init).forEach(function(key) { | |
var asObject = init; | |
var values = asObject[key]; | |
if (Array.isArray(values)) { | |
values.forEach(function(value) { | |
_this.append(key, value); | |
}); | |
} else { | |
_this.append(key, values); | |
} | |
}); | |
} | |
} | |
} | |
BrowserHeaders3.prototype.appendFromString = function(str) { | |
var pairs = str.split("\r\n"); | |
for (var i = 0; i < pairs.length; i++) { | |
var p = pairs[i]; | |
var index = p.indexOf(":"); | |
if (index > 0) { | |
var key = p.substring(0, index).trim(); | |
var value = p.substring(index + 1).trim(); | |
this.append(key, value); | |
} | |
} | |
}; | |
BrowserHeaders3.prototype.delete = function(key, value) { | |
var normalizedKey = util_1.normalizeName(key); | |
if (value === void 0) { | |
delete this.headersMap[normalizedKey]; | |
} else { | |
var existing = this.headersMap[normalizedKey]; | |
if (existing) { | |
var index = existing.indexOf(value); | |
if (index >= 0) { | |
existing.splice(index, 1); | |
} | |
if (existing.length === 0) { | |
delete this.headersMap[normalizedKey]; | |
} | |
} | |
} | |
}; | |
BrowserHeaders3.prototype.append = function(key, value) { | |
var _this = this; | |
var normalizedKey = util_1.normalizeName(key); | |
if (!Array.isArray(this.headersMap[normalizedKey])) { | |
this.headersMap[normalizedKey] = []; | |
} | |
if (Array.isArray(value)) { | |
value.forEach(function(arrayValue) { | |
_this.headersMap[normalizedKey].push(util_1.normalizeValue(arrayValue)); | |
}); | |
} else { | |
this.headersMap[normalizedKey].push(util_1.normalizeValue(value)); | |
} | |
}; | |
BrowserHeaders3.prototype.set = function(key, value) { | |
var normalizedKey = util_1.normalizeName(key); | |
if (Array.isArray(value)) { | |
var normalized_1 = []; | |
value.forEach(function(arrayValue) { | |
normalized_1.push(util_1.normalizeValue(arrayValue)); | |
}); | |
this.headersMap[normalizedKey] = normalized_1; | |
} else { | |
this.headersMap[normalizedKey] = [util_1.normalizeValue(value)]; | |
} | |
}; | |
BrowserHeaders3.prototype.has = function(key, value) { | |
var keyArray = this.headersMap[util_1.normalizeName(key)]; | |
var keyExists = Array.isArray(keyArray); | |
if (!keyExists) { | |
return false; | |
} | |
if (value !== void 0) { | |
var normalizedValue = util_1.normalizeValue(value); | |
return keyArray.indexOf(normalizedValue) >= 0; | |
} else { | |
return true; | |
} | |
}; | |
BrowserHeaders3.prototype.get = function(key) { | |
var values = this.headersMap[util_1.normalizeName(key)]; | |
if (values !== void 0) { | |
return values.concat(); | |
} | |
return []; | |
}; | |
BrowserHeaders3.prototype.forEach = function(callback) { | |
var _this = this; | |
Object.getOwnPropertyNames(this.headersMap).forEach(function(key) { | |
callback(key, _this.headersMap[key]); | |
}, this); | |
}; | |
BrowserHeaders3.prototype.toHeaders = function() { | |
if (typeof Headers !== "undefined") { | |
var headers_1 = new Headers(); | |
this.forEach(function(key, values) { | |
values.forEach(function(value) { | |
headers_1.append(key, value); | |
}); | |
}); | |
return headers_1; | |
} else { | |
throw new Error("Headers class is not defined"); | |
} | |
}; | |
return BrowserHeaders3; | |
}(); | |
exports3.BrowserHeaders = BrowserHeaders2; | |
}, | |
/* 1 */ | |
/***/ | |
function(module3, exports3, __webpack_require__) { | |
"use strict"; | |
Object.defineProperty(exports3, "__esModule", { value: true }); | |
var BrowserHeaders_1 = __webpack_require__(0); | |
exports3.BrowserHeaders = BrowserHeaders_1.BrowserHeaders; | |
}, | |
/* 2 */ | |
/***/ | |
function(module3, exports3, __webpack_require__) { | |
"use strict"; | |
Object.defineProperty(exports3, "__esModule", { value: true }); | |
function iterateHeaders(headers, callback) { | |
var iterator = headers[Symbol.iterator](); | |
var entry = iterator.next(); | |
while (!entry.done) { | |
callback(entry.value[0]); | |
entry = iterator.next(); | |
} | |
} | |
exports3.iterateHeaders = iterateHeaders; | |
function iterateHeadersKeys(headers, callback) { | |
var iterator = headers.keys(); | |
var entry = iterator.next(); | |
while (!entry.done) { | |
callback(entry.value); | |
entry = iterator.next(); | |
} | |
} | |
exports3.iterateHeadersKeys = iterateHeadersKeys; | |
}, | |
/* 3 */ | |
/***/ | |
function(module3, exports3, __webpack_require__) { | |
"use strict"; | |
Object.defineProperty(exports3, "__esModule", { value: true }); | |
var iterateHeaders_1 = __webpack_require__(2); | |
function normalizeName(name) { | |
if (typeof name !== "string") { | |
name = String(name); | |
} | |
if (/[^a-z0-9\-#$%&'*+.\^_`|~]/i.test(name)) { | |
throw new TypeError("Invalid character in header field name"); | |
} | |
return name.toLowerCase(); | |
} | |
exports3.normalizeName = normalizeName; | |
function normalizeValue(value) { | |
if (typeof value !== "string") { | |
value = String(value); | |
} | |
return value; | |
} | |
exports3.normalizeValue = normalizeValue; | |
function getHeaderValues(headersAsNative, key) { | |
var headers = toWindowHeaders(headersAsNative); | |
if (headers instanceof Headers && headers.getAll) { | |
return headers.getAll(key); | |
} | |
var getValue = headers.get(key); | |
if (getValue && typeof getValue === "string") { | |
return [getValue]; | |
} | |
return getValue; | |
} | |
exports3.getHeaderValues = getHeaderValues; | |
function toWindowHeaders(headersAsNative) { | |
return headersAsNative; | |
} | |
function getHeaderKeys(headersAsNative) { | |
var headers = toWindowHeaders(headersAsNative); | |
var asMap = {}; | |
var keys = []; | |
if (headers.keys) { | |
iterateHeaders_1.iterateHeadersKeys(headers, function(key) { | |
if (!asMap[key]) { | |
asMap[key] = true; | |
keys.push(key); | |
} | |
}); | |
} else if (headers.forEach) { | |
headers.forEach(function(_, key) { | |
if (!asMap[key]) { | |
asMap[key] = true; | |
keys.push(key); | |
} | |
}); | |
} else { | |
iterateHeaders_1.iterateHeaders(headers, function(entry) { | |
var key = entry[0]; | |
if (!asMap[key]) { | |
asMap[key] = true; | |
keys.push(key); | |
} | |
}); | |
} | |
return keys; | |
} | |
exports3.getHeaderKeys = getHeaderKeys; | |
function splitHeaderValue(str) { | |
var values = []; | |
var commaSpaceValues = str.split(", "); | |
commaSpaceValues.forEach(function(commaSpaceValue) { | |
commaSpaceValue.split(",").forEach(function(commaValue) { | |
values.push(commaValue); | |
}); | |
}); | |
return values; | |
} | |
exports3.splitHeaderValue = splitHeaderValue; | |
} | |
/******/ | |
]) | |
); | |
} | |
}); | |
// ../../node_modules/long/src/long.js | |
var require_long = __commonJS({ | |
"../../node_modules/long/src/long.js"(exports2, module2) { | |
init_cjs_shims(); | |
module2.exports = Long5; | |
var wasm = null; | |
try { | |
wasm = new WebAssembly.Instance(new WebAssembly.Module(new Uint8Array([ | |
0, | |
97, | |
115, | |
109, | |
1, | |
0, | |
0, | |
0, | |
1, | |
13, | |
2, | |
96, | |
0, | |
1, | |
127, | |
96, | |
4, | |
127, | |
127, | |
127, | |
127, | |
1, | |
127, | |
3, | |
7, | |
6, | |
0, | |
1, | |
1, | |
1, | |
1, | |
1, | |
6, | |
6, | |
1, | |
127, | |
1, | |
65, | |
0, | |
11, | |
7, | |
50, | |
6, | |
3, | |
109, | |
117, | |
108, | |
0, | |
1, | |
5, | |
100, | |
105, | |
118, | |
95, | |
115, | |
0, | |
2, | |
5, | |
100, | |
105, | |
118, | |
95, | |
117, | |
0, | |
3, | |
5, | |
114, | |
101, | |
109, | |
95, | |
115, | |
0, | |
4, | |
5, | |
114, | |
101, | |
109, | |
95, | |
117, | |
0, | |
5, | |
8, | |
103, | |
101, | |
116, | |
95, | |
104, | |
105, | |
103, | |
104, | |
0, | |
0, | |
10, | |
191, | |
1, | |
6, | |
4, | |
0, | |
35, | |
0, | |
11, | |
36, | |
1, | |
1, | |
126, | |
32, | |
0, | |
173, | |
32, | |
1, | |
173, | |
66, | |
32, | |
134, | |
132, | |
32, | |
2, | |
173, | |
32, | |
3, | |
173, | |
66, | |
32, | |
134, | |
132, | |
126, | |
34, | |
4, | |
66, | |
32, | |
135, | |
167, | |
36, | |
0, | |
32, | |
4, | |
167, | |
11, | |
36, | |
1, | |
1, | |
126, | |
32, | |
0, | |
173, | |
32, | |
1, | |
173, | |
66, | |
32, | |
134, | |
132, | |
32, | |
2, | |
173, | |
32, | |
3, | |
173, | |
66, | |
32, | |
134, | |
132, | |
127, | |
34, | |
4, | |
66, | |
32, | |
135, | |
167, | |
36, | |
0, | |
32, | |
4, | |
167, | |
11, | |
36, | |
1, | |
1, | |
126, | |
32, | |
0, | |
173, | |
32, | |
1, | |
173, | |
66, | |
32, | |
134, | |
132, | |
32, | |
2, | |
173, | |
32, | |
3, | |
173, | |
66, | |
32, | |
134, | |
132, | |
128, | |
34, | |
4, | |
66, | |
32, | |
135, | |
167, | |
36, | |
0, | |
32, | |
4, | |
167, | |
11, | |
36, | |
1, | |
1, | |
126, | |
32, | |
0, | |
173, | |
32, | |
1, | |
173, | |
66, | |
32, | |
134, | |
132, | |
32, | |
2, | |
173, | |
32, | |
3, | |
173, | |
66, | |
32, | |
134, | |
132, | |
129, | |
34, | |
4, | |
66, | |
32, | |
135, | |
167, | |
36, | |
0, | |
32, | |
4, | |
167, | |
11, | |
36, | |
1, | |
1, | |
126, | |
32, | |
0, | |
173, | |
32, | |
1, | |
173, | |
66, | |
32, | |
134, | |
132, | |
32, | |
2, | |
173, | |
32, | |
3, | |
173, | |
66, | |
32, | |
134, | |
132, | |
130, | |
34, | |
4, | |
66, | |
32, | |
135, | |
167, | |
36, | |
0, | |
32, | |
4, | |
167, | |
11 | |
])), {}).exports; | |
} catch (e) { | |
} | |
function Long5(low, high, unsigned) { | |
this.low = low | 0; | |
this.high = high | 0; | |
this.unsigned = !!unsigned; | |
} | |
Long5.prototype.__isLong__; | |
Object.defineProperty(Long5.prototype, "__isLong__", { value: true }); | |
function isLong(obj) { | |
return (obj && obj["__isLong__"]) === true; | |
} | |
Long5.isLong = isLong; | |
var INT_CACHE = {}; | |
var UINT_CACHE = {}; | |
function fromInt(value, unsigned) { | |
var obj, cachedObj, cache; | |
if (unsigned) { | |
value >>>= 0; | |
if (cache = 0 <= value && value < 256) { | |
cachedObj = UINT_CACHE[value]; | |
if (cachedObj) | |
return cachedObj; | |
} | |
obj = fromBits(value, (value | 0) < 0 ? -1 : 0, true); | |
if (cache) | |
UINT_CACHE[value] = obj; | |
return obj; | |
} else { | |
value |= 0; | |
if (cache = -128 <= value && value < 128) { | |
cachedObj = INT_CACHE[value]; | |
if (cachedObj) | |
return cachedObj; | |
} | |
obj = fromBits(value, value < 0 ? -1 : 0, false); | |
if (cache) | |
INT_CACHE[value] = obj; | |
return obj; | |
} | |
} | |
Long5.fromInt = fromInt; | |
function fromNumber(value, unsigned) { | |
if (isNaN(value)) | |
return unsigned ? UZERO : ZERO; | |
if (unsigned) { | |
if (value < 0) | |
return UZERO; | |
if (value >= TWO_PWR_64_DBL) | |
return MAX_UNSIGNED_VALUE; | |
} else { | |
if (value <= -TWO_PWR_63_DBL) | |
return MIN_VALUE; | |
if (value + 1 >= TWO_PWR_63_DBL) | |
return MAX_VALUE; | |
} | |
if (value < 0) | |
return fromNumber(-value, unsigned).neg(); | |
return fromBits(value % TWO_PWR_32_DBL | 0, value / TWO_PWR_32_DBL | 0, unsigned); | |
} | |
Long5.fromNumber = fromNumber; | |
function fromBits(lowBits, highBits, unsigned) { | |
return new Long5(lowBits, highBits, unsigned); | |
} | |
Long5.fromBits = fromBits; | |
var pow_dbl = Math.pow; | |
function fromString(str, unsigned, radix) { | |
if (str.length === 0) | |
throw Error("empty string"); | |
if (str === "NaN" || str === "Infinity" || str === "+Infinity" || str === "-Infinity") | |
return ZERO; | |
if (typeof unsigned === "number") { | |
radix = unsigned, unsigned = false; | |
} else { | |
unsigned = !!unsigned; | |
} | |
radix = radix || 10; | |
if (radix < 2 || 36 < radix) | |
throw RangeError("radix"); | |
var p; | |
if ((p = str.indexOf("-")) > 0) | |
throw Error("interior hyphen"); | |
else if (p === 0) { | |
return fromString(str.substring(1), unsigned, radix).neg(); | |
} | |
var radixToPower = fromNumber(pow_dbl(radix, 8)); | |
var result = ZERO; | |
for (var i = 0; i < str.length; i += 8) { | |
var size = Math.min(8, str.length - i), value = parseInt(str.substring(i, i + size), radix); | |
if (size < 8) { | |
var power = fromNumber(pow_dbl(radix, size)); | |
result = result.mul(power).add(fromNumber(value)); | |
} else { | |
result = result.mul(radixToPower); | |
result = result.add(fromNumber(value)); | |
} | |
} | |
result.unsigned = unsigned; | |
return result; | |
} | |
Long5.fromString = fromString; | |
function fromValue(val, unsigned) { | |
if (typeof val === "number") | |
return fromNumber(val, unsigned); | |
if (typeof val === "string") | |
return fromString(val, unsigned); | |
return fromBits(val.low, val.high, typeof unsigned === "boolean" ? unsigned : val.unsigned); | |
} | |
Long5.fromValue = fromValue; | |
var TWO_PWR_16_DBL = 1 << 16; | |
var TWO_PWR_24_DBL = 1 << 24; | |
var TWO_PWR_32_DBL = TWO_PWR_16_DBL * TWO_PWR_16_DBL; | |
var TWO_PWR_64_DBL = TWO_PWR_32_DBL * TWO_PWR_32_DBL; | |
var TWO_PWR_63_DBL = TWO_PWR_64_DBL / 2; | |
var TWO_PWR_24 = fromInt(TWO_PWR_24_DBL); | |
var ZERO = fromInt(0); | |
Long5.ZERO = ZERO; | |
var UZERO = fromInt(0, true); | |
Long5.UZERO = UZERO; | |
var ONE = fromInt(1); | |
Long5.ONE = ONE; | |
var UONE = fromInt(1, true); | |
Long5.UONE = UONE; | |
var NEG_ONE = fromInt(-1); | |
Long5.NEG_ONE = NEG_ONE; | |
var MAX_VALUE = fromBits(4294967295 | 0, 2147483647 | 0, false); | |
Long5.MAX_VALUE = MAX_VALUE; | |
var MAX_UNSIGNED_VALUE = fromBits(4294967295 | 0, 4294967295 | 0, true); | |
Long5.MAX_UNSIGNED_VALUE = MAX_UNSIGNED_VALUE; | |
var MIN_VALUE = fromBits(0, 2147483648 | 0, false); | |
Long5.MIN_VALUE = MIN_VALUE; | |
var LongPrototype = Long5.prototype; | |
LongPrototype.toInt = function toInt() { | |
return this.unsigned ? this.low >>> 0 : this.low; | |
}; | |
LongPrototype.toNumber = function toNumber() { | |
if (this.unsigned) | |
return (this.high >>> 0) * TWO_PWR_32_DBL + (this.low >>> 0); | |
return this.high * TWO_PWR_32_DBL + (this.low >>> 0); | |
}; | |
LongPrototype.toString = function toString(radix) { | |
radix = radix || 10; | |
if (radix < 2 || 36 < radix) | |
throw RangeError("radix"); | |
if (this.isZero()) | |
return "0"; | |
if (this.isNegative()) { | |
if (this.eq(MIN_VALUE)) { | |
var radixLong = fromNumber(radix), div = this.div(radixLong), rem1 = div.mul(radixLong).sub(this); | |
return div.toString(radix) + rem1.toInt().toString(radix); | |
} else | |
return "-" + this.neg().toString(radix); | |
} | |
var radixToPower = fromNumber(pow_dbl(radix, 6), this.unsigned), rem = this; | |
var result = ""; | |
while (true) { | |
var remDiv = rem.div(radixToPower), intval = rem.sub(remDiv.mul(radixToPower)).toInt() >>> 0, digits = intval.toString(radix); | |
rem = remDiv; | |
if (rem.isZero()) | |
return digits + result; | |
else { | |
while (digits.length < 6) | |
digits = "0" + digits; | |
result = "" + digits + result; | |
} | |
} | |
}; | |
LongPrototype.getHighBits = function getHighBits() { | |
return this.high; | |
}; | |
LongPrototype.getHighBitsUnsigned = function getHighBitsUnsigned() { | |
return this.high >>> 0; | |
}; | |
LongPrototype.getLowBits = function getLowBits() { | |
return this.low; | |
}; | |
LongPrototype.getLowBitsUnsigned = function getLowBitsUnsigned() { | |
return this.low >>> 0; | |
}; | |
LongPrototype.getNumBitsAbs = function getNumBitsAbs() { | |
if (this.isNegative()) | |
return this.eq(MIN_VALUE) ? 64 : this.neg().getNumBitsAbs(); | |
var val = this.high != 0 ? this.high : this.low; | |
for (var bit = 31; bit > 0; bit--) | |
if ((val & 1 << bit) != 0) | |
break; | |
return this.high != 0 ? bit + 33 : bit + 1; | |
}; | |
LongPrototype.isZero = function isZero() { | |
return this.high === 0 && this.low === 0; | |
}; | |
LongPrototype.eqz = LongPrototype.isZero; | |
LongPrototype.isNegative = function isNegative() { | |
return !this.unsigned && this.high < 0; | |
}; | |
LongPrototype.isPositive = function isPositive() { | |
return this.unsigned || this.high >= 0; | |
}; | |
LongPrototype.isOdd = function isOdd() { | |
return (this.low & 1) === 1; | |
}; | |
LongPrototype.isEven = function isEven() { | |
return (this.low & 1) === 0; | |
}; | |
LongPrototype.equals = function equals(other) { | |
if (!isLong(other)) | |
other = fromValue(other); | |
if (this.unsigned !== other.unsigned && this.high >>> 31 === 1 && other.high >>> 31 === 1) | |
return false; | |
return this.high === other.high && this.low === other.low; | |
}; | |
LongPrototype.eq = LongPrototype.equals; | |
LongPrototype.notEquals = function notEquals(other) { | |
return !this.eq( | |
/* validates */ | |
other | |
); | |
}; | |
LongPrototype.neq = LongPrototype.notEquals; | |
LongPrototype.ne = LongPrototype.notEquals; | |
LongPrototype.lessThan = function lessThan(other) { | |
return this.comp( | |
/* validates */ | |
other | |
) < 0; | |
}; | |
LongPrototype.lt = LongPrototype.lessThan; | |
LongPrototype.lessThanOrEqual = function lessThanOrEqual(other) { | |
return this.comp( | |
/* validates */ | |
other | |
) <= 0; | |
}; | |
LongPrototype.lte = LongPrototype.lessThanOrEqual; | |
LongPrototype.le = LongPrototype.lessThanOrEqual; | |
LongPrototype.greaterThan = function greaterThan(other) { | |
return this.comp( | |
/* validates */ | |
other | |
) > 0; | |
}; | |
LongPrototype.gt = LongPrototype.greaterThan; | |
LongPrototype.greaterThanOrEqual = function greaterThanOrEqual(other) { | |
return this.comp( | |
/* validates */ | |
other | |
) >= 0; | |
}; | |
LongPrototype.gte = LongPrototype.greaterThanOrEqual; | |
LongPrototype.ge = LongPrototype.greaterThanOrEqual; | |
LongPrototype.compare = function compare(other) { | |
if (!isLong(other)) | |
other = fromValue(other); | |
if (this.eq(other)) | |
return 0; | |
var thisNeg = this.isNegative(), otherNeg = other.isNegative(); | |
if (thisNeg && !otherNeg) | |
return -1; | |
if (!thisNeg && otherNeg) | |
return 1; | |
if (!this.unsigned) | |
return this.sub(other).isNegative() ? -1 : 1; | |
return other.high >>> 0 > this.high >>> 0 || other.high === this.high && other.low >>> 0 > this.low >>> 0 ? -1 : 1; | |
}; | |
LongPrototype.comp = LongPrototype.compare; | |
LongPrototype.negate = function negate() { | |
if (!this.unsigned && this.eq(MIN_VALUE)) | |
return MIN_VALUE; | |
return this.not().add(ONE); | |
}; | |
LongPrototype.neg = LongPrototype.negate; | |
LongPrototype.add = function add(addend) { | |
if (!isLong(addend)) | |
addend = fromValue(addend); | |
var a48 = this.high >>> 16; | |
var a32 = this.high & 65535; | |
var a16 = this.low >>> 16; | |
var a00 = this.low & 65535; | |
var b48 = addend.high >>> 16; | |
var b32 = addend.high & 65535; | |
var b16 = addend.low >>> 16; | |
var b00 = addend.low & 65535; | |
var c48 = 0, c32 = 0, c16 = 0, c00 = 0; | |
c00 += a00 + b00; | |
c16 += c00 >>> 16; | |
c00 &= 65535; | |
c16 += a16 + b16; | |
c32 += c16 >>> 16; | |
c16 &= 65535; | |
c32 += a32 + b32; | |
c48 += c32 >>> 16; | |
c32 &= 65535; | |
c48 += a48 + b48; | |
c48 &= 65535; | |
return fromBits(c16 << 16 | c00, c48 << 16 | c32, this.unsigned); | |
}; | |
LongPrototype.subtract = function subtract(subtrahend) { | |
if (!isLong(subtrahend)) | |
subtrahend = fromValue(subtrahend); | |
return this.add(subtrahend.neg()); | |
}; | |
LongPrototype.sub = LongPrototype.subtract; | |
LongPrototype.multiply = function multiply(multiplier) { | |
if (this.isZero()) | |
return ZERO; | |
if (!isLong(multiplier)) | |
multiplier = fromValue(multiplier); | |
if (wasm) { | |
var low = wasm.mul( | |
this.low, | |
this.high, | |
multiplier.low, | |
multiplier.high | |
); | |
return fromBits(low, wasm.get_high(), this.unsigned); | |
} | |
if (multiplier.isZero()) | |
return ZERO; | |
if (this.eq(MIN_VALUE)) | |
return multiplier.isOdd() ? MIN_VALUE : ZERO; | |
if (multiplier.eq(MIN_VALUE)) | |
return this.isOdd() ? MIN_VALUE : ZERO; | |
if (this.isNegative()) { | |
if (multiplier.isNegative()) | |
return this.neg().mul(multiplier.neg()); | |
else | |
return this.neg().mul(multiplier).neg(); | |
} else if (multiplier.isNegative()) | |
return this.mul(multiplier.neg()).neg(); | |
if (this.lt(TWO_PWR_24) && multiplier.lt(TWO_PWR_24)) | |
return fromNumber(this.toNumber() * multiplier.toNumber(), this.unsigned); | |
var a48 = this.high >>> 16; | |
var a32 = this.high & 65535; | |
var a16 = this.low >>> 16; | |
var a00 = this.low & 65535; | |
var b48 = multiplier.high >>> 16; | |
var b32 = multiplier.high & 65535; | |
var b16 = multiplier.low >>> 16; | |
var b00 = multiplier.low & 65535; | |
var c48 = 0, c32 = 0, c16 = 0, c00 = 0; | |
c00 += a00 * b00; | |
c16 += c00 >>> 16; | |
c00 &= 65535; | |
c16 += a16 * b00; | |
c32 += c16 >>> 16; | |
c16 &= 65535; | |
c16 += a00 * b16; | |
c32 += c16 >>> 16; | |
c16 &= 65535; | |
c32 += a32 * b00; | |
c48 += c32 >>> 16; | |
c32 &= 65535; | |
c32 += a16 * b16; | |
c48 += c32 >>> 16; | |
c32 &= 65535; | |
c32 += a00 * b32; | |
c48 += c32 >>> 16; | |
c32 &= 65535; | |
c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48; | |
c48 &= 65535; | |
return fromBits(c16 << 16 | c00, c48 << 16 | c32, this.unsigned); | |
}; | |
LongPrototype.mul = LongPrototype.multiply; | |
LongPrototype.divide = function divide(divisor) { | |
if (!isLong(divisor)) | |
divisor = fromValue(divisor); | |
if (divisor.isZero()) | |
throw Error("division by zero"); | |
if (wasm) { | |
if (!this.unsigned && this.high === -2147483648 && divisor.low === -1 && divisor.high === -1) { | |
return this; | |
} | |
var low = (this.unsigned ? wasm.div_u : wasm.div_s)( | |
this.low, | |
this.high, | |
divisor.low, | |
divisor.high | |
); | |
return fromBits(low, wasm.get_high(), this.unsigned); | |
} | |
if (this.isZero()) | |
return this.unsigned ? UZERO : ZERO; | |
var approx, rem, res; | |
if (!this.unsigned) { | |
if (this.eq(MIN_VALUE)) { | |
if (divisor.eq(ONE) || divisor.eq(NEG_ONE)) | |
return MIN_VALUE; | |
else if (divisor.eq(MIN_VALUE)) | |
return ONE; | |
else { | |
var halfThis = this.shr(1); | |
approx = halfThis.div(divisor).shl(1); | |
if (approx.eq(ZERO)) { | |
return divisor.isNegative() ? ONE : NEG_ONE; | |
} else { | |
rem = this.sub(divisor.mul(approx)); | |
res = approx.add(rem.div(divisor)); | |
return res; | |
} | |
} | |
} else if (divisor.eq(MIN_VALUE)) | |
return this.unsigned ? UZERO : ZERO; | |
if (this.isNegative()) { | |
if (divisor.isNegative()) | |
return this.neg().div(divisor.neg()); | |
return this.neg().div(divisor).neg(); | |
} else if (divisor.isNegative()) | |
return this.div(divisor.neg()).neg(); | |
res = ZERO; | |
} else { | |
if (!divisor.unsigned) | |
divisor = divisor.toUnsigned(); | |
if (divisor.gt(this)) | |
return UZERO; | |
if (divisor.gt(this.shru(1))) | |
return UONE; | |
res = UZERO; | |
} | |
rem = this; | |
while (rem.gte(divisor)) { | |
approx = Math.max(1, Math.floor(rem.toNumber() / divisor.toNumber())); | |
var log2 = Math.ceil(Math.log(approx) / Math.LN2), delta = log2 <= 48 ? 1 : pow_dbl(2, log2 - 48), approxRes = fromNumber(approx), approxRem = approxRes.mul(divisor); | |
while (approxRem.isNegative() || approxRem.gt(rem)) { | |
approx -= delta; | |
approxRes = fromNumber(approx, this.unsigned); | |
approxRem = approxRes.mul(divisor); | |
} | |
if (approxRes.isZero()) | |
approxRes = ONE; | |
res = res.add(approxRes); | |
rem = rem.sub(approxRem); | |
} | |
return res; | |
}; | |
LongPrototype.div = LongPrototype.divide; | |
LongPrototype.modulo = function modulo(divisor) { | |
if (!isLong(divisor)) | |
divisor = fromValue(divisor); | |
if (wasm) { | |
var low = (this.unsigned ? wasm.rem_u : wasm.rem_s)( | |
this.low, | |
this.high, | |
divisor.low, | |
divisor.high | |
); | |
return fromBits(low, wasm.get_high(), this.unsigned); | |
} | |
return this.sub(this.div(divisor).mul(divisor)); | |
}; | |
LongPrototype.mod = LongPrototype.modulo; | |
LongPrototype.rem = LongPrototype.modulo; | |
LongPrototype.not = function not() { | |
return fromBits(~this.low, ~this.high, this.unsigned); | |
}; | |
LongPrototype.and = function and(other) { | |
if (!isLong(other)) | |
other = fromValue(other); | |
return fromBits(this.low & other.low, this.high & other.high, this.unsigned); | |
}; | |
LongPrototype.or = function or(other) { | |
if (!isLong(other)) | |
other = fromValue(other); | |
return fromBits(this.low | other.low, this.high | other.high, this.unsigned); | |
}; | |
LongPrototype.xor = function xor(other) { | |
if (!isLong(other)) | |
other = fromValue(other); | |
return fromBits(this.low ^ other.low, this.high ^ other.high, this.unsigned); | |
}; | |
LongPrototype.shiftLeft = function shiftLeft(numBits) { | |
if (isLong(numBits)) | |
numBits = numBits.toInt(); | |
if ((numBits &= 63) === 0) | |
return this; | |
else if (numBits < 32) | |
return fromBits(this.low << numBits, this.high << numBits | this.low >>> 32 - numBits, this.unsigned); | |
else | |
return fromBits(0, this.low << numBits - 32, this.unsigned); | |
}; | |
LongPrototype.shl = LongPrototype.shiftLeft; | |
LongPrototype.shiftRight = function shiftRight(numBits) { | |
if (isLong(numBits)) | |
numBits = numBits.toInt(); | |
if ((numBits &= 63) === 0) | |
return this; | |
else if (numBits < 32) | |
return fromBits(this.low >>> numBits | this.high << 32 - numBits, this.high >> numBits, this.unsigned); | |
else | |
return fromBits(this.high >> numBits - 32, this.high >= 0 ? 0 : -1, this.unsigned); | |
}; | |
LongPrototype.shr = LongPrototype.shiftRight; | |
LongPrototype.shiftRightUnsigned = function shiftRightUnsigned(numBits) { | |
if (isLong(numBits)) | |
numBits = numBits.toInt(); | |
numBits &= 63; | |
if (numBits === 0) | |
return this; | |
else { | |
var high = this.high; | |
if (numBits < 32) { | |
var low = this.low; | |
return fromBits(low >>> numBits | high << 32 - numBits, high >>> numBits, this.unsigned); | |
} else if (numBits === 32) | |
return fromBits(high, 0, this.unsigned); | |
else | |
return fromBits(high >>> numBits - 32, 0, this.unsigned); | |
} | |
}; | |
LongPrototype.shru = LongPrototype.shiftRightUnsigned; | |
LongPrototype.shr_u = LongPrototype.shiftRightUnsigned; | |
LongPrototype.toSigned = function toSigned() { | |
if (!this.unsigned) | |
return this; | |
return fromBits(this.low, this.high, false); | |
}; | |
LongPrototype.toUnsigned = function toUnsigned() { | |
if (this.unsigned) | |
return this; | |
return fromBits(this.low, this.high, true); | |
}; | |
LongPrototype.toBytes = function toBytes(le) { | |
return le ? this.toBytesLE() : this.toBytesBE(); | |
}; | |
LongPrototype.toBytesLE = function toBytesLE() { | |
var hi = this.high, lo = this.low; | |
return [ | |
lo & 255, | |
lo >>> 8 & 255, | |
lo >>> 16 & 255, | |
lo >>> 24, | |
hi & 255, | |
hi >>> 8 & 255, | |
hi >>> 16 & 255, | |
hi >>> 24 | |
]; | |
}; | |
LongPrototype.toBytesBE = function toBytesBE() { | |
var hi = this.high, lo = this.low; | |
return [ | |
hi >>> 24, | |
hi >>> 16 & 255, | |
hi >>> 8 & 255, | |
hi & 255, | |
lo >>> 24, | |
lo >>> 16 & 255, | |
lo >>> 8 & 255, | |
lo & 255 | |
]; | |
}; | |
Long5.fromBytes = function fromBytes(bytes, unsigned, le) { | |
return le ? Long5.fromBytesLE(bytes, unsigned) : Long5.fromBytesBE(bytes, unsigned); | |
}; | |
Long5.fromBytesLE = function fromBytesLE(bytes, unsigned) { | |
return new Long5( | |
bytes[0] | bytes[1] << 8 | bytes[2] << 16 | bytes[3] << 24, | |
bytes[4] | bytes[5] << 8 | bytes[6] << 16 | bytes[7] << 24, | |
unsigned | |
); | |
}; | |
Long5.fromBytesBE = function fromBytesBE(bytes, unsigned) { | |
return new Long5( | |
bytes[4] << 24 | bytes[5] << 16 | bytes[6] << 8 | bytes[7], | |
bytes[0] << 24 | bytes[1] << 16 | bytes[2] << 8 | bytes[3], | |
unsigned | |
); | |
}; | |
} | |
}); | |
// ../../node_modules/@protobufjs/aspromise/index.js | |
var require_aspromise = __commonJS({ | |
"../../node_modules/@protobufjs/aspromise/index.js"(exports2, module2) { | |
"use strict"; | |
init_cjs_shims(); | |
module2.exports = asPromise; | |
function asPromise(fn, ctx) { | |
var params = new Array(arguments.length - 1), offset = 0, index = 2, pending = true; | |
while (index < arguments.length) | |
params[offset++] = arguments[index++]; | |
return new Promise(function executor(resolve, reject) { | |
params[offset] = function callback(err2) { | |
if (pending) { | |
pending = false; | |
if (err2) | |
reject(err2); | |
else { | |
var params2 = new Array(arguments.length - 1), offset2 = 0; | |
while (offset2 < params2.length) | |
params2[offset2++] = arguments[offset2]; | |
resolve.apply(null, params2); | |
} | |
} | |
}; | |
try { | |
fn.apply(ctx || null, params); | |
} catch (err2) { | |
if (pending) { | |
pending = false; | |
reject(err2); | |
} | |
} | |
}); | |
} | |
} | |
}); | |
// ../../node_modules/@protobufjs/base64/index.js | |
var require_base64 = __commonJS({ | |
"../../node_modules/@protobufjs/base64/index.js"(exports2) { | |
"use strict"; | |
init_cjs_shims(); | |
var base64 = exports2; | |
base64.length = function length(string) { | |
var p = string.length; | |
if (!p) | |
return 0; | |
var n = 0; | |
while (--p % 4 > 1 && string.charAt(p) === "=") | |
++n; | |
return Math.ceil(string.length * 3) / 4 - n; | |
}; | |
var b64 = new Array(64); | |
var s64 = new Array(123); | |
for (i = 0; i < 64; ) | |
s64[b64[i] = i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i - 59 | 43] = i++; | |
var i; | |
base64.encode = function encode(buffer, start, end) { | |
var parts = null, chunk = []; | |
var i2 = 0, j = 0, t; | |
while (start < end) { | |
var b = buffer[start++]; | |
switch (j) { | |
case 0: | |
chunk[i2++] = b64[b >> 2]; | |
t = (b & 3) << 4; | |
j = 1; | |
break; | |
case 1: | |
chunk[i2++] = b64[t | b >> 4]; | |
t = (b & 15) << 2; | |
j = 2; | |
break; | |
case 2: | |
chunk[i2++] = b64[t | b >> 6]; | |
chunk[i2++] = b64[b & 63]; | |
j = 0; | |
break; | |
} | |
if (i2 > 8191) { | |
(parts || (parts = [])).push(String.fromCharCode.apply(String, chunk)); | |
i2 = 0; | |
} | |
} | |
if (j) { | |
chunk[i2++] = b64[t]; | |
chunk[i2++] = 61; | |
if (j === 1) | |
chunk[i2++] = 61; | |
} | |
if (parts) { | |
if (i2) | |
parts.push(String.fromCharCode.apply(String, chunk.slice(0, i2))); | |
return parts.join(""); | |
} | |
return String.fromCharCode.apply(String, chunk.slice(0, i2)); | |
}; | |
var invalidEncoding = "invalid encoding"; | |
base64.decode = function decode(string, buffer, offset) { | |
var start = offset; | |
var j = 0, t; | |
for (var i2 = 0; i2 < string.length; ) { | |
var c = string.charCodeAt(i2++); | |
if (c === 61 && j > 1) | |
break; | |
if ((c = s64[c]) === void 0) | |
throw Error(invalidEncoding); | |
switch (j) { | |
case 0: | |
t = c; | |
j = 1; | |
break; | |
case 1: | |
buffer[offset++] = t << 2 | (c & 48) >> 4; | |
t = c; | |
j = 2; | |
break; | |
case 2: | |
buffer[offset++] = (t & 15) << 4 | (c & 60) >> 2; | |
t = c; | |
j = 3; | |
break; | |
case 3: | |
buffer[offset++] = (t & 3) << 6 | c; | |
j = 0; | |
break; | |
} | |
} | |
if (j === 1) | |
throw Error(invalidEncoding); | |
return offset - start; | |
}; | |
base64.test = function test(string) { | |
return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(string); | |
}; | |
} | |
}); | |
// ../../node_modules/@protobufjs/eventemitter/index.js | |
var require_eventemitter = __commonJS({ | |
"../../node_modules/@protobufjs/eventemitter/index.js"(exports2, module2) { | |
"use strict"; | |
init_cjs_shims(); | |
module2.exports = EventEmitter; | |
function EventEmitter() { | |
this._listeners = {}; | |
} | |
EventEmitter.prototype.on = function on(evt, fn, ctx) { | |
(this._listeners[evt] || (this._listeners[evt] = [])).push({ | |
fn, | |
ctx: ctx || this | |
}); | |
return this; | |
}; | |
EventEmitter.prototype.off = function off(evt, fn) { | |
if (evt === void 0) | |
this._listeners = {}; | |
else { | |
if (fn === void 0) | |
this._listeners[evt] = []; | |
else { | |
var listeners = this._listeners[evt]; | |
for (var i = 0; i < listeners.length; ) | |
if (listeners[i].fn === fn) | |
listeners.splice(i, 1); | |
else | |
++i; | |
} | |
} | |
return this; | |
}; | |
EventEmitter.prototype.emit = function emit(evt) { | |
var listeners = this._listeners[evt]; | |
if (listeners) { | |
var args = [], i = 1; | |
for (; i < arguments.length; ) | |
args.push(arguments[i++]); | |
for (i = 0; i < listeners.length; ) | |
listeners[i].fn.apply(listeners[i++].ctx, args); | |
} | |
return this; | |
}; | |
} | |
}); | |
// ../../node_modules/@protobufjs/float/index.js | |
var require_float = __commonJS({ | |
"../../node_modules/@protobufjs/float/index.js"(exports2, module2) { | |
"use strict"; | |
init_cjs_shims(); | |
module2.exports = factory(factory); | |
function factory(exports3) { | |
if (typeof Float32Array !== "undefined") | |
(function() { | |
var f32 = new Float32Array([-0]), f8b = new Uint8Array(f32.buffer), le = f8b[3] === 128; | |
function writeFloat_f32_cpy(val, buf, pos) { | |
f32[0] = val; | |
buf[pos] = f8b[0]; | |
buf[pos + 1] = f8b[1]; | |
buf[pos + 2] = f8b[2]; | |
buf[pos + 3] = f8b[3]; | |
} | |
function writeFloat_f32_rev(val, buf, pos) { | |
f32[0] = val; | |
buf[pos] = f8b[3]; | |
buf[pos + 1] = f8b[2]; | |
buf[pos + 2] = f8b[1]; | |
buf[pos + 3] = f8b[0]; | |
} | |
exports3.writeFloatLE = le ? writeFloat_f32_cpy : writeFloat_f32_rev; | |
exports3.writeFloatBE = le ? writeFloat_f32_rev : writeFloat_f32_cpy; | |
function readFloat_f32_cpy(buf, pos) { | |
f8b[0] = buf[pos]; | |
f8b[1] = buf[pos + 1]; | |
f8b[2] = buf[pos + 2]; | |
f8b[3] = buf[pos + 3]; | |
return f32[0]; | |
} | |
function readFloat_f32_rev(buf, pos) { | |
f8b[3] = buf[pos]; | |
f8b[2] = buf[pos + 1]; | |
f8b[1] = buf[pos + 2]; | |
f8b[0] = buf[pos + 3]; | |
return f32[0]; | |
} | |
exports3.readFloatLE = le ? readFloat_f32_cpy : readFloat_f32_rev; | |
exports3.readFloatBE = le ? readFloat_f32_rev : readFloat_f32_cpy; | |
})(); | |
else | |
(function() { | |
function writeFloat_ieee754(writeUint, val, buf, pos) { | |
var sign = val < 0 ? 1 : 0; | |
if (sign) | |
val = -val; | |
if (val === 0) | |
writeUint(1 / val > 0 ? ( | |
/* positive */ | |
0 | |
) : ( | |
/* negative 0 */ | |
2147483648 | |
), buf, pos); | |
else if (isNaN(val)) | |
writeUint(2143289344, buf, pos); | |
else if (val > 34028234663852886e22) | |
writeUint((sign << 31 | 2139095040) >>> 0, buf, pos); | |
else if (val < 11754943508222875e-54) | |
writeUint((sign << 31 | Math.round(val / 1401298464324817e-60)) >>> 0, buf, pos); | |
else { | |
var exponent = Math.floor(Math.log(val) / Math.LN2), mantissa = Math.round(val * Math.pow(2, -exponent) * 8388608) & 8388607; | |
writeUint((sign << 31 | exponent + 127 << 23 | mantissa) >>> 0, buf, pos); | |
} | |
} | |
exports3.writeFloatLE = writeFloat_ieee754.bind(null, writeUintLE); | |
exports3.writeFloatBE = writeFloat_ieee754.bind(null, writeUintBE); | |
function readFloat_ieee754(readUint, buf, pos) { | |
var uint = readUint(buf, pos), sign = (uint >> 31) * 2 + 1, exponent = uint >>> 23 & 255, mantissa = uint & 8388607; | |
return exponent === 255 ? mantissa ? NaN : sign * Infinity : exponent === 0 ? sign * 1401298464324817e-60 * mantissa : sign * Math.pow(2, exponent - 150) * (mantissa + 8388608); | |
} | |
exports3.readFloatLE = readFloat_ieee754.bind(null, readUintLE); | |
exports3.readFloatBE = readFloat_ieee754.bind(null, readUintBE); | |
})(); | |
if (typeof Float64Array !== "undefined") | |
(function() { | |
var f64 = new Float64Array([-0]), f8b = new Uint8Array(f64.buffer), le = f8b[7] === 128; | |
function writeDouble_f64_cpy(val, buf, pos) { | |
f64[0] = val; | |
buf[pos] = f8b[0]; | |
buf[pos + 1] = f8b[1]; | |
buf[pos + 2] = f8b[2]; | |
buf[pos + 3] = f8b[3]; | |
buf[pos + 4] = f8b[4]; | |
buf[pos + 5] = f8b[5]; | |
buf[pos + 6] = f8b[6]; | |
buf[pos + 7] = f8b[7]; | |
} | |
function writeDouble_f64_rev(val, buf, pos) { | |
f64[0] = val; | |
buf[pos] = f8b[7]; | |
buf[pos + 1] = f8b[6]; | |
buf[pos + 2] = f8b[5]; | |
buf[pos + 3] = f8b[4]; | |
buf[pos + 4] = f8b[3]; | |
buf[pos + 5] = f8b[2]; | |
buf[pos + 6] = f8b[1]; | |
buf[pos + 7] = f8b[0]; | |
} | |
exports3.writeDoubleLE = le ? writeDouble_f64_cpy : writeDouble_f64_rev; | |
exports3.writeDoubleBE = le ? writeDouble_f64_rev : writeDouble_f64_cpy; | |
function readDouble_f64_cpy(buf, pos) { | |
f8b[0] = buf[pos]; | |
f8b[1] = buf[pos + 1]; | |
f8b[2] = buf[pos + 2]; | |
f8b[3] = buf[pos + 3]; | |
f8b[4] = buf[pos + 4]; | |
f8b[5] = buf[pos + 5]; | |
f8b[6] = buf[pos + 6]; | |
f8b[7] = buf[pos + 7]; | |
return f64[0]; | |
} | |
function readDouble_f64_rev(buf, pos) { | |
f8b[7] = buf[pos]; | |
f8b[6] = buf[pos + 1]; | |
f8b[5] = buf[pos + 2]; | |
f8b[4] = buf[pos + 3]; | |
f8b[3] = buf[pos + 4]; | |
f8b[2] = buf[pos + 5]; | |
f8b[1] = buf[pos + 6]; | |
f8b[0] = buf[pos + 7]; | |
return f64[0]; | |
} | |
exports3.readDoubleLE = le ? readDouble_f64_cpy : readDouble_f64_rev; | |
exports3.readDoubleBE = le ? readDouble_f64_rev : readDouble_f64_cpy; | |
})(); | |
else | |
(function() { | |
function writeDouble_ieee754(writeUint, off0, off1, val, buf, pos) { | |
var sign = val < 0 ? 1 : 0; | |
if (sign) | |
val = -val; | |
if (val === 0) { | |
writeUint(0, buf, pos + off0); | |
writeUint(1 / val > 0 ? ( | |
/* positive */ | |
0 | |
) : ( | |
/* negative 0 */ | |
2147483648 | |
), buf, pos + off1); | |
} else if (isNaN(val)) { | |
writeUint(0, buf, pos + off0); | |
writeUint(2146959360, buf, pos + off1); | |
} else if (val > 17976931348623157e292) { | |
writeUint(0, buf, pos + off0); | |
writeUint((sign << 31 | 2146435072) >>> 0, buf, pos + off1); | |
} else { | |
var mantissa; | |
if (val < 22250738585072014e-324) { | |
mantissa = val / 5e-324; | |
writeUint(mantissa >>> 0, buf, pos + off0); | |
writeUint((sign << 31 | mantissa / 4294967296) >>> 0, buf, pos + off1); | |
} else { | |
var exponent = Math.floor(Math.log(val) / Math.LN2); | |
if (exponent === 1024) | |
exponent = 1023; | |
mantissa = val * Math.pow(2, -exponent); | |
writeUint(mantissa * 4503599627370496 >>> 0, buf, pos + off0); | |
writeUint((sign << 31 | exponent + 1023 << 20 | mantissa * 1048576 & 1048575) >>> 0, buf, pos + off1); | |
} | |
} | |
} | |
exports3.writeDoubleLE = writeDouble_ieee754.bind(null, writeUintLE, 0, 4); | |
exports3.writeDoubleBE = writeDouble_ieee754.bind(null, writeUintBE, 4, 0); | |
function readDouble_ieee754(readUint, off0, off1, buf, pos) { | |
var lo = readUint(buf, pos + off0), hi = readUint(buf, pos + off1); | |
var sign = (hi >> 31) * 2 + 1, exponent = hi >>> 20 & 2047, mantissa = 4294967296 * (hi & 1048575) + lo; | |
return exponent === 2047 ? mantissa ? NaN : sign * Infinity : exponent === 0 ? sign * 5e-324 * mantissa : sign * Math.pow(2, exponent - 1075) * (mantissa + 4503599627370496); | |
} | |
exports3.readDoubleLE = readDouble_ieee754.bind(null, readUintLE, 0, 4); | |
exports3.readDoubleBE = readDouble_ieee754.bind(null, readUintBE, 4, 0); | |
})(); | |
return exports3; | |
} | |
function writeUintLE(val, buf, pos) { | |
buf[pos] = val & 255; | |
buf[pos + 1] = val >>> 8 & 255; | |
buf[pos + 2] = val >>> 16 & 255; | |
buf[pos + 3] = val >>> 24; | |
} | |
function writeUintBE(val, buf, pos) { | |
buf[pos] = val >>> 24; | |
buf[pos + 1] = val >>> 16 & 255; | |
buf[pos + 2] = val >>> 8 & 255; | |
buf[pos + 3] = val & 255; | |
} | |
function readUintLE(buf, pos) { | |
return (buf[pos] | buf[pos + 1] << 8 | buf[pos + 2] << 16 | buf[pos + 3] << 24) >>> 0; | |
} | |
function readUintBE(buf, pos) { | |
return (buf[pos] << 24 | buf[pos + 1] << 16 | buf[pos + 2] << 8 | buf[pos + 3]) >>> 0; | |
} | |
} | |
}); | |
// ../../node_modules/@protobufjs/inquire/index.js | |
var require_inquire = __commonJS({ | |
"../../node_modules/@protobufjs/inquire/index.js"(exports, module) { | |
"use strict"; | |
init_cjs_shims(); | |
module.exports = inquire; | |
function inquire(moduleName) { | |
try { | |
var mod = eval("quire".replace(/^/, "re"))(moduleName); | |
if (mod && (mod.length || Object.keys(mod).length)) | |
return mod; | |
} catch (e) { | |
} | |
return null; | |
} | |
} | |
}); | |
// ../../node_modules/@protobufjs/utf8/index.js | |
var require_utf8 = __commonJS({ | |
"../../node_modules/@protobufjs/utf8/index.js"(exports2) { | |
"use strict"; | |
init_cjs_shims(); | |
var utf8 = exports2; | |
utf8.length = function utf8_length(string) { | |
var len = 0, c = 0; | |
for (var i = 0; i < string.length; ++i) { | |
c = string.charCodeAt(i); | |
if (c < 128) | |
len += 1; | |
else if (c < 2048) | |
len += 2; | |
else if ((c & 64512) === 55296 && (string.charCodeAt(i + 1) & 64512) === 56320) { | |
++i; | |
len += 4; | |
} else | |
len += 3; | |
} | |
return len; | |
}; | |
utf8.read = function utf8_read(buffer, start, end) { | |
var len = end - start; | |
if (len < 1) | |
return ""; | |
var parts = null, chunk = [], i = 0, t; | |
while (start < end) { | |
t = buffer[start++]; | |
if (t < 128) | |
chunk[i++] = t; | |
else if (t > 191 && t < 224) | |
chunk[i++] = (t & 31) << 6 | buffer[start++] & 63; | |
else if (t > 239 && t < 365) { | |
t = ((t & 7) << 18 | (buffer[start++] & 63) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63) - 65536; | |
chunk[i++] = 55296 + (t >> 10); | |
chunk[i++] = 56320 + (t & 1023); | |
} else | |
chunk[i++] = (t & 15) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63; | |
if (i > 8191) { | |
(parts || (parts = [])).push(String.fromCharCode.apply(String, chunk)); | |
i = 0; | |
} | |
} | |
if (parts) { | |
if (i) | |
parts.push(String.fromCharCode.apply(String, chunk.slice(0, i))); | |
return parts.join(""); | |
} | |
return String.fromCharCode.apply(String, chunk.slice(0, i)); | |
}; | |
utf8.write = function utf8_write(string, buffer, offset) { | |
var start = offset, c1, c2; | |
for (var i = 0; i < string.length; ++i) { | |
c1 = string.charCodeAt(i); | |
if (c1 < 128) { | |
buffer[offset++] = c1; | |
} else if (c1 < 2048) { | |
buffer[offset++] = c1 >> 6 | 192; | |
buffer[offset++] = c1 & 63 | 128; | |
} else if ((c1 & 64512) === 55296 && ((c2 = string.charCodeAt(i + 1)) & 64512) === 56320) { | |
c1 = 65536 + ((c1 & 1023) << 10) + (c2 & 1023); | |
++i; | |
buffer[offset++] = c1 >> 18 | 240; | |
buffer[offset++] = c1 >> 12 & 63 | 128; | |
buffer[offset++] = c1 >> 6 & 63 | 128; | |
buffer[offset++] = c1 & 63 | 128; | |
} else { | |
buffer[offset++] = c1 >> 12 | 224; | |
buffer[offset++] = c1 >> 6 & 63 | 128; | |
buffer[offset++] = c1 & 63 | 128; | |
} | |
} | |
return offset - start; | |
}; | |
} | |
}); | |
// ../../node_modules/@protobufjs/pool/index.js | |
var require_pool = __commonJS({ | |
"../../node_modules/@protobufjs/pool/index.js"(exports2, module2) { | |
"use strict"; | |
init_cjs_shims(); | |
module2.exports = pool; | |
function pool(alloc, slice, size) { | |
var SIZE = size || 8192; | |
var MAX = SIZE >>> 1; | |
var slab = null; | |
var offset = SIZE; | |
return function pool_alloc(size2) { | |
if (size2 < 1 || size2 > MAX) | |
return alloc(size2); | |
if (offset + size2 > SIZE) { | |
slab = alloc(SIZE); | |
offset = 0; | |
} | |
var buf = slice.call(slab, offset, offset += size2); | |
if (offset & 7) | |
offset = (offset | 7) + 1; | |
return buf; | |
}; | |
} | |
} | |
}); | |
// ../../node_modules/protobufjs/src/util/longbits.js | |
var require_longbits = __commonJS({ | |
"../../node_modules/protobufjs/src/util/longbits.js"(exports2, module2) { | |
"use strict"; | |
init_cjs_shims(); | |
module2.exports = LongBits; | |
var util = require_minimal(); | |
function LongBits(lo, hi) { | |
this.lo = lo >>> 0; | |
this.hi = hi >>> 0; | |
} | |
var zero = LongBits.zero = new LongBits(0, 0); | |
zero.toNumber = function() { | |
return 0; | |
}; | |
zero.zzEncode = zero.zzDecode = function() { | |
return this; | |
}; | |
zero.length = function() { | |
return 1; | |
}; | |
var zeroHash = LongBits.zeroHash = "\0\0\0\0\0\0\0\0"; | |
LongBits.fromNumber = function fromNumber(value) { | |
if (value === 0) | |
return zero; | |
var sign = value < 0; | |
if (sign) | |
value = -value; | |
var lo = value >>> 0, hi = (value - lo) / 4294967296 >>> 0; | |
if (sign) { | |
hi = ~hi >>> 0; | |
lo = ~lo >>> 0; | |
if (++lo > 4294967295) { | |
lo = 0; | |
if (++hi > 4294967295) | |
hi = 0; | |
} | |
} | |
return new LongBits(lo, hi); | |
}; | |
LongBits.from = function from(value) { | |
if (typeof value === "number") | |
return LongBits.fromNumber(value); | |
if (util.isString(value)) { | |
if (util.Long) | |
value = util.Long.fromString(value); | |
else | |
return LongBits.fromNumber(parseInt(value, 10)); | |
} | |
return value.low || value.high ? new LongBits(value.low >>> 0, value.high >>> 0) : zero; | |
}; | |
LongBits.prototype.toNumber = function toNumber(unsigned) { | |
if (!unsigned && this.hi >>> 31) { | |
var lo = ~this.lo + 1 >>> 0, hi = ~this.hi >>> 0; | |
if (!lo) | |
hi = hi + 1 >>> 0; | |
return -(lo + hi * 4294967296); | |
} | |
return this.lo + this.hi * 4294967296; | |
}; | |
LongBits.prototype.toLong = function toLong(unsigned) { | |
return util.Long ? new util.Long(this.lo | 0, this.hi | 0, Boolean(unsigned)) : { low: this.lo | 0, high: this.hi | 0, unsigned: Boolean(unsigned) }; | |
}; | |
var charCodeAt = String.prototype.charCodeAt; | |
LongBits.fromHash = function fromHash(hash) { | |
if (hash === zeroHash) | |
return zero; | |
return new LongBits( | |
(charCodeAt.call(hash, 0) | charCodeAt.call(hash, 1) << 8 | charCodeAt.call(hash, 2) << 16 | charCodeAt.call(hash, 3) << 24) >>> 0, | |
(charCodeAt.call(hash, 4) | charCodeAt.call(hash, 5) << 8 | charCodeAt.call(hash, 6) << 16 | charCodeAt.call(hash, 7) << 24) >>> 0 | |
); | |
}; | |
LongBits.prototype.toHash = function toHash() { | |
return String.fromCharCode( | |
this.lo & 255, | |
this.lo >>> 8 & 255, | |
this.lo >>> 16 & 255, | |
this.lo >>> 24, | |
this.hi & 255, | |
this.hi >>> 8 & 255, | |
this.hi >>> 16 & 255, | |
this.hi >>> 24 | |
); | |
}; | |
LongBits.prototype.zzEncode = function zzEncode() { | |
var mask = this.hi >> 31; | |
this.hi = ((this.hi << 1 | this.lo >>> 31) ^ mask) >>> 0; | |
this.lo = (this.lo << 1 ^ mask) >>> 0; | |
return this; | |
}; | |
LongBits.prototype.zzDecode = function zzDecode() { | |
var mask = -(this.lo & 1); | |
this.lo = ((this.lo >>> 1 | this.hi << 31) ^ mask) >>> 0; | |
this.hi = (this.hi >>> 1 ^ mask) >>> 0; | |
return this; | |
}; | |
LongBits.prototype.length = function length() { | |
var part0 = this.lo, part1 = (this.lo >>> 28 | this.hi << 4) >>> 0, part2 = this.hi >>> 24; | |
return part2 === 0 ? part1 === 0 ? part0 < 16384 ? part0 < 128 ? 1 : 2 : part0 < 2097152 ? 3 : 4 : part1 < 16384 ? part1 < 128 ? 5 : 6 : part1 < 2097152 ? 7 : 8 : part2 < 128 ? 9 : 10; | |
}; | |
} | |
}); | |
// ../../node_modules/protobufjs/src/util/minimal.js | |
var require_minimal = __commonJS({ | |
"../../node_modules/protobufjs/src/util/minimal.js"(exports2) { | |
"use strict"; | |
init_cjs_shims(); | |
var util = exports2; | |
util.asPromise = require_aspromise(); | |
util.base64 = require_base64(); | |
util.EventEmitter = require_eventemitter(); | |
util.float = require_float(); | |
util.inquire = require_inquire(); | |
util.utf8 = require_utf8(); | |
util.pool = require_pool(); | |
util.LongBits = require_longbits(); | |
util.isNode = Boolean(typeof global !== "undefined" && global && global.process && global.process.versions && global.process.versions.node); | |
util.global = util.isNode && global || typeof window !== "undefined" && window || typeof self !== "undefined" && self || exports2; | |
util.emptyArray = Object.freeze ? Object.freeze([]) : ( | |
/* istanbul ignore next */ | |
[] | |
); | |
util.emptyObject = Object.freeze ? Object.freeze({}) : ( | |
/* istanbul ignore next */ | |
{} | |
); | |
util.isInteger = Number.isInteger || /* istanbul ignore next */ | |
function isInteger(value) { | |
return typeof value === "number" && isFinite(value) && Math.floor(value) === value; | |
}; | |
util.isString = function isString(value) { | |
return typeof value === "string" || value instanceof String; | |
}; | |
util.isObject = function isObject(value) { | |
return value && typeof value === "object"; | |
}; | |
util.isset = /** | |
* Checks if a property on a message is considered to be present. | |
* @param {Object} obj Plain object or message instance | |
* @param {string} prop Property name | |
* @returns {boolean} `true` if considered to be present, otherwise `false` | |
*/ | |
util.isSet = function isSet6(obj, prop) { | |
var value = obj[prop]; | |
if (value != null && obj.hasOwnProperty(prop)) | |
return typeof value !== "object" || (Array.isArray(value) ? value.length : Object.keys(value).length) > 0; | |
return false; | |
}; | |
util.Buffer = function() { | |
try { | |
var Buffer2 = util.inquire("buffer").Buffer; | |
return Buffer2.prototype.utf8Write ? Buffer2 : ( | |
/* istanbul ignore next */ | |
null | |
); | |
} catch (e) { | |
return null; | |
} | |
}(); | |
util._Buffer_from = null; | |
util._Buffer_allocUnsafe = null; | |
util.newBuffer = function newBuffer(sizeOrArray) { | |
return typeof sizeOrArray === "number" ? util.Buffer ? util._Buffer_allocUnsafe(sizeOrArray) : new util.Array(sizeOrArray) : util.Buffer ? util._Buffer_from(sizeOrArray) : typeof Uint8Array === "undefined" ? sizeOrArray : new Uint8Array(sizeOrArray); | |
}; | |
util.Array = typeof Uint8Array !== "undefined" ? Uint8Array : Array; | |
util.Long = /* istanbul ignore next */ | |
util.global.dcodeIO && /* istanbul ignore next */ | |
util.global.dcodeIO.Long || /* istanbul ignore next */ | |
util.global.Long || util.inquire("long"); | |
util.key2Re = /^true|false|0|1$/; | |
util.key32Re = /^-?(?:0|[1-9][0-9]*)$/; | |
util.key64Re = /^(?:[\\x00-\\xff]{8}|-?(?:0|[1-9][0-9]*))$/; | |
util.longToHash = function longToHash(value) { | |
return value ? util.LongBits.from(value).toHash() : util.LongBits.zeroHash; | |
}; | |
util.longFromHash = function longFromHash(hash, unsigned) { | |
var bits = util.LongBits.fromHash(hash); | |
if (util.Long) | |
return util.Long.fromBits(bits.lo, bits.hi, unsigned); | |
return bits.toNumber(Boolean(unsigned)); | |
}; | |
function merge(dst, src, ifNotSet) { | |
for (var keys = Object.keys(src), i = 0; i < keys.length; ++i) | |
if (dst[keys[i]] === void 0 || !ifNotSet) | |
dst[keys[i]] = src[keys[i]]; | |
return dst; | |
} | |
util.merge = merge; | |
util.lcFirst = function lcFirst(str) { | |
return str.charAt(0).toLowerCase() + str.substring(1); | |
}; | |
function newError(name) { | |
function CustomError(message, properties) { | |
if (!(this instanceof CustomError)) | |
return new CustomError(message, properties); | |
Object.defineProperty(this, "message", { get: function() { | |
return message; | |
} }); | |
if (Error.captureStackTrace) | |
Error.captureStackTrace(this, CustomError); | |
else | |
Object.defineProperty(this, "stack", { value: new Error().stack || "" }); | |
if (properties) | |
merge(this, properties); | |
} | |
(CustomError.prototype = Object.create(Error.prototype)).constructor = CustomError; | |
Object.defineProperty(CustomError.prototype, "name", { get: function() { | |
return name; | |
} }); | |
CustomError.prototype.toString = function toString() { | |
return this.name + ": " + this.message; | |
}; | |
return CustomError; | |
} | |
util.newError = newError; | |
util.ProtocolError = newError("ProtocolError"); | |
util.oneOfGetter = function getOneOf(fieldNames) { | |
var fieldMap = {}; | |
for (var i = 0; i < fieldNames.length; ++i) | |
fieldMap[fieldNames[i]] = 1; | |
return function() { | |
for (var keys = Object.keys(this), i2 = keys.length - 1; i2 > -1; --i2) | |
if (fieldMap[keys[i2]] === 1 && this[keys[i2]] !== void 0 && this[keys[i2]] !== null) | |
return keys[i2]; | |
}; | |
}; | |
util.oneOfSetter = function setOneOf(fieldNames) { | |
return function(name) { | |
for (var i = 0; i < fieldNames.length; ++i) | |
if (fieldNames[i] !== name) | |
delete this[fieldNames[i]]; | |
}; | |
}; | |
util.toJSONOptions = { | |
longs: String, | |
enums: String, | |
bytes: String, | |
json: true | |
}; | |
util._configure = function() { | |
var Buffer2 = util.Buffer; | |
if (!Buffer2) { | |
util._Buffer_from = util._Buffer_allocUnsafe = null; | |
return; | |
} | |
util._Buffer_from = Buffer2.from !== Uint8Array.from && Buffer2.from || /* istanbul ignore next */ | |
function Buffer_from(value, encoding) { | |
return new Buffer2(value, encoding); | |
}; | |
util._Buffer_allocUnsafe = Buffer2.allocUnsafe || /* istanbul ignore next */ | |
function Buffer_allocUnsafe(size) { | |
return new Buffer2(size); | |
}; | |
}; | |
} | |
}); | |
// ../../node_modules/protobufjs/src/writer.js | |
var require_writer = __commonJS({ | |
"../../node_modules/protobufjs/src/writer.js"(exports2, module2) { | |
"use strict"; | |
init_cjs_shims(); | |
module2.exports = Writer; | |
var util = require_minimal(); | |
var BufferWriter; | |
var LongBits = util.LongBits; | |
var base64 = util.base64; | |
var utf8 = util.utf8; | |
function Op(fn, len, val) { | |
this.fn = fn; | |
this.len = len; | |
this.next = void 0; | |
this.val = val; | |
} | |
function noop() { | |
} | |
function State(writer) { | |
this.head = writer.head; | |
this.tail = writer.tail; | |
this.len = writer.len; | |
this.next = writer.states; | |
} | |
function Writer() { | |
this.len = 0; | |
this.head = new Op(noop, 0, 0); | |
this.tail = this.head; | |
this.states = null; | |
} | |
var create = function create2() { | |
return util.Buffer ? function create_buffer_setup() { | |
return (Writer.create = function create_buffer() { | |
return new BufferWriter(); | |
})(); | |
} : function create_array() { | |
return new Writer(); | |
}; | |
}; | |
Writer.create = create(); | |
Writer.alloc = function alloc(size) { | |
return new util.Array(size); | |
}; | |
if (util.Array !== Array) | |
Writer.alloc = util.pool(Writer.alloc, util.Array.prototype.subarray); | |
Writer.prototype._push = function push(fn, len, val) { | |
this.tail = this.tail.next = new Op(fn, len, val); | |
this.len += len; | |
return this; | |
}; | |
function writeByte(val, buf, pos) { | |
buf[pos] = val & 255; | |
} | |
function writeVarint32(val, buf, pos) { | |
while (val > 127) { | |
buf[pos++] = val & 127 | 128; | |
val >>>= 7; | |
} | |
buf[pos] = val; | |
} | |
function VarintOp(len, val) { | |
this.len = len; | |
this.next = void 0; | |
this.val = val; | |
} | |
VarintOp.prototype = Object.create(Op.prototype); | |
VarintOp.prototype.fn = writeVarint32; | |
Writer.prototype.uint32 = function write_uint32(value) { | |
this.len += (this.tail = this.tail.next = new VarintOp( | |
(value = value >>> 0) < 128 ? 1 : value < 16384 ? 2 : value < 2097152 ? 3 : value < 268435456 ? 4 : 5, | |
value | |
)).len; | |
return this; | |
}; | |
Writer.prototype.int32 = function write_int32(value) { | |
return value < 0 ? this._push(writeVarint64, 10, LongBits.fromNumber(value)) : this.uint32(value); | |
}; | |
Writer.prototype.sint32 = function write_sint32(value) { | |
return this.uint32((value << 1 ^ value >> 31) >>> 0); | |
}; | |
function writeVarint64(val, buf, pos) { | |
while (val.hi) { | |
buf[pos++] = val.lo & 127 | 128; | |
val.lo = (val.lo >>> 7 | val.hi << 25) >>> 0; | |
val.hi >>>= 7; | |
} | |
while (val.lo > 127) { | |
buf[pos++] = val.lo & 127 | 128; | |
val.lo = val.lo >>> 7; | |
} | |
buf[pos++] = val.lo; | |
} | |
Writer.prototype.uint64 = function write_uint64(value) { | |
var bits = LongBits.from(value); | |
return this._push(writeVarint64, bits.length(), bits); | |
}; | |
Writer.prototype.int64 = Writer.prototype.uint64; | |
Writer.prototype.sint64 = function write_sint64(value) { | |
var bits = LongBits.from(value).zzEncode(); | |
return this._push(writeVarint64, bits.length(), bits); | |
}; | |
Writer.prototype.bool = function write_bool(value) { | |
return this._push(writeByte, 1, value ? 1 : 0); | |
}; | |
function writeFixed32(val, buf, pos) { | |
buf[pos] = val & 255; | |
buf[pos + 1] = val >>> 8 & 255; | |
buf[pos + 2] = val >>> 16 & 255; | |
buf[pos + 3] = val >>> 24; | |
} | |
Writer.prototype.fixed32 = function write_fixed32(value) { | |
return this._push(writeFixed32, 4, value >>> 0); | |
}; | |
Writer.prototype.sfixed32 = Writer.prototype.fixed32; | |
Writer.prototype.fixed64 = function write_fixed64(value) { | |
var bits = LongBits.from(value); | |
return this._push(writeFixed32, 4, bits.lo)._push(writeFixed32, 4, bits.hi); | |
}; | |
Writer.prototype.sfixed64 = Writer.prototype.fixed64; | |
Writer.prototype.float = function write_float(value) { | |
return this._push(util.float.writeFloatLE, 4, value); | |
}; | |
Writer.prototype.double = function write_double(value) { | |
return this._push(util.float.writeDoubleLE, 8, value); | |
}; | |
var writeBytes = util.Array.prototype.set ? function writeBytes_set(val, buf, pos) { | |
buf.set(val, pos); | |
} : function writeBytes_for(val, buf, pos) { | |
for (var i = 0; i < val.length; ++i) | |
buf[pos + i] = val[i]; | |
}; | |
Writer.prototype.bytes = function write_bytes(value) { | |
var len = value.length >>> 0; | |
if (!len) | |
return this._push(writeByte, 1, 0); | |
if (util.isString(value)) { | |
var buf = Writer.alloc(len = base64.length(value)); | |
base64.decode(value, buf, 0); | |
value = buf; | |
} | |
return this.uint32(len)._push(writeBytes, len, value); | |
}; | |
Writer.prototype.string = function write_string(value) { | |
var len = utf8.length(value); | |
return len ? this.uint32(len)._push(utf8.write, len, value) : this._push(writeByte, 1, 0); | |
}; | |
Writer.prototype.fork = function fork() { | |
this.states = new State(this); | |
this.head = this.tail = new Op(noop, 0, 0); | |
this.len = 0; | |
return this; | |
}; | |
Writer.prototype.reset = function reset() { | |
if (this.states) { | |
this.head = this.states.head; | |
this.tail = this.states.tail; | |
this.len = this.states.len; | |
this.states = this.states.next; | |
} else { | |
this.head = this.tail = new Op(noop, 0, 0); | |
this.len = 0; | |
} | |
return this; | |
}; | |
Writer.prototype.ldelim = function ldelim() { | |
var head = this.head, tail = this.tail, len = this.len; | |
this.reset().uint32(len); | |
if (len) { | |
this.tail.next = head.next; | |
this.tail = tail; | |
this.len += len; | |
} | |
return this; | |
}; | |
Writer.prototype.finish = function finish() { | |
var head = this.head.next, buf = this.constructor.alloc(this.len), pos = 0; | |
while (head) { | |
head.fn(head.val, buf, pos); | |
pos += head.len; | |
head = head.next; | |
} | |
return buf; | |
}; | |
Writer._configure = function(BufferWriter_) { | |
BufferWriter = BufferWriter_; | |
Writer.create = create(); | |
BufferWriter._configure(); | |
}; | |
} | |
}); | |
// ../../node_modules/protobufjs/src/writer_buffer.js | |
var require_writer_buffer = __commonJS({ | |
"../../node_modules/protobufjs/src/writer_buffer.js"(exports2, module2) { | |
"use strict"; | |
init_cjs_shims(); | |
module2.exports = BufferWriter; | |
var Writer = require_writer(); | |
(BufferWriter.prototype = Object.create(Writer.prototype)).constructor = BufferWriter; | |
var util = require_minimal(); | |
function BufferWriter() { | |
Writer.call(this); | |
} | |
BufferWriter._configure = function() { | |
BufferWriter.alloc = util._Buffer_allocUnsafe; | |
BufferWriter.writeBytesBuffer = util.Buffer && util.Buffer.prototype instanceof Uint8Array && util.Buffer.prototype.set.name === "set" ? function writeBytesBuffer_set(val, buf, pos) { | |
buf.set(val, pos); | |
} : function writeBytesBuffer_copy(val, buf, pos) { | |
if (val.copy) | |
val.copy(buf, pos, 0, val.length); | |
else | |
for (var i = 0; i < val.length; ) | |
buf[pos++] = val[i++]; | |
}; | |
}; | |
BufferWriter.prototype.bytes = function write_bytes_buffer(value) { | |
if (util.isString(value)) | |
value = util._Buffer_from(value, "base64"); | |
var len = value.length >>> 0; | |
this.uint32(len); | |
if (len) | |
this._push(BufferWriter.writeBytesBuffer, len, value); | |
return this; | |
}; | |
function writeStringBuffer(val, buf, pos) { | |
if (val.length < 40) | |
util.utf8.write(val, buf, pos); | |
else if (buf.utf8Write) | |
buf.utf8Write(val, pos); | |
else | |
buf.write(val, pos); | |
} | |
BufferWriter.prototype.string = function write_string_buffer(value) { | |
var len = util.Buffer.byteLength(value); | |
this.uint32(len); | |
if (len) | |
this._push(writeStringBuffer, len, value); | |
return this; | |
}; | |
BufferWriter._configure(); | |
} | |
}); | |
// ../../node_modules/protobufjs/src/reader.js | |
var require_reader = __commonJS({ | |
"../../node_modules/protobufjs/src/reader.js"(exports2, module2) { | |
"use strict"; | |
init_cjs_shims(); | |
module2.exports = Reader; | |
var util = require_minimal(); | |
var BufferReader; | |
var LongBits = util.LongBits; | |
var utf8 = util.utf8; | |
function indexOutOfRange(reader, writeLength) { | |
return RangeError("index out of range: " + reader.pos + " + " + (writeLength || 1) + " > " + reader.len); | |
} | |
function Reader(buffer) { | |
this.buf = buffer; | |
this.pos = 0; | |
this.len = buffer.length; | |
} | |
var create_array = typeof Uint8Array !== "undefined" ? function create_typed_array(buffer) { | |
if (buffer instanceof Uint8Array || Array.isArray(buffer)) | |
return new Reader(buffer); | |
throw Error("illegal buffer"); | |
} : function create_array2(buffer) { | |
if (Array.isArray(buffer)) | |
return new Reader(buffer); | |
throw Error("illegal buffer"); | |
}; | |
var create = function create2() { | |
return util.Buffer ? function create_buffer_setup(buffer) { | |
return (Reader.create = function create_buffer(buffer2) { | |
return util.Buffer.isBuffer(buffer2) ? new BufferReader(buffer2) : create_array(buffer2); | |
})(buffer); | |
} : create_array; | |
}; | |
Reader.create = create(); | |
Reader.prototype._slice = util.Array.prototype.subarray || /* istanbul ignore next */ | |
util.Array.prototype.slice; | |
Reader.prototype.uint32 = function read_uint32_setup() { | |
var value = 4294967295; | |
return function read_uint32() { | |
value = (this.buf[this.pos] & 127) >>> 0; | |
if (this.buf[this.pos++] < 128) | |
return value; | |
value = (value | (this.buf[this.pos] & 127) << 7) >>> 0; | |
if (this.buf[this.pos++] < 128) | |
return value; | |
value = (value | (this.buf[this.pos] & 127) << 14) >>> 0; | |
if (this.buf[this.pos++] < 128) | |
return value; | |
value = (value | (this.buf[this.pos] & 127) << 21) >>> 0; | |
if (this.buf[this.pos++] < 128) | |
return value; | |
value = (value | (this.buf[this.pos] & 15) << 28) >>> 0; | |
if (this.buf[this.pos++] < 128) | |
return value; | |
if ((this.pos += 5) > this.len) { | |
this.pos = this.len; | |
throw indexOutOfRange(this, 10); | |
} | |
return value; | |
}; | |
}(); | |
Reader.prototype.int32 = function read_int32() { | |
return this.uint32() | 0; | |
}; | |
Reader.prototype.sint32 = function read_sint32() { | |
var value = this.uint32(); | |
return value >>> 1 ^ -(value & 1) | 0; | |
}; | |
function readLongVarint() { | |
var bits = new LongBits(0, 0); | |
var i = 0; | |
if (this.len - this.pos > 4) { | |
for (; i < 4; ++i) { | |
bits.lo = (bits.lo | (this.buf[this.pos] & 127) << i * 7) >>> 0; | |
if (this.buf[this.pos++] < 128) | |
return bits; | |
} | |
bits.lo = (bits.lo | (this.buf[this.pos] & 127) << 28) >>> 0; | |
bits.hi = (bits.hi | (this.buf[this.pos] & 127) >> 4) >>> 0; | |
if (this.buf[this.pos++] < 128) | |
return bits; | |
i = 0; | |
} else { | |
for (; i < 3; ++i) { | |
if (this.pos >= this.len) | |
throw indexOutOfRange(this); | |
bits.lo = (bits.lo | (this.buf[this.pos] & 127) << i * 7) >>> 0; | |
if (this.buf[this.pos++] < 128) | |
return bits; | |
} | |
bits.lo = (bits.lo | (this.buf[this.pos++] & 127) << i * 7) >>> 0; | |
return bits; | |
} | |
if (this.len - this.pos > 4) { | |
for (; i < 5; ++i) { | |
bits.hi = (bits.hi | (this.buf[this.pos] & 127) << i * 7 + 3) >>> 0; | |
if (this.buf[this.pos++] < 128) | |
return bits; | |
} | |
} else { | |
for (; i < 5; ++i) { | |
if (this.pos >= this.len) | |
throw indexOutOfRange(this); | |
bits.hi = (bits.hi | (this.buf[this.pos] & 127) << i * 7 + 3) >>> 0; | |
if (this.buf[this.pos++] < 128) | |
return bits; | |
} | |
} | |
throw Error("invalid varint encoding"); | |
} | |
Reader.prototype.bool = function read_bool() { | |
return this.uint32() !== 0; | |
}; | |
function readFixed32_end(buf, end) { | |
return (buf[end - 4] | buf[end - 3] << 8 | buf[end - 2] << 16 | buf[end - 1] << 24) >>> 0; | |
} | |
Reader.prototype.fixed32 = function read_fixed32() { | |
if (this.pos + 4 > this.len) | |
throw indexOutOfRange(this, 4); | |
return readFixed32_end(this.buf, this.pos += 4); | |
}; | |
Reader.prototype.sfixed32 = function read_sfixed32() { | |
if (this.pos + 4 > this.len) | |
throw indexOutOfRange(this, 4); | |
return readFixed32_end(this.buf, this.pos += 4) | 0; | |
}; | |
function readFixed64() { | |
if (this.pos + 8 > this.len) | |
throw indexOutOfRange(this, 8); | |
return new LongBits(readFixed32_end(this.buf, this.pos += 4), readFixed32_end(this.buf, this.pos += 4)); | |
} | |
Reader.prototype.float = function read_float() { | |
if (this.pos + 4 > this.len) | |
throw indexOutOfRange(this, 4); | |
var value = util.float.readFloatLE(this.buf, this.pos); | |
this.pos += 4; | |
return value; | |
}; | |
Reader.prototype.double = function read_double() { | |
if (this.pos + 8 > this.len) | |
throw indexOutOfRange(this, 4); | |
var value = util.float.readDoubleLE(this.buf, this.pos); | |
this.pos += 8; | |
return value; | |
}; | |
Reader.prototype.bytes = function read_bytes() { | |
var length = this.uint32(), start = this.pos, end = this.pos + length; | |
if (end > this.len) | |
throw indexOutOfRange(this, length); | |
this.pos += length; | |
if (Array.isArray(this.buf)) | |
return this.buf.slice(start, end); | |
return start === end ? new this.buf.constructor(0) : this._slice.call(this.buf, start, end); | |
}; | |
Reader.prototype.string = function read_string() { | |
var bytes = this.bytes(); | |
return utf8.read(bytes, 0, bytes.length); | |
}; | |
Reader.prototype.skip = function skip(length) { | |
if (typeof length === "number") { | |
if (this.pos + length > this.len) | |
throw indexOutOfRange(this, length); | |
this.pos += length; | |
} else { | |
do { | |
if (this.pos >= this.len) | |
throw indexOutOfRange(this); | |
} while (this.buf[this.pos++] & 128); | |
} | |
return this; | |
}; | |
Reader.prototype.skipType = function(wireType) { | |
switch (wireType) { | |
case 0: | |
this.skip(); | |
break; | |
case 1: | |
this.skip(8); | |
break; | |
case 2: | |
this.skip(this.uint32()); | |
break; | |
case 3: | |
while ((wireType = this.uint32() & 7) !== 4) { | |
this.skipType(wireType); | |
} | |
break; | |
case 5: | |
this.skip(4); | |
break; | |
default: | |
throw Error("invalid wire type " + wireType + " at offset " + this.pos); | |
} | |
return this; | |
}; | |
Reader._configure = function(BufferReader_) { | |
BufferReader = BufferReader_; | |
Reader.create = create(); | |
BufferReader._configure(); | |
var fn = util.Long ? "toLong" : ( | |
/* istanbul ignore next */ | |
"toNumber" | |
); | |
util.merge(Reader.prototype, { | |
int64: function read_int64() { | |
return readLongVarint.call(this)[fn](false); | |
}, | |
uint64: function read_uint64() { | |
return readLongVarint.call(this)[fn](true); | |
}, | |
sint64: function read_sint64() { | |
return readLongVarint.call(this).zzDecode()[fn](false); | |
}, | |
fixed64: function read_fixed64() { | |
return readFixed64.call(this)[fn](true); | |
}, | |
sfixed64: function read_sfixed64() { | |
return readFixed64.call(this)[fn](false); | |
} | |
}); | |
}; | |
} | |
}); | |
// ../../node_modules/protobufjs/src/reader_buffer.js | |
var require_reader_buffer = __commonJS({ | |
"../../node_modules/protobufjs/src/reader_buffer.js"(exports2, module2) { | |
"use strict"; | |
init_cjs_shims(); | |
module2.exports = BufferReader; | |
var Reader = require_reader(); | |
(BufferReader.prototype = Object.create(Reader.prototype)).constructor = BufferReader; | |
var util = require_minimal(); | |
function BufferReader(buffer) { | |
Reader.call(this, buffer); | |
} | |
BufferReader._configure = function() { | |
if (util.Buffer) | |
BufferReader.prototype._slice = util.Buffer.prototype.slice; | |
}; | |
BufferReader.prototype.string = function read_string_buffer() { | |
var len = this.uint32(); | |
return this.buf.utf8Slice ? this.buf.utf8Slice(this.pos, this.pos = Math.min(this.pos + len, this.len)) : this.buf.toString("utf-8", this.pos, this.pos = Math.min(this.pos + len, this.len)); | |
}; | |
BufferReader._configure(); | |
} | |
}); | |
// ../../node_modules/protobufjs/src/rpc/service.js | |
var require_service = __commonJS({ | |
"../../node_modules/protobufjs/src/rpc/service.js"(exports2, module2) { | |
"use strict"; | |
init_cjs_shims(); | |
module2.exports = Service; | |
var util = require_minimal(); | |
(Service.prototype = Object.create(util.EventEmitter.prototype)).constructor = Service; | |
function Service(rpcImpl, requestDelimited, responseDelimited) { | |
if (typeof rpcImpl !== "function") | |
throw TypeError("rpcImpl must be a function"); | |
util.EventEmitter.call(this); | |
this.rpcImpl = rpcImpl; | |
this.requestDelimited = Boolean(requestDelimited); | |
this.responseDelimited = Boolean(responseDelimited); | |
} | |
Service.prototype.rpcCall = function rpcCall(method, requestCtor, responseCtor, request, callback) { | |
if (!request) | |
throw TypeError("request must be specified"); | |
var self2 = this; | |
if (!callback) | |
return util.asPromise(rpcCall, self2, method, requestCtor, responseCtor, request); | |
if (!self2.rpcImpl) { | |
setTimeout(function() { | |
callback(Error("already ended")); | |
}, 0); | |
return void 0; | |
} | |
try { | |
return self2.rpcImpl( | |
method, | |
requestCtor[self2.requestDelimited ? "encodeDelimited" : "encode"](request).finish(), | |
function rpcCallback(err2, response) { | |
if (err2) { | |
self2.emit("error", err2, method); | |
return callback(err2); | |
} | |
if (response === null) { | |
self2.end( | |
/* endedByRPC */ | |
true | |
); | |
return void 0; | |
} | |
if (!(response instanceof responseCtor)) { | |
try { | |
response = responseCtor[self2.responseDelimited ? "decodeDelimited" : "decode"](response); | |
} catch (err3) { | |
self2.emit("error", err3, method); | |
return callback(err3); | |
} | |
} | |
self2.emit("data", response, method); | |
return callback(null, response); | |
} | |
); | |
} catch (err2) { | |
self2.emit("error", err2, method); | |
setTimeout(function() { | |
callback(err2); | |
}, 0); | |
return void 0; | |
} | |
}; | |
Service.prototype.end = function end(endedByRPC) { | |
if (this.rpcImpl) { | |
if (!endedByRPC) | |
this.rpcImpl(null, null, null); | |
this.rpcImpl = null; | |
this.emit("end").off(); | |
} | |
return this; | |
}; | |
} | |
}); | |
// ../../node_modules/protobufjs/src/rpc.js | |
var require_rpc = __commonJS({ | |
"../../node_modules/protobufjs/src/rpc.js"(exports2) { | |
"use strict"; | |
init_cjs_shims(); | |
var rpc = exports2; | |
rpc.Service = require_service(); | |
} | |
}); | |
// ../../node_modules/protobufjs/src/roots.js | |
var require_roots = __commonJS({ | |
"../../node_modules/protobufjs/src/roots.js"(exports2, module2) { | |
"use strict"; | |
init_cjs_shims(); | |
module2.exports = {}; | |
} | |
}); | |
// ../../node_modules/protobufjs/src/index-minimal.js | |
var require_index_minimal = __commonJS({ | |
"../../node_modules/protobufjs/src/index-minimal.js"(exports2) { | |
"use strict"; | |
init_cjs_shims(); | |
var protobuf = exports2; | |
protobuf.build = "minimal"; | |
protobuf.Writer = require_writer(); | |
protobuf.BufferWriter = require_writer_buffer(); | |
protobuf.Reader = require_reader(); | |
protobuf.BufferReader = require_reader_buffer(); | |
protobuf.util = require_minimal(); | |
protobuf.rpc = require_rpc(); | |
protobuf.roots = require_roots(); | |
protobuf.configure = configure; | |
function configure() { | |
protobuf.util._configure(); | |
protobuf.Writer._configure(protobuf.BufferWriter); | |
protobuf.Reader._configure(protobuf.BufferReader); | |
} | |
configure(); | |
} | |
}); | |
// ../../node_modules/protobufjs/minimal.js | |
var require_minimal2 = __commonJS({ | |
"../../node_modules/protobufjs/minimal.js"(exports2, module2) { | |
"use strict"; | |
init_cjs_shims(); | |
module2.exports = require_index_minimal(); | |
} | |
}); | |
// src/index.ts | |
var src_exports = {}; | |
__export(src_exports, { | |
AdminServiceClientImpl: () => AdminServiceClientImpl, | |
AdminServiceDeleteAllMessagesFromDbDesc: () => AdminServiceDeleteAllMessagesFromDbDesc, | |
AdminServiceDesc: () => AdminServiceDesc, | |
AdminServiceRebuildSyncTrieDesc: () => AdminServiceRebuildSyncTrieDesc, | |
AdminServiceSubmitIdRegistryEventDesc: () => AdminServiceSubmitIdRegistryEventDesc, | |
AdminServiceSubmitNameRegistryEventDesc: () => AdminServiceSubmitNameRegistryEventDesc, | |
GrpcWebError: () => GrpcWebError, | |
GrpcWebImpl: () => GrpcWebImpl, | |
HubServiceClientImpl: () => HubServiceClientImpl, | |
HubServiceDesc: () => HubServiceDesc, | |
HubServiceGetAllCastMessagesByFidDesc: () => HubServiceGetAllCastMessagesByFidDesc, | |
HubServiceGetAllMessagesBySyncIdsDesc: () => HubServiceGetAllMessagesBySyncIdsDesc, | |
HubServiceGetAllReactionMessagesByFidDesc: () => HubServiceGetAllReactionMessagesByFidDesc, | |
HubServiceGetAllSignerMessagesByFidDesc: () => HubServiceGetAllSignerMessagesByFidDesc, | |
HubServiceGetAllSyncIdsByPrefixDesc: () => HubServiceGetAllSyncIdsByPrefixDesc, | |
HubServiceGetAllUserDataMessagesByFidDesc: () => HubServiceGetAllUserDataMessagesByFidDesc, | |
HubServiceGetAllVerificationMessagesByFidDesc: () => HubServiceGetAllVerificationMessagesByFidDesc, | |
HubServiceGetCastDesc: () => HubServiceGetCastDesc, | |
HubServiceGetCastsByFidDesc: () => HubServiceGetCastsByFidDesc, | |
HubServiceGetCastsByMentionDesc: () => HubServiceGetCastsByMentionDesc, | |
HubServiceGetCastsByParentDesc: () => HubServiceGetCastsByParentDesc, | |
HubServiceGetEventDesc: () => HubServiceGetEventDesc, | |
HubServiceGetFidsDesc: () => HubServiceGetFidsDesc, | |
HubServiceGetIdRegistryEventByAddressDesc: () => HubServiceGetIdRegistryEventByAddressDesc, | |
HubServiceGetIdRegistryEventDesc: () => HubServiceGetIdRegistryEventDesc, | |
HubServiceGetInfoDesc: () => HubServiceGetInfoDesc, | |
HubServiceGetNameRegistryEventDesc: () => HubServiceGetNameRegistryEventDesc, | |
HubServiceGetReactionDesc: () => HubServiceGetReactionDesc, | |
HubServiceGetReactionsByCastDesc: () => HubServiceGetReactionsByCastDesc, | |
HubServiceGetReactionsByFidDesc: () => HubServiceGetReactionsByFidDesc, | |
HubServiceGetSignerDesc: () => HubServiceGetSignerDesc, | |
HubServiceGetSignersByFidDesc: () => HubServiceGetSignersByFidDesc, | |
HubServiceGetSyncMetadataByPrefixDesc: () => HubServiceGetSyncMetadataByPrefixDesc, | |
HubServiceGetSyncSnapshotByPrefixDesc: () => HubServiceGetSyncSnapshotByPrefixDesc, | |
HubServiceGetUserDataByFidDesc: () => HubServiceGetUserDataByFidDesc, | |
HubServiceGetUserDataDesc: () => HubServiceGetUserDataDesc, | |
HubServiceGetVerificationDesc: () => HubServiceGetVerificationDesc, | |
HubServiceGetVerificationsByFidDesc: () => HubServiceGetVerificationsByFidDesc, | |
HubServiceSubmitMessageDesc: () => HubServiceSubmitMessageDesc, | |
HubServiceSubscribeDesc: () => HubServiceSubscribeDesc, | |
Observable: () => import_rxjs2.Observable, | |
getAdminRpcClient: () => getAdminRpcClient, | |
getAuthMetadata: () => getAuthMetadata, | |
getHubRpcClient: () => getHubRpcClient | |
}); | |
module.exports = __toCommonJS(src_exports); | |
init_cjs_shims(); | |
__reExport(src_exports, require("@farcaster/core"), module.exports); | |
// src/generated/rpc.ts | |
init_cjs_shims(); | |
var import_grpc_web = __toESM(require("@improbable-eng/grpc-web")); | |
var import_browser_headers = __toESM(require_browser_headers()); | |
var import_rxjs = require("rxjs"); | |
var import_operators = require("rxjs/operators"); | |
// src/generated/hub_event.ts | |
init_cjs_shims(); | |
var import_long3 = __toESM(require_long()); | |
var import_minimal4 = __toESM(require_minimal2()); | |
// src/generated/id_registry_event.ts | |
init_cjs_shims(); | |
var import_long = __toESM(require_long()); | |
var import_minimal = __toESM(require_minimal2()); | |
function idRegistryEventTypeFromJSON(object) { | |
switch (object) { | |
case 0: | |
case "ID_REGISTRY_EVENT_TYPE_NONE": | |
return 0 /* NONE */; | |
case 1: | |
case "ID_REGISTRY_EVENT_TYPE_REGISTER": | |
return 1 /* REGISTER */; | |
case 2: | |
case "ID_REGISTRY_EVENT_TYPE_TRANSFER": | |
return 2 /* TRANSFER */; | |
default: | |
throw new tsProtoGlobalThis.Error("Unrecognized enum value " + object + " for enum IdRegistryEventType"); | |
} | |
} | |
function idRegistryEventTypeToJSON(object) { | |
switch (object) { | |
case 0 /* NONE */: | |
return "ID_REGISTRY_EVENT_TYPE_NONE"; | |
case 1 /* REGISTER */: | |
return "ID_REGISTRY_EVENT_TYPE_REGISTER"; | |
case 2 /* TRANSFER */: | |
return "ID_REGISTRY_EVENT_TYPE_TRANSFER"; | |
default: | |
throw new tsProtoGlobalThis.Error("Unrecognized enum value " + object + " for enum IdRegistryEventType"); | |
} | |
} | |
function createBaseIdRegistryEvent() { | |
return { | |
blockNumber: 0, | |
blockHash: new Uint8Array(), | |
transactionHash: new Uint8Array(), | |
logIndex: 0, | |
fid: 0, | |
to: new Uint8Array(), | |
type: 0, | |
from: new Uint8Array() | |
}; | |
} | |
var IdRegistryEvent = { | |
encode(message, writer = import_minimal.default.Writer.create()) { | |
if (message.blockNumber !== 0) { | |
writer.uint32(8).uint32(message.blockNumber); | |
} | |
if (message.blockHash.length !== 0) { | |
writer.uint32(18).bytes(message.blockHash); | |
} | |
if (message.transactionHash.length !== 0) { | |
writer.uint32(26).bytes(message.transactionHash); | |
} | |
if (message.logIndex !== 0) { | |
writer.uint32(32).uint32(message.logIndex); | |
} | |
if (message.fid !== 0) { | |
writer.uint32(40).uint64(message.fid); | |
} | |
if (message.to.length !== 0) { | |
writer.uint32(50).bytes(message.to); | |
} | |
if (message.type !== 0) { | |
writer.uint32(56).int32(message.type); | |
} | |
if (message.from.length !== 0) { | |
writer.uint32(66).bytes(message.from); | |
} | |
return writer; | |
}, | |
decode(input, length) { | |
const reader = input instanceof import_minimal.default.Reader ? input : import_minimal.default.Reader.create(input); | |
let end = length === void 0 ? reader.len : reader.pos + length; | |
const message = createBaseIdRegistryEvent(); | |
while (reader.pos < end) { | |
const tag = reader.uint32(); | |
switch (tag >>> 3) { | |
case 1: | |
if (tag != 8) { | |
break; | |
} | |
message.blockNumber = reader.uint32(); | |
continue; | |
case 2: | |
if (tag != 18) { | |
break; | |
} | |
message.blockHash = reader.bytes(); | |
continue; | |
case 3: | |
if (tag != 26) { | |
break; | |
} | |
message.transactionHash = reader.bytes(); | |
continue; | |
case 4: | |
if (tag != 32) { | |
break; | |
} | |
message.logIndex = reader.uint32(); | |
continue; | |
case 5: | |
if (tag != 40) { | |
break; | |
} | |
message.fid = longToNumber(reader.uint64()); | |
continue; | |
case 6: | |
if (tag != 50) { | |
break; | |
} | |
message.to = reader.bytes(); | |
continue; | |
case 7: | |
if (tag != 56) { | |
break; | |
} | |
message.type = reader.int32(); | |
continue; | |
case 8: | |
if (tag != 66) { | |
break; | |
} | |
message.from = reader.bytes(); | |
continue; | |
} | |
if ((tag & 7) == 4 || tag == 0) { | |
break; | |
} | |
reader.skipType(tag & 7); | |
} | |
return message; | |
}, | |
fromJSON(object) { | |
return { | |
blockNumber: isSet(object.blockNumber) ? Number(object.blockNumber) : 0, | |
blockHash: isSet(object.blockHash) ? bytesFromBase64(object.blockHash) : new Uint8Array(), | |
transactionHash: isSet(object.transactionHash) ? bytesFromBase64(object.transactionHash) : new Uint8Array(), | |
logIndex: isSet(object.logIndex) ? Number(object.logIndex) : 0, | |
fid: isSet(object.fid) ? Number(object.fid) : 0, | |
to: isSet(object.to) ? bytesFromBase64(object.to) : new Uint8Array(), | |
type: isSet(object.type) ? idRegistryEventTypeFromJSON(object.type) : 0, | |
from: isSet(object.from) ? bytesFromBase64(object.from) : new Uint8Array() | |
}; | |
}, | |
toJSON(message) { | |
const obj = {}; | |
message.blockNumber !== void 0 && (obj.blockNumber = Math.round(message.blockNumber)); | |
message.blockHash !== void 0 && (obj.blockHash = base64FromBytes(message.blockHash !== void 0 ? message.blockHash : new Uint8Array())); | |
message.transactionHash !== void 0 && (obj.transactionHash = base64FromBytes( | |
message.transactionHash !== void 0 ? message.transactionHash : new Uint8Array() | |
)); | |
message.logIndex !== void 0 && (obj.logIndex = Math.round(message.logIndex)); | |
message.fid !== void 0 && (obj.fid = Math.round(message.fid)); | |
message.to !== void 0 && (obj.to = base64FromBytes(message.to !== void 0 ? message.to : new Uint8Array())); | |
message.type !== void 0 && (obj.type = idRegistryEventTypeToJSON(message.type)); | |
message.from !== void 0 && (obj.from = base64FromBytes(message.from !== void 0 ? message.from : new Uint8Array())); | |
return obj; | |
}, | |
create(base) { | |
return IdRegistryEvent.fromPartial(base != null ? base : {}); | |
}, | |
fromPartial(object) { | |
var _a, _b, _c, _d, _e, _f, _g, _h; | |
const message = createBaseIdRegistryEvent(); | |
message.blockNumber = (_a = object.blockNumber) != null ? _a : 0; | |
message.blockHash = (_b = object.blockHash) != null ? _b : new Uint8Array(); | |
message.transactionHash = (_c = object.transactionHash) != null ? _c : new Uint8Array(); | |
message.logIndex = (_d = object.logIndex) != null ? _d : 0; | |
message.fid = (_e = object.fid) != null ? _e : 0; | |
message.to = (_f = object.to) != null ? _f : new Uint8Array(); | |
message.type = (_g = object.type) != null ? _g : 0; | |
message.from = (_h = object.from) != null ? _h : new Uint8Array(); | |
return message; | |
} | |
}; | |
var tsProtoGlobalThis = (() => { | |
if (typeof globalThis !== "undefined") { | |
return globalThis; | |
} | |
if (typeof self !== "undefined") { | |
return self; | |
} | |
if (typeof window !== "undefined") { | |
return window; | |
} | |
if (typeof global !== "undefined") { | |
return global; | |
} | |
throw "Unable to locate global object"; | |
})(); | |
function bytesFromBase64(b64) { | |
if (tsProtoGlobalThis.Buffer) { | |
return Uint8Array.from(tsProtoGlobalThis.Buffer.from(b64, "base64")); | |
} else { | |
const bin = tsProtoGlobalThis.atob(b64); | |
const arr = new Uint8Array(bin.length); | |
for (let i = 0; i < bin.length; ++i) { | |
arr[i] = bin.charCodeAt(i); | |
} | |
return arr; | |
} | |
} | |
function base64FromBytes(arr) { | |
if (tsProtoGlobalThis.Buffer) { | |
return tsProtoGlobalThis.Buffer.from(arr).toString("base64"); | |
} else { | |
const bin = []; | |
arr.forEach((byte) => { | |
bin.push(String.fromCharCode(byte)); | |
}); | |
return tsProtoGlobalThis.btoa(bin.join("")); | |
} | |
} | |
function longToNumber(long) { | |
if (long.gt(Number.MAX_SAFE_INTEGER)) { | |
throw new tsProtoGlobalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER"); | |
} | |
return long.toNumber(); | |
} | |
if (import_minimal.default.util.Long !== import_long.default) { | |
import_minimal.default.util.Long = import_long.default; | |
import_minimal.default.configure(); | |
} | |
function isSet(value) { | |
return value !== null && value !== void 0; | |
} | |
// src/generated/message.ts | |
init_cjs_shims(); | |
var import_long2 = __toESM(require_long()); | |
var import_minimal2 = __toESM(require_minimal2()); | |
function hashSchemeFromJSON(object) { | |
switch (object) { | |
case 0: | |
case "HASH_SCHEME_NONE": | |
return 0 /* NONE */; | |
case 1: | |
case "HASH_SCHEME_BLAKE3": | |
return 1 /* BLAKE3 */; | |
default: | |
throw new tsProtoGlobalThis2.Error("Unrecognized enum value " + object + " for enum HashScheme"); | |
} | |
} | |
function hashSchemeToJSON(object) { | |
switch (object) { | |
case 0 /* NONE */: | |
return "HASH_SCHEME_NONE"; | |
case 1 /* BLAKE3 */: | |
return "HASH_SCHEME_BLAKE3"; | |
default: | |
throw new tsProtoGlobalThis2.Error("Unrecognized enum value " + object + " for enum HashScheme"); | |
} | |
} | |
function signatureSchemeFromJSON(object) { | |
switch (object) { | |
case 0: | |
case "SIGNATURE_SCHEME_NONE": | |
return 0 /* NONE */; | |
case 1: | |
case "SIGNATURE_SCHEME_ED25519": | |
return 1 /* ED25519 */; | |
case 2: | |
case "SIGNATURE_SCHEME_EIP712": | |
return 2 /* EIP712 */; | |
default: | |
throw new tsProtoGlobalThis2.Error("Unrecognized enum value " + object + " for enum SignatureScheme"); | |
} | |
} | |
function signatureSchemeToJSON(object) { | |
switch (object) { | |
case 0 /* NONE */: | |
return "SIGNATURE_SCHEME_NONE"; | |
case 1 /* ED25519 */: | |
return "SIGNATURE_SCHEME_ED25519"; | |
case 2 /* EIP712 */: | |
return "SIGNATURE_SCHEME_EIP712"; | |
default: | |
throw new tsProtoGlobalThis2.Error("Unrecognized enum value " + object + " for enum SignatureScheme"); | |
} | |
} | |
function messageTypeFromJSON(object) { | |
switch (object) { | |
case 0: | |
case "MESSAGE_TYPE_NONE": | |
return 0 /* NONE */; | |
case 1: | |
case "MESSAGE_TYPE_CAST_ADD": | |
return 1 /* CAST_ADD */; | |
case 2: | |
case "MESSAGE_TYPE_CAST_REMOVE": | |
return 2 /* CAST_REMOVE */; | |
case 3: | |
case "MESSAGE_TYPE_REACTION_ADD": | |
return 3 /* REACTION_ADD */; | |
case 4: | |
case "MESSAGE_TYPE_REACTION_REMOVE": | |
return 4 /* REACTION_REMOVE */; | |
case 7: | |
case "MESSAGE_TYPE_VERIFICATION_ADD_ETH_ADDRESS": | |
return 7 /* VERIFICATION_ADD_ETH_ADDRESS */; | |
case 8: | |
case "MESSAGE_TYPE_VERIFICATION_REMOVE": | |
return 8 /* VERIFICATION_REMOVE */; | |
case 9: | |
case "MESSAGE_TYPE_SIGNER_ADD": | |
return 9 /* SIGNER_ADD */; | |
case 10: | |
case "MESSAGE_TYPE_SIGNER_REMOVE": | |
return 10 /* SIGNER_REMOVE */; | |
case 11: | |
case "MESSAGE_TYPE_USER_DATA_ADD": | |
return 11 /* USER_DATA_ADD */; | |
default: | |
throw new tsProtoGlobalThis2.Error("Unrecognized enum value " + object + " for enum MessageType"); | |
} | |
} | |
function messageTypeToJSON(object) { | |
switch (object) { | |
case 0 /* NONE */: | |
return "MESSAGE_TYPE_NONE"; | |
case 1 /* CAST_ADD */: | |
return "MESSAGE_TYPE_CAST_ADD"; | |
case 2 /* CAST_REMOVE */: | |
return "MESSAGE_TYPE_CAST_REMOVE"; | |
case 3 /* REACTION_ADD */: | |
return "MESSAGE_TYPE_REACTION_ADD"; | |
case 4 /* REACTION_REMOVE */: | |
return "MESSAGE_TYPE_REACTION_REMOVE"; | |
case 7 /* VERIFICATION_ADD_ETH_ADDRESS */: | |
return "MESSAGE_TYPE_VERIFICATION_ADD_ETH_ADDRESS"; | |
case 8 /* VERIFICATION_REMOVE */: | |
return "MESSAGE_TYPE_VERIFICATION_REMOVE"; | |
case 9 /* SIGNER_ADD */: | |
return "MESSAGE_TYPE_SIGNER_ADD"; | |
case 10 /* SIGNER_REMOVE */: | |
return "MESSAGE_TYPE_SIGNER_REMOVE"; | |
case 11 /* USER_DATA_ADD */: | |
return "MESSAGE_TYPE_USER_DATA_ADD"; | |
default: | |
throw new tsProtoGlobalThis2.Error("Unrecognized enum value " + object + " for enum MessageType"); | |
} | |
} | |
function farcasterNetworkFromJSON(object) { | |
switch (object) { | |
case 0: | |
case "FARCASTER_NETWORK_NONE": | |
return 0 /* NONE */; | |
case 1: | |
case "FARCASTER_NETWORK_MAINNET": | |
return 1 /* MAINNET */; | |
case 2: | |
case "FARCASTER_NETWORK_TESTNET": | |
return 2 /* TESTNET */; | |
case 3: | |
case "FARCASTER_NETWORK_DEVNET": | |
return 3 /* DEVNET */; | |
default: | |
throw new tsProtoGlobalThis2.Error("Unrecognized enum value " + object + " for enum FarcasterNetwork"); | |
} | |
} | |
function farcasterNetworkToJSON(object) { | |
switch (object) { | |
case 0 /* NONE */: | |
return "FARCASTER_NETWORK_NONE"; | |
case 1 /* MAINNET */: | |
return "FARCASTER_NETWORK_MAINNET"; | |
case 2 /* TESTNET */: | |
return "FARCASTER_NETWORK_TESTNET"; | |
case 3 /* DEVNET */: | |
return "FARCASTER_NETWORK_DEVNET"; | |
default: | |
throw new tsProtoGlobalThis2.Error("Unrecognized enum value " + object + " for enum FarcasterNetwork"); | |
} | |
} | |
function userDataTypeFromJSON(object) { | |
switch (object) { | |
case 0: | |
case "USER_DATA_TYPE_NONE": | |
return 0 /* NONE */; | |
case 1: | |
case "USER_DATA_TYPE_PFP": | |
return 1 /* PFP */; | |
case 2: | |
case "USER_DATA_TYPE_DISPLAY": | |
return 2 /* DISPLAY */; | |
case 3: | |
case "USER_DATA_TYPE_BIO": | |
return 3 /* BIO */; | |
case 5: | |
case "USER_DATA_TYPE_URL": | |
return 5 /* URL */; | |
case 6: | |
case "USER_DATA_TYPE_FNAME": | |
return 6 /* FNAME */; | |
default: | |
throw new tsProtoGlobalThis2.Error("Unrecognized enum value " + object + " for enum UserDataType"); | |
} | |
} | |
function userDataTypeToJSON(object) { | |
switch (object) { | |
case 0 /* NONE */: | |
return "USER_DATA_TYPE_NONE"; | |
case 1 /* PFP */: | |
return "USER_DATA_TYPE_PFP"; | |
case 2 /* DISPLAY */: | |
return "USER_DATA_TYPE_DISPLAY"; | |
case 3 /* BIO */: | |
return "USER_DATA_TYPE_BIO"; | |
case 5 /* URL */: | |
return "USER_DATA_TYPE_URL"; | |
case 6 /* FNAME */: | |
return "USER_DATA_TYPE_FNAME"; | |
default: | |
throw new tsProtoGlobalThis2.Error("Unrecognized enum value " + object + " for enum UserDataType"); | |
} | |
} | |
function reactionTypeFromJSON(object) { | |
switch (object) { | |
case 0: | |
case "REACTION_TYPE_NONE": | |
return 0 /* NONE */; | |
case 1: | |
case "REACTION_TYPE_LIKE": | |
return 1 /* LIKE */; | |
case 2: | |
case "REACTION_TYPE_RECAST": | |
return 2 /* RECAST */; | |
default: | |
throw new tsProtoGlobalThis2.Error("Unrecognized enum value " + object + " for enum ReactionType"); | |
} | |
} | |
function reactionTypeToJSON(object) { | |
switch (object) { | |
case 0 /* NONE */: | |
return "REACTION_TYPE_NONE"; | |
case 1 /* LIKE */: | |
return "REACTION_TYPE_LIKE"; | |
case 2 /* RECAST */: | |
return "REACTION_TYPE_RECAST"; | |
default: | |
throw new tsProtoGlobalThis2.Error("Unrecognized enum value " + object + " for enum ReactionType"); | |
} | |
} | |
function createBaseMessage() { | |
return { | |
data: void 0, | |
hash: new Uint8Array(), | |
hashScheme: 0, | |
signature: new Uint8Array(), | |
signatureScheme: 0, | |
signer: new Uint8Array() | |
}; | |
} | |
var Message = { | |
encode(message, writer = import_minimal2.default.Writer.create()) { | |
if (message.data !== void 0) { | |
MessageData.encode(message.data, writer.uint32(10).fork()).ldelim(); | |
} | |
if (message.hash.length !== 0) { | |
writer.uint32(18).bytes(message.hash); | |
} | |
if (message.hashScheme !== 0) { | |
writer.uint32(24).int32(message.hashScheme); | |
} | |
if (message.signature.length !== 0) { | |
writer.uint32(34).bytes(message.signature); | |
} | |
if (message.signatureScheme !== 0) { | |
writer.uint32(40).int32(message.signatureScheme); | |
} | |
if (message.signer.length !== 0) { | |
writer.uint32(50).bytes(message.signer); | |
} | |
return writer; | |
}, | |
decode(input, length) { | |
const reader = input instanceof import_minimal2.default.Reader ? input : import_minimal2.default.Reader.create(input); | |
let end = length === void 0 ? reader.len : reader.pos + length; | |
const message = createBaseMessage(); | |
while (reader.pos < end) { | |
const tag = reader.uint32(); | |
switch (tag >>> 3) { | |
case 1: | |
if (tag != 10) { | |
break; | |
} | |
message.data = MessageData.decode(reader, reader.uint32()); | |
continue; | |
case 2: | |
if (tag != 18) { | |
break; | |
} | |
message.hash = reader.bytes(); | |
continue; | |
case 3: | |
if (tag != 24) { | |
break; | |
} | |
message.hashScheme = reader.int32(); | |
continue; | |
case 4: | |
if (tag != 34) { | |
break; | |
} | |
message.signature = reader.bytes(); | |
continue; | |
case 5: | |
if (tag != 40) { | |
break; | |
} | |
message.signatureScheme = reader.int32(); | |
continue; | |
case 6: | |
if (tag != 50) { | |
break; | |
} | |
message.signer = reader.bytes(); | |
continue; | |
} | |
if ((tag & 7) == 4 || tag == 0) { | |
break; | |
} | |
reader.skipType(tag & 7); | |
} | |
return message; | |
}, | |
fromJSON(object) { | |
return { | |
data: isSet2(object.data) ? MessageData.fromJSON(object.data) : void 0, | |
hash: isSet2(object.hash) ? bytesFromBase642(object.hash) : new Uint8Array(), | |
hashScheme: isSet2(object.hashScheme) ? hashSchemeFromJSON(object.hashScheme) : 0, | |
signature: isSet2(object.signature) ? bytesFromBase642(object.signature) : new Uint8Array(), | |
signatureScheme: isSet2(object.signatureScheme) ? signatureSchemeFromJSON(object.signatureScheme) : 0, | |
signer: isSet2(object.signer) ? bytesFromBase642(object.signer) : new Uint8Array() | |
}; | |
}, | |
toJSON(message) { | |
const obj = {}; | |
message.data !== void 0 && (obj.data = message.data ? MessageData.toJSON(message.data) : void 0); | |
message.hash !== void 0 && (obj.hash = base64FromBytes2(message.hash !== void 0 ? message.hash : new Uint8Array())); | |
message.hashScheme !== void 0 && (obj.hashScheme = hashSchemeToJSON(message.hashScheme)); | |
message.signature !== void 0 && (obj.signature = base64FromBytes2(message.signature !== void 0 ? message.signature : new Uint8Array())); | |
message.signatureScheme !== void 0 && (obj.signatureScheme = signatureSchemeToJSON(message.signatureScheme)); | |
message.signer !== void 0 && (obj.signer = base64FromBytes2(message.signer !== void 0 ? message.signer : new Uint8Array())); | |
return obj; | |
}, | |
create(base) { | |
return Message.fromPartial(base != null ? base : {}); | |
}, | |
fromPartial(object) { | |
var _a, _b, _c, _d, _e; | |
const message = createBaseMessage(); | |
message.data = object.data !== void 0 && object.data !== null ? MessageData.fromPartial(object.data) : void 0; | |
message.hash = (_a = object.hash) != null ? _a : new Uint8Array(); | |
message.hashScheme = (_b = object.hashScheme) != null ? _b : 0; | |
message.signature = (_c = object.signature) != null ? _c : new Uint8Array(); | |
message.signatureScheme = (_d = object.signatureScheme) != null ? _d : 0; | |
message.signer = (_e = object.signer) != null ? _e : new Uint8Array(); | |
return message; | |
} | |
}; | |
function createBaseMessageData() { | |
return { | |
type: 0, | |
fid: 0, | |
timestamp: 0, | |
network: 0, | |
castAddBody: void 0, | |
castRemoveBody: void 0, | |
reactionBody: void 0, | |
verificationAddEthAddressBody: void 0, | |
verificationRemoveBody: void 0, | |
signerAddBody: void 0, | |
userDataBody: void 0, | |
signerRemoveBody: void 0 | |
}; | |
} | |
var MessageData = { | |
encode(message, writer = import_minimal2.default.Writer.create()) { | |
if (message.type !== 0) { | |
writer.uint32(8).int32(message.type); | |
} | |
if (message.fid !== 0) { | |
writer.uint32(16).uint64(message.fid); | |
} | |
if (message.timestamp !== 0) { | |
writer.uint32(24).uint32(message.timestamp); | |
} | |
if (message.network !== 0) { | |
writer.uint32(32).int32(message.network); | |
} | |
if (message.castAddBody !== void 0) { | |
CastAddBody.encode(message.castAddBody, writer.uint32(42).fork()).ldelim(); | |
} | |
if (message.castRemoveBody !== void 0) { | |
CastRemoveBody.encode(message.castRemoveBody, writer.uint32(50).fork()).ldelim(); | |
} | |
if (message.reactionBody !== void 0) { | |
ReactionBody.encode(message.reactionBody, writer.uint32(58).fork()).ldelim(); | |
} | |
if (message.verificationAddEthAddressBody !== void 0) { | |
VerificationAddEthAddressBody.encode(message.verificationAddEthAddressBody, writer.uint32(74).fork()).ldelim(); | |
} | |
if (message.verificationRemoveBody !== void 0) { | |
VerificationRemoveBody.encode(message.verificationRemoveBody, writer.uint32(82).fork()).ldelim(); | |
} | |
if (message.signerAddBody !== void 0) { | |
SignerAddBody.encode(message.signerAddBody, writer.uint32(90).fork()).ldelim(); | |
} | |
if (message.userDataBody !== void 0) { | |
UserDataBody.encode(message.userDataBody, writer.uint32(98).fork()).ldelim(); | |
} | |
if (message.signerRemoveBody !== void 0) { | |
SignerRemoveBody.encode(message.signerRemoveBody, writer.uint32(106).fork()).ldelim(); | |
} | |
return writer; | |
}, | |
decode(input, length) { | |
const reader = input instanceof import_minimal2.default.Reader ? input : import_minimal2.default.Reader.create(input); | |
let end = length === void 0 ? reader.len : reader.pos + length; | |
const message = createBaseMessageData(); | |
while (reader.pos < end) { | |
const tag = reader.uint32(); | |
switch (tag >>> 3) { | |
case 1: | |
if (tag != 8) { | |
break; | |
} | |
message.type = reader.int32(); | |
continue; | |
case 2: | |
if (tag != 16) { | |
break; | |
} | |
message.fid = longToNumber2(reader.uint64()); | |
continue; | |
case 3: | |
if (tag != 24) { | |
break; | |
} | |
message.timestamp = reader.uint32(); | |
continue; | |
case 4: | |
if (tag != 32) { | |
break; | |
} | |
message.network = reader.int32(); | |
continue; | |
case 5: | |
if (tag != 42) { | |
break; | |
} | |
message.castAddBody = CastAddBody.decode(reader, reader.uint32()); | |
continue; | |
case 6: | |
if (tag != 50) { | |
break; | |
} | |
message.castRemoveBody = CastRemoveBody.decode(reader, reader.uint32()); | |
continue; | |
case 7: | |
if (tag != 58) { | |
break; | |
} | |
message.reactionBody = ReactionBody.decode(reader, reader.uint32()); | |
continue; | |
case 9: | |
if (tag != 74) { | |
break; | |
} | |
message.verificationAddEthAddressBody = VerificationAddEthAddressBody.decode(reader, reader.uint32()); | |
continue; | |
case 10: | |
if (tag != 82) { | |
break; | |
} | |
message.verificationRemoveBody = VerificationRemoveBody.decode(reader, reader.uint32()); | |
continue; | |
case 11: | |
if (tag != 90) { | |
break; | |
} | |
message.signerAddBody = SignerAddBody.decode(reader, reader.uint32()); | |
continue; | |
case 12: | |
if (tag != 98) { | |
break; | |
} | |
message.userDataBody = UserDataBody.decode(reader, reader.uint32()); | |
continue; | |
case 13: | |
if (tag != 106) { | |
break; | |
} | |
message.signerRemoveBody = SignerRemoveBody.decode(reader, reader.uint32()); | |
continue; | |
} | |
if ((tag & 7) == 4 || tag == 0) { | |
break; | |
} | |
reader.skipType(tag & 7); | |
} | |
return message; | |
}, | |
fromJSON(object) { | |
return { | |
type: isSet2(object.type) ? messageTypeFromJSON(object.type) : 0, | |
fid: isSet2(object.fid) ? Number(object.fid) : 0, | |
timestamp: isSet2(object.timestamp) ? Number(object.timestamp) : 0, | |
network: isSet2(object.network) ? farcasterNetworkFromJSON(object.network) : 0, | |
castAddBody: isSet2(object.castAddBody) ? CastAddBody.fromJSON(object.castAddBody) : void 0, | |
castRemoveBody: isSet2(object.castRemoveBody) ? CastRemoveBody.fromJSON(object.castRemoveBody) : void 0, | |
reactionBody: isSet2(object.reactionBody) ? ReactionBody.fromJSON(object.reactionBody) : void 0, | |
verificationAddEthAddressBody: isSet2(object.verificationAddEthAddressBody) ? VerificationAddEthAddressBody.fromJSON(object.verificationAddEthAddressBody) : void 0, | |
verificationRemoveBody: isSet2(object.verificationRemoveBody) ? VerificationRemoveBody.fromJSON(object.verificationRemoveBody) : void 0, | |
signerAddBody: isSet2(object.signerAddBody) ? SignerAddBody.fromJSON(object.signerAddBody) : void 0, | |
userDataBody: isSet2(object.userDataBody) ? UserDataBody.fromJSON(object.userDataBody) : void 0, | |
signerRemoveBody: isSet2(object.signerRemoveBody) ? SignerRemoveBody.fromJSON(object.signerRemoveBody) : void 0 | |
}; | |
}, | |
toJSON(message) { | |
const obj = {}; | |
message.type !== void 0 && (obj.type = messageTypeToJSON(message.type)); | |
message.fid !== void 0 && (obj.fid = Math.round(message.fid)); | |
message.timestamp !== void 0 && (obj.timestamp = Math.round(message.timestamp)); | |
message.network !== void 0 && (obj.network = farcasterNetworkToJSON(message.network)); | |
message.castAddBody !== void 0 && (obj.castAddBody = message.castAddBody ? CastAddBody.toJSON(message.castAddBody) : void 0); | |
message.castRemoveBody !== void 0 && (obj.castRemoveBody = message.castRemoveBody ? CastRemoveBody.toJSON(message.castRemoveBody) : void 0); | |
message.reactionBody !== void 0 && (obj.reactionBody = message.reactionBody ? ReactionBody.toJSON(message.reactionBody) : void 0); | |
message.verificationAddEthAddressBody !== void 0 && (obj.verificationAddEthAddressBody = message.verificationAddEthAddressBody ? VerificationAddEthAddressBody.toJSON(message.verificationAddEthAddressBody) : void 0); | |
message.verificationRemoveBody !== void 0 && (obj.verificationRemoveBody = message.verificationRemoveBody ? VerificationRemoveBody.toJSON(message.verificationRemoveBody) : void 0); | |
message.signerAddBody !== void 0 && (obj.signerAddBody = message.signerAddBody ? SignerAddBody.toJSON(message.signerAddBody) : void 0); | |
message.userDataBody !== void 0 && (obj.userDataBody = message.userDataBody ? UserDataBody.toJSON(message.userDataBody) : void 0); | |
message.signerRemoveBody !== void 0 && (obj.signerRemoveBody = message.signerRemoveBody ? SignerRemoveBody.toJSON(message.signerRemoveBody) : void 0); | |
return obj; | |
}, | |
create(base) { | |
return MessageData.fromPartial(base != null ? base : {}); | |
}, | |
fromPartial(object) { | |
var _a, _b, _c, _d; | |
const message = createBaseMessageData(); | |
message.type = (_a = object.type) != null ? _a : 0; | |
message.fid = (_b = object.fid) != null ? _b : 0; | |
message.timestamp = (_c = object.timestamp) != null ? _c : 0; | |
message.network = (_d = object.network) != null ? _d : 0; | |
message.castAddBody = object.castAddBody !== void 0 && object.castAddBody !== null ? CastAddBody.fromPartial(object.castAddBody) : void 0; | |
message.castRemoveBody = object.castRemoveBody !== void 0 && object.castRemoveBody !== null ? CastRemoveBody.fromPartial(object.castRemoveBody) : void 0; | |
message.reactionBody = object.reactionBody !== void 0 && object.reactionBody !== null ? ReactionBody.fromPartial(object.reactionBody) : void 0; | |
message.verificationAddEthAddressBody = object.verificationAddEthAddressBody !== void 0 && object.verificationAddEthAddressBody !== null ? VerificationAddEthAddressBody.fromPartial(object.verificationAddEthAddressBody) : void 0; | |
message.verificationRemoveBody = object.verificationRemoveBody !== void 0 && object.verificationRemoveBody !== null ? VerificationRemoveBody.fromPartial(object.verificationRemoveBody) : void 0; | |
message.signerAddBody = object.signerAddBody !== void 0 && object.signerAddBody !== null ? SignerAddBody.fromPartial(object.signerAddBody) : void 0; | |
message.userDataBody = object.userDataBody !== void 0 && object.userDataBody !== null ? UserDataBody.fromPartial(object.userDataBody) : void 0; | |
message.signerRemoveBody = object.signerRemoveBody !== void 0 && object.signerRemoveBody !== null ? SignerRemoveBody.fromPartial(object.signerRemoveBody) : void 0; | |
return message; | |
} | |
}; | |
function createBaseSignerAddBody() { | |
return { signer: new Uint8Array(), name: void 0 }; | |
} | |
var SignerAddBody = { | |
encode(message, writer = import_minimal2.default.Writer.create()) { | |
if (message.signer.length !== 0) { | |
writer.uint32(10).bytes(message.signer); | |
} | |
if (message.name !== void 0) { | |
writer.uint32(18).string(message.name); | |
} | |
return writer; | |
}, | |
decode(input, length) { | |
const reader = input instanceof import_minimal2.default.Reader ? input : import_minimal2.default.Reader.create(input); | |
let end = length === void 0 ? reader.len : reader.pos + length; | |
const message = createBaseSignerAddBody(); | |
while (reader.pos < end) { | |
const tag = reader.uint32(); | |
switch (tag >>> 3) { | |
case 1: | |
if (tag != 10) { | |
break; | |
} | |
message.signer = reader.bytes(); | |
continue; | |
case 2: | |
if (tag != 18) { | |
break; | |
} | |
message.name = reader.string(); | |
continue; | |
} | |
if ((tag & 7) == 4 || tag == 0) { | |
break; | |
} | |
reader.skipType(tag & 7); | |
} | |
return message; | |
}, | |
fromJSON(object) { | |
return { | |
signer: isSet2(object.signer) ? bytesFromBase642(object.signer) : new Uint8Array(), | |
name: isSet2(object.name) ? String(object.name) : void 0 | |
}; | |
}, | |
toJSON(message) { | |
const obj = {}; | |
message.signer !== void 0 && (obj.signer = base64FromBytes2(message.signer !== void 0 ? message.signer : new Uint8Array())); | |
message.name !== void 0 && (obj.name = message.name); | |
return obj; | |
}, | |
create(base) { | |
return SignerAddBody.fromPartial(base != null ? base : {}); | |
}, | |
fromPartial(object) { | |
var _a, _b; | |
const message = createBaseSignerAddBody(); | |
message.signer = (_a = object.signer) != null ? _a : new Uint8Array(); | |
message.name = (_b = object.name) != null ? _b : void 0; | |
return message; | |
} | |
}; | |
function createBaseSignerRemoveBody() { | |
return { signer: new Uint8Array() }; | |
} | |
var SignerRemoveBody = { | |
encode(message, writer = import_minimal2.default.Writer.create()) { | |
if (message.signer.length !== 0) { | |
writer.uint32(10).bytes(message.signer); | |
} | |
return writer; | |
}, | |
decode(input, length) { | |
const reader = input instanceof import_minimal2.default.Reader ? input : import_minimal2.default.Reader.create(input); | |
let end = length === void 0 ? reader.len : reader.pos + length; | |
const message = createBaseSignerRemoveBody(); | |
while (reader.pos < end) { | |
const tag = reader.uint32(); | |
switch (tag >>> 3) { | |
case 1: | |
if (tag != 10) { | |
break; | |
} | |
message.signer = reader.bytes(); | |
continue; | |
} | |
if ((tag & 7) == 4 || tag == 0) { | |
break; | |
} | |
reader.skipType(tag & 7); | |
} | |
return message; | |
}, | |
fromJSON(object) { | |
return { signer: isSet2(object.signer) ? bytesFromBase642(object.signer) : new Uint8Array() }; | |
}, | |
toJSON(message) { | |
const obj = {}; | |
message.signer !== void 0 && (obj.signer = base64FromBytes2(message.signer !== void 0 ? message.signer : new Uint8Array())); | |
return obj; | |
}, | |
create(base) { | |
return SignerRemoveBody.fromPartial(base != null ? base : {}); | |
}, | |
fromPartial(object) { | |
var _a; | |
const message = createBaseSignerRemoveBody(); | |
message.signer = (_a = object.signer) != null ? _a : new Uint8Array(); | |
return message; | |
} | |
}; | |
function createBaseUserDataBody() { | |
return { type: 0, value: "" }; | |
} | |
var UserDataBody = { | |
encode(message, writer = import_minimal2.default.Writer.create()) { | |
if (message.type !== 0) { | |
writer.uint32(8).int32(message.type); | |
} | |
if (message.value !== "") { | |
writer.uint32(18).string(message.value); | |
} | |
return writer; | |
}, | |
decode(input, length) { | |
const reader = input instanceof import_minimal2.default.Reader ? input : import_minimal2.default.Reader.create(input); | |
let end = length === void 0 ? reader.len : reader.pos + length; | |
const message = createBaseUserDataBody(); | |
while (reader.pos < end) { | |
const tag = reader.uint32(); | |
switch (tag >>> 3) { | |
case 1: | |
if (tag != 8) { | |
break; | |
} | |
message.type = reader.int32(); | |
continue; | |
case 2: | |
if (tag != 18) { | |
break; | |
} | |
message.value = reader.string(); | |
continue; | |
} | |
if ((tag & 7) == 4 || tag == 0) { | |
break; | |
} | |
reader.skipType(tag & 7); | |
} | |
return message; | |
}, | |
fromJSON(object) { | |
return { | |
type: isSet2(object.type) ? userDataTypeFromJSON(object.type) : 0, | |
value: isSet2(object.value) ? String(object.value) : "" | |
}; | |
}, | |
toJSON(message) { | |
const obj = {}; | |
message.type !== void 0 && (obj.type = userDataTypeToJSON(message.type)); | |
message.value !== void 0 && (obj.value = message.value); | |
return obj; | |
}, | |
create(base) { | |
return UserDataBody.fromPartial(base != null ? base : {}); | |
}, | |
fromPartial(object) { | |
var _a, _b; | |
const message = createBaseUserDataBody(); | |
message.type = (_a = object.type) != null ? _a : 0; | |
message.value = (_b = object.value) != null ? _b : ""; | |
return message; | |
} | |
}; | |
function createBaseCastAddBody() { | |
return { embeds: [], mentions: [], parentCastId: void 0, text: "", mentionsPositions: [] }; | |
} | |
var CastAddBody = { | |
encode(message, writer = import_minimal2.default.Writer.create()) { | |
for (const v of message.embeds) { | |
writer.uint32(10).string(v); | |
} | |
writer.uint32(18).fork(); | |
for (const v of message.mentions) { | |
writer.uint64(v); | |
} | |
writer.ldelim(); | |
if (message.parentCastId !== void 0) { | |
CastId.encode(message.parentCastId, writer.uint32(26).fork()).ldelim(); | |
} | |
if (message.text !== "") { | |
writer.uint32(34).string(message.text); | |
} | |
writer.uint32(42).fork(); | |
for (const v of message.mentionsPositions) { | |
writer.uint32(v); | |
} | |
writer.ldelim(); | |
return writer; | |
}, | |
decode(input, length) { | |
const reader = input instanceof import_minimal2.default.Reader ? input : import_minimal2.default.Reader.create(input); | |
let end = length === void 0 ? reader.len : reader.pos + length; | |
const message = createBaseCastAddBody(); | |
while (reader.pos < end) { | |
const tag = reader.uint32(); | |
switch (tag >>> 3) { | |
case 1: | |
if (tag != 10) { | |
break; | |
} | |
message.embeds.push(reader.string()); | |
continue; | |
case 2: | |
if (tag == 16) { | |
message.mentions.push(longToNumber2(reader.uint64())); | |
continue; | |
} | |
if (tag == 18) { | |
const end2 = reader.uint32() + reader.pos; | |
while (reader.pos < end2) { | |
message.mentions.push(longToNumber2(reader.uint64())); | |
} | |
continue; | |
} | |
break; | |
case 3: | |
if (tag != 26) { | |
break; | |
} | |
message.parentCastId = CastId.decode(reader, reader.uint32()); | |
continue; | |
case 4: | |
if (tag != 34) { | |
break; | |
} | |
message.text = reader.string(); | |
continue; | |
case 5: | |
if (tag == 40) { | |
message.mentionsPositions.push(reader.uint32()); | |
continue; | |
} | |
if (tag == 42) { | |
const end2 = reader.uint32() + reader.pos; | |
while (reader.pos < end2) { | |
message.mentionsPositions.push(reader.uint32()); | |
} | |
continue; | |
} | |
break; | |
} | |
if ((tag & 7) == 4 || tag == 0) { | |
break; | |
} | |
reader.skipType(tag & 7); | |
} | |
return message; | |
}, | |
fromJSON(object) { | |
return { | |
embeds: Array.isArray(object == null ? void 0 : object.embeds) ? object.embeds.map((e) => String(e)) : [], | |
mentions: Array.isArray(object == null ? void 0 : object.mentions) ? object.mentions.map((e) => Number(e)) : [], | |
parentCastId: isSet2(object.parentCastId) ? CastId.fromJSON(object.parentCastId) : void 0, | |
text: isSet2(object.text) ? String(object.text) : "", | |
mentionsPositions: Array.isArray(object == null ? void 0 : object.mentionsPositions) ? object.mentionsPositions.map((e) => Number(e)) : [] | |
}; | |
}, | |
toJSON(message) { | |
const obj = {}; | |
if (message.embeds) { | |
obj.embeds = message.embeds.map((e) => e); | |
} else { | |
obj.embeds = []; | |
} | |
if (message.mentions) { | |
obj.mentions = message.mentions.map((e) => Math.round(e)); | |
} else { | |
obj.mentions = []; | |
} | |
message.parentCastId !== void 0 && (obj.parentCastId = message.parentCastId ? CastId.toJSON(message.parentCastId) : void 0); | |
message.text !== void 0 && (obj.text = message.text); | |
if (message.mentionsPositions) { | |
obj.mentionsPositions = message.mentionsPositions.map((e) => Math.round(e)); | |
} else { | |
obj.mentionsPositions = []; | |
} | |
return obj; | |
}, | |
create(base) { | |
return CastAddBody.fromPartial(base != null ? base : {}); | |
}, | |
fromPartial(object) { | |
var _a, _b, _c, _d; | |
const message = createBaseCastAddBody(); | |
message.embeds = ((_a = object.embeds) == null ? void 0 : _a.map((e) => e)) || []; | |
message.mentions = ((_b = object.mentions) == null ? void 0 : _b.map((e) => e)) || []; | |
message.parentCastId = object.parentCastId !== void 0 && object.parentCastId !== null ? CastId.fromPartial(object.parentCastId) : void 0; | |
message.text = (_c = object.text) != null ? _c : ""; | |
message.mentionsPositions = ((_d = object.mentionsPositions) == null ? void 0 : _d.map((e) => e)) || []; | |
return message; | |
} | |
}; | |
function createBaseCastRemoveBody() { | |
return { targetHash: new Uint8Array() }; | |
} | |
var CastRemoveBody = { | |
encode(message, writer = import_minimal2.default.Writer.create()) { | |
if (message.targetHash.length !== 0) { | |
writer.uint32(10).bytes(message.targetHash); | |
} | |
return writer; | |
}, | |
decode(input, length) { | |
const reader = input instanceof import_minimal2.default.Reader ? input : import_minimal2.default.Reader.create(input); | |
let end = length === void 0 ? reader.len : reader.pos + length; | |
const message = createBaseCastRemoveBody(); | |
while (reader.pos < end) { | |
const tag = reader.uint32(); | |
switch (tag >>> 3) { | |
case 1: | |
if (tag != 10) { | |
break; | |
} | |
message.targetHash = reader.bytes(); | |
continue; | |
} | |
if ((tag & 7) == 4 || tag == 0) { | |
break; | |
} | |
reader.skipType(tag & 7); | |
} | |
return message; | |
}, | |
fromJSON(object) { | |
return { targetHash: isSet2(object.targetHash) ? bytesFromBase642(object.targetHash) : new Uint8Array() }; | |
}, | |
toJSON(message) { | |
const obj = {}; | |
message.targetHash !== void 0 && (obj.targetHash = base64FromBytes2(message.targetHash !== void 0 ? message.targetHash : new Uint8Array())); | |
return obj; | |
}, | |
create(base) { | |
return CastRemoveBody.fromPartial(base != null ? base : {}); | |
}, | |
fromPartial(object) { | |
var _a; | |
const message = createBaseCastRemoveBody(); | |
message.targetHash = (_a = object.targetHash) != null ? _a : new Uint8Array(); | |
return message; | |
} | |
}; | |
function createBaseCastId() { | |
return { fid: 0, hash: new Uint8Array() }; | |
} | |
var CastId = { | |
encode(message, writer = import_minimal2.default.Writer.create()) { | |
if (message.fid !== 0) { | |
writer.uint32(8).uint64(message.fid); | |
} | |
if (message.hash.length !== 0) { | |
writer.uint32(18).bytes(message.hash); | |
} | |
return writer; | |
}, | |
decode(input, length) { | |
const reader = input instanceof import_minimal2.default.Reader ? input : import_minimal2.default.Reader.create(input); | |
let end = length === void 0 ? reader.len : reader.pos + length; | |
const message = createBaseCastId(); | |
while (reader.pos < end) { | |
const tag = reader.uint32(); | |
switch (tag >>> 3) { | |
case 1: | |
if (tag != 8) { | |
break; | |
} | |
message.fid = longToNumber2(reader.uint64()); | |
continue; | |
case 2: | |
if (tag != 18) { | |
break; | |
} | |
message.hash = reader.bytes(); | |
continue; | |
} | |
if ((tag & 7) == 4 || tag == 0) { | |
break; | |
} | |
reader.skipType(tag & 7); | |
} | |
return message; | |
}, | |
fromJSON(object) { | |
return { | |
fid: isSet2(object.fid) ? Number(object.fid) : 0, | |
hash: isSet2(object.hash) ? bytesFromBase642(object.hash) : new Uint8Array() | |
}; | |
}, | |
toJSON(message) { | |
const obj = {}; | |
message.fid !== void 0 && (obj.fid = Math.round(message.fid)); | |
message.hash !== void 0 && (obj.hash = base64FromBytes2(message.hash !== void 0 ? message.hash : new Uint8Array())); | |
return obj; | |
}, | |
create(base) { | |
return CastId.fromPartial(base != null ? base : {}); | |
}, | |
fromPartial(object) { | |
var _a, _b; | |
const message = createBaseCastId(); | |
message.fid = (_a = object.fid) != null ? _a : 0; | |
message.hash = (_b = object.hash) != null ? _b : new Uint8Array(); | |
return message; | |
} | |
}; | |
function createBaseReactionBody() { | |
return { type: 0, targetCastId: void 0 }; | |
} | |
var ReactionBody = { | |
encode(message, writer = import_minimal2.default.Writer.create()) { | |
if (message.type !== 0) { | |
writer.uint32(8).int32(message.type); | |
} | |
if (message.targetCastId !== void 0) { | |
CastId.encode(message.targetCastId, writer.uint32(18).fork()).ldelim(); | |
} | |
return writer; | |
}, | |
decode(input, length) { | |
const reader = input instanceof import_minimal2.default.Reader ? input : import_minimal2.default.Reader.create(input); | |
let end = length === void 0 ? reader.len : reader.pos + length; | |
const message = createBaseReactionBody(); | |
while (reader.pos < end) { | |
const tag = reader.uint32(); | |
switch (tag >>> 3) { | |
case 1: | |
if (tag != 8) { | |
break; | |
} | |
message.type = reader.int32(); | |
continue; | |
case 2: | |
if (tag != 18) { | |
break; | |
} | |
message.targetCastId = CastId.decode(reader, reader.uint32()); | |
continue; | |
} | |
if ((tag & 7) == 4 || tag == 0) { | |
break; | |
} | |
reader.skipType(tag & 7); | |
} | |
return message; | |
}, | |
fromJSON(object) { | |
return { | |
type: isSet2(object.type) ? reactionTypeFromJSON(object.type) : 0, | |
targetCastId: isSet2(object.targetCastId) ? CastId.fromJSON(object.targetCastId) : void 0 | |
}; | |
}, | |
toJSON(message) { | |
const obj = {}; | |
message.type !== void 0 && (obj.type = reactionTypeToJSON(message.type)); | |
message.targetCastId !== void 0 && (obj.targetCastId = message.targetCastId ? CastId.toJSON(message.targetCastId) : void 0); | |
return obj; | |
}, | |
create(base) { | |
return ReactionBody.fromPartial(base != null ? base : {}); | |
}, | |
fromPartial(object) { | |
var _a; | |
const message = createBaseReactionBody(); | |
message.type = (_a = object.type) != null ? _a : 0; | |
message.targetCastId = object.targetCastId !== void 0 && object.targetCastId !== null ? CastId.fromPartial(object.targetCastId) : void 0; | |
return message; | |
} | |
}; | |
function createBaseVerificationAddEthAddressBody() { | |
return { address: new Uint8Array(), ethSignature: new Uint8Array(), blockHash: new Uint8Array() }; | |
} | |
var VerificationAddEthAddressBody = { | |
encode(message, writer = import_minimal2.default.Writer.create()) { | |
if (message.address.length !== 0) { | |
writer.uint32(10).bytes(message.address); | |
} | |
if (message.ethSignature.length !== 0) { | |
writer.uint32(18).bytes(message.ethSignature); | |
} | |
if (message.blockHash.length !== 0) { | |
writer.uint32(26).bytes(message.blockHash); | |
} | |
return writer; | |
}, | |
decode(input, length) { | |
const reader = input instanceof import_minimal2.default.Reader ? input : import_minimal2.default.Reader.create(input); | |
let end = length === void 0 ? reader.len : reader.pos + length; | |
const message = createBaseVerificationAddEthAddressBody(); | |
while (reader.pos < end) { | |
const tag = reader.uint32(); | |
switch (tag >>> 3) { | |
case 1: | |
if (tag != 10) { | |
break; | |
} | |
message.address = reader.bytes(); | |
continue; | |
case 2: | |
if (tag != 18) { | |
break; | |
} | |
message.ethSignature = reader.bytes(); | |
continue; | |
case 3: | |
if (tag != 26) { | |
break; | |
} | |
message.blockHash = reader.bytes(); | |
continue; | |
} | |
if ((tag & 7) == 4 || tag == 0) { | |
break; | |
} | |
reader.skipType(tag & 7); | |
} | |
return message; | |
}, | |
fromJSON(object) { | |
return { | |
address: isSet2(object.address) ? bytesFromBase642(object.address) : new Uint8Array(), | |
ethSignature: isSet2(object.ethSignature) ? bytesFromBase642(object.ethSignature) : new Uint8Array(), | |
blockHash: isSet2(object.blockHash) ? bytesFromBase642(object.blockHash) : new Uint8Array() | |
}; | |
}, | |
toJSON(message) { | |
const obj = {}; | |
message.address !== void 0 && (obj.address = base64FromBytes2(message.address !== void 0 ? message.address : new Uint8Array())); | |
message.ethSignature !== void 0 && (obj.ethSignature = base64FromBytes2( | |
message.ethSignature !== void 0 ? message.ethSignature : new Uint8Array() | |
)); | |
message.blockHash !== void 0 && (obj.blockHash = base64FromBytes2(message.blockHash !== void 0 ? message.blockHash : new Uint8Array())); | |
return obj; | |
}, | |
create(base) { | |
return VerificationAddEthAddressBody.fromPartial(base != null ? base : {}); | |
}, | |
fromPartial(object) { | |
var _a, _b, _c; | |
const message = createBaseVerificationAddEthAddressBody(); | |
message.address = (_a = object.address) != null ? _a : new Uint8Array(); | |
message.ethSignature = (_b = object.ethSignature) != null ? _b : new Uint8Array(); | |
message.blockHash = (_c = object.blockHash) != null ? _c : new Uint8Array(); | |
return message; | |
} | |
}; | |
function createBaseVerificationRemoveBody() { | |
return { address: new Uint8Array() }; | |
} | |
var VerificationRemoveBody = { | |
encode(message, writer = import_minimal2.default.Writer.create()) { | |
if (message.address.length !== 0) { | |
writer.uint32(10).bytes(message.address); | |
} | |
return writer; | |
}, | |
decode(input, length) { | |
const reader = input instanceof import_minimal2.default.Reader ? input : import_minimal2.default.Reader.create(input); | |
let end = length === void 0 ? reader.len : reader.pos + length; | |
const message = createBaseVerificationRemoveBody(); | |
while (reader.pos < end) { | |
const tag = reader.uint32(); | |
switch (tag >>> 3) { | |
case 1: | |
if (tag != 10) { | |
break; | |
} | |
message.address = reader.bytes(); | |
continue; | |
} | |
if ((tag & 7) == 4 || tag == 0) { | |
break; | |
} | |
reader.skipType(tag & 7); | |
} | |
return message; | |
}, | |
fromJSON(object) { | |
return { address: isSet2(object.address) ? bytesFromBase642(object.address) : new Uint8Array() }; | |
}, | |
toJSON(message) { | |
const obj = {}; | |
message.address !== void 0 && (obj.address = base64FromBytes2(message.address !== void 0 ? message.address : new Uint8Array())); | |
return obj; | |
}, | |
create(base) { | |
return VerificationRemoveBody.fromPartial(base != null ? base : {}); | |
}, | |
fromPartial(object) { | |
var _a; | |
const message = createBaseVerificationRemoveBody(); | |
message.address = (_a = object.address) != null ? _a : new Uint8Array(); | |
return message; | |
} | |
}; | |
var tsProtoGlobalThis2 = (() => { | |
if (typeof globalThis !== "undefined") { | |
return globalThis; | |
} | |
if (typeof self !== "undefined") { | |
return self; | |
} | |
if (typeof window !== "undefined") { | |
return window; | |
} | |
if (typeof global !== "undefined") { | |
return global; | |
} | |
throw "Unable to locate global object"; | |
})(); | |
function bytesFromBase642(b64) { | |
if (tsProtoGlobalThis2.Buffer) { | |
return Uint8Array.from(tsProtoGlobalThis2.Buffer.from(b64, "base64")); | |
} else { | |
const bin = tsProtoGlobalThis2.atob(b64); | |
const arr = new Uint8Array(bin.length); | |
for (let i = 0; i < bin.length; ++i) { | |
arr[i] = bin.charCodeAt(i); | |
} | |
return arr; | |
} | |
} | |
function base64FromBytes2(arr) { | |
if (tsProtoGlobalThis2.Buffer) { | |
return tsProtoGlobalThis2.Buffer.from(arr).toString("base64"); | |
} else { | |
const bin = []; | |
arr.forEach((byte) => { | |
bin.push(String.fromCharCode(byte)); | |
}); | |
return tsProtoGlobalThis2.btoa(bin.join("")); | |
} | |
} | |
function longToNumber2(long) { | |
if (long.gt(Number.MAX_SAFE_INTEGER)) { | |
throw new tsProtoGlobalThis2.Error("Value is larger than Number.MAX_SAFE_INTEGER"); | |
} | |
return long.toNumber(); | |
} | |
if (import_minimal2.default.util.Long !== import_long2.default) { | |
import_minimal2.default.util.Long = import_long2.default; | |
import_minimal2.default.configure(); | |
} | |
function isSet2(value) { | |
return value !== null && value !== void 0; | |
} | |
// src/generated/name_registry_event.ts | |
init_cjs_shims(); | |
var import_minimal3 = __toESM(require_minimal2()); | |
function nameRegistryEventTypeFromJSON(object) { | |
switch (object) { | |
case 0: | |
case "NAME_REGISTRY_EVENT_TYPE_NONE": | |
return 0 /* NONE */; | |
case 1: | |
case "NAME_REGISTRY_EVENT_TYPE_TRANSFER": | |
return 1 /* TRANSFER */; | |
case 2: | |
case "NAME_REGISTRY_EVENT_TYPE_RENEW": | |
return 2 /* RENEW */; | |
default: | |
throw new tsProtoGlobalThis3.Error("Unrecognized enum value " + object + " for enum NameRegistryEventType"); | |
} | |
} | |
function nameRegistryEventTypeToJSON(object) { | |
switch (object) { | |
case 0 /* NONE */: | |
return "NAME_REGISTRY_EVENT_TYPE_NONE"; | |
case 1 /* TRANSFER */: | |
return "NAME_REGISTRY_EVENT_TYPE_TRANSFER"; | |
case 2 /* RENEW */: | |
return "NAME_REGISTRY_EVENT_TYPE_RENEW"; | |
default: | |
throw new tsProtoGlobalThis3.Error("Unrecognized enum value " + object + " for enum NameRegistryEventType"); | |
} | |
} | |
function createBaseNameRegistryEvent() { | |
return { | |
blockNumber: 0, | |
blockHash: new Uint8Array(), | |
transactionHash: new Uint8Array(), | |
logIndex: 0, | |
fname: new Uint8Array(), | |
from: new Uint8Array(), | |
to: new Uint8Array(), | |
type: 0, | |
expiry: 0 | |
}; | |
} | |
var NameRegistryEvent = { | |
encode(message, writer = import_minimal3.default.Writer.create()) { | |
if (message.blockNumber !== 0) { | |
writer.uint32(8).uint32(message.blockNumber); | |
} | |
if (message.blockHash.length !== 0) { | |
writer.uint32(18).bytes(message.blockHash); | |
} | |
if (message.transactionHash.length !== 0) { | |
writer.uint32(26).bytes(message.transactionHash); | |
} | |
if (message.logIndex !== 0) { | |
writer.uint32(32).uint32(message.logIndex); | |
} | |
if (message.fname.length !== 0) { | |
writer.uint32(42).bytes(message.fname); | |
} | |
if (message.from.length !== 0) { | |
writer.uint32(50).bytes(message.from); | |
} | |
if (message.to.length !== 0) { | |
writer.uint32(58).bytes(message.to); | |
} | |
if (message.type !== 0) { | |
writer.uint32(64).int32(message.type); | |
} | |
if (message.expiry !== 0) { | |
writer.uint32(72).uint32(message.expiry); | |
} | |
return writer; | |
}, | |
decode(input, length) { | |
const reader = input instanceof import_minimal3.default.Reader ? input : import_minimal3.default.Reader.create(input); | |
let end = length === void 0 ? reader.len : reader.pos + length; | |
const message = createBaseNameRegistryEvent(); | |
while (reader.pos < end) { | |
const tag = reader.uint32(); | |
switch (tag >>> 3) { | |
case 1: | |
if (tag != 8) { | |
break; | |
} | |
message.blockNumber = reader.uint32(); | |
continue; | |
case 2: | |
if (tag != 18) { | |
break; | |
} | |
message.blockHash = reader.bytes(); | |
continue; | |
case 3: | |
if (tag != 26) { | |
break; | |
} | |
message.transactionHash = reader.bytes(); | |
continue; | |
case 4: | |
if (tag != 32) { | |
break; | |
} | |
message.logIndex = reader.uint32(); | |
continue; | |
case 5: | |
if (tag != 42) { | |
break; | |
} | |
message.fname = reader.bytes(); | |
continue; | |
case 6: | |
if (tag != 50) { | |
break; | |
} | |
message.from = reader.bytes(); | |
continue; | |
case 7: | |
if (tag != 58) { | |
break; | |
} | |
message.to = reader.bytes(); | |
continue; | |
case 8: | |
if (tag != 64) { | |
break; | |
} | |
message.type = reader.int32(); | |
continue; | |
case 9: | |
if (tag != 72) { | |
break; | |
} | |
message.expiry = reader.uint32(); | |
continue; | |
} | |
if ((tag & 7) == 4 || tag == 0) { | |
break; | |
} | |
reader.skipType(tag & 7); | |
} | |
return message; | |
}, | |
fromJSON(object) { | |
return { | |
blockNumber: isSet3(object.blockNumber) ? Number(object.blockNumber) : 0, | |
blockHash: isSet3(object.blockHash) ? bytesFromBase643(object.blockHash) : new Uint8Array(), | |
transactionHash: isSet3(object.transactionHash) ? bytesFromBase643(object.transactionHash) : new Uint8Array(), | |
logIndex: isSet3(object.logIndex) ? Number(object.logIndex) : 0, | |
fname: isSet3(object.fname) ? bytesFromBase643(object.fname) : new Uint8Array(), | |
from: isSet3(object.from) ? bytesFromBase643(object.from) : new Uint8Array(), | |
to: isSet3(object.to) ? bytesFromBase643(object.to) : new Uint8Array(), | |
type: isSet3(object.type) ? nameRegistryEventTypeFromJSON(object.type) : 0, | |
expiry: isSet3(object.expiry) ? Number(object.expiry) : 0 | |
}; | |
}, | |
toJSON(message) { | |
const obj = {}; | |
message.blockNumber !== void 0 && (obj.blockNumber = Math.round(message.blockNumber)); | |
message.blockHash !== void 0 && (obj.blockHash = base64FromBytes3(message.blockHash !== void 0 ? message.blockHash : new Uint8Array())); | |
message.transactionHash !== void 0 && (obj.transactionHash = base64FromBytes3( | |
message.transactionHash !== void 0 ? message.transactionHash : new Uint8Array() | |
)); | |
message.logIndex !== void 0 && (obj.logIndex = Math.round(message.logIndex)); | |
message.fname !== void 0 && (obj.fname = base64FromBytes3(message.fname !== void 0 ? message.fname : new Uint8Array())); | |
message.from !== void 0 && (obj.from = base64FromBytes3(message.from !== void 0 ? message.from : new Uint8Array())); | |
message.to !== void 0 && (obj.to = base64FromBytes3(message.to !== void 0 ? message.to : new Uint8Array())); | |
message.type !== void 0 && (obj.type = nameRegistryEventTypeToJSON(message.type)); | |
message.expiry !== void 0 && (obj.expiry = Math.round(message.expiry)); | |
return obj; | |
}, | |
create(base) { | |
return NameRegistryEvent.fromPartial(base != null ? base : {}); | |
}, | |
fromPartial(object) { | |
var _a, _b, _c, _d, _e, _f, _g, _h, _i; | |
const message = createBaseNameRegistryEvent(); | |
message.blockNumber = (_a = object.blockNumber) != null ? _a : 0; | |
message.blockHash = (_b = object.blockHash) != null ? _b : new Uint8Array(); | |
message.transactionHash = (_c = object.transactionHash) != null ? _c : new Uint8Array(); | |
message.logIndex = (_d = object.logIndex) != null ? _d : 0; | |
message.fname = (_e = object.fname) != null ? _e : new Uint8Array(); | |
message.from = (_f = object.from) != null ? _f : new Uint8Array(); | |
message.to = (_g = object.to) != null ? _g : new Uint8Array(); | |
message.type = (_h = object.type) != null ? _h : 0; | |
message.expiry = (_i = object.expiry) != null ? _i : 0; | |
return message; | |
} | |
}; | |
var tsProtoGlobalThis3 = (() => { | |
if (typeof globalThis !== "undefined") { | |
return globalThis; | |
} | |
if (typeof self !== "undefined") { | |
return self; | |
} | |
if (typeof window !== "undefined") { | |
return window; | |
} | |
if (typeof global !== "undefined") { | |
return global; | |
} | |
throw "Unable to locate global object"; | |
})(); | |
function bytesFromBase643(b64) { | |
if (tsProtoGlobalThis3.Buffer) { | |
return Uint8Array.from(tsProtoGlobalThis3.Buffer.from(b64, "base64")); | |
} else { | |
const bin = tsProtoGlobalThis3.atob(b64); | |
const arr = new Uint8Array(bin.length); | |
for (let i = 0; i < bin.length; ++i) { | |
arr[i] = bin.charCodeAt(i); | |
} | |
return arr; | |
} | |
} | |
function base64FromBytes3(arr) { | |
if (tsProtoGlobalThis3.Buffer) { | |
return tsProtoGlobalThis3.Buffer.from(arr).toString("base64"); | |
} else { | |
const bin = []; | |
arr.forEach((byte) => { | |
bin.push(String.fromCharCode(byte)); | |
}); | |
return tsProtoGlobalThis3.btoa(bin.join("")); | |
} | |
} | |
function isSet3(value) { | |
return value !== null && value !== void 0; | |
} | |
// src/generated/hub_event.ts | |
function hubEventTypeFromJSON(object) { | |
switch (object) { | |
case 0: | |
case "HUB_EVENT_TYPE_NONE": | |
return 0 /* NONE */; | |
case 1: | |
case "HUB_EVENT_TYPE_MERGE_MESSAGE": | |
return 1 /* MERGE_MESSAGE */; | |
case 2: | |
case "HUB_EVENT_TYPE_PRUNE_MESSAGE": | |
return 2 /* PRUNE_MESSAGE */; | |
case 3: | |
case "HUB_EVENT_TYPE_REVOKE_MESSAGE": | |
return 3 /* REVOKE_MESSAGE */; | |
case 4: | |
case "HUB_EVENT_TYPE_MERGE_ID_REGISTRY_EVENT": | |
return 4 /* MERGE_ID_REGISTRY_EVENT */; | |
case 5: | |
case "HUB_EVENT_TYPE_MERGE_NAME_REGISTRY_EVENT": | |
return 5 /* MERGE_NAME_REGISTRY_EVENT */; | |
default: | |
throw new tsProtoGlobalThis4.Error("Unrecognized enum value " + object + " for enum HubEventType"); | |
} | |
} | |
function hubEventTypeToJSON(object) { | |
switch (object) { | |
case 0 /* NONE */: | |
return "HUB_EVENT_TYPE_NONE"; | |
case 1 /* MERGE_MESSAGE */: | |
return "HUB_EVENT_TYPE_MERGE_MESSAGE"; | |
case 2 /* PRUNE_MESSAGE */: | |
return "HUB_EVENT_TYPE_PRUNE_MESSAGE"; | |
case 3 /* REVOKE_MESSAGE */: | |
return "HUB_EVENT_TYPE_REVOKE_MESSAGE"; | |
case 4 /* MERGE_ID_REGISTRY_EVENT */: | |
return "HUB_EVENT_TYPE_MERGE_ID_REGISTRY_EVENT"; | |
case 5 /* MERGE_NAME_REGISTRY_EVENT */: | |
return "HUB_EVENT_TYPE_MERGE_NAME_REGISTRY_EVENT"; | |
default: | |
throw new tsProtoGlobalThis4.Error("Unrecognized enum value " + object + " for enum HubEventType"); | |
} | |
} | |
function createBaseMergeMessageBody() { | |
return { message: void 0, deletedMessages: [] }; | |
} | |
var MergeMessageBody = { | |
encode(message, writer = import_minimal4.default.Writer.create()) { | |
if (message.message !== void 0) { | |
Message.encode(message.message, writer.uint32(10).fork()).ldelim(); | |
} | |
for (const v of message.deletedMessages) { | |
Message.encode(v, writer.uint32(18).fork()).ldelim(); | |
} | |
return writer; | |
}, | |
decode(input, length) { | |
const reader = input instanceof import_minimal4.default.Reader ? input : import_minimal4.default.Reader.create(input); | |
let end = length === void 0 ? reader.len : reader.pos + length; | |
const message = createBaseMergeMessageBody(); | |
while (reader.pos < end) { | |
const tag = reader.uint32(); | |
switch (tag >>> 3) { | |
case 1: | |
if (tag != 10) { | |
break; | |
} | |
message.message = Message.decode(reader, reader.uint32()); | |
continue; | |
case 2: | |
if (tag != 18) { | |
break; | |
} | |
message.deletedMessages.push(Message.decode(reader, reader.uint32())); | |
continue; | |
} | |
if ((tag & 7) == 4 || tag == 0) { | |
break; | |
} | |
reader.skipType(tag & 7); | |
} | |
return message; | |
}, | |
fromJSON(object) { | |
return { | |
message: isSet4(object.message) ? Message.fromJSON(object.message) : void 0, | |
deletedMessages: Array.isArray(object == null ? void 0 : object.deletedMessages) ? object.deletedMessages.map((e) => Message.fromJSON(e)) : [] | |
}; | |
}, | |
toJSON(message) { | |
const obj = {}; | |
message.message !== void 0 && (obj.message = message.message ? Message.toJSON(message.message) : void 0); | |
if (message.deletedMessages) { | |
obj.deletedMessages = message.deletedMessages.map((e) => e ? Message.toJSON(e) : void 0); | |
} else { | |
obj.deletedMessages = []; | |
} | |
return obj; | |
}, | |
create(base) { | |
return MergeMessageBody.fromPartial(base != null ? base : {}); | |
}, | |
fromPartial(object) { | |
var _a; | |
const message = createBaseMergeMessageBody(); | |
message.message = object.message !== void 0 && object.message !== null ? Message.fromPartial(object.message) : void 0; | |
message.deletedMessages = ((_a = object.deletedMessages) == null ? void 0 : _a.map((e) => Message.fromPartial(e))) || []; | |
return message; | |
} | |
}; | |
function createBasePruneMessageBody() { | |
return { message: void 0 }; | |
} | |
var PruneMessageBody = { | |
encode(message, writer = import_minimal4.default.Writer.create()) { | |
if (message.message !== void 0) { | |
Message.encode(message.message, writer.uint32(10).fork()).ldelim(); | |
} | |
return writer; | |
}, | |
decode(input, length) { | |
const reader = input instanceof import_minimal4.default.Reader ? input : import_minimal4.default.Reader.create(input); | |
let end = length === void 0 ? reader.len : reader.pos + length; | |
const message = createBasePruneMessageBody(); | |
while (reader.pos < end) { | |
const tag = reader.uint32(); | |
switch (tag >>> 3) { | |
case 1: | |
if (tag != 10) { | |
break; | |
} | |
message.message = Message.decode(reader, reader.uint32()); | |
continue; | |
} | |
if ((tag & 7) == 4 || tag == 0) { | |
break; | |
} | |
reader.skipType(tag & 7); | |
} | |
return message; | |
}, | |
fromJSON(object) { | |
return { message: isSet4(object.message) ? Message.fromJSON(object.message) : void 0 }; | |
}, | |
toJSON(message) { | |
const obj = {}; | |
message.message !== void 0 && (obj.message = message.message ? Message.toJSON(message.message) : void 0); | |
return obj; | |
}, | |
create(base) { | |
return PruneMessageBody.fromPartial(base != null ? base : {}); | |
}, | |
fromPartial(object) { | |
const message = createBasePruneMessageBody(); | |
message.message = object.message !== void 0 && object.message !== null ? Message.fromPartial(object.message) : void 0; | |
return message; | |
} | |
}; | |
function createBaseRevokeMessageBody() { | |
return { message: void 0 }; | |
} | |
var RevokeMessageBody = { | |
encode(message, writer = import_minimal4.default.Writer.create()) { | |
if (message.message !== void 0) { | |
Message.encode(message.message, writer.uint32(10).fork()).ldelim(); | |
} | |
return writer; | |
}, | |
decode(input, length) { | |
const reader = input instanceof import_minimal4.default.Reader ? input : import_minimal4.default.Reader.create(input); | |
let end = length === void 0 ? reader.len : reader.pos + length; | |
const message = createBaseRevokeMessageBody(); | |
while (reader.pos < end) { | |
const tag = reader.uint32(); | |
switch (tag >>> 3) { | |
case 1: | |
if (tag != 10) { | |
break; | |
} | |
message.message = Message.decode(reader, reader.uint32()); | |
continue; | |
} | |
if ((tag & 7) == 4 || tag == 0) { | |
break; | |
} | |
reader.skipType(tag & 7); | |
} | |
return message; | |
}, | |
fromJSON(object) { | |
return { message: isSet4(object.message) ? Message.fromJSON(object.message) : void 0 }; | |
}, | |
toJSON(message) { | |
const obj = {}; | |
message.message !== void 0 && (obj.message = message.message ? Message.toJSON(message.message) : void 0); | |
return obj; | |
}, | |
create(base) { | |
return RevokeMessageBody.fromPartial(base != null ? base : {}); | |
}, | |
fromPartial(object) { | |
const message = createBaseRevokeMessageBody(); | |
message.message = object.message !== void 0 && object.message !== null ? Message.fromPartial(object.message) : void 0; | |
return message; | |
} | |
}; | |
function createBaseMergeIdRegistryEventBody() { | |
return { idRegistryEvent: void 0 }; | |
} | |
var MergeIdRegistryEventBody = { | |
encode(message, writer = import_minimal4.default.Writer.create()) { | |
if (message.idRegistryEvent !== void 0) { | |
IdRegistryEvent.encode(message.idRegistryEvent, writer.uint32(10).fork()).ldelim(); | |
} | |
return writer; | |
}, | |
decode(input, length) { | |
const reader = input instanceof import_minimal4.default.Reader ? input : import_minimal4.default.Reader.create(input); | |
let end = length === void 0 ? reader.len : reader.pos + length; | |
const message = createBaseMergeIdRegistryEventBody(); | |
while (reader.pos < end) { | |
const tag = reader.uint32(); | |
switch (tag >>> 3) { | |
case 1: | |
if (tag != 10) { | |
break; | |
} | |
message.idRegistryEvent = IdRegistryEvent.decode(reader, reader.uint32()); | |
continue; | |
} | |
if ((tag & 7) == 4 || tag == 0) { | |
break; | |
} | |
reader.skipType(tag & 7); | |
} | |
return message; | |
}, | |
fromJSON(object) { | |
return { | |
idRegistryEvent: isSet4(object.idRegistryEvent) ? IdRegistryEvent.fromJSON(object.idRegistryEvent) : void 0 | |
}; | |
}, | |
toJSON(message) { | |
const obj = {}; | |
message.idRegistryEvent !== void 0 && (obj.idRegistryEvent = message.idRegistryEvent ? IdRegistryEvent.toJSON(message.idRegistryEvent) : void 0); | |
return obj; | |
}, | |
create(base) { | |
return MergeIdRegistryEventBody.fromPartial(base != null ? base : {}); | |
}, | |
fromPartial(object) { | |
const message = createBaseMergeIdRegistryEventBody(); | |
message.idRegistryEvent = object.idRegistryEvent !== void 0 && object.idRegistryEvent !== null ? IdRegistryEvent.fromPartial(object.idRegistryEvent) : void 0; | |
return message; | |
} | |
}; | |
function createBaseMergeNameRegistryEventBody() { | |
return { nameRegistryEvent: void 0 }; | |
} | |
var MergeNameRegistryEventBody = { | |
encode(message, writer = import_minimal4.default.Writer.create()) { | |
if (message.nameRegistryEvent !== void 0) { | |
NameRegistryEvent.encode(message.nameRegistryEvent, writer.uint32(10).fork()).ldelim(); | |
} | |
return writer; | |
}, | |
decode(input, length) { | |
const reader = input instanceof import_minimal4.default.Reader ? input : import_minimal4.default.Reader.create(input); | |
let end = length === void 0 ? reader.len : reader.pos + length; | |
const message = createBaseMergeNameRegistryEventBody(); | |
while (reader.pos < end) { | |
const tag = reader.uint32(); | |
switch (tag >>> 3) { | |
case 1: | |
if (tag != 10) { | |
break; | |
} | |
message.nameRegistryEvent = NameRegistryEvent.decode(reader, reader.uint32()); | |
continue; | |
} | |
if ((tag & 7) == 4 || tag == 0) { | |
break; | |
} | |
reader.skipType(tag & 7); | |
} | |
return message; | |
}, | |
fromJSON(object) { | |
return { | |
nameRegistryEvent: isSet4(object.nameRegistryEvent) ? NameRegistryEvent.fromJSON(object.nameRegistryEvent) : void 0 | |
}; | |
}, | |
toJSON(message) { | |
const obj = {}; | |
message.nameRegistryEvent !== void 0 && (obj.nameRegistryEvent = message.nameRegistryEvent ? NameRegistryEvent.toJSON(message.nameRegistryEvent) : void 0); | |
return obj; | |
}, | |
create(base) { | |
return MergeNameRegistryEventBody.fromPartial(base != null ? base : {}); | |
}, | |
fromPartial(object) { | |
const message = createBaseMergeNameRegistryEventBody(); | |
message.nameRegistryEvent = object.nameRegistryEvent !== void 0 && object.nameRegistryEvent !== null ? NameRegistryEvent.fromPartial(object.nameRegistryEvent) : void 0; | |
return message; | |
} | |
}; | |
function createBaseHubEvent() { | |
return { | |
type: 0, | |
id: 0, | |
mergeMessageBody: void 0, | |
pruneMessageBody: void 0, | |
revokeMessageBody: void 0, | |
mergeIdRegistryEventBody: void 0, | |
mergeNameRegistryEventBody: void 0 | |
}; | |
} | |
var HubEvent = { | |
encode(message, writer = import_minimal4.default.Writer.create()) { | |
if (message.type !== 0) { | |
writer.uint32(8).int32(message.type); | |
} | |
if (message.id !== 0) { | |
writer.uint32(16).uint64(message.id); | |
} | |
if (message.mergeMessageBody !== void 0) { | |
MergeMessageBody.encode(message.mergeMessageBody, writer.uint32(26).fork()).ldelim(); | |
} | |
if (message.pruneMessageBody !== void 0) { | |
PruneMessageBody.encode(message.pruneMessageBody, writer.uint32(34).fork()).ldelim(); | |
} | |
if (message.revokeMessageBody !== void 0) { | |
RevokeMessageBody.encode(message.revokeMessageBody, writer.uint32(42).fork()).ldelim(); | |
} | |
if (message.mergeIdRegistryEventBody !== void 0) { | |
MergeIdRegistryEventBody.encode(message.mergeIdRegistryEventBody, writer.uint32(50).fork()).ldelim(); | |
} | |
if (message.mergeNameRegistryEventBody !== void 0) { | |
MergeNameRegistryEventBody.encode(message.mergeNameRegistryEventBody, writer.uint32(58).fork()).ldelim(); | |
} | |
return writer; | |
}, | |
decode(input, length) { | |
const reader = input instanceof import_minimal4.default.Reader ? input : import_minimal4.default.Reader.create(input); | |
let end = length === void 0 ? reader.len : reader.pos + length; | |
const message = createBaseHubEvent(); | |
while (reader.pos < end) { | |
const tag = reader.uint32(); | |
switch (tag >>> 3) { | |
case 1: | |
if (tag != 8) { | |
break; | |
} | |
message.type = reader.int32(); | |
continue; | |
case 2: | |
if (tag != 16) { | |
break; | |
} | |
message.id = longToNumber3(reader.uint64()); | |
continue; | |
case 3: | |
if (tag != 26) { | |
break; | |
} | |
message.mergeMessageBody = MergeMessageBody.decode(reader, reader.uint32()); | |
continue; | |
case 4: | |
if (tag != 34) { | |
break; | |
} | |
message.pruneMessageBody = PruneMessageBody.decode(reader, reader.uint32()); | |
continue; | |
case 5: | |
if (tag != 42) { | |
break; | |
} | |
message.revokeMessageBody = RevokeMessageBody.decode(reader, reader.uint32()); | |
continue; | |
case 6: | |
if (tag != 50) { | |
break; | |
} | |
message.mergeIdRegistryEventBody = MergeIdRegistryEventBody.decode(reader, reader.uint32()); | |
continue; | |
case 7: | |
if (tag != 58) { | |
break; | |
} | |
message.mergeNameRegistryEventBody = MergeNameRegistryEventBody.decode(reader, reader.uint32()); | |
continue; | |
} | |
if ((tag & 7) == 4 || tag == 0) { | |
break; | |
} | |
reader.skipType(tag & 7); | |
} | |
return message; | |
}, | |
fromJSON(object) { | |
return { | |
type: isSet4(object.type) ? hubEventTypeFromJSON(object.type) : 0, | |
id: isSet4(object.id) ? Number(object.id) : 0, | |
mergeMessageBody: isSet4(object.mergeMessageBody) ? MergeMessageBody.fromJSON(object.mergeMessageBody) : void 0, | |
pruneMessageBody: isSet4(object.pruneMessageBody) ? PruneMessageBody.fromJSON(object.pruneMessageBody) : void 0, | |
revokeMessageBody: isSet4(object.revokeMessageBody) ? RevokeMessageBody.fromJSON(object.revokeMessageBody) : void 0, | |
mergeIdRegistryEventBody: isSet4(object.mergeIdRegistryEventBody) ? MergeIdRegistryEventBody.fromJSON(object.mergeIdRegistryEventBody) : void 0, | |
mergeNameRegistryEventBody: isSet4(object.mergeNameRegistryEventBody) ? MergeNameRegistryEventBody.fromJSON(object.mergeNameRegistryEventBody) : void 0 | |
}; | |
}, | |
toJSON(message) { | |
const obj = {}; | |
message.type !== void 0 && (obj.type = hubEventTypeToJSON(message.type)); | |
message.id !== void 0 && (obj.id = Math.round(message.id)); | |
message.mergeMessageBody !== void 0 && (obj.mergeMessageBody = message.mergeMessageBody ? MergeMessageBody.toJSON(message.mergeMessageBody) : void 0); | |
message.pruneMessageBody !== void 0 && (obj.pruneMessageBody = message.pruneMessageBody ? PruneMessageBody.toJSON(message.pruneMessageBody) : void 0); | |
message.revokeMessageBody !== void 0 && (obj.revokeMessageBody = message.revokeMessageBody ? RevokeMessageBody.toJSON(message.revokeMessageBody) : void 0); | |
message.mergeIdRegistryEventBody !== void 0 && (obj.mergeIdRegistryEventBody = message.mergeIdRegistryEventBody ? MergeIdRegistryEventBody.toJSON(message.mergeIdRegistryEventBody) : void 0); | |
message.mergeNameRegistryEventBody !== void 0 && (obj.mergeNameRegistryEventBody = message.mergeNameRegistryEventBody ? MergeNameRegistryEventBody.toJSON(message.mergeNameRegistryEventBody) : void 0); | |
return obj; | |
}, | |
create(base) { | |
return HubEvent.fromPartial(base != null ? base : {}); | |
}, | |
fromPartial(object) { | |
var _a, _b; | |
const message = createBaseHubEvent(); | |
message.type = (_a = object.type) != null ? _a : 0; | |
message.id = (_b = object.id) != null ? _b : 0; | |
message.mergeMessageBody = object.mergeMessageBody !== void 0 && object.mergeMessageBody !== null ? MergeMessageBody.fromPartial(object.mergeMessageBody) : void 0; | |
message.pruneMessageBody = object.pruneMessageBody !== void 0 && object.pruneMessageBody !== null ? PruneMessageBody.fromPartial(object.pruneMessageBody) : void 0; | |
message.revokeMessageBody = object.revokeMessageBody !== void 0 && object.revokeMessageBody !== null ? RevokeMessageBody.fromPartial(object.revokeMessageBody) : void 0; | |
message.mergeIdRegistryEventBody = object.mergeIdRegistryEventBody !== void 0 && object.mergeIdRegistryEventBody !== null ? MergeIdRegistryEventBody.fromPartial(object.mergeIdRegistryEventBody) : void 0; | |
message.mergeNameRegistryEventBody = object.mergeNameRegistryEventBody !== void 0 && object.mergeNameRegistryEventBody !== null ? MergeNameRegistryEventBody.fromPartial(object.mergeNameRegistryEventBody) : void 0; | |
return message; | |
} | |
}; | |
var tsProtoGlobalThis4 = (() => { | |
if (typeof globalThis !== "undefined") { | |
return globalThis; | |
} | |
if (typeof self !== "undefined") { | |
return self; | |
} | |
if (typeof window !== "undefined") { | |
return window; | |
} | |
if (typeof global !== "undefined") { | |
return global; | |
} | |
throw "Unable to locate global object"; | |
})(); | |
function longToNumber3(long) { | |
if (long.gt(Number.MAX_SAFE_INTEGER)) { | |
throw new tsProtoGlobalThis4.Error("Value is larger than Number.MAX_SAFE_INTEGER"); | |
} | |
return long.toNumber(); | |
} | |
if (import_minimal4.default.util.Long !== import_long3.default) { | |
import_minimal4.default.util.Long = import_long3.default; | |
import_minimal4.default.configure(); | |
} | |
function isSet4(value) { | |
return value !== null && value !== void 0; | |
} | |
// src/generated/request_response.ts | |
init_cjs_shims(); | |
var import_long4 = __toESM(require_long()); | |
var import_minimal5 = __toESM(require_minimal2()); | |
function createBaseEmpty() { | |
return {}; | |
} | |
var Empty = { | |
encode(_, writer = import_minimal5.default.Writer.create()) { | |
return writer; | |
}, | |
decode(input, length) { | |
const reader = input instanceof import_minimal5.default.Reader ? input : import_minimal5.default.Reader.create(input); | |
let end = length === void 0 ? reader.len : reader.pos + length; | |
const message = createBaseEmpty(); | |
while (reader.pos < end) { | |
const tag = reader.uint32(); | |
switch (tag >>> 3) { | |
} | |
if ((tag & 7) == 4 || tag == 0) { | |
break; | |
} | |
reader.skipType(tag & 7); | |
} | |
return message; | |
}, | |
fromJSON(_) { | |
return {}; | |
}, | |
toJSON(_) { | |
const obj = {}; | |
return obj; | |
}, | |
create(base) { | |
return Empty.fromPartial(base != null ? base : {}); | |
}, | |
fromPartial(_) { | |
const message = createBaseEmpty(); | |
return message; | |
} | |
}; | |
function createBaseSubscribeRequest() { | |
return { eventTypes: [], fromId: void 0 }; | |
} | |
var SubscribeRequest = { | |
encode(message, writer = import_minimal5.default.Writer.create()) { | |
writer.uint32(10).fork(); | |
for (const v of message.eventTypes) { | |
writer.int32(v); | |
} | |
writer.ldelim(); | |
if (message.fromId !== void 0) { | |
writer.uint32(16).uint64(message.fromId); | |
} | |
return writer; | |
}, | |
decode(input, length) { | |
const reader = input instanceof import_minimal5.default.Reader ? input : import_minimal5.default.Reader.create(input); | |
let end = length === void 0 ? reader.len : reader.pos + length; | |
const message = createBaseSubscribeRequest(); | |
while (reader.pos < end) { | |
const tag = reader.uint32(); | |
switch (tag >>> 3) { | |
case 1: | |
if (tag == 8) { | |
message.eventTypes.push(reader.int32()); | |
continue; | |
} | |
if (tag == 10) { | |
const end2 = reader.uint32() + reader.pos; | |
while (reader.pos < end2) { | |
message.eventTypes.push(reader.int32()); | |
} | |
continue; | |
} | |
break; | |
case 2: | |
if (tag != 16) { | |
break; | |
} | |
message.fromId = longToNumber4(reader.uint64()); | |
continue; | |
} | |
if ((tag & 7) == 4 || tag == 0) { | |
break; | |
} | |
reader.skipType(tag & 7); | |
} | |
return message; | |
}, | |
fromJSON(object) { | |
return { | |
eventTypes: Array.isArray(object == null ? void 0 : object.eventTypes) ? object.eventTypes.map((e) => hubEventTypeFromJSON(e)) : [], | |
fromId: isSet5(object.fromId) ? Number(object.fromId) : void 0 | |
}; | |
}, | |
toJSON(message) { | |
const obj = {}; | |
if (message.eventTypes) { | |
obj.eventTypes = message.eventTypes.map((e) => hubEventTypeToJSON(e)); | |
} else { | |
obj.eventTypes = []; | |
} | |
message.fromId !== void 0 && (obj.fromId = Math.round(message.fromId)); | |
return obj; | |
}, | |
create(base) { | |
return SubscribeRequest.fromPartial(base != null ? base : {}); | |
}, | |
fromPartial(object) { | |
var _a, _b; | |
const message = createBaseSubscribeRequest(); | |
message.eventTypes = ((_a = object.eventTypes) == null ? void 0 : _a.map((e) => e)) || []; | |
message.fromId = (_b = object.fromId) != null ? _b : void 0; | |
return message; | |
} | |
}; | |
function createBaseEventRequest() { | |
return { id: 0 }; | |
} | |
var EventRequest = { | |
encode(message, writer = import_minimal5.default.Writer.create()) { | |
if (message.id !== 0) { | |
writer.uint32(8).uint64(message.id); | |
} | |
return writer; | |
}, | |
decode(input, length) { | |
const reader = input instanceof import_minimal5.default.Reader ? input : import_minimal5.default.Reader.create(input); | |
let end = length === void 0 ? reader.len : reader.pos + length; | |
const message = createBaseEventRequest(); | |
while (reader.pos < end) { | |
const tag = reader.uint32(); | |
switch (tag >>> 3) { | |
case 1: | |
if (tag != 8) { | |
break; | |
} | |
message.id = longToNumber4(reader.uint64()); | |
continue; | |
} | |
if ((tag & 7) == 4 || tag == 0) { | |
break; | |
} | |
reader.skipType(tag & 7); | |
} | |
return message; | |
}, | |
fromJSON(object) { | |
return { id: isSet5(object.id) ? Number(object.id) : 0 }; | |
}, | |
toJSON(message) { | |
const obj = {}; | |
message.id !== void 0 && (obj.id = Math.round(message.id)); | |
return obj; | |
}, | |
create(base) { | |
return EventRequest.fromPartial(base != null ? base : {}); | |
}, | |
fromPartial(object) { | |
var _a; | |
const message = createBaseEventRequest(); | |
message.id = (_a = object.id) != null ? _a : 0; | |
return message; | |
} | |
}; | |
function createBaseHubInfoResponse() { | |
return { version: "", isSynced: false, nickname: "", rootHash: "" }; | |
} | |
var HubInfoResponse = { | |
encode(message, writer = import_minimal5.default.Writer.create()) { | |
if (message.version !== "") { | |
writer.uint32(10).string(message.version); | |
} | |
if (message.isSynced === true) { | |
writer.uint32(16).bool(message.isSynced); | |
} | |
if (message.nickname !== "") { | |
writer.uint32(26).string(message.nickname); | |
} | |
if (message.rootHash !== "") { | |
writer.uint32(34).string(message.rootHash); | |
} | |
return writer; | |
}, | |
decode(input, length) { | |
const reader = input instanceof import_minimal5.default.Reader ? input : import_minimal5.default.Reader.create(input); | |
let end = length === void 0 ? reader.len : reader.pos + length; | |
const message = createBaseHubInfoResponse(); | |
while (reader.pos < end) { | |
const tag = reader.uint32(); | |
switch (tag >>> 3) { | |
case 1: | |
if (tag != 10) { | |
break; | |
} | |
message.version = reader.string(); | |
continue; | |
case 2: | |
if (tag != 16) { | |
break; | |
} | |
message.isSynced = reader.bool(); | |
continue; | |
case 3: | |
if (tag != 26) { | |
break; | |
} | |
message.nickname = reader.string(); | |
continue; | |
case 4: | |
if (tag != 34) { | |
break; | |
} | |
message.rootHash = reader.string(); | |
continue; | |
} | |
if ((tag & 7) == 4 || tag == 0) { | |
break; | |
} | |
reader.skipType(tag & 7); | |
} | |
return message; | |
}, | |
fromJSON(object) { | |
return { | |
version: isSet5(object.version) ? String(object.version) : "", | |
isSynced: isSet5(object.isSynced) ? Boolean(object.isSynced) : false, | |
nickname: isSet5(object.nickname) ? String(object.nickname) : "", | |
rootHash: isSet5(object.rootHash) ? String(object.rootHash) : "" | |
}; | |
}, | |
toJSON(message) { | |
const obj = {}; | |
message.version !== void 0 && (obj.version = message.version); | |
message.isSynced !== void 0 && (obj.isSynced = message.isSynced); | |
message.nickname !== void 0 && (obj.nickname = message.nickname); | |
message.rootHash !== void 0 && (obj.rootHash = message.rootHash); | |
return obj; | |
}, | |
create(base) { | |
return HubInfoResponse.fromPartial(base != null ? base : {}); | |
}, | |
fromPartial(object) { | |
var _a, _b, _c, _d; | |
const message = createBaseHubInfoResponse(); | |
message.version = (_a = object.version) != null ? _a : ""; | |
message.isSynced = (_b = object.isSynced) != null ? _b : false; | |
message.nickname = (_c = object.nickname) != null ? _c : ""; | |
message.rootHash = (_d = object.rootHash) != null ? _d : ""; | |
return message; | |
} | |
}; | |
function createBaseTrieNodeMetadataResponse() { | |
return { prefix: new Uint8Array(), numMessages: 0, hash: "", children: [] }; | |
} | |
var TrieNodeMetadataResponse = { | |
encode(message, writer = import_minimal5.default.Writer.create()) { | |
if (message.prefix.length !== 0) { | |
writer.uint32(10).bytes(message.prefix); | |
} | |
if (message.numMessages !== 0) { | |
writer.uint32(16).uint64(message.numMessages); | |
} | |
if (message.hash !== "") { | |
writer.uint32(26).string(message.hash); | |
} | |
for (const v of message.children) { | |
TrieNodeMetadataResponse.encode(v, writer.uint32(34).fork()).ldelim(); | |
} | |
return writer; | |
}, | |
decode(input, length) { | |
const reader = input instanceof import_minimal5.default.Reader ? input : import_minimal5.default.Reader.create(input); | |
let end = length === void 0 ? reader.len : reader.pos + length; | |
const message = createBaseTrieNodeMetadataResponse(); | |
while (reader.pos < end) { | |
const tag = reader.uint32(); | |
switch (tag >>> 3) { | |
case 1: | |
if (tag != 10) { | |
break; | |
} | |
message.prefix = reader.bytes(); | |
continue; | |
case 2: | |
if (tag != 16) { | |
break; | |
} | |
message.numMessages = longToNumber4(reader.uint64()); | |
continue; | |
case 3: | |
if (tag != 26) { | |
break; | |
} | |
message.hash = reader.string(); | |
continue; | |
case 4: | |
if (tag != 34) { | |
break; | |
} | |
message.children.push(TrieNodeMetadataResponse.decode(reader, reader.uint32())); | |
continue; | |
} | |
if ((tag & 7) == 4 || tag == 0) { | |
break; | |
} | |
reader.skipType(tag & 7); | |
} | |
return message; | |
}, | |
fromJSON(object) { | |
return { | |
prefix: isSet5(object.prefix) ? bytesFromBase644(object.prefix) : new Uint8Array(), | |
numMessages: isSet5(object.numMessages) ? Number(object.numMessages) : 0, | |
hash: isSet5(object.hash) ? String(object.hash) : "", | |
children: Array.isArray(object == null ? void 0 : object.children) ? object.children.map((e) => TrieNodeMetadataResponse.fromJSON(e)) : [] | |
}; | |
}, | |
toJSON(message) { | |
const obj = {}; | |
message.prefix !== void 0 && (obj.prefix = base64FromBytes4(message.prefix !== void 0 ? message.prefix : new Uint8Array())); | |
message.numMessages !== void 0 && (obj.numMessages = Math.round(message.numMessages)); | |
message.hash !== void 0 && (obj.hash = message.hash); | |
if (message.children) { | |
obj.children = message.children.map((e) => e ? TrieNodeMetadataResponse.toJSON(e) : void 0); | |
} else { | |
obj.children = []; | |
} | |
return obj; | |
}, | |
create(base) { | |
return TrieNodeMetadataResponse.fromPartial(base != null ? base : {}); | |
}, | |
fromPartial(object) { | |
var _a, _b, _c, _d; | |
const message = createBaseTrieNodeMetadataResponse(); | |
message.prefix = (_a = object.prefix) != null ? _a : new Uint8Array(); | |
message.numMessages = (_b = object.numMessages) != null ? _b : 0; | |
message.hash = (_c = object.hash) != null ? _c : ""; | |
message.children = ((_d = object.children) == null ? void 0 : _d.map((e) => TrieNodeMetadataResponse.fromPartial(e))) || []; | |
return message; | |
} | |
}; | |
function createBaseTrieNodeSnapshotResponse() { | |
return { prefix: new Uint8Array(), excludedHashes: [], numMessages: 0, rootHash: "" }; | |
} | |
var TrieNodeSnapshotResponse = { | |
encode(message, writer = import_minimal5.default.Writer.create()) { | |
if (message.prefix.length !== 0) { | |
writer.uint32(10).bytes(message.prefix); | |
} | |
for (const v of message.excludedHashes) { | |
writer.uint32(18).string(v); | |
} | |
if (message.numMessages !== 0) { | |
writer.uint32(24).uint64(message.numMessages); | |
} | |
if (message.rootHash !== "") { | |
writer.uint32(34).string(message.rootHash); | |
} | |
return writer; | |
}, | |
decode(input, length) { | |
const reader = input instanceof import_minimal5.default.Reader ? input : import_minimal5.default.Reader.create(input); | |
let end = length === void 0 ? reader.len : reader.pos + length; | |
const message = createBaseTrieNodeSnapshotResponse(); | |
while (reader.pos < end) { | |
const tag = reader.uint32(); | |
switch (tag >>> 3) { | |
case 1: | |
if (tag != 10) { | |
break; | |
} | |
message.prefix = reader.bytes(); | |
continue; | |
case 2: | |
if (tag != 18) { | |
break; | |
} | |
message.excludedHashes.push(reader.string()); | |
continue; | |
case 3: | |
if (tag != 24) { | |
break; | |
} | |
message.numMessages = longToNumber4(reader.uint64()); | |
continue; | |
case 4: | |
if (tag != 34) { | |
break; | |
} | |
message.rootHash = reader.string(); | |
continue; | |
} | |
if ((tag & 7) == 4 || tag == 0) { | |
break; | |
} | |
reader.skipType(tag & 7); | |
} | |
return message; | |
}, | |
fromJSON(object) { | |
return { | |
prefix: isSet5(object.prefix) ? bytesFromBase644(object.prefix) : new Uint8Array(), | |
excludedHashes: Array.isArray(object == null ? void 0 : object.excludedHashes) ? object.excludedHashes.map((e) => String(e)) : [], | |
numMessages: isSet5(object.numMessages) ? Number(object.numMessages) : 0, | |
rootHash: isSet5(object.rootHash) ? String(object.rootHash) : "" | |
}; | |
}, | |
toJSON(message) { | |
const obj = {}; | |
message.prefix !== void 0 && (obj.prefix = base64FromBytes4(message.prefix !== void 0 ? message.prefix : new Uint8Array())); | |
if (message.excludedHashes) { | |
obj.excludedHashes = message.excludedHashes.map((e) => e); | |
} else { | |
obj.excludedHashes = []; | |
} | |
message.numMessages !== void 0 && (obj.numMessages = Math.round(message.numMessages)); | |
message.rootHash !== void 0 && (obj.rootHash = message.rootHash); | |
return obj; | |
}, | |
create(base) { | |
return TrieNodeSnapshotResponse.fromPartial(base != null ? base : {}); | |
}, | |
fromPartial(object) { | |
var _a, _b, _c, _d; | |
const message = createBaseTrieNodeSnapshotResponse(); | |
message.prefix = (_a = object.prefix) != null ? _a : new Uint8Array(); | |
message.excludedHashes = ((_b = object.excludedHashes) == null ? void 0 : _b.map((e) => e)) || []; | |
message.numMessages = (_c = object.numMessages) != null ? _c : 0; | |
message.rootHash = (_d = object.rootHash) != null ? _d : ""; | |
return message; | |
} | |
}; | |
function createBaseTrieNodePrefix() { | |
return { prefix: new Uint8Array() }; | |
} | |
var TrieNodePrefix = { | |
encode(message, writer = import_minimal5.default.Writer.create()) { | |
if (message.prefix.length !== 0) { | |
writer.uint32(10).bytes(message.prefix); | |
} | |
return writer; | |
}, | |
decode(input, length) { | |
const reader = input instanceof import_minimal5.default.Reader ? input : import_minimal5.default.Reader.create(input); | |
let end = length === void 0 ? reader.len : reader.pos + length; | |
const message = createBaseTrieNodePrefix(); | |
while (reader.pos < end) { | |
const tag = reader.uint32(); | |
switch (tag >>> 3) { | |
case 1: | |
if (tag != 10) { | |
break; | |
} | |
message.prefix = reader.bytes(); | |
continue; | |
} | |
if ((tag & 7) == 4 || tag == 0) { | |
break; | |
} | |
reader.skipType(tag & 7); | |
} | |
return message; | |
}, | |
fromJSON(object) { | |
return { prefix: isSet5(object.prefix) ? bytesFromBase644(object.prefix) : new Uint8Array() }; | |
}, | |
toJSON(message) { | |
const obj = {}; | |
message.prefix !== void 0 && (obj.prefix = base64FromBytes4(message.prefix !== void 0 ? message.prefix : new Uint8Array())); | |
return obj; | |
}, | |
create(base) { | |
return TrieNodePrefix.fromPartial(base != null ? base : {}); | |
}, | |
fromPartial(object) { | |
var _a; | |
const message = createBaseTrieNodePrefix(); | |
message.prefix = (_a = object.prefix) != null ? _a : new Uint8Array(); | |
return message; | |
} | |
}; | |
function createBaseSyncIds() { | |
return { syncIds: [] }; | |
} | |
var SyncIds = { | |
encode(message, writer = import_minimal5.default.Writer.create()) { | |
for (const v of message.syncIds) { | |
writer.uint32(10).bytes(v); | |
} | |
return writer; | |
}, | |
decode(input, length) { | |
const reader = input instanceof import_minimal5.default.Reader ? input : import_minimal5.default.Reader.create(input); | |
let end = length === void 0 ? reader.len : reader.pos + length; | |
const message = createBaseSyncIds(); | |
while (reader.pos < end) { | |
const tag = reader.uint32(); | |
switch (tag >>> 3) { | |
case 1: | |
if (tag != 10) { | |
break; | |
} | |
message.syncIds.push(reader.bytes()); | |
continue; | |
} | |
if ((tag & 7) == 4 || tag == 0) { | |
break; | |
} | |
reader.skipType(tag & 7); | |
} | |
return message; | |
}, | |
fromJSON(object) { | |
return { syncIds: Array.isArray(object == null ? void 0 : object.syncIds) ? object.syncIds.map((e) => bytesFromBase644(e)) : [] }; | |
}, | |
toJSON(message) { | |
const obj = {}; | |
if (message.syncIds) { | |
obj.syncIds = message.syncIds.map((e) => base64FromBytes4(e !== void 0 ? e : new Uint8Array())); | |
} else { | |
obj.syncIds = []; | |
} | |
return obj; | |
}, | |
create(base) { | |
return SyncIds.fromPartial(base != null ? base : {}); | |
}, | |
fromPartial(object) { | |
var _a; | |
const message = createBaseSyncIds(); | |
message.syncIds = ((_a = object.syncIds) == null ? void 0 : _a.map((e) => e)) || []; | |
return message; | |
} | |
}; | |
function createBaseFidRequest() { | |
return { fid: 0, pageSize: void 0, pageToken: void 0, reverse: void 0 }; | |
} | |
var FidRequest = { | |
encode(message, writer = import_minimal5.default.Writer.create()) { | |
if (message.fid !== 0) { | |
writer.uint32(8).uint64(message.fid); | |
} | |
if (message.pageSize !== void 0) { | |
writer.uint32(16).uint32(message.pageSize); | |
} | |
if (message.pageToken !== void 0) { | |
writer.uint32(26).bytes(message.pageToken); | |
} | |
if (message.reverse !== void 0) { | |
writer.uint32(32).bool(message.reverse); | |
} | |
return writer; | |
}, | |
decode(input, length) { | |
const reader = input instanceof import_minimal5.default.Reader ? input : import_minimal5.default.Reader.create(input); | |
let end = length === void 0 ? reader.len : reader.pos + length; | |
const message = createBaseFidRequest(); | |
while (reader.pos < end) { | |
const tag = reader.uint32(); | |
switch (tag >>> 3) { | |
case 1: | |
if (tag != 8) { | |
break; | |
} | |
message.fid = longToNumber4(reader.uint64()); | |
continue; | |
case 2: | |
if (tag != 16) { | |
break; | |
} | |
message.pageSize = reader.uint32(); | |
continue; | |
case 3: | |
if (tag != 26) { | |
break; | |
} | |
message.pageToken = reader.bytes(); | |
continue; | |
case 4: | |
if (tag != 32) { | |
break; | |
} | |
message.reverse = reader.bool(); | |
continue; | |
} | |
if ((tag & 7) == 4 || tag == 0) { | |
break; | |
} | |
reader.skipType(tag & 7); | |
} | |
return message; | |
}, | |
fromJSON(object) { | |
return { | |
fid: isSet5(object.fid) ? Number(object.fid) : 0, | |
pageSize: isSet5(object.pageSize) ? Number(object.pageSize) : void 0, | |
pageToken: isSet5(object.pageToken) ? bytesFromBase644(object.pageToken) : void 0, | |
reverse: isSet5(object.reverse) ? Boolean(object.reverse) : void 0 | |
}; | |
}, | |
toJSON(message) { | |
const obj = {}; | |
message.fid !== void 0 && (obj.fid = Math.round(message.fid)); | |
message.pageSize !== void 0 && (obj.pageSize = Math.round(message.pageSize)); | |
message.pageToken !== void 0 && (obj.pageToken = message.pageToken !== void 0 ? base64FromBytes4(message.pageToken) : void 0); | |
message.reverse !== void 0 && (obj.reverse = message.reverse); | |
return obj; | |
}, | |
create(base) { | |
return FidRequest.fromPartial(base != null ? base : {}); | |
}, | |
fromPartial(object) { | |
var _a, _b, _c, _d; | |
const message = createBaseFidRequest(); | |
message.fid = (_a = object.fid) != null ? _a : 0; | |
message.pageSize = (_b = object.pageSize) != null ? _b : void 0; | |
message.pageToken = (_c = object.pageToken) != null ? _c : void 0; | |
message.reverse = (_d = object.reverse) != null ? _d : void 0; | |
return message; | |
} | |
}; | |
function createBaseFidsRequest() { | |
return { pageSize: void 0, pageToken: void 0, reverse: void 0 }; | |
} | |
var FidsRequest = { | |
encode(message, writer = import_minimal5.default.Writer.create()) { | |
if (message.pageSize !== void 0) { | |
writer.uint32(8).uint32(message.pageSize); | |
} | |
if (message.pageToken !== void 0) { | |
writer.uint32(18).bytes(message.pageToken); | |
} | |
if (message.reverse !== void 0) { | |
writer.uint32(24).bool(message.reverse); | |
} | |
return writer; | |
}, | |
decode(input, length) { | |
const reader = input instanceof import_minimal5.default.Reader ? input : import_minimal5.default.Reader.create(input); | |
let end = length === void 0 ? reader.len : reader.pos + length; | |
const message = createBaseFidsRequest(); | |
while (reader.pos < end) { | |
const tag = reader.uint32(); | |
switch (tag >>> 3) { | |
case 1: | |
if (tag != 8) { | |
break; | |
} | |
message.pageSize = reader.uint32(); | |
continue; | |
case 2: | |
if (tag != 18) { | |
break; | |
} | |
message.pageToken = reader.bytes(); | |
continue; | |
case 3: | |
if (tag != 24) { | |
break; | |
} | |
message.reverse = reader.bool(); | |
continue; | |
} | |
if ((tag & 7) == 4 || tag == 0) { | |
break; | |
} | |
reader.skipType(tag & 7); | |
} | |
return message; | |
}, | |
fromJSON(object) { | |
return { | |
pageSize: isSet5(object.pageSize) ? Number(object.pageSize) : void 0, | |
pageToken: isSet5(object.pageToken) ? bytesFromBase644(object.pageToken) : void 0, | |
reverse: isSet5(object.reverse) ? Boolean(object.reverse) : void 0 | |
}; | |
}, | |
toJSON(message) { | |
const obj = {}; | |
message.pageSize !== void 0 && (obj.pageSize = Math.round(message.pageSize)); | |
message.pageToken !== void 0 && (obj.pageToken = message.pageToken !== void 0 ? base64FromBytes4(message.pageToken) : void 0); | |
message.reverse !== void 0 && (obj.reverse = message.reverse); | |
return obj; | |
}, | |
create(base) { | |
return FidsRequest.fromPartial(base != null ? base : {}); | |
}, | |
fromPartial(object) { | |
var _a, _b, _c; | |
const message = createBaseFidsRequest(); | |
message.pageSize = (_a = object.pageSize) != null ? _a : void 0; | |
message.pageToken = (_b = object.pageToken) != null ? _b : void 0; | |
message.reverse = (_c = object.reverse) != null ? _c : void 0; | |
return message; | |
} | |
}; | |
function createBaseFidsResponse() { | |
return { fids: [], nextPageToken: void 0 }; | |
} | |
var FidsResponse = { | |
encode(message, writer = import_minimal5.default.Writer.create()) { | |
writer.uint32(10).fork(); | |
for (const v of message.fids) { | |
writer.uint64(v); | |
} | |
writer.ldelim(); | |
if (message.nextPageToken !== void 0) { | |
writer.uint32(18).bytes(message.nextPageToken); | |
} | |
return writer; | |
}, | |
decode(input, length) { | |
const reader = input instanceof import_minimal5.default.Reader ? input : import_minimal5.default.Reader.create(input); | |
let end = length === void 0 ? reader.len : reader.pos + length; | |
const message = createBaseFidsResponse(); | |
while (reader.pos < end) { | |
const tag = reader.uint32(); | |
switch (tag >>> 3) { | |
case 1: | |
if (tag == 8) { | |
message.fids.push(longToNumber4(reader.uint64())); | |
continue; | |
} | |
if (tag == 10) { | |
const end2 = reader.uint32() + reader.pos; | |
while (reader.pos < end2) { | |
message.fids.push(longToNumber4(reader.uint64())); | |
} | |
continue; | |
} | |
break; | |
case 2: | |
if (tag != 18) { | |
break; | |
} | |
message.nextPageToken = reader.bytes(); | |
continue; | |
} | |
if ((tag & 7) == 4 || tag == 0) { | |
break; | |
} | |
reader.skipType(tag & 7); | |
} | |
return message; | |
}, | |
fromJSON(object) { | |
return { | |
fids: Array.isArray(object == null ? void 0 : object.fids) ? object.fids.map((e) => Number(e)) : [], | |
nextPageToken: isSet5(object.nextPageToken) ? bytesFromBase644(object.nextPageToken) : void 0 | |
}; | |
}, | |
toJSON(message) { | |
const obj = {}; | |
if (message.fids) { | |
obj.fids = message.fids.map((e) => Math.round(e)); | |
} else { | |
obj.fids = []; | |
} | |
message.nextPageToken !== void 0 && (obj.nextPageToken = message.nextPageToken !== void 0 ? base64FromBytes4(message.nextPageToken) : void 0); | |
return obj; | |
}, | |
create(base) { | |
return FidsResponse.fromPartial(base != null ? base : {}); | |
}, | |
fromPartial(object) { | |
var _a, _b; | |
const message = createBaseFidsResponse(); | |
message.fids = ((_a = object.fids) == null ? void 0 : _a.map((e) => e)) || []; | |
message.nextPageToken = (_b = object.nextPageToken) != null ? _b : void 0; | |
return message; | |
} | |
}; | |
function createBaseMessagesResponse() { | |
return { messages: [], nextPageToken: void 0 }; | |
} | |
var MessagesResponse = { | |
encode(message, writer = import_minimal5.default.Writer.create()) { | |
for (const v of message.messages) { | |
Message.encode(v, writer.uint32(10).fork()).ldelim(); | |
} | |
if (message.nextPageToken !== void 0) { | |
writer.uint32(18).bytes(message.nextPageToken); | |
} | |
return writer; | |
}, | |
decode(input, length) { | |
const reader = input instanceof import_minimal5.default.Reader ? input : import_minimal5.default.Reader.create(input); | |
let end = length === void 0 ? reader.len : reader.pos + length; | |
const message = createBaseMessagesResponse(); | |
while (reader.pos < end) { | |
const tag = reader.uint32(); | |
switch (tag >>> 3) { | |
case 1: | |
if (tag != 10) { | |
break; | |
} | |
message.messages.push(Message.decode(reader, reader.uint32())); | |
continue; | |
case 2: | |
if (tag != 18) { | |
break; | |
} | |
message.nextPageToken = reader.bytes(); | |
continue; | |
} | |
if ((tag & 7) == 4 || tag == 0) { | |
break; | |
} | |
reader.skipType(tag & 7); | |
} | |
return message; | |
}, | |
fromJSON(object) { | |
return { | |
messages: Array.isArray(object == null ? void 0 : object.messages) ? object.messages.map((e) => Message.fromJSON(e)) : [], | |
nextPageToken: isSet5(object.nextPageToken) ? bytesFromBase644(object.nextPageToken) : void 0 | |
}; | |
}, | |
toJSON(message) { | |
const obj = {}; | |
if (message.messages) { | |
obj.messages = message.messages.map((e) => e ? Message.toJSON(e) : void 0); | |
} else { | |
obj.messages = []; | |
} | |
message.nextPageToken !== void 0 && (obj.nextPageToken = message.nextPageToken !== void 0 ? base64FromBytes4(message.nextPageToken) : void 0); | |
return obj; | |
}, | |
create(base) { | |
return MessagesResponse.fromPartial(base != null ? base : {}); | |
}, | |
fromPartial(object) { | |
var _a, _b; | |
const message = createBaseMessagesResponse(); | |
message.messages = ((_a = object.messages) == null ? void 0 : _a.map((e) => Message.fromPartial(e))) || []; | |
message.nextPageToken = (_b = object.nextPageToken) != null ? _b : void 0; | |
return message; | |
} | |
}; | |
function createBaseCastsByParentRequest() { | |
return { castId: void 0, pageSize: void 0, pageToken: void 0, reverse: void 0 }; | |
} | |
var CastsByParentRequest = { | |
encode(message, writer = import_minimal5.default.Writer.create()) { | |
if (message.castId !== void 0) { | |
CastId.encode(message.castId, writer.uint32(10).fork()).ldelim(); | |
} | |
if (message.pageSize !== void 0) { | |
writer.uint32(16).uint32(message.pageSize); | |
} | |
if (message.pageToken !== void 0) { | |
writer.uint32(26).bytes(message.pageToken); | |
} | |
if (message.reverse !== void 0) { | |
writer.uint32(32).bool(message.reverse); | |
} | |
return writer; | |
}, | |
decode(input, length) { | |
const reader = input instanceof import_minimal5.default.Reader ? input : import_minimal5.default.Reader.create(input); | |
let end = length === void 0 ? reader.len : reader.pos + length; | |
const message = createBaseCastsByParentRequest(); | |
while (reader.pos < end) { | |
const tag = reader.uint32(); | |
switch (tag >>> 3) { | |
case 1: | |
if (tag != 10) { | |
break; | |
} | |
message.castId = CastId.decode(reader, reader.uint32()); | |
continue; | |
case 2: | |
if (tag != 16) { | |
break; | |
} | |
message.pageSize = reader.uint32(); | |
continue; | |
case 3: | |
if (tag != 26) { | |
break; | |
} | |
message.pageToken = reader.bytes(); | |
continue; | |
case 4: | |
if (tag != 32) { | |
break; | |
} | |
message.reverse = reader.bool(); | |
continue; | |
} | |
if ((tag & 7) == 4 || tag == 0) { | |
break; | |
} | |
reader.skipType(tag & 7); | |
} | |
return message; | |
}, | |
fromJSON(object) { | |
return { | |
castId: isSet5(object.castId) ? CastId.fromJSON(object.castId) : void 0, | |
pageSize: isSet5(object.pageSize) ? Number(object.pageSize) : void 0, | |
pageToken: isSet5(object.pageToken) ? bytesFromBase644(object.pageToken) : void 0, | |
reverse: isSet5(object.reverse) ? Boolean(object.reverse) : void 0 | |
}; | |
}, | |
toJSON(message) { | |
const obj = {}; | |
message.castId !== void 0 && (obj.castId = message.castId ? CastId.toJSON(message.castId) : void 0); | |
message.pageSize !== void 0 && (obj.pageSize = Math.round(message.pageSize)); | |
message.pageToken !== void 0 && (obj.pageToken = message.pageToken !== void 0 ? base64FromBytes4(message.pageToken) : void 0); | |
message.reverse !== void 0 && (obj.reverse = message.reverse); | |
return obj; | |
}, | |
create(base) { | |
return CastsByParentRequest.fromPartial(base != null ? base : {}); | |
}, | |
fromPartial(object) { | |
var _a, _b, _c; | |
const message = createBaseCastsByParentRequest(); | |
message.castId = object.castId !== void 0 && object.castId !== null ? CastId.fromPartial(object.castId) : void 0; | |
message.pageSize = (_a = object.pageSize) != null ? _a : void 0; | |
message.pageToken = (_b = object.pageToken) != null ? _b : void 0; | |
message.reverse = (_c = object.reverse) != null ? _c : void 0; | |
return message; | |
} | |
}; | |
function createBaseReactionRequest() { | |
return { fid: 0, reactionType: 0, castId: void 0 }; | |
} | |
var ReactionRequest = { | |
encode(message, writer = import_minimal5.default.Writer.create()) { | |
if (message.fid !== 0) { | |
writer.uint32(8).uint64(message.fid); | |
} | |
if (message.reactionType !== 0) { | |
writer.uint32(16).int32(message.reactionType); | |
} | |
if (message.castId !== void 0) { | |
CastId.encode(message.castId, writer.uint32(26).fork()).ldelim(); | |
} | |
return writer; | |
}, | |
decode(input, length) { | |
const reader = input instanceof import_minimal5.default.Reader ? input : import_minimal5.default.Reader.create(input); | |
let end = length === void 0 ? reader.len : reader.pos + length; | |
const message = createBaseReactionRequest(); | |
while (reader.pos < end) { | |
const tag = reader.uint32(); | |
switch (tag >>> 3) { | |
case 1: | |
if (tag != 8) { | |
break; | |
} | |
message.fid = longToNumber4(reader.uint64()); | |
continue; | |
case 2: | |
if (tag != 16) { | |
break; | |
} | |
message.reactionType = reader.int32(); | |
continue; | |
case 3: | |
if (tag != 26) { | |
break; | |
} | |
message.castId = CastId.decode(reader, reader.uint32()); | |
continue; | |
} | |
if ((tag & 7) == 4 || tag == 0) { | |
break; | |
} | |
reader.skipType(tag & 7); | |
} | |
return message; | |
}, | |
fromJSON(object) { | |
return { | |
fid: isSet5(object.fid) ? Number(object.fid) : 0, | |
reactionType: isSet5(object.reactionType) ? reactionTypeFromJSON(object.reactionType) : 0, | |
castId: isSet5(object.castId) ? CastId.fromJSON(object.castId) : void 0 | |
}; | |
}, | |
toJSON(message) { | |
const obj = {}; | |
message.fid !== void 0 && (obj.fid = Math.round(message.fid)); | |
message.reactionType !== void 0 && (obj.reactionType = reactionTypeToJSON(message.reactionType)); | |
message.castId !== void 0 && (obj.castId = message.castId ? CastId.toJSON(message.castId) : void 0); | |
return obj; | |
}, | |
create(base) { | |
return ReactionRequest.fromPartial(base != null ? base : {}); | |
}, | |
fromPartial(object) { | |
var _a, _b; | |
const message = createBaseReactionRequest(); | |
message.fid = (_a = object.fid) != null ? _a : 0; | |
message.reactionType = (_b = object.reactionType) != null ? _b : 0; | |
message.castId = object.castId !== void 0 && object.castId !== null ? CastId.fromPartial(object.castId) : void 0; | |
return message; | |
} | |
}; | |
function createBaseReactionsByFidRequest() { | |
return { fid: 0, reactionType: void 0, pageSize: void 0, pageToken: void 0, reverse: void 0 }; | |
} | |
var ReactionsByFidRequest = { | |
encode(message, writer = import_minimal5.default.Writer.create()) { | |
if (message.fid !== 0) { | |
writer.uint32(8).uint64(message.fid); | |
} | |
if (message.reactionType !== void 0) { | |
writer.uint32(16).int32(message.reactionType); | |
} | |
if (message.pageSize !== void 0) { | |
writer.uint32(24).uint32(message.pageSize); | |
} | |
if (message.pageToken !== void 0) { | |
writer.uint32(34).bytes(message.pageToken); | |
} | |
if (message.reverse !== void 0) { | |
writer.uint32(40).bool(message.reverse); | |
} | |
return writer; | |
}, | |
decode(input, length) { | |
const reader = input instanceof import_minimal5.default.Reader ? input : import_minimal5.default.Reader.create(input); | |
let end = length === void 0 ? reader.len : reader.pos + length; | |
const message = createBaseReactionsByFidRequest(); | |
while (reader.pos < end) { | |
const tag = reader.uint32(); | |
switch (tag >>> 3) { | |
case 1: | |
if (tag != 8) { | |
break; | |
} | |
message.fid = longToNumber4(reader.uint64()); | |
continue; | |
case 2: | |
if (tag != 16) { | |
break; | |
} | |
message.reactionType = reader.int32(); | |
continue; | |
case 3: | |
if (tag != 24) { | |
break; | |
} | |
message.pageSize = reader.uint32(); | |
continue; | |
case 4: | |
if (tag != 34) { | |
break; | |
} | |
message.pageToken = reader.bytes(); | |
continue; | |
case 5: | |
if (tag != 40) { | |
break; | |
} | |
message.reverse = reader.bool(); | |
continue; | |
} | |
if ((tag & 7) == 4 || tag == 0) { | |
break; | |
} | |
reader.skipType(tag & 7); | |
} | |
return message; | |
}, | |
fromJSON(object) { | |
return { | |
fid: isSet5(object.fid) ? Number(object.fid) : 0, | |
reactionType: isSet5(object.reactionType) ? reactionTypeFromJSON(object.reactionType) : void 0, | |
pageSize: isSet5(object.pageSize) ? Number(object.pageSize) : void 0, | |
pageToken: isSet5(object.pageToken) ? bytesFromBase644(object.pageToken) : void 0, | |
reverse: isSet5(object.reverse) ? Boolean(object.reverse) : void 0 | |
}; | |
}, | |
toJSON(message) { | |
const obj = {}; | |
message.fid !== void 0 && (obj.fid = Math.round(message.fid)); | |
message.reactionType !== void 0 && (obj.reactionType = message.reactionType !== void 0 ? reactionTypeToJSON(message.reactionType) : void 0); | |
message.pageSize !== void 0 && (obj.pageSize = Math.round(message.pageSize)); | |
message.pageToken !== void 0 && (obj.pageToken = message.pageToken !== void 0 ? base64FromBytes4(message.pageToken) : void 0); | |
message.reverse !== void 0 && (obj.reverse = message.reverse); | |
return obj; | |
}, | |
create(base) { | |
return ReactionsByFidRequest.fromPartial(base != null ? base : {}); | |
}, | |
fromPartial(object) { | |
var _a, _b, _c, _d, _e; | |
const message = createBaseReactionsByFidRequest(); | |
message.fid = (_a = object.fid) != null ? _a : 0; | |
message.reactionType = (_b = object.reactionType) != null ? _b : void 0; | |
message.pageSize = (_c = object.pageSize) != null ? _c : void 0; | |
message.pageToken = (_d = object.pageToken) != null ? _d : void 0; | |
message.reverse = (_e = object.reverse) != null ? _e : void 0; | |
return message; | |
} | |
}; | |
function createBaseReactionsByCastRequest() { | |
return { castId: void 0, reactionType: void 0, pageSize: void 0, pageToken: void 0, reverse: void 0 }; | |
} | |
var ReactionsByCastRequest = { | |
encode(message, writer = import_minimal5.default.Writer.create()) { | |
if (message.castId !== void 0) { | |
CastId.encode(message.castId, writer.uint32(10).fork()).ldelim(); | |
} | |
if (message.reactionType !== void 0) { | |
writer.uint32(16).int32(message.reactionType); | |
} | |
if (message.pageSize !== void 0) { | |
writer.uint32(24).uint32(message.pageSize); | |
} | |
if (message.pageToken !== void 0) { | |
writer.uint32(34).bytes(message.pageToken); | |
} | |
if (message.reverse !== void 0) { | |
writer.uint32(40).bool(message.reverse); | |
} | |
return writer; | |
}, | |
decode(input, length) { | |
const reader = input instanceof import_minimal5.default.Reader ? input : import_minimal5.default.Reader.create(input); | |
let end = length === void 0 ? reader.len : reader.pos + length; | |
const message = createBaseReactionsByCastRequest(); | |
while (reader.pos < end) { | |
const tag = reader.uint32(); | |
switch (tag >>> 3) { | |
case 1: | |
if (tag != 10) { | |
break; | |
} | |
message.castId = CastId.decode(reader, reader.uint32()); | |
continue; | |
case 2: | |
if (tag != 16) { | |
break; | |
} | |
message.reactionType = reader.int32(); | |
continue; | |
case 3: | |
if (tag != 24) { | |
break; | |
} | |
message.pageSize = reader.uint32(); | |
continue; | |
case 4: | |
if (tag != 34) { | |
break; | |
} | |
message.pageToken = reader.bytes(); | |
continue; | |
case 5: | |
if (tag != 40) { | |
break; | |
} | |
message.reverse = reader.bool(); | |
continue; | |
} | |
if ((tag & 7) == 4 || tag == 0) { | |
break; | |
} | |
reader.skipType(tag & 7); | |
} | |
return message; | |
}, | |
fromJSON(object) { | |
return { | |
castId: isSet5(object.castId) ? CastId.fromJSON(object.castId) : void 0, | |
reactionType: isSet5(object.reactionType) ? reactionTypeFromJSON(object.reactionType) : void 0, | |
pageSize: isSet5(object.pageSize) ? Number(object.pageSize) : void 0, | |
pageToken: isSet5(object.pageToken) ? bytesFromBase644(object.pageToken) : void 0, | |
reverse: isSet5(object.reverse) ? Boolean(object.reverse) : void 0 | |
}; | |
}, | |
toJSON(message) { | |
const obj = {}; | |
message.castId !== void 0 && (obj.castId = message.castId ? CastId.toJSON(message.castId) : void 0); | |
message.reactionType !== void 0 && (obj.reactionType = message.reactionType !== void 0 ? reactionTypeToJSON(message.reactionType) : void 0); | |
message.pageSize !== void 0 && (obj.pageSize = Math.round(message.pageSize)); | |
message.pageToken !== void 0 && (obj.pageToken = message.pageToken !== void 0 ? base64FromBytes4(message.pageToken) : void 0); | |
message.reverse !== void 0 && (obj.reverse = message.reverse); | |
return obj; | |
}, | |
create(base) { | |
return ReactionsByCastRequest.fromPartial(base != null ? base : {}); | |
}, | |
fromPartial(object) { | |
var _a, _b, _c, _d; | |
const message = createBaseReactionsByCastRequest(); | |
message.castId = object.castId !== void 0 && object.castId !== null ? CastId.fromPartial(object.castId) : void 0; | |
message.reactionType = (_a = object.reactionType) != null ? _a : void 0; | |
message.pageSize = (_b = object.pageSize) != null ? _b : void 0; | |
message.pageToken = (_c = object.pageToken) != null ? _c : void 0; | |
message.reverse = (_d = object.reverse) != null ? _d : void 0; | |
return message; | |
} | |
}; | |
function createBaseUserDataRequest() { | |
return { fid: 0, userDataType: 0 }; | |
} | |
var UserDataRequest = { | |
encode(message, writer = import_minimal5.default.Writer.create()) { | |
if (message.fid !== 0) { | |
writer.uint32(8).uint64(message.fid); | |
} | |
if (message.userDataType !== 0) { | |
writer.uint32(16).int32(message.userDataType); | |
} | |
return writer; | |
}, | |
decode(input, length) { | |
const reader = input instanceof import_minimal5.default.Reader ? input : import_minimal5.default.Reader.create(input); | |
let end = length === void 0 ? reader.len : reader.pos + length; | |
const message = createBaseUserDataRequest(); | |
while (reader.pos < end) { | |
const tag = reader.uint32(); | |
switch (tag >>> 3) { | |
case 1: | |
if (tag != 8) { | |
break; | |
} | |
message.fid = longToNumber4(reader.uint64()); | |
continue; | |
case 2: | |
if (tag != 16) { | |
break; | |
} | |
message.userDataType = reader.int32(); | |
continue; | |
} | |
if ((tag & 7) == 4 || tag == 0) { | |
break; | |
} | |
reader.skipType(tag & 7); | |
} | |
return message; | |
}, | |
fromJSON(object) { | |
return { | |
fid: isSet5(object.fid) ? Number(object.fid) : 0, | |
userDataType: isSet5(object.userDataType) ? userDataTypeFromJSON(object.userDataType) : 0 | |
}; | |
}, | |
toJSON(message) { | |
const obj = {}; | |
message.fid !== void 0 && (obj.fid = Math.round(message.fid)); | |
message.userDataType !== void 0 && (obj.userDataType = userDataTypeToJSON(message.userDataType)); | |
return obj; | |
}, | |
create(base) { | |
return UserDataRequest.fromPartial(base != null ? base : {}); | |
}, | |
fromPartial(object) { | |
var _a, _b; | |
const message = createBaseUserDataRequest(); | |
message.fid = (_a = object.fid) != null ? _a : 0; | |
message.userDataType = (_b = object.userDataType) != null ? _b : 0; | |
return message; | |
} | |
}; | |
function createBaseNameRegistryEventRequest() { | |
return { name: new Uint8Array() }; | |
} | |
var NameRegistryEventRequest = { | |
encode(message, writer = import_minimal5.default.Writer.create()) { | |
if (message.name.length !== 0) { | |
writer.uint32(10).bytes(message.name); | |
} | |
return writer; | |
}, | |
decode(input, length) { | |
const reader = input instanceof import_minimal5.default.Reader ? input : import_minimal5.default.Reader.create(input); | |
let end = length === void 0 ? reader.len : reader.pos + length; | |
const message = createBaseNameRegistryEventRequest(); | |
while (reader.pos < end) { | |
const tag = reader.uint32(); | |
switch (tag >>> 3) { | |
case 1: | |
if (tag != 10) { | |
break; | |
} | |
message.name = reader.bytes(); | |
continue; | |
} | |
if ((tag & 7) == 4 || tag == 0) { | |
break; | |
} | |
reader.skipType(tag & 7); | |
} | |
return message; | |
}, | |
fromJSON(object) { | |
return { name: isSet5(object.name) ? bytesFromBase644(object.name) : new Uint8Array() }; | |
}, | |
toJSON(message) { | |
const obj = {}; | |
message.name !== void 0 && (obj.name = base64FromBytes4(message.name !== void 0 ? message.name : new Uint8Array())); | |
return obj; | |
}, | |
create(base) { | |
return NameRegistryEventRequest.fromPartial(base != null ? base : {}); | |
}, | |
fromPartial(object) { | |
var _a; | |
const message = createBaseNameRegistryEventRequest(); | |
message.name = (_a = object.name) != null ? _a : new Uint8Array(); | |
return message; | |
} | |
}; | |
function createBaseVerificationRequest() { | |
return { fid: 0, address: new Uint8Array() }; | |
} | |
var VerificationRequest = { | |
encode(message, writer = import_minimal5.default.Writer.create()) { | |
if (message.fid !== 0) { | |
writer.uint32(8).uint64(message.fid); | |
} | |
if (message.address.length !== 0) { | |
writer.uint32(18).bytes(message.address); | |
} | |
return writer; | |
}, | |
decode(input, length) { | |
const reader = input instanceof import_minimal5.default.Reader ? input : import_minimal5.default.Reader.create(input); | |
let end = length === void 0 ? reader.len : reader.pos + length; | |
const message = createBaseVerificationRequest(); | |
while (reader.pos < end) { | |
const tag = reader.uint32(); | |
switch (tag >>> 3) { | |
case 1: | |
if (tag != 8) { | |
break; | |
} | |
message.fid = longToNumber4(reader.uint64()); | |
continue; | |
case 2: | |
if (tag != 18) { | |
break; | |
} | |
message.address = reader.bytes(); | |
continue; | |
} | |
if ((tag & 7) == 4 || tag == 0) { | |
break; | |
} | |
reader.skipType(tag & 7); | |
} | |
return message; | |
}, | |
fromJSON(object) { | |
return { | |
fid: isSet5(object.fid) ? Number(object.fid) : 0, | |
address: isSet5(object.address) ? bytesFromBase644(object.address) : new Uint8Array() | |
}; | |
}, | |
toJSON(message) { | |
const obj = {}; | |
message.fid !== void 0 && (obj.fid = Math.round(message.fid)); | |
message.address !== void 0 && (obj.address = base64FromBytes4(message.address !== void 0 ? message.address : new Uint8Array())); | |
return obj; | |
}, | |
create(base) { | |
return VerificationRequest.fromPartial(base != null ? base : {}); | |
}, | |
fromPartial(object) { | |
var _a, _b; | |
const message = createBaseVerificationRequest(); | |
message.fid = (_a = object.fid) != null ? _a : 0; | |
message.address = (_b = object.address) != null ? _b : new Uint8Array(); | |
return message; | |
} | |
}; | |
function createBaseSignerRequest() { | |
return { fid: 0, signer: new Uint8Array() }; | |
} | |
var SignerRequest = { | |
encode(message, writer = import_minimal5.default.Writer.create()) { | |
if (message.fid !== 0) { | |
writer.uint32(8).uint64(message.fid); | |
} | |
if (message.signer.length !== 0) { | |
writer.uint32(18).bytes(message.signer); | |
} | |
return writer; | |
}, | |
decode(input, length) { | |
const reader = input instanceof import_minimal5.default.Reader ? input : import_minimal5.default.Reader.create(input); | |
let end = length === void 0 ? reader.len : reader.pos + length; | |
const message = createBaseSignerRequest(); | |
while (reader.pos < end) { | |
const tag = reader.uint32(); | |
switch (tag >>> 3) { | |
case 1: | |
if (tag != 8) { | |
break; | |
} | |
message.fid = longToNumber4(reader.uint64()); | |
continue; | |
case 2: | |
if (tag != 18) { | |
break; | |
} | |
message.signer = reader.bytes(); | |
continue; | |
} | |
if ((tag & 7) == 4 || tag == 0) { | |
break; | |
} | |
reader.skipType(tag & 7); | |
} | |
return message; | |
}, | |
fromJSON(object) { | |
return { | |
fid: isSet5(object.fid) ? Number(object.fid) : 0, | |
signer: isSet5(object.signer) ? bytesFromBase644(object.signer) : new Uint8Array() | |
}; | |
}, | |
toJSON(message) { | |
const obj = {}; | |
message.fid !== void 0 && (obj.fid = Math.round(message.fid)); | |
message.signer !== void 0 && (obj.signer = base64FromBytes4(message.signer !== void 0 ? message.signer : new Uint8Array())); | |
return obj; | |
}, | |
create(base) { | |
return SignerRequest.fromPartial(base != null ? base : {}); | |
}, | |
fromPartial(object) { | |
var _a, _b; | |
const message = createBaseSignerRequest(); | |
message.fid = (_a = object.fid) != null ? _a : 0; | |
message.signer = (_b = object.signer) != null ? _b : new Uint8Array(); | |
return message; | |
} | |
}; | |
function createBaseIdRegistryEventRequest() { | |
return { fid: 0 }; | |
} | |
var IdRegistryEventRequest = { | |
encode(message, writer = import_minimal5.default.Writer.create()) { | |
if (message.fid !== 0) { | |
writer.uint32(8).uint64(message.fid); | |
} | |
return writer; | |
}, | |
decode(input, length) { | |
const reader = input instanceof import_minimal5.default.Reader ? input : import_minimal5.default.Reader.create(input); | |
let end = length === void 0 ? reader.len : reader.pos + length; | |
const message = createBaseIdRegistryEventRequest(); | |
while (reader.pos < end) { | |
const tag = reader.uint32(); | |
switch (tag >>> 3) { | |
case 1: | |
if (tag != 8) { | |
break; | |
} | |
message.fid = longToNumber4(reader.uint64()); | |
continue; | |
} | |
if ((tag & 7) == 4 || tag == 0) { | |
break; | |
} | |
reader.skipType(tag & 7); | |
} | |
return message; | |
}, | |
fromJSON(object) { | |
return { fid: isSet5(object.fid) ? Number(object.fid) : 0 }; | |
}, | |
toJSON(message) { | |
const obj = {}; | |
message.fid !== void 0 && (obj.fid = Math.round(message.fid)); | |
return obj; | |
}, | |
create(base) { | |
return IdRegistryEventRequest.fromPartial(base != null ? base : {}); | |
}, | |
fromPartial(object) { | |
var _a; | |
const message = createBaseIdRegistryEventRequest(); | |
message.fid = (_a = object.fid) != null ? _a : 0; | |
return message; | |
} | |
}; | |
function createBaseIdRegistryEventByAddressRequest() { | |
return { address: new Uint8Array() }; | |
} | |
var IdRegistryEventByAddressRequest = { | |
encode(message, writer = import_minimal5.default.Writer.create()) { | |
if (message.address.length !== 0) { | |
writer.uint32(10).bytes(message.address); | |
} | |
return writer; | |
}, | |
decode(input, length) { | |
const reader = input instanceof import_minimal5.default.Reader ? input : import_minimal5.default.Reader.create(input); | |
let end = length === void 0 ? reader.len : reader.pos + length; | |
const message = createBaseIdRegistryEventByAddressRequest(); | |
while (reader.pos < end) { | |
const tag = reader.uint32(); | |
switch (tag >>> 3) { | |
case 1: | |
if (tag != 10) { | |
break; | |
} | |
message.address = reader.bytes(); | |
continue; | |
} | |
if ((tag & 7) == 4 || tag == 0) { | |
break; | |
} | |
reader.skipType(tag & 7); | |
} | |
return message; | |
}, | |
fromJSON(object) { | |
return { address: isSet5(object.address) ? bytesFromBase644(object.address) : new Uint8Array() }; | |
}, | |
toJSON(message) { | |
const obj = {}; | |
message.address !== void 0 && (obj.address = base64FromBytes4(message.address !== void 0 ? message.address : new Uint8Array())); | |
return obj; | |
}, | |
create(base) { | |
return IdRegistryEventByAddressRequest.fromPartial(base != null ? base : {}); | |
}, | |
fromPartial(object) { | |
var _a; | |
const message = createBaseIdRegistryEventByAddressRequest(); | |
message.address = (_a = object.address) != null ? _a : new Uint8Array(); | |
return message; | |
} | |
}; | |
var tsProtoGlobalThis5 = (() => { | |
if (typeof globalThis !== "undefined") { | |
return globalThis; | |
} | |
if (typeof self !== "undefined") { | |
return self; | |
} | |
if (typeof window !== "undefined") { | |
return window; | |
} | |
if (typeof global !== "undefined") { | |
return global; | |
} | |
throw "Unable to locate global object"; | |
})(); | |
function bytesFromBase644(b64) { | |
if (tsProtoGlobalThis5.Buffer) { | |
return Uint8Array.from(tsProtoGlobalThis5.Buffer.from(b64, "base64")); | |
} else { | |
const bin = tsProtoGlobalThis5.atob(b64); | |
const arr = new Uint8Array(bin.length); | |
for (let i = 0; i < bin.length; ++i) { | |
arr[i] = bin.charCodeAt(i); | |
} | |
return arr; | |
} | |
} | |
function base64FromBytes4(arr) { | |
if (tsProtoGlobalThis5.Buffer) { | |
return tsProtoGlobalThis5.Buffer.from(arr).toString("base64"); | |
} else { | |
const bin = []; | |
arr.forEach((byte) => { | |
bin.push(String.fromCharCode(byte)); | |
}); | |
return tsProtoGlobalThis5.btoa(bin.join("")); | |
} | |
} | |
function longToNumber4(long) { | |
if (long.gt(Number.MAX_SAFE_INTEGER)) { | |
throw new tsProtoGlobalThis5.Error("Value is larger than Number.MAX_SAFE_INTEGER"); | |
} | |
return long.toNumber(); | |
} | |
if (import_minimal5.default.util.Long !== import_long4.default) { | |
import_minimal5.default.util.Long = import_long4.default; | |
import_minimal5.default.configure(); | |
} | |
function isSet5(value) { | |
return value !== null && value !== void 0; | |
} | |
// src/generated/rpc.ts | |
var HubServiceClientImpl = class { | |
constructor(rpc) { | |
__publicField(this, "rpc"); | |
this.rpc = rpc; | |
this.submitMessage = this.submitMessage.bind(this); | |
this.subscribe = this.subscribe.bind(this); | |
this.getEvent = this.getEvent.bind(this); | |
this.getCast = this.getCast.bind(this); | |
this.getCastsByFid = this.getCastsByFid.bind(this); | |
this.getCastsByParent = this.getCastsByParent.bind(this); | |
this.getCastsByMention = this.getCastsByMention.bind(this); | |
this.getReaction = this.getReaction.bind(this); | |
this.getReactionsByFid = this.getReactionsByFid.bind(this); | |
this.getReactionsByCast = this.getReactionsByCast.bind(this); | |
this.getUserData = this.getUserData.bind(this); | |
this.getUserDataByFid = this.getUserDataByFid.bind(this); | |
this.getNameRegistryEvent = this.getNameRegistryEvent.bind(this); | |
this.getVerification = this.getVerification.bind(this); | |
this.getVerificationsByFid = this.getVerificationsByFid.bind(this); | |
this.getSigner = this.getSigner.bind(this); | |
this.getSignersByFid = this.getSignersByFid.bind(this); | |
this.getIdRegistryEvent = this.getIdRegistryEvent.bind(this); | |
this.getIdRegistryEventByAddress = this.getIdRegistryEventByAddress.bind(this); | |
this.getFids = this.getFids.bind(this); | |
this.getAllCastMessagesByFid = this.getAllCastMessagesByFid.bind(this); | |
this.getAllReactionMessagesByFid = this.getAllReactionMessagesByFid.bind(this); | |
this.getAllVerificationMessagesByFid = this.getAllVerificationMessagesByFid.bind(this); | |
this.getAllSignerMessagesByFid = this.getAllSignerMessagesByFid.bind(this); | |
this.getAllUserDataMessagesByFid = this.getAllUserDataMessagesByFid.bind(this); | |
this.getInfo = this.getInfo.bind(this); | |
this.getAllSyncIdsByPrefix = this.getAllSyncIdsByPrefix.bind(this); | |
this.getAllMessagesBySyncIds = this.getAllMessagesBySyncIds.bind(this); | |
this.getSyncMetadataByPrefix = this.getSyncMetadataByPrefix.bind(this); | |
this.getSyncSnapshotByPrefix = this.getSyncSnapshotByPrefix.bind(this); | |
} | |
submitMessage(request, metadata) { | |
return this.rpc.unary(HubServiceSubmitMessageDesc, Message.fromPartial(request), metadata); | |
} | |
subscribe(request, metadata) { | |
return this.rpc.invoke(HubServiceSubscribeDesc, SubscribeRequest.fromPartial(request), metadata); | |
} | |
getEvent(request, metadata) { | |
return this.rpc.unary(HubServiceGetEventDesc, EventRequest.fromPartial(request), metadata); | |
} | |
getCast(request, metadata) { | |
return this.rpc.unary(HubServiceGetCastDesc, CastId.fromPartial(request), metadata); | |
} | |
getCastsByFid(request, metadata) { | |
return this.rpc.unary(HubServiceGetCastsByFidDesc, FidRequest.fromPartial(request), metadata); | |
} | |
getCastsByParent(request, metadata) { | |
return this.rpc.unary(HubServiceGetCastsByParentDesc, CastsByParentRequest.fromPartial(request), metadata); | |
} | |
getCastsByMention(request, metadata) { | |
return this.rpc.unary(HubServiceGetCastsByMentionDesc, FidRequest.fromPartial(request), metadata); | |
} | |
getReaction(request, metadata) { | |
return this.rpc.unary(HubServiceGetReactionDesc, ReactionRequest.fromPartial(request), metadata); | |
} | |
getReactionsByFid(request, metadata) { | |
return this.rpc.unary(HubServiceGetReactionsByFidDesc, ReactionsByFidRequest.fromPartial(request), metadata); | |
} | |
getReactionsByCast(request, metadata) { | |
return this.rpc.unary(HubServiceGetReactionsByCastDesc, ReactionsByCastRequest.fromPartial(request), metadata); | |
} | |
getUserData(request, metadata) { | |
return this.rpc.unary(HubServiceGetUserDataDesc, UserDataRequest.fromPartial(request), metadata); | |
} | |
getUserDataByFid(request, metadata) { | |
return this.rpc.unary(HubServiceGetUserDataByFidDesc, FidRequest.fromPartial(request), metadata); | |
} | |
getNameRegistryEvent(request, metadata) { | |
return this.rpc.unary(HubServiceGetNameRegistryEventDesc, NameRegistryEventRequest.fromPartial(request), metadata); | |
} | |
getVerification(request, metadata) { | |
return this.rpc.unary(HubServiceGetVerificationDesc, VerificationRequest.fromPartial(request), metadata); | |
} | |
getVerificationsByFid(request, metadata) { | |
return this.rpc.unary(HubServiceGetVerificationsByFidDesc, FidRequest.fromPartial(request), metadata); | |
} | |
getSigner(request, metadata) { | |
return this.rpc.unary(HubServiceGetSignerDesc, SignerRequest.fromPartial(request), metadata); | |
} | |
getSignersByFid(request, metadata) { | |
return this.rpc.unary(HubServiceGetSignersByFidDesc, FidRequest.fromPartial(request), metadata); | |
} | |
getIdRegistryEvent(request, metadata) { | |
return this.rpc.unary(HubServiceGetIdRegistryEventDesc, IdRegistryEventRequest.fromPartial(request), metadata); | |
} | |
getIdRegistryEventByAddress(request, metadata) { | |
return this.rpc.unary( | |
HubServiceGetIdRegistryEventByAddressDesc, | |
IdRegistryEventByAddressRequest.fromPartial(request), | |
metadata | |
); | |
} | |
getFids(request, metadata) { | |
return this.rpc.unary(HubServiceGetFidsDesc, FidsRequest.fromPartial(request), metadata); | |
} | |
getAllCastMessagesByFid(request, metadata) { | |
return this.rpc.unary(HubServiceGetAllCastMessagesByFidDesc, FidRequest.fromPartial(request), metadata); | |
} | |
getAllReactionMessagesByFid(request, metadata) { | |
return this.rpc.unary(HubServiceGetAllReactionMessagesByFidDesc, FidRequest.fromPartial(request), metadata); | |
} | |
getAllVerificationMessagesByFid(request, metadata) { | |
return this.rpc.unary(HubServiceGetAllVerificationMessagesByFidDesc, FidRequest.fromPartial(request), metadata); | |
} | |
getAllSignerMessagesByFid(request, metadata) { | |
return this.rpc.unary(HubServiceGetAllSignerMessagesByFidDesc, FidRequest.fromPartial(request), metadata); | |
} | |
getAllUserDataMessagesByFid(request, metadata) { | |
return this.rpc.unary(HubServiceGetAllUserDataMessagesByFidDesc, FidRequest.fromPartial(request), metadata); | |
} | |
getInfo(request, metadata) { | |
return this.rpc.unary(HubServiceGetInfoDesc, Empty.fromPartial(request), metadata); | |
} | |
getAllSyncIdsByPrefix(request, metadata) { | |
return this.rpc.unary(HubServiceGetAllSyncIdsByPrefixDesc, TrieNodePrefix.fromPartial(request), metadata); | |
} | |
getAllMessagesBySyncIds(request, metadata) { | |
return this.rpc.unary(HubServiceGetAllMessagesBySyncIdsDesc, SyncIds.fromPartial(request), metadata); | |
} | |
getSyncMetadataByPrefix(request, metadata) { | |
return this.rpc.unary(HubServiceGetSyncMetadataByPrefixDesc, TrieNodePrefix.fromPartial(request), metadata); | |
} | |
getSyncSnapshotByPrefix(request, metadata) { | |
return this.rpc.unary(HubServiceGetSyncSnapshotByPrefixDesc, TrieNodePrefix.fromPartial(request), metadata); | |
} | |
}; | |
var HubServiceDesc = { serviceName: "HubService" }; | |
var HubServiceSubmitMessageDesc = { | |
methodName: "SubmitMessage", | |
service: HubServiceDesc, | |
requestStream: false, | |
responseStream: false, | |
requestType: { | |
serializeBinary() { | |
return Message.encode(this).finish(); | |
} | |
}, | |
responseType: { | |
deserializeBinary(data) { | |
const value = Message.decode(data); | |
return { | |
...value, | |
toObject() { | |
return value; | |
} | |
}; | |
} | |
} | |
}; | |
var HubServiceSubscribeDesc = { | |
methodName: "Subscribe", | |
service: HubServiceDesc, | |
requestStream: false, | |
responseStream: true, | |
requestType: { | |
serializeBinary() { | |
return SubscribeRequest.encode(this).finish(); | |
} | |
}, | |
responseType: { | |
deserializeBinary(data) { | |
const value = HubEvent.decode(data); | |
return { | |
...value, | |
toObject() { | |
return value; | |
} | |
}; | |
} | |
} | |
}; | |
var HubServiceGetEventDesc = { | |
methodName: "GetEvent", | |
service: HubServiceDesc, | |
requestStream: false, | |
responseStream: false, | |
requestType: { | |
serializeBinary() { | |
return EventRequest.encode(this).finish(); | |
} | |
}, | |
responseType: { | |
deserializeBinary(data) { | |
const value = HubEvent.decode(data); | |
return { | |
...value, | |
toObject() { | |
return value; | |
} | |
}; | |
} | |
} | |
}; | |
var HubServiceGetCastDesc = { | |
methodName: "GetCast", | |
service: HubServiceDesc, | |
requestStream: false, | |
responseStream: false, | |
requestType: { | |
serializeBinary() { | |
return CastId.encode(this).finish(); | |
} | |
}, | |
responseType: { | |
deserializeBinary(data) { | |
const value = Message.decode(data); | |
return { | |
...value, | |
toObject() { | |
return value; | |
} | |
}; | |
} | |
} | |
}; | |
var HubServiceGetCastsByFidDesc = { | |
methodName: "GetCastsByFid", | |
service: HubServiceDesc, | |
requestStream: false, | |
responseStream: false, | |
requestType: { | |
serializeBinary() { | |
return FidRequest.encode(this).finish(); | |
} | |
}, | |
responseType: { | |
deserializeBinary(data) { | |
const value = MessagesResponse.decode(data); | |
return { | |
...value, | |
toObject() { | |
return value; | |
} | |
}; | |
} | |
} | |
}; | |
var HubServiceGetCastsByParentDesc = { | |
methodName: "GetCastsByParent", | |
service: HubServiceDesc, | |
requestStream: false, | |
responseStream: false, | |
requestType: { | |
serializeBinary() { | |
return CastsByParentRequest.encode(this).finish(); | |
} | |
}, | |
responseType: { | |
deserializeBinary(data) { | |
const value = MessagesResponse.decode(data); | |
return { | |
...value, | |
toObject() { | |
return value; | |
} | |
}; | |
} | |
} | |
}; | |
var HubServiceGetCastsByMentionDesc = { | |
methodName: "GetCastsByMention", | |
service: HubServiceDesc, | |
requestStream: false, | |
responseStream: false, | |
requestType: { | |
serializeBinary() { | |
return FidRequest.encode(this).finish(); | |
} | |
}, | |
responseType: { | |
deserializeBinary(data) { | |
const value = MessagesResponse.decode(data); | |
return { | |
...value, | |
toObject() { | |
return value; | |
} | |
}; | |
} | |
} | |
}; | |
var HubServiceGetReactionDesc = { | |
methodName: "GetReaction", | |
service: HubServiceDesc, | |
requestStream: false, | |
responseStream: false, | |
requestType: { | |
serializeBinary() { | |
return ReactionRequest.encode(this).finish(); | |
} | |
}, | |
responseType: { | |
deserializeBinary(data) { | |
const value = Message.decode(data); | |
return { | |
...value, | |
toObject() { | |
return value; | |
} | |
}; | |
} | |
} | |
}; | |
var HubServiceGetReactionsByFidDesc = { | |
methodName: "GetReactionsByFid", | |
service: HubServiceDesc, | |
requestStream: false, | |
responseStream: false, | |
requestType: { | |
serializeBinary() { | |
return ReactionsByFidRequest.encode(this).finish(); | |
} | |
}, | |
responseType: { | |
deserializeBinary(data) { | |
const value = MessagesResponse.decode(data); | |
return { | |
...value, | |
toObject() { | |
return value; | |
} | |
}; | |
} | |
} | |
}; | |
var HubServiceGetReactionsByCastDesc = { | |
methodName: "GetReactionsByCast", | |
service: HubServiceDesc, | |
requestStream: false, | |
responseStream: false, | |
requestType: { | |
serializeBinary() { | |
return ReactionsByCastRequest.encode(this).finish(); | |
} | |
}, | |
responseType: { | |
deserializeBinary(data) { | |
const value = MessagesResponse.decode(data); | |
return { | |
...value, | |
toObject() { | |
return value; | |
} | |
}; | |
} | |
} | |
}; | |
var HubServiceGetUserDataDesc = { | |
methodName: "GetUserData", | |
service: HubServiceDesc, | |
requestStream: false, | |
responseStream: false, | |
requestType: { | |
serializeBinary() { | |
return UserDataRequest.encode(this).finish(); | |
} | |
}, | |
responseType: { | |
deserializeBinary(data) { | |
const value = Message.decode(data); | |
return { | |
...value, | |
toObject() { | |
return value; | |
} | |
}; | |
} | |
} | |
}; | |
var HubServiceGetUserDataByFidDesc = { | |
methodName: "GetUserDataByFid", | |
service: HubServiceDesc, | |
requestStream: false, | |
responseStream: false, | |
requestType: { | |
serializeBinary() { | |
return FidRequest.encode(this).finish(); | |
} | |
}, | |
responseType: { | |
deserializeBinary(data) { | |
const value = MessagesResponse.decode(data); | |
return { | |
...value, | |
toObject() { | |
return value; | |
} | |
}; | |
} | |
} | |
}; | |
var HubServiceGetNameRegistryEventDesc = { | |
methodName: "GetNameRegistryEvent", | |
service: HubServiceDesc, | |
requestStream: false, | |
responseStream: false, | |
requestType: { | |
serializeBinary() { | |
return NameRegistryEventRequest.encode(this).finish(); | |
} | |
}, | |
responseType: { | |
deserializeBinary(data) { | |
const value = NameRegistryEvent.decode(data); | |
return { | |
...value, | |
toObject() { | |
return value; | |
} | |
}; | |
} | |
} | |
}; | |
var HubServiceGetVerificationDesc = { | |
methodName: "GetVerification", | |
service: HubServiceDesc, | |
requestStream: false, | |
responseStream: false, | |
requestType: { | |
serializeBinary() { | |
return VerificationRequest.encode(this).finish(); | |
} | |
}, | |
responseType: { | |
deserializeBinary(data) { | |
const value = Message.decode(data); | |
return { | |
...value, | |
toObject() { | |
return value; | |
} | |
}; | |
} | |
} | |
}; | |
var HubServiceGetVerificationsByFidDesc = { | |
methodName: "GetVerificationsByFid", | |
service: HubServiceDesc, | |
requestStream: false, | |
responseStream: false, | |
requestType: { | |
serializeBinary() { | |
return FidRequest.encode(this).finish(); | |
} | |
}, | |
responseType: { | |
deserializeBinary(data) { | |
const value = MessagesResponse.decode(data); | |
return { | |
...value, | |
toObject() { | |
return value; | |
} | |
}; | |
} | |
} | |
}; | |
var HubServiceGetSignerDesc = { | |
methodName: "GetSigner", | |
service: HubServiceDesc, | |
requestStream: false, | |
responseStream: false, | |
requestType: { | |
serializeBinary() { | |
return SignerRequest.encode(this).finish(); | |
} | |
}, | |
responseType: { | |
deserializeBinary(data) { | |
const value = Message.decode(data); | |
return { | |
...value, | |
toObject() { | |
return value; | |
} | |
}; | |
} | |
} | |
}; | |
var HubServiceGetSignersByFidDesc = { | |
methodName: "GetSignersByFid", | |
service: HubServiceDesc, | |
requestStream: false, | |
responseStream: false, | |
requestType: { | |
serializeBinary() { | |
return FidRequest.encode(this).finish(); | |
} | |
}, | |
responseType: { | |
deserializeBinary(data) { | |
const value = MessagesResponse.decode(data); | |
return { | |
...value, | |
toObject() { | |
return value; | |
} | |
}; | |
} | |
} | |
}; | |
var HubServiceGetIdRegistryEventDesc = { | |
methodName: "GetIdRegistryEvent", | |
service: HubServiceDesc, | |
requestStream: false, | |
responseStream: false, | |
requestType: { | |
serializeBinary() { | |
return IdRegistryEventRequest.encode(this).finish(); | |
} | |
}, | |
responseType: { | |
deserializeBinary(data) { | |
const value = IdRegistryEvent.decode(data); | |
return { | |
...value, | |
toObject() { | |
return value; | |
} | |
}; | |
} | |
} | |
}; | |
var HubServiceGetIdRegistryEventByAddressDesc = { | |
methodName: "GetIdRegistryEventByAddress", | |
service: HubServiceDesc, | |
requestStream: false, | |
responseStream: false, | |
requestType: { | |
serializeBinary() { | |
return IdRegistryEventByAddressRequest.encode(this).finish(); | |
} | |
}, | |
responseType: { | |
deserializeBinary(data) { | |
const value = IdRegistryEvent.decode(data); | |
return { | |
...value, | |
toObject() { | |
return value; | |
} | |
}; | |
} | |
} | |
}; | |
var HubServiceGetFidsDesc = { | |
methodName: "GetFids", | |
service: HubServiceDesc, | |
requestStream: false, | |
responseStream: false, | |
requestType: { | |
serializeBinary() { | |
return FidsRequest.encode(this).finish(); | |
} | |
}, | |
responseType: { | |
deserializeBinary(data) { | |
const value = FidsResponse.decode(data); | |
return { | |
...value, | |
toObject() { | |
return value; | |
} | |
}; | |
} | |
} | |
}; | |
var HubServiceGetAllCastMessagesByFidDesc = { | |
methodName: "GetAllCastMessagesByFid", | |
service: HubServiceDesc, | |
requestStream: false, | |
responseStream: false, | |
requestType: { | |
serializeBinary() { | |
return FidRequest.encode(this).finish(); | |
} | |
}, | |
responseType: { | |
deserializeBinary(data) { | |
const value = MessagesResponse.decode(data); | |
return { | |
...value, | |
toObject() { | |
return value; | |
} | |
}; | |
} | |
} | |
}; | |
var HubServiceGetAllReactionMessagesByFidDesc = { | |
methodName: "GetAllReactionMessagesByFid", | |
service: HubServiceDesc, | |
requestStream: false, | |
responseStream: false, | |
requestType: { | |
serializeBinary() { | |
return FidRequest.encode(this).finish(); | |
} | |
}, | |
responseType: { | |
deserializeBinary(data) { | |
const value = MessagesResponse.decode(data); | |
return { | |
...value, | |
toObject() { | |
return value; | |
} | |
}; | |
} | |
} | |
}; | |
var HubServiceGetAllVerificationMessagesByFidDesc = { | |
methodName: "GetAllVerificationMessagesByFid", | |
service: HubServiceDesc, | |
requestStream: false, | |
responseStream: false, | |
requestType: { | |
serializeBinary() { | |
return FidRequest.encode(this).finish(); | |
} | |
}, | |
responseType: { | |
deserializeBinary(data) { | |
const value = MessagesResponse.decode(data); | |
return { | |
...value, | |
toObject() { | |
return value; | |
} | |
}; | |
} | |
} | |
}; | |
var HubServiceGetAllSignerMessagesByFidDesc = { | |
methodName: "GetAllSignerMessagesByFid", | |
service: HubServiceDesc, | |
requestStream: false, | |
responseStream: false, | |
requestType: { | |
serializeBinary() { | |
return FidRequest.encode(this).finish(); | |
} | |
}, | |
responseType: { | |
deserializeBinary(data) { | |
const value = MessagesResponse.decode(data); | |
return { | |
...value, | |
toObject() { | |
return value; | |
} | |
}; | |
} | |
} | |
}; | |
var HubServiceGetAllUserDataMessagesByFidDesc = { | |
methodName: "GetAllUserDataMessagesByFid", | |
service: HubServiceDesc, | |
requestStream: false, | |
responseStream: false, | |
requestType: { | |
serializeBinary() { | |
return FidRequest.encode(this).finish(); | |
} | |
}, | |
responseType: { | |
deserializeBinary(data) { | |
const value = MessagesResponse.decode(data); | |
return { | |
...value, | |
toObject() { | |
return value; | |
} | |
}; | |
} | |
} | |
}; | |
var HubServiceGetInfoDesc = { | |
methodName: "GetInfo", | |
service: HubServiceDesc, | |
requestStream: false, | |
responseStream: false, | |
requestType: { | |
serializeBinary() { | |
return Empty.encode(this).finish(); | |
} | |
}, | |
responseType: { | |
deserializeBinary(data) { | |
const value = HubInfoResponse.decode(data); | |
return { | |
...value, | |
toObject() { | |
return value; | |
} | |
}; | |
} | |
} | |
}; | |
var HubServiceGetAllSyncIdsByPrefixDesc = { | |
methodName: "GetAllSyncIdsByPrefix", | |
service: HubServiceDesc, | |
requestStream: false, | |
responseStream: false, | |
requestType: { | |
serializeBinary() { | |
return TrieNodePrefix.encode(this).finish(); | |
} | |
}, | |
responseType: { | |
deserializeBinary(data) { | |
const value = SyncIds.decode(data); | |
return { | |
...value, | |
toObject() { | |
return value; | |
} | |
}; | |
} | |
} | |
}; | |
var HubServiceGetAllMessagesBySyncIdsDesc = { | |
methodName: "GetAllMessagesBySyncIds", | |
service: HubServiceDesc, | |
requestStream: false, | |
responseStream: false, | |
requestType: { | |
serializeBinary() { | |
return SyncIds.encode(this).finish(); | |
} | |
}, | |
responseType: { | |
deserializeBinary(data) { | |
const value = MessagesResponse.decode(data); | |
return { | |
...value, | |
toObject() { | |
return value; | |
} | |
}; | |
} | |
} | |
}; | |
var HubServiceGetSyncMetadataByPrefixDesc = { | |
methodName: "GetSyncMetadataByPrefix", | |
service: HubServiceDesc, | |
requestStream: false, | |
responseStream: false, | |
requestType: { | |
serializeBinary() { | |
return TrieNodePrefix.encode(this).finish(); | |
} | |
}, | |
responseType: { | |
deserializeBinary(data) { | |
const value = TrieNodeMetadataResponse.decode(data); | |
return { | |
...value, | |
toObject() { | |
return value; | |
} | |
}; | |
} | |
} | |
}; | |
var HubServiceGetSyncSnapshotByPrefixDesc = { | |
methodName: "GetSyncSnapshotByPrefix", | |
service: HubServiceDesc, | |
requestStream: false, | |
responseStream: false, | |
requestType: { | |
serializeBinary() { | |
return TrieNodePrefix.encode(this).finish(); | |
} | |
}, | |
responseType: { | |
deserializeBinary(data) { | |
const value = TrieNodeSnapshotResponse.decode(data); | |
return { | |
...value, | |
toObject() { | |
return value; | |
} | |
}; | |
} | |
} | |
}; | |
var AdminServiceClientImpl = class { | |
constructor(rpc) { | |
__publicField(this, "rpc"); | |
this.rpc = rpc; | |
this.rebuildSyncTrie = this.rebuildSyncTrie.bind(this); | |
this.deleteAllMessagesFromDb = this.deleteAllMessagesFromDb.bind(this); | |
this.submitIdRegistryEvent = this.submitIdRegistryEvent.bind(this); | |
this.submitNameRegistryEvent = this.submitNameRegistryEvent.bind(this); | |
} | |
rebuildSyncTrie(request, metadata) { | |
return this.rpc.unary(AdminServiceRebuildSyncTrieDesc, Empty.fromPartial(request), metadata); | |
} | |
deleteAllMessagesFromDb(request, metadata) { | |
return this.rpc.unary(AdminServiceDeleteAllMessagesFromDbDesc, Empty.fromPartial(request), metadata); | |
} | |
submitIdRegistryEvent(request, metadata) { | |
return this.rpc.unary(AdminServiceSubmitIdRegistryEventDesc, IdRegistryEvent.fromPartial(request), metadata); | |
} | |
submitNameRegistryEvent(request, metadata) { | |
return this.rpc.unary(AdminServiceSubmitNameRegistryEventDesc, NameRegistryEvent.fromPartial(request), metadata); | |
} | |
}; | |
var AdminServiceDesc = { serviceName: "AdminService" }; | |
var AdminServiceRebuildSyncTrieDesc = { | |
methodName: "RebuildSyncTrie", | |
service: AdminServiceDesc, | |
requestStream: false, | |
responseStream: false, | |
requestType: { | |
serializeBinary() { | |
return Empty.encode(this).finish(); | |
} | |
}, | |
responseType: { | |
deserializeBinary(data) { | |
const value = Empty.decode(data); | |
return { | |
...value, | |
toObject() { | |
return value; | |
} | |
}; | |
} | |
} | |
}; | |
var AdminServiceDeleteAllMessagesFromDbDesc = { | |
methodName: "DeleteAllMessagesFromDb", | |
service: AdminServiceDesc, | |
requestStream: false, | |
responseStream: false, | |
requestType: { | |
serializeBinary() { | |
return Empty.encode(this).finish(); | |
} | |
}, | |
responseType: { | |
deserializeBinary(data) { | |
const value = Empty.decode(data); | |
return { | |
...value, | |
toObject() { | |
return value; | |
} | |
}; | |
} | |
} | |
}; | |
var AdminServiceSubmitIdRegistryEventDesc = { | |
methodName: "SubmitIdRegistryEvent", | |
service: AdminServiceDesc, | |
requestStream: false, | |
responseStream: false, | |
requestType: { | |
serializeBinary() { | |
return IdRegistryEvent.encode(this).finish(); | |
} | |
}, | |
responseType: { | |
deserializeBinary(data) { | |
const value = IdRegistryEvent.decode(data); | |
return { | |
...value, | |
toObject() { | |
return value; | |
} | |
}; | |
} | |
} | |
}; | |
var AdminServiceSubmitNameRegistryEventDesc = { | |
methodName: "SubmitNameRegistryEvent", | |
service: AdminServiceDesc, | |
requestStream: false, | |
responseStream: false, | |
requestType: { | |
serializeBinary() { | |
return NameRegistryEvent.encode(this).finish(); | |
} | |
}, | |
responseType: { | |
deserializeBinary(data) { | |
const value = NameRegistryEvent.decode(data); | |
return { | |
...value, | |
toObject() { | |
return value; | |
} | |
}; | |
} | |
} | |
}; | |
var GrpcWebImpl = class { | |
constructor(host, options) { | |
__publicField(this, "host"); | |
__publicField(this, "options"); | |
this.host = host; | |
this.options = options; | |
} | |
unary(methodDesc, _request, metadata) { | |
var _a; | |
const request = { ..._request, ...methodDesc.requestType }; | |
const maybeCombinedMetadata = metadata && this.options.metadata ? new import_browser_headers.BrowserHeaders({ ...(_a = this.options) == null ? void 0 : _a.metadata.headersMap, ...metadata == null ? void 0 : metadata.headersMap }) : metadata || this.options.metadata; | |
return new Promise((resolve, reject) => { | |
import_grpc_web.default.grpc.unary(methodDesc, { | |
request, | |
host: this.host, | |
metadata: maybeCombinedMetadata, | |
transport: this.options.transport, | |
debug: this.options.debug, | |
onEnd: function(response) { | |
if (response.status === import_grpc_web.default.grpc.Code.OK) { | |
resolve(response.message.toObject()); | |
} else { | |
const err2 = new GrpcWebError(response.statusMessage, response.status, response.trailers); | |
reject(err2); | |
} | |
} | |
}); | |
}); | |
} | |
invoke(methodDesc, _request, metadata) { | |
var _a; | |
const upStreamCodes = this.options.upStreamRetryCodes || []; | |
const DEFAULT_TIMEOUT_TIME = 3e3; | |
const request = { ..._request, ...methodDesc.requestType }; | |
const maybeCombinedMetadata = metadata && this.options.metadata ? new import_browser_headers.BrowserHeaders({ ...(_a = this.options) == null ? void 0 : _a.metadata.headersMap, ...metadata == null ? void 0 : metadata.headersMap }) : metadata || this.options.metadata; | |
return new import_rxjs.Observable((observer) => { | |
const upStream = () => { | |
const client = import_grpc_web.default.grpc.invoke(methodDesc, { | |
host: this.host, | |
request, | |
transport: this.options.streamingTransport || this.options.transport, | |
metadata: maybeCombinedMetadata, | |
debug: this.options.debug, | |
onMessage: (next) => observer.next(next), | |
onEnd: (code, message, trailers) => { | |
if (code === 0) { | |
observer.complete(); | |
} else if (upStreamCodes.includes(code)) { | |
setTimeout(upStream, DEFAULT_TIMEOUT_TIME); | |
} else { | |
const err2 = new Error(message); | |
err2.code = code; | |
err2.metadata = trailers; | |
observer.error(err2); | |
} | |
} | |
}); | |
observer.add(() => { | |
if (!observer.closed) { | |
return client.close(); | |
} | |
}); | |
}; | |
upStream(); | |
}).pipe((0, import_operators.share)()); | |
} | |
}; | |
var tsProtoGlobalThis6 = (() => { | |
if (typeof globalThis !== "undefined") { | |
return globalThis; | |
} | |
if (typeof self !== "undefined") { | |
return self; | |
} | |
if (typeof window !== "undefined") { | |
return window; | |
} | |
if (typeof global !== "undefined") { | |
return global; | |
} | |
throw "Unable to locate global object"; | |
})(); | |
var GrpcWebError = class extends tsProtoGlobalThis6.Error { | |
constructor(message, code, metadata) { | |
super(message); | |
this.code = code; | |
this.metadata = metadata; | |
} | |
}; | |
// src/client.ts | |
init_cjs_shims(); | |
var import_grpc_web_node_http_transport = require("@improbable-eng/grpc-web-node-http-transport"); | |
var import_grpc_web2 = __toESM(require("@improbable-eng/grpc-web")); | |
// ../../node_modules/neverthrow/dist/index.es.js | |
init_cjs_shims(); | |
function __awaiter(thisArg, _arguments, P, generator) { | |
function adopt(value) { | |
return value instanceof P ? value : new P(function(resolve) { | |
resolve(value); | |
}); | |
} | |
return new (P || (P = Promise))(function(resolve, reject) { | |
function fulfilled(value) { | |
try { | |
step(generator.next(value)); | |
} catch (e) { | |
reject(e); | |
} | |
} | |
function rejected(value) { | |
try { | |
step(generator["throw"](value)); | |
} catch (e) { | |
reject(e); | |
} | |
} | |
function step(result) { | |
result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); | |
} | |
step((generator = generator.apply(thisArg, _arguments || [])).next()); | |
}); | |
} | |
function __generator(thisArg, body) { | |
var _ = { label: 0, sent: function() { | |
if (t[0] & 1) | |
throw t[1]; | |
return t[1]; | |
}, trys: [], ops: [] }, f, y, t, g; | |
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { | |
return this; | |
}), g; | |
function verb(n) { | |
return function(v) { | |
return step([n, v]); | |
}; | |
} | |
function step(op) { | |
if (f) | |
throw new TypeError("Generator is already executing."); | |
while (_) | |
try { | |
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) | |
return t; | |
if (y = 0, t) | |
op = [op[0] & 2, t.value]; | |
switch (op[0]) { | |
case 0: | |
case 1: | |
t = op; | |
break; | |
case 4: | |
_.label++; | |
return { value: op[1], done: false }; | |
case 5: | |
_.label++; | |
y = op[1]; | |
op = [0]; | |
continue; | |
case 7: | |
op = _.ops.pop(); | |
_.trys.pop(); | |
continue; | |
default: | |
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { | |
_ = 0; | |
continue; | |
} | |
if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) { | |
_.label = op[1]; | |
break; | |
} | |
if (op[0] === 6 && _.label < t[1]) { | |
_.label = t[1]; | |
t = op; | |
break; | |
} | |
if (t && _.label < t[2]) { | |
_.label = t[2]; | |
_.ops.push(op); | |
break; | |
} | |
if (t[2]) | |
_.ops.pop(); | |
_.trys.pop(); | |
continue; | |
} | |
op = body.call(thisArg, _); | |
} catch (e) { | |
op = [6, e]; | |
y = 0; | |
} finally { | |
f = t = 0; | |
} | |
if (op[0] & 5) | |
throw op[1]; | |
return { value: op[0] ? op[1] : void 0, done: true }; | |
} | |
} | |
function __read(o, n) { | |
var m = typeof Symbol === "function" && o[Symbol.iterator]; | |
if (!m) | |
return o; | |
var i = m.call(o), r, ar = [], e; | |
try { | |
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) | |
ar.push(r.value); | |
} catch (error) { | |
e = { error }; | |
} finally { | |
try { | |
if (r && !r.done && (m = i["return"])) | |
m.call(i); | |
} finally { | |
if (e) | |
throw e.error; | |
} | |
} | |
return ar; | |
} | |
function __spreadArray(to, from, pack) { | |
if (pack || arguments.length === 2) | |
for (var i = 0, l = from.length, ar; i < l; i++) { | |
if (ar || !(i in from)) { | |
if (!ar) | |
ar = Array.prototype.slice.call(from, 0, i); | |
ar[i] = from[i]; | |
} | |
} | |
return to.concat(ar || Array.prototype.slice.call(from)); | |
} | |
var defaultErrorConfig = { | |
withStackTrace: false | |
}; | |
var createNeverThrowError = function(message, result, config) { | |
if (config === void 0) { | |
config = defaultErrorConfig; | |
} | |
var data = result.isOk() ? { type: "Ok", value: result.value } : { type: "Err", value: result.error }; | |
var maybeStack = config.withStackTrace ? new Error().stack : void 0; | |
return { | |
data, | |
message, | |
stack: maybeStack | |
}; | |
}; | |
var ResultAsync = ( | |
/** @class */ | |
function() { | |
function ResultAsync2(res) { | |
this._promise = res; | |
} | |
ResultAsync2.fromSafePromise = function(promise) { | |
var newPromise = promise.then(function(value) { | |
return new Ok(value); | |
}); | |
return new ResultAsync2(newPromise); | |
}; | |
ResultAsync2.fromPromise = function(promise, errorFn) { | |
var newPromise = promise.then(function(value) { | |
return new Ok(value); | |
})["catch"](function(e) { | |
return new Err(errorFn(e)); | |
}); | |
return new ResultAsync2(newPromise); | |
}; | |
ResultAsync2.combine = function(asyncResultList) { | |
return combineResultAsyncList(asyncResultList); | |
}; | |
ResultAsync2.combineWithAllErrors = function(asyncResultList) { | |
return combineResultAsyncListWithAllErrors(asyncResultList); | |
}; | |
ResultAsync2.prototype.map = function(f) { | |
var _this = this; | |
return new ResultAsync2(this._promise.then(function(res) { | |
return __awaiter(_this, void 0, void 0, function() { | |
var _a; | |
return __generator(this, function(_b) { | |
switch (_b.label) { | |
case 0: | |
if (res.isErr()) { | |
return [2, new Err(res.error)]; | |
} | |
_a = Ok.bind; | |
return [4, f(res.value)]; | |
case 1: | |
return [2, new (_a.apply(Ok, [void 0, _b.sent()]))()]; | |
} | |
}); | |
}); | |
})); | |
}; | |
ResultAsync2.prototype.mapErr = function(f) { | |
var _this = this; | |
return new ResultAsync2(this._promise.then(function(res) { | |
return __awaiter(_this, void 0, void 0, function() { | |
var _a; | |
return __generator(this, function(_b) { | |
switch (_b.label) { | |
case 0: | |
if (res.isOk()) { | |
return [2, new Ok(res.value)]; | |
} | |
_a = Err.bind; | |
return [4, f(res.error)]; | |
case 1: | |
return [2, new (_a.apply(Err, [void 0, _b.sent()]))()]; | |
} | |
}); | |
}); | |
})); | |
}; | |
ResultAsync2.prototype.andThen = function(f) { | |
return new ResultAsync2(this._promise.then(function(res) { | |
if (res.isErr()) { | |
return new Err(res.error); | |
} | |
var newValue = f(res.value); | |
return newValue instanceof ResultAsync2 ? newValue._promise : newValue; | |
})); | |
}; | |
ResultAsync2.prototype.orElse = function(f) { | |
var _this = this; | |
return new ResultAsync2(this._promise.then(function(res) { | |
return __awaiter(_this, void 0, void 0, function() { | |
return __generator(this, function(_a) { | |
if (res.isErr()) { | |
return [2, f(res.error)]; | |
} | |
return [2, new Ok(res.value)]; | |
}); | |
}); | |
})); | |
}; | |
ResultAsync2.prototype.match = function(ok2, _err) { | |
return this._promise.then(function(res) { | |
return res.match(ok2, _err); | |
}); | |
}; | |
ResultAsync2.prototype.unwrapOr = function(t) { | |
return this._promise.then(function(res) { | |
return res.unwrapOr(t); | |
}); | |
}; | |
ResultAsync2.prototype.then = function(successCallback, failureCallback) { | |
return this._promise.then(successCallback, failureCallback); | |
}; | |
return ResultAsync2; | |
}() | |
); | |
var errAsync = function(err2) { | |
return new ResultAsync(Promise.resolve(new Err(err2))); | |
}; | |
var fromPromise = ResultAsync.fromPromise; | |
var fromSafePromise = ResultAsync.fromSafePromise; | |
var appendValueToEndOfList = function(value) { | |
return function(list) { | |
return __spreadArray(__spreadArray([], __read(list), false), [value], false); | |
}; | |
}; | |
var combineResultList = function(resultList) { | |
return resultList.reduce(function(acc, result) { | |
return acc.isOk() ? result.isErr() ? err(result.error) : acc.map(appendValueToEndOfList(result.value)) : acc; | |
}, ok([])); | |
}; | |
var combineResultAsyncList = function(asyncResultList) { | |
return ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(combineResultList); | |
}; | |
var combineResultListWithAllErrors = function(resultList) { | |
return resultList.reduce(function(acc, result) { | |
return result.isErr() ? acc.isErr() ? err(__spreadArray(__spreadArray([], __read(acc.error), false), [result.error], false)) : err([result.error]) : acc.isErr() ? acc : ok(__spreadArray(__spreadArray([], __read(acc.value), false), [result.value], false)); | |
}, ok([])); | |
}; | |
var combineResultAsyncListWithAllErrors = function(asyncResultList) { | |
return ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(combineResultListWithAllErrors); | |
}; | |
var Result; | |
(function(Result2) { | |
function fromThrowable2(fn, errorFn) { | |
return function() { | |
var args = []; | |
for (var _i = 0; _i < arguments.length; _i++) { | |
args[_i] = arguments[_i]; | |
} | |
try { | |
var result = fn.apply(void 0, __spreadArray([], __read(args), false)); | |
return ok(result); | |
} catch (e) { | |
return err(errorFn ? errorFn(e) : e); | |
} | |
}; | |
} | |
Result2.fromThrowable = fromThrowable2; | |
function combine(resultList) { | |
return combineResultList(resultList); | |
} | |
Result2.combine = combine; | |
function combineWithAllErrors(resultList) { | |
return combineResultListWithAllErrors(resultList); | |
} | |
Result2.combineWithAllErrors = combineWithAllErrors; | |
})(Result || (Result = {})); | |
var ok = function(value) { | |
return new Ok(value); | |
}; | |
var err = function(err2) { | |
return new Err(err2); | |
}; | |
var Ok = ( | |
/** @class */ | |
function() { | |
function Ok2(value) { | |
this.value = value; | |
} | |
Ok2.prototype.isOk = function() { | |
return true; | |
}; | |
Ok2.prototype.isErr = function() { | |
return !this.isOk(); | |
}; | |
Ok2.prototype.map = function(f) { | |
return ok(f(this.value)); | |
}; | |
Ok2.prototype.mapErr = function(_f) { | |
return ok(this.value); | |
}; | |
Ok2.prototype.andThen = function(f) { | |
return f(this.value); | |
}; | |
Ok2.prototype.orElse = function(_f) { | |
return ok(this.value); | |
}; | |
Ok2.prototype.asyncAndThen = function(f) { | |
return f(this.value); | |
}; | |
Ok2.prototype.asyncMap = function(f) { | |
return ResultAsync.fromSafePromise(f(this.value)); | |
}; | |
Ok2.prototype.unwrapOr = function(_v) { | |
return this.value; | |
}; | |
Ok2.prototype.match = function(ok2, _err) { | |
return ok2(this.value); | |
}; | |
Ok2.prototype._unsafeUnwrap = function(_) { | |
return this.value; | |
}; | |
Ok2.prototype._unsafeUnwrapErr = function(config) { | |
throw createNeverThrowError("Called `_unsafeUnwrapErr` on an Ok", this, config); | |
}; | |
return Ok2; | |
}() | |
); | |
var Err = ( | |
/** @class */ | |
function() { | |
function Err2(error) { | |
this.error = error; | |
} | |
Err2.prototype.isOk = function() { | |
return false; | |
}; | |
Err2.prototype.isErr = function() { | |
return !this.isOk(); | |
}; | |
Err2.prototype.map = function(_f) { | |
return err(this.error); | |
}; | |
Err2.prototype.mapErr = function(f) { | |
return err(f(this.error)); | |
}; | |
Err2.prototype.andThen = function(_f) { | |
return err(this.error); | |
}; | |
Err2.prototype.orElse = function(f) { | |
return f(this.error); | |
}; | |
Err2.prototype.asyncAndThen = function(_f) { | |
return errAsync(this.error); | |
}; | |
Err2.prototype.asyncMap = function(_f) { | |
return errAsync(this.error); | |
}; | |
Err2.prototype.unwrapOr = function(v) { | |
return v; | |
}; | |
Err2.prototype.match = function(_ok, err2) { | |
return err2(this.error); | |
}; | |
Err2.prototype._unsafeUnwrap = function(config) { | |
throw createNeverThrowError("Called `_unsafeUnwrap` on an Err", this, config); | |
}; | |
Err2.prototype._unsafeUnwrapErr = function(_) { | |
return this.error; | |
}; | |
return Err2; | |
}() | |
); | |
var fromThrowable = Result.fromThrowable; | |
// src/client.ts | |
var import_core = require("@farcaster/core"); | |
var import_rxjs2 = require("rxjs"); | |
var grpcCodeToHubErrorCode = (code) => { | |
switch (code) { | |
case import_grpc_web2.default.grpc.Code.Unauthenticated: | |
return "unauthenticated"; | |
case import_grpc_web2.default.grpc.Code.PermissionDenied: | |
return "unauthorized"; | |
case import_grpc_web2.default.grpc.Code.InvalidArgument: | |
return "bad_request"; | |
case import_grpc_web2.default.grpc.Code.NotFound: | |
return "not_found"; | |
case import_grpc_web2.default.grpc.Code.Unavailable: | |
return "unavailable"; | |
default: | |
return "unknown"; | |
} | |
}; | |
var fromServiceError = (err2) => { | |
var _a; | |
let context = err2["message"]; | |
if (err2.code === 2 && context === "Response closed without headers") { | |
context = "Connection failed: please check that the hub\u2019s address, ports and authentication config are correct. " + context; | |
return new import_core.HubError("unavailable", context); | |
} | |
return new import_core.HubError(((_a = err2.metadata) == null ? void 0 : _a.get("errcode")[0]) || grpcCodeToHubErrorCode(err2.code), context); | |
}; | |
var wrapClient = (client) => { | |
return new Proxy(client, { | |
get: (target, descriptor) => { | |
const key = descriptor; | |
if (key === "$") | |
return target; | |
const func = target[key]; | |
if (typeof func === "function") { | |
return (...args) => { | |
const result = func.call(target, ...args); | |
if (result instanceof Promise) { | |
return result.then( | |
(res) => ok(res), | |
(e) => err(fromServiceError(e)) | |
); | |
} | |
return ok(result); | |
}; | |
} | |
return func; | |
} | |
}); | |
}; | |
var getHubRpcClient = (url, isBrowser = true) => { | |
return wrapClient(new HubServiceClientImpl(getRpcWebClient(url, isBrowser))); | |
}; | |
var getAdminRpcClient = (url, isBrowser = true) => { | |
return wrapClient(new AdminServiceClientImpl(getRpcWebClient(url, isBrowser))); | |
}; | |
var getRpcWebClient = (address, isBrowser = true) => { | |
return new GrpcWebImpl(address, isBrowser ? {} : { transport: (0, import_grpc_web_node_http_transport.NodeHttpTransport)() }); | |
}; | |
var getAuthMetadata = (username, password) => { | |
const metadata = new import_grpc_web2.default.grpc.Metadata(); | |
if (typeof btoa === "undefined") { | |
metadata.set("authorization", `Basic ${Buffer.from(`${username}:${password}`).toString("base64")}`); | |
} else { | |
metadata.set("authorization", `Basic ${btoa(`${username}:${password}`)}`); | |
} | |
return metadata; | |
}; | |
// Annotate the CommonJS export names for ESM import in node: | |
0 && (module.exports = { | |
AdminServiceClientImpl, | |
AdminServiceDeleteAllMessagesFromDbDesc, | |
AdminServiceDesc, | |
AdminServiceRebuildSyncTrieDesc, | |
AdminServiceSubmitIdRegistryEventDesc, | |
AdminServiceSubmitNameRegistryEventDesc, | |
GrpcWebError, | |
GrpcWebImpl, | |
HubServiceClientImpl, | |
HubServiceDesc, | |
HubServiceGetAllCastMessagesByFidDesc, | |
HubServiceGetAllMessagesBySyncIdsDesc, | |
HubServiceGetAllReactionMessagesByFidDesc, | |
HubServiceGetAllSignerMessagesByFidDesc, | |
HubServiceGetAllSyncIdsByPrefixDesc, | |
HubServiceGetAllUserDataMessagesByFidDesc, | |
HubServiceGetAllVerificationMessagesByFidDesc, | |
HubServiceGetCastDesc, | |
HubServiceGetCastsByFidDesc, | |
HubServiceGetCastsByMentionDesc, | |
HubServiceGetCastsByParentDesc, | |
HubServiceGetEventDesc, | |
HubServiceGetFidsDesc, | |
HubServiceGetIdRegistryEventByAddressDesc, | |
HubServiceGetIdRegistryEventDesc, | |
HubServiceGetInfoDesc, | |
HubServiceGetNameRegistryEventDesc, | |
HubServiceGetReactionDesc, | |
HubServiceGetReactionsByCastDesc, | |
HubServiceGetReactionsByFidDesc, | |
HubServiceGetSignerDesc, | |
HubServiceGetSignersByFidDesc, | |
HubServiceGetSyncMetadataByPrefixDesc, | |
HubServiceGetSyncSnapshotByPrefixDesc, | |
HubServiceGetUserDataByFidDesc, | |
HubServiceGetUserDataDesc, | |
HubServiceGetVerificationDesc, | |
HubServiceGetVerificationsByFidDesc, | |
HubServiceSubmitMessageDesc, | |
HubServiceSubscribeDesc, | |
Observable, | |
getAdminRpcClient, | |
getAuthMetadata, | |
getHubRpcClient | |
}); |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment