@jackallabs/jackal.js-protos
Version:
Package of all protos used by Jackal.js
1,454 lines (1,453 loc) • 889 kB
JavaScript
"use strict";
var __defProp2 = Object.defineProperty;
var __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __publicField2 = (obj, key, value) => __defNormalProp2(obj, typeof key !== "symbol" ? key + "" : key, value);
Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
const stargate = require("@cosmjs/stargate");
const tendermintRpc = require("@cosmjs/tendermint-rpc");
const protoSigning = require("@cosmjs/proto-signing");
const adaptor = require("@cosmjs/tendermint-rpc/build/tendermint34/adaptor");
const adaptor$1 = require("@cosmjs/tendermint-rpc/build/comet38/adaptor");
const utils = require("@cosmjs/utils");
const modules = require("@cosmjs/stargate/build/modules");
var __defProp = Object.defineProperty;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
function processExtensions(tmClient, ex) {
const [aa, bb, cc, dd, ee, ff, gg, hh, ii, jj, kk, ll, mm, nn, oo, pp, qq, rr] = ex;
switch (ex.length) {
case 0:
return stargate.QueryClient.withExtensions(tmClient);
case 1:
return stargate.QueryClient.withExtensions(tmClient, aa);
case 2:
return stargate.QueryClient.withExtensions(tmClient, aa, bb);
case 3:
return stargate.QueryClient.withExtensions(tmClient, aa, bb, cc);
case 4:
return stargate.QueryClient.withExtensions(tmClient, aa, bb, cc, dd);
case 5:
return stargate.QueryClient.withExtensions(tmClient, aa, bb, cc, dd, ee);
case 6:
return stargate.QueryClient.withExtensions(tmClient, aa, bb, cc, dd, ee, ff);
case 7:
return stargate.QueryClient.withExtensions(tmClient, aa, bb, cc, dd, ee, ff, gg);
case 8:
return stargate.QueryClient.withExtensions(tmClient, aa, bb, cc, dd, ee, ff, gg, hh);
case 9:
return stargate.QueryClient.withExtensions(tmClient, aa, bb, cc, dd, ee, ff, gg, hh, ii);
case 10:
return stargate.QueryClient.withExtensions(tmClient, aa, bb, cc, dd, ee, ff, gg, hh, ii, jj);
case 11:
return stargate.QueryClient.withExtensions(tmClient, aa, bb, cc, dd, ee, ff, gg, hh, ii, jj, kk);
case 12:
return stargate.QueryClient.withExtensions(tmClient, aa, bb, cc, dd, ee, ff, gg, hh, ii, jj, kk, ll);
case 13:
return stargate.QueryClient.withExtensions(tmClient, aa, bb, cc, dd, ee, ff, gg, hh, ii, jj, kk, ll, mm);
case 14:
return stargate.QueryClient.withExtensions(tmClient, aa, bb, cc, dd, ee, ff, gg, hh, ii, jj, kk, ll, mm, nn);
case 15:
return stargate.QueryClient.withExtensions(tmClient, aa, bb, cc, dd, ee, ff, gg, hh, ii, jj, kk, ll, mm, nn, oo);
case 16:
return stargate.QueryClient.withExtensions(tmClient, aa, bb, cc, dd, ee, ff, gg, hh, ii, jj, kk, ll, mm, nn, oo, pp);
case 17:
return stargate.QueryClient.withExtensions(tmClient, aa, bb, cc, dd, ee, ff, gg, hh, ii, jj, kk, ll, mm, nn, oo, pp, qq);
case 18:
return stargate.QueryClient.withExtensions(tmClient, aa, bb, cc, dd, ee, ff, gg, hh, ii, jj, kk, ll, mm, nn, oo, pp, qq, rr);
default:
throw new Error("Too many extensions");
}
}
function warnError$1(thing, err) {
const notice = `Banshee | ${thing}: ${err}`;
console.warn(notice);
return err;
}
function tidyString(source, toTidy, mode = "both") {
let startIndex = 0;
let endIndex = source.length;
if (mode === "start" || mode === "both") {
while (startIndex < endIndex && source[startIndex] === toTidy) {
startIndex++;
}
}
if (mode === "end" || mode === "both") {
while (startIndex < endIndex && source[endIndex - 1] === toTidy) {
endIndex--;
}
}
return source.slice(startIndex, endIndex);
}
class IbcQueryClient extends stargate.StargateClient {
constructor(tmClient, options) {
super(tmClient, options);
__publicField(this, "queries");
__publicField(this, "wsCore");
const { queryExtensions = [] } = options;
this.queries = processExtensions(tmClient, queryExtensions);
this.wsCore = new WebsocketCore();
}
/**
* @function connect
* @memberof IbcQueryClient
* @async
* @static
*/
static async connect(endpoint, options = {}) {
try {
const client = await tendermintRpc.connectComet(endpoint);
return new IbcQueryClient(client, options);
} catch (err) {
throw warnError$1("IbcQueryClient connect()", err);
}
}
async monitor(connections) {
try {
await this.wsCore.monitor(connections);
} catch (err) {
throw warnError$1("IbcQueryClient monitor()", err);
}
}
}
function createDefaultRegistry(source) {
const full = [...stargate.defaultRegistryTypes];
for (let one of source) {
full.push(...Object.values(one));
}
return new protoSigning.Registry(full);
}
class IbcSigningClient extends stargate.SigningStargateClient {
constructor(tmClient, signer, address, options) {
super(tmClient, signer, options);
__publicField(this, "queries");
__publicField(this, "txLibrary");
__publicField(this, "address");
__publicField(this, "wsCore");
const { queryExtensions = [], txLibrary = {} } = options;
this.address = address;
this.queries = processExtensions(tmClient, queryExtensions);
this.txLibrary = txLibrary;
this.wsCore = new WebsocketCore();
}
/**
* @function connectWithSigner
* @memberof IbcSigningClient
* @async
* @static
*/
static async connectWithSigner(endpoint, signer, options = {}) {
try {
const client = await tendermintRpc.connectComet(endpoint);
const { address } = (await signer.getAccounts())[0];
const { customModules = [] } = options;
return new IbcSigningClient(client, signer, address, {
registry: createDefaultRegistry(customModules),
...options
});
} catch (err) {
throw warnError$1("IbcSigningClient connectWithSigner()", err);
}
}
async monitor(connections) {
try {
await this.wsCore.monitor(connections);
} catch (err) {
throw warnError$1("IbcSigningClient monitor()", err);
}
}
async selfSignAndBroadcast(msgs, options = {}) {
try {
const { fee, memo, timeoutHeight } = {
fee: {
amount: [],
gas: (msgs.length * 1e5).toString()
},
...options
};
return this.signAndBroadcast(this.address, msgs, fee, memo, timeoutHeight);
} catch (err) {
throw warnError$1("IbcSigningClient selfSignAndBroadcast()", err);
}
}
}
class WebsocketCore {
constructor() {
__publicField(this, "wsConnections");
__publicField(this, "wsFeeds");
this.wsConnections = {};
this.wsFeeds = {};
}
monitor(connections) {
try {
if (connections instanceof Array) {
for (let conn of connections) {
this.setupMonitoring(conn);
}
} else {
this.setupMonitoring(connections);
}
} catch (err) {
throw err;
}
}
setupMonitoring(conn) {
try {
if (!conn.endpoint.startsWith("ws://") && !conn.endpoint.startsWith("wss://")) {
throw new Error("invalid url");
}
const cleanEndpoint = tidyString(conn.endpoint, "/");
const finalEndpoint = cleanEndpoint.endsWith("websocket") ? cleanEndpoint : `${cleanEndpoint}/websocket`;
if (!this.wsConnections[conn.chainId]) {
this.wsConnections[conn.chainId] = new WebSocket(finalEndpoint);
}
const client = this.wsConnections[conn.chainId];
const query = conn.query ? `tm.event = 'Tx' AND ${conn.query}` : `tm.event = 'Tx'`;
const marker = Date.now().toString();
this.wsFeeds[`${marker}|${query}`] = conn.feed;
const wsQuery = {
jsonrpc: "2.0",
method: "subscribe",
id: marker,
params: { query }
};
if (client.readyState === 1) {
client.send(JSON.stringify(wsQuery));
} else {
client.onopen = () => {
client.send(JSON.stringify(wsQuery));
};
}
client.onmessage = (msg) => {
try {
const data = JSON.parse(msg.data);
if (!data.result || !data.result.data) {
return;
}
let ready;
try {
ready = adaptor.Responses.decodeTxEvent(data.result);
} catch (_) {
try {
ready = adaptor$1.Responses.decodeTxEvent(data.result);
} catch (_2) {
throw new Error("Unable to decode event");
}
}
this.wsFeeds[`${marker}|${data.result.query}`].push(ready);
this.wsFeeds[`${marker}|${data.result.query}`] = [];
} catch (err) {
console.error(err);
}
};
} catch (err) {
throw err;
}
}
}
var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
function getDefaultExportFromCjs(x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
}
var src = { exports: {} };
var indexLight = { exports: {} };
var indexMinimal = {};
var minimal = {};
var aspromise;
var hasRequiredAspromise;
function requireAspromise() {
if (hasRequiredAspromise) return aspromise;
hasRequiredAspromise = 1;
aspromise = 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(err) {
if (pending) {
pending = false;
if (err)
reject(err);
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 (err) {
if (pending) {
pending = false;
reject(err);
}
}
});
}
return aspromise;
}
var base64 = {};
var hasRequiredBase64;
function requireBase64() {
if (hasRequiredBase64) return base64;
hasRequiredBase64 = 1;
(function(exports2) {
var base642 = exports2;
base642.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 (var i = 0; i < 64; )
s64[b64[i] = i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i - 59 | 43] = i++;
base642.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";
base642.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;
};
base642.test = function test(string) {
return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(string);
};
})(base64);
return base64;
}
var eventemitter;
var hasRequiredEventemitter;
function requireEventemitter() {
if (hasRequiredEventemitter) return eventemitter;
hasRequiredEventemitter = 1;
eventemitter = 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;
};
return eventemitter;
}
var float;
var hasRequiredFloat;
function requireFloat() {
if (hasRequiredFloat) return float;
hasRequiredFloat = 1;
float = factory(factory);
function factory(exports2) {
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];
}
exports2.writeFloatLE = le ? writeFloat_f32_cpy : writeFloat_f32_rev;
exports2.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];
}
exports2.readFloatLE = le ? readFloat_f32_cpy : readFloat_f32_rev;
exports2.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);
}
}
exports2.writeFloatLE = writeFloat_ieee754.bind(null, writeUintLE);
exports2.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);
}
exports2.readFloatLE = readFloat_ieee754.bind(null, readUintLE);
exports2.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];
}
exports2.writeDoubleLE = le ? writeDouble_f64_cpy : writeDouble_f64_rev;
exports2.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];
}
exports2.readDoubleLE = le ? readDouble_f64_cpy : readDouble_f64_rev;
exports2.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);
}
}
}
exports2.writeDoubleLE = writeDouble_ieee754.bind(null, writeUintLE, 0, 4);
exports2.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);
}
exports2.readDoubleLE = readDouble_ieee754.bind(null, readUintLE, 0, 4);
exports2.readDoubleBE = readDouble_ieee754.bind(null, readUintBE, 4, 0);
})();
return exports2;
}
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;
}
return float;
}
var inquire_1;
var hasRequiredInquire;
function requireInquire() {
if (hasRequiredInquire) return inquire_1;
hasRequiredInquire = 1;
inquire_1 = 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;
}
return inquire_1;
}
var utf8 = {};
var hasRequiredUtf8;
function requireUtf8() {
if (hasRequiredUtf8) return utf8;
hasRequiredUtf8 = 1;
(function(exports2) {
var utf82 = exports2;
utf82.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;
};
utf82.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));
};
utf82.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;
};
})(utf8);
return utf8;
}
var pool_1;
var hasRequiredPool;
function requirePool() {
if (hasRequiredPool) return pool_1;
hasRequiredPool = 1;
pool_1 = 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;
};
}
return pool_1;
}
var longbits;
var hasRequiredLongbits;
function requireLongbits() {
if (hasRequiredLongbits) return longbits;
hasRequiredLongbits = 1;
longbits = LongBits;
var util2 = requireMinimal();
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 (util2.isString(value)) {
if (util2.Long)
value = util2.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 util2.Long ? new util2.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;
};
return longbits;
}
var hasRequiredMinimal;
function requireMinimal() {
if (hasRequiredMinimal) return minimal;
hasRequiredMinimal = 1;
(function(exports2) {
var util2 = exports2;
util2.asPromise = requireAspromise();
util2.base64 = requireBase64();
util2.EventEmitter = requireEventemitter();
util2.float = requireFloat();
util2.inquire = requireInquire();
util2.utf8 = requireUtf8();
util2.pool = requirePool();
util2.LongBits = requireLongbits();
util2.isNode = Boolean(typeof commonjsGlobal !== "undefined" && commonjsGlobal && commonjsGlobal.process && commonjsGlobal.process.versions && commonjsGlobal.process.versions.node);
util2.global = util2.isNode && commonjsGlobal || typeof window !== "undefined" && window || typeof self !== "undefined" && self || minimal;
util2.emptyArray = Object.freeze ? Object.freeze([]) : (
/* istanbul ignore next */
[]
);
util2.emptyObject = Object.freeze ? Object.freeze({}) : (
/* istanbul ignore next */
{}
);
util2.isInteger = Number.isInteger || /* istanbul ignore next */
function isInteger(value) {
return typeof value === "number" && isFinite(value) && Math.floor(value) === value;
};
util2.isString = function isString(value) {
return typeof value === "string" || value instanceof String;
};
util2.isObject = function isObject2(value) {
return value && typeof value === "object";
};
util2.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`
*/
util2.isSet = function isSet2(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;
};
util2.Buffer = function() {
try {
var Buffer2 = util2.inquire("buffer").Buffer;
return Buffer2.prototype.utf8Write ? Buffer2 : (
/* istanbul ignore next */
null
);
} catch (e) {
return null;
}
}();
util2._Buffer_from = null;
util2._Buffer_allocUnsafe = null;
util2.newBuffer = function newBuffer(sizeOrArray) {
return typeof sizeOrArray === "number" ? util2.Buffer ? util2._Buffer_allocUnsafe(sizeOrArray) : new util2.Array(sizeOrArray) : util2.Buffer ? util2._Buffer_from(sizeOrArray) : typeof Uint8Array === "undefined" ? sizeOrArray : new Uint8Array(sizeOrArray);
};
util2.Array = typeof Uint8Array !== "undefined" ? Uint8Array : Array;
util2.Long = /* istanbul ignore next */
util2.global.dcodeIO && /* istanbul ignore next */
util2.global.dcodeIO.Long || /* istanbul ignore next */
util2.global.Long || util2.inquire("long");
util2.key2Re = /^true|false|0|1$/;
util2.key32Re = /^-?(?:0|[1-9][0-9]*)$/;
util2.key64Re = /^(?:[\\x00-\\xff]{8}|-?(?:0|[1-9][0-9]*))$/;
util2.longToHash = function longToHash(value) {
return value ? util2.LongBits.from(value).toHash() : util2.LongBits.zeroHash;
};
util2.longFromHash = function longFromHash(hash, unsigned) {
var bits = util2.LongBits.fromHash(hash);
if (util2.Long)
return util2.Long.fromBits(bits.lo, bits.hi, unsigned);
return bits.toNumber(Boolean(unsigned));
};
function merge(dst, src2, ifNotSet) {
for (var keys = Object.keys(src2), i = 0; i < keys.length; ++i)
if (dst[keys[i]] === void 0 || !ifNotSet)
dst[keys[i]] = src2[keys[i]];
return dst;
}
util2.merge = merge;
util2.lcFirst = function lcFirst(str) {
return str.charAt(0).toLowerCase() + str.substring(1);
};
function newError(name) {
function CustomError(message2, properties) {
if (!(this instanceof CustomError))
return new CustomError(message2, properties);
Object.defineProperty(this, "message", { get: function() {
return message2;
} });
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: {
value: CustomError,
writable: true,
enumerable: false,
configurable: true
},
name: {
get: function get() {
return name;
},
set: void 0,
enumerable: false,
// configurable: false would accurately preserve the behavior of
// the original, but I'm guessing that was not intentional.
// For an actual error subclass, this property would
// be configurable.
configurable: true
},
toString: {
value: function value() {
return this.name + ": " + this.message;
},
writable: true,
enumerable: false,
configurable: true
}
});
return CustomError;
}
util2.newError = newError;
util2.ProtocolError = newError("ProtocolError");
util2.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];
};
};
util2.oneOfSetter = function setOneOf(fieldNames) {
return function(name) {
for (var i = 0; i < fieldNames.length; ++i)
if (fieldNames[i] !== name)
delete this[fieldNames[i]];
};
};
util2.toJSONOptions = {
longs: String,
enums: String,
bytes: String,
json: true
};
util2._configure = function() {
var Buffer2 = util2.Buffer;
if (!Buffer2) {
util2._Buffer_from = util2._Buffer_allocUnsafe = null;
return;
}
util2._Buffer_from = Buffer2.from !== Uint8Array.from && Buffer2.from || /* istanbul ignore next */
function Buffer_from(value, encoding) {
return new Buffer2(value, encoding);
};
util2._Buffer_allocUnsafe = Buffer2.allocUnsafe || /* istanbul ignore next */
function Buffer_allocUnsafe(size) {
return new Buffer2(size);
};
};
})(minimal);
return minimal;
}
var writer;
var hasRequiredWriter;
function requireWriter() {
if (hasRequiredWriter) return writer;
hasRequiredWriter = 1;
writer = Writer;
var util2 = requireMinimal();
var BufferWriter;
var LongBits = util2.LongBits, base642 = util2.base64, utf82 = util2.utf8;
function Op(fn, len, val) {
this.fn = fn;
this.len = len;
this.next = void 0;
this.val = val;
}
function noop() {
}
function State(writer2) {
this.head = writer2.head;
this.tail = writer2.tail;
this.len = writer2.len;
this.next = writer2.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 util2.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 util2.Array(size);
};
if (util2.Array !== Array)
Writer.alloc = util2.pool(Writer.alloc, util2.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(util2.float.writeFloatLE, 4, value);
};
Writer.prototype.double = function write_double(value) {
return this._push(util2.float.writeDoubleLE, 8, value);
};
var writeBytes = util2.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 (util2.isString(value)) {
var buf = Writer.alloc(len = base642.length(value));
base642.decode(value, buf, 0);
value = buf;
}
return this.uint32(len)._push(writeBytes, len, value);
};
Writer.prototype.string = function write_string(value) {
var len = utf82.length(value);
return len ? this.uint32(len)._push(utf82.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();
};
return writer;
}
var writer_buffer;
var hasRequiredWriter_buffer;
function requireWriter_buffer() {
if (hasRequiredWriter_buffer) return writer_buffer;
hasRequiredWriter_buffer = 1;
writer_buffer = BufferWriter;
var Writer = requireWriter();
(BufferWriter.prototype = Object.create(Writer.prototype)).constructor = BufferWriter;
var util2 = requireMinimal();
function BufferWriter() {
Writer.call(this);
}
BufferWriter._configure = function() {
BufferWriter.alloc = util2._Buffer_allocUnsafe;
BufferWriter.writeBytesBuffer = util2.Buffer && util2.Buffer.prototype instanceof Uint8Array && util2.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 (util2.isString(value))
value = util2._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) {
util2.utf8.write(val, buf, pos);
}
BufferWriter.prototype.string = function write_string_buffer(value) {
var len = util2.Buffer.byteLength(value);
this.uint32(len);
if (len)
this._push(writeStringBuffer, len, value);
return this;
};
BufferWriter._configure();
return writer_buffer;
}
var reader;
var hasRequiredReader;
function requireReader() {
if (hasRequiredReader) return reader;
hasRequiredReader = 1;
reader = Reader;
var util2 = requireMinimal();
var BufferReader;
var LongBits = util2.LongBits, utf82 = util2.utf8;
function indexOutOfRange(reader2, writeLength) {
return RangeError("index out of range: " + reader2.pos + " + " + (writeLength || 1) + " > " + reader2.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 util2.Buffer ? function create_buffer_setup(buffer) {
return (Reader.create = function create_buffer(buffer2) {
return util2.Buffer.isBuffer(buffer2) ? new BufferReader(buffer2) : create_array(buffer2);
})(buffer);
} : create_array;
};
Reader.create = create();
Reader.prototype._slice = util2.Array.prototype.subarray || /* istanbul ignore next */
util2.Array.prototype.slice;
Reader.prototype.uint32 = /* @__PURE__ */ 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 = util2.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 = util2.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);
if (start === end) {
var nativeBuffer = util2.Buffer;
return nativeBuffer ? nativeBuffer.alloc(0) : new this.buf.constructor(0);
}
return this._slice.call(this.buf, start, end);
};
Reader.prototype.string = function read_string() {
var bytes = this.bytes();
return utf82.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);