| Server IP : 80.87.202.40 / Your IP : 216.73.216.169 Web Server : Apache System : Linux rospirotorg.ru 5.14.0-539.el9.x86_64 #1 SMP PREEMPT_DYNAMIC Thu Dec 5 22:26:13 UTC 2024 x86_64 User : bitrix ( 600) PHP Version : 8.2.27 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : ON Directory : /home/bitrix/ext_www/rospirotorg.ru/bitrix/js/pull/connector/dist/ |
Upload File : |
/* eslint-disable */
this.BX = this.BX || {};
(function (exports) {
'use strict';
const REVISION = 19; // api revision - check module/pull/include.php
const ConnectionType = {
WebSocket: 'webSocket',
LongPolling: 'longPolling'
};
const PullStatus = {
Online: 'online',
Offline: 'offline',
Connecting: 'connect'
};
const CloseReasons = {
NORMAL_CLOSURE: 1000,
SERVER_DIE: 1001,
CONFIG_REPLACED: 3000,
CHANNEL_EXPIRED: 3001,
SERVER_RESTARTED: 3002,
CONFIG_EXPIRED: 3003,
MANUAL: 3004,
STUCK: 3005,
BACKEND_ERROR: 3006,
WRONG_CHANNEL_ID: 4010
};
const SystemCommands = {
CHANNEL_EXPIRE: 'CHANNEL_EXPIRE',
CONFIG_EXPIRE: 'CONFIG_EXPIRE',
SERVER_RESTART: 'SERVER_RESTART'
};
const ServerMode = {
Shared: 'shared',
Personal: 'personal'
};
const RpcMethod = {
Publish: 'publish',
GetUsersLastSeen: 'getUsersLastSeen',
Ping: 'ping',
ListChannels: 'listChannels',
SubscribeStatusChange: 'subscribeStatusChange',
UnsubscribeStatusChange: 'unsubscribeStatusChange'
};
/* eslint-disable @bitrix24/bitrix24-rules/no-typeof */
const browser = {
IsChrome() {
return navigator.userAgent.toLowerCase().includes('chrome');
},
IsFirefox() {
return navigator.userAgent.toLowerCase().includes('firefox');
},
IsIe() {
return navigator.userAgent.match(/(Trident\/|MSIE\/)/) !== null;
}
};
function getTimestamp() {
return Date.now();
}
function isString(item) {
return item === '' ? true : item ? typeof item === 'string' || item instanceof String : false;
}
function isArray(item) {
return item && Object.prototype.toString.call(item) === '[object Array]';
}
function isFunction(item) {
return item === null ? false : typeof item === 'function' || item instanceof Function;
}
function isPlainObject(item) {
return Boolean(item) && typeof item === 'object' && item.constructor === Object;
}
function isNotEmptyString(item) {
return isString(item) ? item.length > 0 : false;
}
function isJsonRpcRequest(item) {
return typeof item === 'object' && item && 'jsonrpc' in item && isNotEmptyString(item.jsonrpc) && 'method' in item && isNotEmptyString(item.method);
}
function isJsonRpcResponse(item) {
return typeof item === 'object' && item && 'jsonrpc' in item && isNotEmptyString(item.jsonrpc) && 'id' in item && ('result' in item || 'error' in item);
}
function buildQueryString(params) {
let result = '';
for (const key of Object.keys(params)) {
const value = params[key];
if (isArray(value)) {
for (const [index, valueElement] of value.entries()) {
const left = encodeURIComponent(`${key}[${index}]`);
const right = `${encodeURIComponent(valueElement)}&`;
result += `${left}=${right}`;
}
} else {
result += `${encodeURIComponent(key)}=${encodeURIComponent(value)}&`;
}
}
if (result.length > 0) {
result = result.slice(0, Math.max(0, result.length - 1));
}
return result;
}
function getDateForLog() {
const d = new Date();
return `${d.getFullYear()}-${lpad(d.getMonth(), 2, '0')}-${lpad(d.getDate(), 2, '0')} ${lpad(d.getHours(), 2, '0')}:${lpad(d.getMinutes(), 2, '0')}`;
}
function lpad(str, length, chr = ' ') {
if (str.length > length) {
return str;
}
let result = '';
for (let i = 0; i < length - result.length; i++) {
result += chr;
}
return result + str;
}
class ErrorNotConnected extends Error {
constructor(message) {
super(message);
this.name = 'ErrorNotConnected';
}
}
class ErrorTimeout extends Error {
constructor(message) {
super(message);
this.name = 'ErrorTimeout';
}
}
const JSON_RPC_VERSION = '2.0';
const RpcError = {
Parse: {
code: -32700,
message: 'Parse error'
},
InvalidRequest: {
code: -32600,
message: 'Invalid Request'
},
MethodNotFound: {
code: -32601,
message: 'Method not found'
},
InvalidParams: {
code: -32602,
message: 'Invalid params'
},
Internal: {
code: -32603,
message: 'Internal error'
}
};
class JsonRpc extends EventTarget {
constructor(options) {
super();
this.idCounter = 0;
this.handlers = {};
this.rpcResponseAwaiters = new Map();
this.sender = options.sender;
for (const method of Object.keys(options.handlers || {})) {
this.handle(method, options.handlers[method]);
}
for (const eventType of Object.keys(options.events || {})) {
// eslint-disable-next-line @bitrix24/bitrix24-rules/no-native-events-binding
this.addEventListener(eventType, options.events[eventType]);
}
}
/**
* @param {string} method
* @param {function} handler
*/
handle(method, handler) {
this.handlers[method] = handler;
}
/**
* Sends RPC command to the server.
*
* @param {string} method Method name
* @param {object} params
* @param {int} timeout
* @returns {Promise}
*/
executeOutgoingRpcCommand(method, params, timeout = 5) {
return new Promise((resolve, reject) => {
const request = this.createRequest(method, params);
if (this.sender.send(JSON.stringify(request)) === false) {
reject(new ErrorNotConnected('send failed'));
}
if (timeout > 0) {
const t = setTimeout(() => {
this.rpcResponseAwaiters.delete(request.id);
reject(new ErrorTimeout('no response'));
}, timeout * 1000);
this.rpcResponseAwaiters.set(request.id, {
resolve,
reject,
timeout: t
});
} else {
resolve();
}
});
}
/**
* Executes array or rpc commands. Returns array of promises, each promise will be resolved individually.
*
* @param {JsonRpcRequest[]} batch
* @returns {Promise[]}
*/
executeOutgoingRpcBatch(batch) {
const requests = [];
const promises = [];
batch.forEach(({
method,
params,
id
}) => {
const request = this.createRequest(method, params, id);
requests.push(request);
promises.push(new Promise((resolve, reject) => {
this.rpcResponseAwaiters.set(request.id, {
resolve,
reject
});
}));
});
this.sender.send(JSON.stringify(requests));
return promises;
}
processRpcResponse(response) {
if ('id' in response && this.rpcResponseAwaiters.has(response.id)) {
const awaiter = this.rpcResponseAwaiters.get(response.id);
if ('result' in response) {
awaiter.resolve(response.result);
} else if ('error' in response) {
awaiter.reject(response.error);
} else {
awaiter.reject(new Error('wrong response structure'));
}
clearTimeout(awaiter.timeout);
this.rpcResponseAwaiters.delete(response.id);
} else {
this.dispatchEvent(new CustomEvent('error', {
error: new Error(`received rpc response with unknown id ${response}`)
}));
}
}
async handleIncomingMessage(message) {
let decoded = {};
try {
decoded = JSON.parse(message);
} catch (e) {
throw new Error(`could not decode json rpc message: ${e}`);
}
if (isArray(decoded)) {
this.executeIncomingRpcBatch(decoded);
} else if (isJsonRpcRequest(decoded)) {
const commandResult = await this.executeIncomingRpcCommand(decoded);
if (commandResult !== null && commandResult !== undefined) {
const response = commandResult.error ? this.createErrorResponse(decoded.id, commandResult.error) : this.createResponse(decoded.id, commandResult);
this.sender.send(JSON.stringify(response));
} else {
this.sender.send(JSON.stringify(this.createResponse(decoded.id, null)));
}
} else if (isJsonRpcResponse(decoded)) {
this.processRpcResponse(decoded);
} else {
throw new Error(`unknown rpc packet: ${decoded}`);
}
}
/**
* Executes RPC command, received from the server
*
* @param {string} method
* @param {object} params
* @returns {object}
*/
async executeIncomingRpcCommand({
method,
params
}) {
if (method in this.handlers) {
try {
return this.handlers[method].call(this, params);
} catch (e) {
return {
jsonrpc: '2.0',
error: e.toString()
};
}
}
return {
error: RpcError.MethodNotFound
};
}
async executeIncomingRpcBatch(batch) {
const result = [];
for (const command of batch) {
if ('jsonrpc' in command) {
if ('method' in command) {
const commandResult = this.executeIncomingRpcCommand(command);
if (commandResult) {
commandResult.jsonrpc = JSON_RPC_VERSION;
commandResult.id = command.id;
result.push(commandResult);
}
} else {
this.processRpcResponse(command);
}
} else {
this.dispatchEvent(new CustomEvent('error', {
error: new Error(`unknown rpc command in batch: ${command}`)
}));
result.push({
jsonrpc: '2.0',
error: RpcError.InvalidRequest
});
}
}
return result;
}
nextId() {
this.idCounter++;
return this.idCounter;
}
createPublishRequest(messageBatch) {
const result = messageBatch.map(message => this.createRequest('publish', message));
if (result.length === 0) {
return result[0];
}
return result;
}
createRequest(method, params, id) {
return {
jsonrpc: JSON_RPC_VERSION,
method,
params,
id: id != null ? id : this.nextId()
};
}
createResponse(id, result) {
return {
jsonrpc: JSON_RPC_VERSION,
id,
result
};
}
createErrorResponse(id, error) {
return {
jsonrpc: JSON_RPC_VERSION,
id,
error
};
}
}
class ChannelManager {
constructor(params) {
var _params$restClient;
this.publicIds = {};
this.restClient = (_params$restClient = params.restClient) != null ? _params$restClient : BX.rest;
this.getPublicListMethod = params.getPublicListMethod;
}
/**
*
* @param {Array} users Array of user ids.
* @return {Promise}
*/
getPublicIds(users) {
const now = new Date();
const result = {};
const unknownUsers = [];
for (const userId of users) {
if (this.publicIds[userId] && this.publicIds[userId].end > now) {
result[userId] = this.publicIds[userId];
} else {
unknownUsers.push(userId);
}
}
if (unknownUsers.length === 0) {
return Promise.resolve(result);
}
return new Promise((resolve, reject) => {
this.restClient.callMethod(this.getPublicListMethod, {
users: unknownUsers
}).then(response => {
if (response.error()) {
resolve({});
} else {
const data = response.data();
this.setPublicIds(Object.values(data));
for (const userId of unknownUsers) {
result[userId] = this.publicIds[userId];
}
resolve(result);
}
}).catch(e => reject(e));
});
}
/**
*
* @param {object[]} publicIds
* @param {integer} publicIds.user_id
* @param {string} publicIds.public_id
* @param {string} publicIds.signature
* @param {Date} publicIds.start
* @param {Date} publicIds.end
*/
setPublicIds(publicIds) {
for (const publicIdDescriptor of publicIds) {
const userId = publicIdDescriptor.user_id;
this.publicIds[userId] = {
userId,
publicId: publicIdDescriptor.public_id,
signature: publicIdDescriptor.signature,
start: new Date(publicIdDescriptor.start),
end: new Date(publicIdDescriptor.end)
};
}
}
}
/* eslint-disable @bitrix24/bitrix24-rules/no-pseudo-private */
class AbstractConnector {
constructor(config) {
this._connected = false;
this.connectionType = '';
this.disconnectCode = '';
this.disconnectReason = '';
this.pathGetter = config.pathGetter;
this.callbacks = {
onOpen: isFunction(config.onOpen) ? config.onOpen : function () {},
onDisconnect: isFunction(config.onDisconnect) ? config.onDisconnect : function () {},
onError: isFunction(config.onError) ? config.onError : function () {},
onMessage: isFunction(config.onMessage) ? config.onMessage : function () {}
};
}
get connected() {
return this._connected;
}
set connected(value) {
if (value === this._connected) {
return;
}
this._connected = value;
if (this._connected) {
this.callbacks.onOpen();
} else {
this.callbacks.onDisconnect({
code: this.disconnectCode,
reason: this.disconnectReason
});
}
}
get path() {
return this.pathGetter();
}
}
/* eslint-disable @bitrix24/bitrix24-rules/no-native-events-binding */
class WebSocketConnector extends AbstractConnector {
constructor(...args) {
super(...args);
this.connectionType = ConnectionType.WebSocket;
this.onSocketOpenHandler = this.onSocketOpen.bind(this);
this.onSocketCloseHandler = this.onSocketClose.bind(this);
this.onSocketErrorHandler = this.onSocketError.bind(this);
this.onSocketMessageHandler = this.onSocketMessage.bind(this);
}
connect() {
if (this.socket) {
if (this.socket.readyState === WebSocket.OPEN || this.socket.readyState === WebSocket.CONNECTING) {
return;
}
this.socket.removeEventListener('open', this.onSocketOpenHandler);
this.socket.removeEventListener('close', this.onSocketCloseHandler);
this.socket.removeEventListener('error', this.onSocketErrorHandler);
this.socket.removeEventListener('message', this.onSocketMessageHandler);
this.socket.close();
this.socket = null;
}
this.createSocket();
}
disconnect(code, message) {
if (this.socket !== null) {
this.socket.removeEventListener('open', this.onSocketOpenHandler);
this.socket.removeEventListener('close', this.onSocketCloseHandler);
this.socket.removeEventListener('error', this.onSocketErrorHandler);
this.socket.removeEventListener('message', this.onSocketMessageHandler);
this.socket.close(code, message);
}
this.socket = null;
this.disconnectCode = code;
this.disconnectReason = message;
this.connected = false;
}
createSocket() {
if (this.socket) {
throw new Error('Socket already exists');
}
if (!this.path) {
throw new Error('Websocket connection path is not defined');
}
this.socket = new WebSocket(this.path);
this.socket.binaryType = 'arraybuffer';
this.socket.addEventListener('open', this.onSocketOpenHandler);
this.socket.addEventListener('close', this.onSocketCloseHandler);
this.socket.addEventListener('error', this.onSocketErrorHandler);
this.socket.addEventListener('message', this.onSocketMessageHandler);
}
/**
* Sends some data to the server via websocket connection.
* @param {ArrayBuffer} buffer Data to send.
*/
send(buffer) {
if (!this.socket || this.socket.readyState !== 1) {
console.error(`${getDateForLog()}: Pull: WebSocket is not connected`);
return false;
}
this.socket.send(buffer);
return true;
}
onSocketOpen() {
this.connected = true;
}
onSocketClose(e) {
this.socket = null;
this.disconnectCode = e.code;
this.disconnectReason = e.reason;
this.connected = false;
}
onSocketError(e) {
this.callbacks.onError(e);
}
onSocketMessage(e) {
this.callbacks.onMessage(e.data);
}
destroy() {
if (this.socket) {
this.socket.close();
this.socket = null;
}
}
}
/* eslint-disable @bitrix24/bitrix24-rules/no-native-events-binding */
const LONG_POLLING_TIMEOUT = 60;
class LongPollingConnector extends AbstractConnector {
constructor(config) {
super(config);
this.connectionType = ConnectionType.LongPolling;
this.active = false;
this.requestTimeout = null;
this.failureTimeout = null;
this.requestAborted = false;
this.xhr = this.createXhr();
this.isBinary = config.isBinary;
}
createXhr() {
const result = new XMLHttpRequest();
if (this.isBinary) {
result.responseType = 'arraybuffer';
}
result.addEventListener('readystatechange', this.onXhrReadyStateChange.bind(this));
return result;
}
connect() {
this.active = true;
this.performRequest();
}
disconnect(code, reason) {
this.active = false;
if (this.failureTimeout) {
clearTimeout(this.failureTimeout);
this.failureTimeout = null;
}
if (this.requestTimeout) {
clearTimeout(this.requestTimeout);
this.requestTimeout = null;
}
if (this.xhr) {
this.requestAborted = true;
this.xhr.abort();
}
this.disconnectCode = code;
this.disconnectReason = reason;
this.connected = false;
}
performRequest() {
if (!this.active) {
return;
}
if (!this.path) {
throw new Error('Long polling connection path is not defined');
}
if (this.xhr.readyState !== 0 && this.xhr.readyState !== 4) {
return;
}
clearTimeout(this.failureTimeout);
clearTimeout(this.requestTimeout);
this.failureTimeout = setTimeout(() => {
this.connected = true;
}, 5000);
this.requestTimeout = setTimeout(this.onRequestTimeout.bind(this), LONG_POLLING_TIMEOUT * 1000);
this.xhr.open('GET', this.path);
this.xhr.send();
}
onRequestTimeout() {
this.requestAborted = true;
this.xhr.abort();
this.performRequest();
}
onXhrReadyStateChange() {
if (this.xhr.readyState === 4) {
if (!this.requestAborted || this.xhr.status === 200) {
this.onResponse(this.xhr.response);
}
this.requestAborted = false;
}
}
/**
* Sends some data to the server via http request.
*/
send(buffer) {
const path = this.parent.getPublicationPath();
if (!path) {
console.error(`${getDateForLog()}: Pull: publication path is empty`);
return;
}
const xhr = new XMLHttpRequest();
xhr.open('POST', path);
xhr.send(buffer);
}
onResponse(response) {
if (this.failureTimeout) {
clearTimeout(this.failureTimeout);
this.failureTimeout = 0;
}
if (this.requestTimeout) {
clearTimeout(this.requestTimeout);
this.requestTimeout = 0;
}
if (this.xhr.status === 200) {
this.connected = true;
if (isNotEmptyString(response) || response instanceof ArrayBuffer) {
this.callbacks.onMessage(response);
} else {
this.parent.session.mid = null;
}
this.performRequest();
} else if (this.xhr.status === 304) {
this.connected = true;
if (this.xhr.getResponseHeader('Expires') === 'Thu, 01 Jan 1973 11:11:01 GMT') {
const lastMessageId = this.xhr.getResponseHeader('Last-Message-Id');
if (isNotEmptyString(lastMessageId)) {
this.parent.setLastMessageId(lastMessageId);
}
}
this.performRequest();
} else {
this.callbacks.onError('Could not connect to the server');
this.connected = false;
}
}
}
/*!
* protobuf.js v6.8.6 (c) 2016, daniel wirtz
* compiled mon, 26 feb 2018 11:35:34 utc
* licensed under the bsd-3-clause license
* see: https://github.com/dcodeio/protobuf.js for details
*
* Modify list for integration with Bitrix Framework:
* - removed integration with RequireJS and AMD package builders;
*/
(function (global, undefined) {
(function prelude(modules, cache, entries) {
// This is the prelude used to bundle protobuf.js for the browser. Wraps up the CommonJS
// sources through a conflict-free require shim and is again wrapped within an iife that
// provides a unified `global` and a minification-friendly `undefined` var plus a global
// "use strict" directive so that minification can remove the directives of each module.
function $require(name) {
var $module = cache[name];
if (!$module) modules[name][0].call($module = cache[name] = {
exports: {}
}, $require, $module, $module.exports);
return $module.exports;
}
// Expose globally
var protobuf = global.protobuf = $require(entries[0]);
// Be nice to AMD
/*if (typeof define === "function" && define.amd)
define(["long"], function(Long) {
if (Long && Long.isLong) {
protobuf.util.Long = Long;
protobuf.configure();
}
return protobuf;
});*/
// Be nice to CommonJS
/*if (typeof module === "object" && module && module.exports)
module.exports = protobuf;*/
} /* end of prelude */)({
1: [function (require, module, exports) {
module.exports = asPromise;
/**
* Callback as used by {@link util.asPromise}.
* @typedef asPromiseCallback
* @type {function}
* @param {Error|null} error Error, if any
* @param {...*} params Additional arguments
* @returns {undefined}
*/
/**
* Returns a promise from a node-style callback function.
* @memberof util
* @param {asPromiseCallback} fn Function to call
* @param {*} ctx Function context
* @param {...*} params Function arguments
* @returns {Promise<*>} Promisified function
*/
function asPromise(fn, ctx /*, varargs */) {
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 /*, varargs */) {
if (pending) {
pending = false;
if (err) reject(err);else {
var params = new Array(arguments.length - 1),
offset = 0;
while (offset < params.length) params[offset++] = arguments[offset];
resolve.apply(null, params);
}
}
};
try {
fn.apply(ctx || null, params);
} catch (err) {
if (pending) {
pending = false;
reject(err);
}
}
});
}
}, {}],
2: [function (require, module, exports) {
/**
* A minimal base64 implementation for number arrays.
* @memberof util
* @namespace
*/
var base64 = exports;
/**
* Calculates the byte length of a base64 encoded string.
* @param {string} string Base64 encoded string
* @returns {number} Byte length
*/
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;
};
// Base64 encoding table
var b64 = new Array(64);
// Base64 decoding table
var s64 = new Array(123);
// 65..90, 97..122, 48..57, 43, 47
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++;
/**
* Encodes a buffer to a base64 encoded string.
* @param {Uint8Array} buffer Source buffer
* @param {number} start Source start
* @param {number} end Source end
* @returns {string} Base64 encoded string
*/
base64.encode = function encode(buffer, start, end) {
var parts = null,
chunk = [];
var i = 0,
// output index
j = 0,
// goto index
t; // temporary
while (start < end) {
var b = buffer[start++];
switch (j) {
case 0:
chunk[i++] = b64[b >> 2];
t = (b & 3) << 4;
j = 1;
break;
case 1:
chunk[i++] = b64[t | b >> 4];
t = (b & 15) << 2;
j = 2;
break;
case 2:
chunk[i++] = b64[t | b >> 6];
chunk[i++] = b64[b & 63];
j = 0;
break;
}
if (i > 8191) {
(parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));
i = 0;
}
}
if (j) {
chunk[i++] = b64[t];
chunk[i++] = 61;
if (j === 1) chunk[i++] = 61;
}
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));
};
var invalidEncoding = "invalid encoding";
/**
* Decodes a base64 encoded string to a buffer.
* @param {string} string Source string
* @param {Uint8Array} buffer Destination buffer
* @param {number} offset Destination offset
* @returns {number} Number of bytes written
* @throws {Error} If encoding is invalid
*/
base64.decode = function decode(string, buffer, offset) {
var start = offset;
var j = 0,
// goto index
t; // temporary
for (var i = 0; i < string.length;) {
var c = string.charCodeAt(i++);
if (c === 61 && j > 1) break;
if ((c = s64[c]) === undefined) 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;
};
/**
* Tests if the specified string appears to be base64 encoded.
* @param {string} string String to test
* @returns {boolean} `true` if probably base64 encoded, otherwise false
*/
base64.test = function test(string) {
return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(string);
};
}, {}],
3: [function (require, module, exports) {
module.exports = codegen;
/**
* Begins generating a function.
* @memberof util
* @param {string[]} functionParams Function parameter names
* @param {string} [functionName] Function name if not anonymous
* @returns {Codegen} Appender that appends code to the function's body
*/
function codegen(functionParams, functionName) {
/* istanbul ignore if */
if (typeof functionParams === "string") {
functionName = functionParams;
functionParams = undefined;
}
var body = [];
/**
* Appends code to the function's body or finishes generation.
* @typedef Codegen
* @type {function}
* @param {string|Object.<string,*>} [formatStringOrScope] Format string or, to finish the function, an object of additional scope variables, if any
* @param {...*} [formatParams] Format parameters
* @returns {Codegen|Function} Itself or the generated function if finished
* @throws {Error} If format parameter counts do not match
*/
function Codegen(formatStringOrScope) {
// note that explicit array handling below makes this ~50% faster
// finish the function
if (typeof formatStringOrScope !== "string") {
var source = toString();
if (codegen.verbose) console.log("codegen: " + source); // eslint-disable-line no-console
source = "return " + source;
if (formatStringOrScope) {
var scopeKeys = Object.keys(formatStringOrScope),
scopeParams = new Array(scopeKeys.length + 1),
scopeValues = new Array(scopeKeys.length),
scopeOffset = 0;
while (scopeOffset < scopeKeys.length) {
scopeParams[scopeOffset] = scopeKeys[scopeOffset];
scopeValues[scopeOffset] = formatStringOrScope[scopeKeys[scopeOffset++]];
}
scopeParams[scopeOffset] = source;
return Function.apply(null, scopeParams).apply(null, scopeValues); // eslint-disable-line no-new-func
}
return Function(source)(); // eslint-disable-line no-new-func
}
// otherwise append to body
var formatParams = new Array(arguments.length - 1),
formatOffset = 0;
while (formatOffset < formatParams.length) formatParams[formatOffset] = arguments[++formatOffset];
formatOffset = 0;
formatStringOrScope = formatStringOrScope.replace(/%([%dfijs])/g, function replace($0, $1) {
var value = formatParams[formatOffset++];
switch ($1) {
case "d":
case "f":
return String(Number(value));
case "i":
return String(Math.floor(value));
case "j":
return JSON.stringify(value);
case "s":
return String(value);
}
return "%";
});
if (formatOffset !== formatParams.length) throw Error("parameter count mismatch");
body.push(formatStringOrScope);
return Codegen;
}
function toString(functionNameOverride) {
return "function " + (functionNameOverride || functionName || "") + "(" + (functionParams && functionParams.join(",") || "") + "){\n " + body.join("\n ") + "\n}";
}
Codegen.toString = toString;
return Codegen;
}
/**
* Begins generating a function.
* @memberof util
* @function codegen
* @param {string} [functionName] Function name if not anonymous
* @returns {Codegen} Appender that appends code to the function's body
* @variation 2
*/
/**
* When set to `true`, codegen will log generated code to console. Useful for debugging.
* @name util.codegen.verbose
* @type {boolean}
*/
codegen.verbose = false;
}, {}],
4: [function (require, module, exports) {
module.exports = EventEmitter;
/**
* Constructs a new event emitter instance.
* @classdesc A minimal event emitter.
* @memberof util
* @constructor
*/
function EventEmitter() {
/**
* Registered listeners.
* @type {Object.<string,*>}
* @private
*/
this._listeners = {};
}
/**
* Registers an event listener.
* @param {string} evt Event name
* @param {function} fn Listener
* @param {*} [ctx] Listener context
* @returns {util.EventEmitter} `this`
*/
EventEmitter.prototype.on = function on(evt, fn, ctx) {
(this._listeners[evt] || (this._listeners[evt] = [])).push({
fn: fn,
ctx: ctx || this
});
return this;
};
/**
* Removes an event listener or any matching listeners if arguments are omitted.
* @param {string} [evt] Event name. Removes all listeners if omitted.
* @param {function} [fn] Listener to remove. Removes all listeners of `evt` if omitted.
* @returns {util.EventEmitter} `this`
*/
EventEmitter.prototype.off = function off(evt, fn) {
if (evt === undefined) this._listeners = {};else {
if (fn === undefined) 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;
};
/**
* Emits an event by calling its listeners with the specified arguments.
* @param {string} evt Event name
* @param {...*} args Arguments
* @returns {util.EventEmitter} `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;
};
}, {}],
5: [function (require, module, exports) {
module.exports = fetch;
var asPromise = require(1),
inquire = require(7);
var fs = inquire("fs");
/**
* Node-style callback as used by {@link util.fetch}.
* @typedef FetchCallback
* @type {function}
* @param {?Error} error Error, if any, otherwise `null`
* @param {string} [contents] File contents, if there hasn't been an error
* @returns {undefined}
*/
/**
* Options as used by {@link util.fetch}.
* @typedef FetchOptions
* @type {Object}
* @property {boolean} [binary=false] Whether expecting a binary response
* @property {boolean} [xhr=false] If `true`, forces the use of XMLHttpRequest
*/
/**
* Fetches the contents of a file.
* @memberof util
* @param {string} filename File path or url
* @param {FetchOptions} options Fetch options
* @param {FetchCallback} callback Callback function
* @returns {undefined}
*/
function fetch(filename, options, callback) {
if (typeof options === "function") {
callback = options;
options = {};
} else if (!options) options = {};
if (!callback) return asPromise(fetch, this, filename, options); // eslint-disable-line no-invalid-this
// if a node-like filesystem is present, try it first but fall back to XHR if nothing is found.
if (!options.xhr && fs && fs.readFile) return fs.readFile(filename, function fetchReadFileCallback(err, contents) {
return err && typeof XMLHttpRequest !== "undefined" ? fetch.xhr(filename, options, callback) : err ? callback(err) : callback(null, options.binary ? contents : contents.toString("utf8"));
});
// use the XHR version otherwise.
return fetch.xhr(filename, options, callback);
}
/**
* Fetches the contents of a file.
* @name util.fetch
* @function
* @param {string} path File path or url
* @param {FetchCallback} callback Callback function
* @returns {undefined}
* @variation 2
*/
/**
* Fetches the contents of a file.
* @name util.fetch
* @function
* @param {string} path File path or url
* @param {FetchOptions} [options] Fetch options
* @returns {Promise<string|Uint8Array>} Promise
* @variation 3
*/
/**/
fetch.xhr = function fetch_xhr(filename, options, callback) {
var xhr = new XMLHttpRequest();
xhr.onreadystatechange /* works everywhere */ = function fetchOnReadyStateChange() {
if (xhr.readyState !== 4) return undefined;
// local cors security errors return status 0 / empty string, too. afaik this cannot be
// reliably distinguished from an actually empty file for security reasons. feel free
// to send a pull request if you are aware of a solution.
if (xhr.status !== 0 && xhr.status !== 200) return callback(Error("status " + xhr.status));
// if binary data is expected, make sure that some sort of array is returned, even if
// ArrayBuffers are not supported. the binary string fallback, however, is unsafe.
if (options.binary) {
var buffer = xhr.response;
if (!buffer) {
buffer = [];
for (var i = 0; i < xhr.responseText.length; ++i) buffer.push(xhr.responseText.charCodeAt(i) & 255);
}
return callback(null, typeof Uint8Array !== "undefined" ? new Uint8Array(buffer) : buffer);
}
return callback(null, xhr.responseText);
};
if (options.binary) {
// ref: https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/Sending_and_Receiving_Binary_Data#Receiving_binary_data_in_older_browsers
if ("overrideMimeType" in xhr) xhr.overrideMimeType("text/plain; charset=x-user-defined");
xhr.responseType = "arraybuffer";
}
xhr.open("GET", filename);
xhr.send();
};
}, {
"1": 1,
"7": 7
}],
6: [function (require, module, exports) {
module.exports = factory(factory);
/**
* Reads / writes floats / doubles from / to buffers.
* @name util.float
* @namespace
*/
/**
* Writes a 32 bit float to a buffer using little endian byte order.
* @name util.float.writeFloatLE
* @function
* @param {number} val Value to write
* @param {Uint8Array} buf Target buffer
* @param {number} pos Target buffer offset
* @returns {undefined}
*/
/**
* Writes a 32 bit float to a buffer using big endian byte order.
* @name util.float.writeFloatBE
* @function
* @param {number} val Value to write
* @param {Uint8Array} buf Target buffer
* @param {number} pos Target buffer offset
* @returns {undefined}
*/
/**
* Reads a 32 bit float from a buffer using little endian byte order.
* @name util.float.readFloatLE
* @function
* @param {Uint8Array} buf Source buffer
* @param {number} pos Source buffer offset
* @returns {number} Value read
*/
/**
* Reads a 32 bit float from a buffer using big endian byte order.
* @name util.float.readFloatBE
* @function
* @param {Uint8Array} buf Source buffer
* @param {number} pos Source buffer offset
* @returns {number} Value read
*/
/**
* Writes a 64 bit double to a buffer using little endian byte order.
* @name util.float.writeDoubleLE
* @function
* @param {number} val Value to write
* @param {Uint8Array} buf Target buffer
* @param {number} pos Target buffer offset
* @returns {undefined}
*/
/**
* Writes a 64 bit double to a buffer using big endian byte order.
* @name util.float.writeDoubleBE
* @function
* @param {number} val Value to write
* @param {Uint8Array} buf Target buffer
* @param {number} pos Target buffer offset
* @returns {undefined}
*/
/**
* Reads a 64 bit double from a buffer using little endian byte order.
* @name util.float.readDoubleLE
* @function
* @param {Uint8Array} buf Source buffer
* @param {number} pos Source buffer offset
* @returns {number} Value read
*/
/**
* Reads a 64 bit double from a buffer using big endian byte order.
* @name util.float.readDoubleBE
* @function
* @param {Uint8Array} buf Source buffer
* @param {number} pos Source buffer offset
* @returns {number} Value read
*/
// Factory function for the purpose of node-based testing in modified global environments
function factory(exports) {
// float: typed array
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];
}
/* istanbul ignore next */
exports.writeFloatLE = le ? writeFloat_f32_cpy : writeFloat_f32_rev;
/* istanbul ignore next */
exports.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];
}
/* istanbul ignore next */
exports.readFloatLE = le ? readFloat_f32_cpy : readFloat_f32_rev;
/* istanbul ignore next */
exports.readFloatBE = le ? readFloat_f32_rev : readFloat_f32_cpy;
// float: ieee754
})();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 > 3.4028234663852886e+38)
// +-Infinity
writeUint((sign << 31 | 2139095040) >>> 0, buf, pos);else if (val < 1.1754943508222875e-38)
// denormal
writeUint((sign << 31 | Math.round(val / 1.401298464324817e-45)) >>> 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);
}
}
exports.writeFloatLE = writeFloat_ieee754.bind(null, writeUintLE);
exports.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 // denormal
? sign * 1.401298464324817e-45 * mantissa : sign * Math.pow(2, exponent - 150) * (mantissa + 8388608);
}
exports.readFloatLE = readFloat_ieee754.bind(null, readUintLE);
exports.readFloatBE = readFloat_ieee754.bind(null, readUintBE);
})();
// double: typed array
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];
}
/* istanbul ignore next */
exports.writeDoubleLE = le ? writeDouble_f64_cpy : writeDouble_f64_rev;
/* istanbul ignore next */
exports.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];
}
/* istanbul ignore next */
exports.readDoubleLE = le ? readDouble_f64_cpy : readDouble_f64_rev;
/* istanbul ignore next */
exports.readDoubleBE = le ? readDouble_f64_rev : readDouble_f64_cpy;
// double: ieee754
})();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 > 1.7976931348623157e+308) {
// +-Infinity
writeUint(0, buf, pos + off0);
writeUint((sign << 31 | 2146435072) >>> 0, buf, pos + off1);
} else {
var mantissa;
if (val < 2.2250738585072014e-308) {
// denormal
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);
}
}
}
exports.writeDoubleLE = writeDouble_ieee754.bind(null, writeUintLE, 0, 4);
exports.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 // denormal
? sign * 5e-324 * mantissa : sign * Math.pow(2, exponent - 1075) * (mantissa + 4503599627370496);
}
exports.readDoubleLE = readDouble_ieee754.bind(null, readUintLE, 0, 4);
exports.readDoubleBE = readDouble_ieee754.bind(null, readUintBE, 4, 0);
})();
return exports;
}
// uint helpers
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;
}
}, {}],
7: [function (require, module, exports) {
module.exports = inquire;
/**
* Requires a module only if available.
* @memberof util
* @param {string} moduleName Module to require
* @returns {?Object} Required module if available and not empty, otherwise `null`
*/
function inquire(moduleName) {
try {
var mod = eval("quire".replace(/^/, "re"))(moduleName); // eslint-disable-line no-eval
if (mod && (mod.length || Object.keys(mod).length)) return mod;
} catch (e) {} // eslint-disable-line no-empty
return null;
}
}, {}],
8: [function (require, module, exports) {
/**
* A minimal path module to resolve Unix, Windows and URL paths alike.
* @memberof util
* @namespace
*/
var path = exports;
var isAbsolute =
/**
* Tests if the specified path is absolute.
* @param {string} path Path to test
* @returns {boolean} `true` if path is absolute
*/
path.isAbsolute = function isAbsolute(path) {
return /^(?:\/|\w+:)/.test(path);
};
var normalize =
/**
* Normalizes the specified path.
* @param {string} path Path to normalize
* @returns {string} Normalized path
*/
path.normalize = function normalize(path) {
path = path.replace(/\\/g, "/").replace(/\/{2,}/g, "/");
var parts = path.split("/"),
absolute = isAbsolute(path),
prefix = "";
if (absolute) prefix = parts.shift() + "/";
for (var i = 0; i < parts.length;) {
if (parts[i] === "..") {
if (i > 0 && parts[i - 1] !== "..") parts.splice(--i, 2);else if (absolute) parts.splice(i, 1);else ++i;
} else if (parts[i] === ".") parts.splice(i, 1);else ++i;
}
return prefix + parts.join("/");
};
/**
* Resolves the specified include path against the specified origin path.
* @param {string} originPath Path to the origin file
* @param {string} includePath Include path relative to origin path
* @param {boolean} [alreadyNormalized=false] `true` if both paths are already known to be normalized
* @returns {string} Path to the include file
*/
path.resolve = function resolve(originPath, includePath, alreadyNormalized) {
if (!alreadyNormalized) includePath = normalize(includePath);
if (isAbsolute(includePath)) return includePath;
if (!alreadyNormalized) originPath = normalize(originPath);
return (originPath = originPath.replace(/(?:\/|^)[^/]+$/, "")).length ? normalize(originPath + "/" + includePath) : includePath;
};
}, {}],
9: [function (require, module, exports) {
module.exports = pool;
/**
* An allocator as used by {@link util.pool}.
* @typedef PoolAllocator
* @type {function}
* @param {number} size Buffer size
* @returns {Uint8Array} Buffer
*/
/**
* A slicer as used by {@link util.pool}.
* @typedef PoolSlicer
* @type {function}
* @param {number} start Start offset
* @param {number} end End offset
* @returns {Uint8Array} Buffer slice
* @this {Uint8Array}
*/
/**
* A general purpose buffer pool.
* @memberof util
* @function
* @param {PoolAllocator} alloc Allocator
* @param {PoolSlicer} slice Slicer
* @param {number} [size=8192] Slab size
* @returns {PoolAllocator} Pooled allocator
*/
function pool(alloc, slice, size) {
var SIZE = size || 8192;
var MAX = SIZE >>> 1;
var slab = null;
var offset = SIZE;
return function pool_alloc(size) {
if (size < 1 || size > MAX) return alloc(size);
if (offset + size > SIZE) {
slab = alloc(SIZE);
offset = 0;
}
var buf = slice.call(slab, offset, offset += size);
if (offset & 7)
// align to 32 bit
offset = (offset | 7) + 1;
return buf;
};
}
}, {}],
10: [function (require, module, exports) {
/**
* A minimal UTF8 implementation for number arrays.
* @memberof util
* @namespace
*/
var utf8 = exports;
/**
* Calculates the UTF8 byte length of a string.
* @param {string} string String
* @returns {number} Byte length
*/
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 & 0xFC00) === 0xD800 && (string.charCodeAt(i + 1) & 0xFC00) === 0xDC00) {
++i;
len += 4;
} else len += 3;
}
return len;
};
/**
* Reads UTF8 bytes as a string.
* @param {Uint8Array} buffer Source buffer
* @param {number} start Source start
* @param {number} end Source end
* @returns {string} String read
*/
utf8.read = function utf8_read(buffer, start, end) {
var len = end - start;
if (len < 1) return "";
var parts = null,
chunk = [],
i = 0,
// char offset
t; // temporary
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) - 0x10000;
chunk[i++] = 0xD800 + (t >> 10);
chunk[i++] = 0xDC00 + (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));
};
/**
* Writes a string as UTF8 bytes.
* @param {string} string Source string
* @param {Uint8Array} buffer Destination buffer
* @param {number} offset Destination offset
* @returns {number} Bytes written
*/
utf8.write = function utf8_write(string, buffer, offset) {
var start = offset,
c1,
// character 1
c2; // character 2
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 & 0xFC00) === 0xD800 && ((c2 = string.charCodeAt(i + 1)) & 0xFC00) === 0xDC00) {
c1 = 0x10000 + ((c1 & 0x03FF) << 10) + (c2 & 0x03FF);
++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;
};
}, {}],
11: [function (require, module, exports) {
module.exports = common;
var commonRe = /\/|\./;
/**
* Provides common type definitions.
* Can also be used to provide additional google types or your own custom types.
* @param {string} name Short name as in `google/protobuf/[name].proto` or full file name
* @param {Object.<string,*>} json JSON definition within `google.protobuf` if a short name, otherwise the file's root definition
* @returns {undefined}
* @property {INamespace} google/protobuf/any.proto Any
* @property {INamespace} google/protobuf/duration.proto Duration
* @property {INamespace} google/protobuf/empty.proto Empty
* @property {INamespace} google/protobuf/field_mask.proto FieldMask
* @property {INamespace} google/protobuf/struct.proto Struct, Value, NullValue and ListValue
* @property {INamespace} google/protobuf/timestamp.proto Timestamp
* @property {INamespace} google/protobuf/wrappers.proto Wrappers
* @example
* // manually provides descriptor.proto (assumes google/protobuf/ namespace and .proto extension)
* protobuf.common("descriptor", descriptorJson);
*
* // manually provides a custom definition (uses my.foo namespace)
* protobuf.common("my/foo/bar.proto", myFooBarJson);
*/
function common(name, json) {
if (!commonRe.test(name)) {
name = "google/protobuf/" + name + ".proto";
json = {
nested: {
google: {
nested: {
protobuf: {
nested: json
}
}
}
}
};
}
common[name] = json;
}
// Not provided because of limited use (feel free to discuss or to provide yourself):
//
// google/protobuf/descriptor.proto
// google/protobuf/source_context.proto
// google/protobuf/type.proto
//
// Stripped and pre-parsed versions of these non-bundled files are instead available as part of
// the repository or package within the google/protobuf directory.
common("any", {
/**
* Properties of a google.protobuf.Any message.
* @interface IAny
* @type {Object}
* @property {string} [typeUrl]
* @property {Uint8Array} [bytes]
* @memberof common
*/
Any: {
fields: {
type_url: {
type: "string",
id: 1
},
value: {
type: "bytes",
id: 2
}
}
}
});
var timeType;
common("duration", {
/**
* Properties of a google.protobuf.Duration message.
* @interface IDuration
* @type {Object}
* @property {number|Long} [seconds]
* @property {number} [nanos]
* @memberof common
*/
Duration: timeType = {
fields: {
seconds: {
type: "int64",
id: 1
},
nanos: {
type: "int32",
id: 2
}
}
}
});
common("timestamp", {
/**
* Properties of a google.protobuf.Timestamp message.
* @interface ITimestamp
* @type {Object}
* @property {number|Long} [seconds]
* @property {number} [nanos]
* @memberof common
*/
Timestamp: timeType
});
common("empty", {
/**
* Properties of a google.protobuf.Empty message.
* @interface IEmpty
* @memberof common
*/
Empty: {
fields: {}
}
});
common("struct", {
/**
* Properties of a google.protobuf.Struct message.
* @interface IStruct
* @type {Object}
* @property {Object.<string,IValue>} [fields]
* @memberof common
*/
Struct: {
fields: {
fields: {
keyType: "string",
type: "Value",
id: 1
}
}
},
/**
* Properties of a google.protobuf.Value message.
* @interface IValue
* @type {Object}
* @property {string} [kind]
* @property {0} [nullValue]
* @property {number} [numberValue]
* @property {string} [stringValue]
* @property {boolean} [boolValue]
* @property {IStruct} [structValue]
* @property {IListValue} [listValue]
* @memberof common
*/
Value: {
oneofs: {
kind: {
oneof: ["nullValue", "numberValue", "stringValue", "boolValue", "structValue", "listValue"]
}
},
fields: {
nullValue: {
type: "NullValue",
id: 1
},
numberValue: {
type: "double",
id: 2
},
stringValue: {
type: "string",
id: 3
},
boolValue: {
type: "bool",
id: 4
},
structValue: {
type: "Struct",
id: 5
},
listValue: {
type: "ListValue",
id: 6
}
}
},
NullValue: {
values: {
NULL_VALUE: 0
}
},
/**
* Properties of a google.protobuf.ListValue message.
* @interface IListValue
* @type {Object}
* @property {Array.<IValue>} [values]
* @memberof common
*/
ListValue: {
fields: {
values: {
rule: "repeated",
type: "Value",
id: 1
}
}
}
});
common("wrappers", {
/**
* Properties of a google.protobuf.DoubleValue message.
* @interface IDoubleValue
* @type {Object}
* @property {number} [value]
* @memberof common
*/
DoubleValue: {
fields: {
value: {
type: "double",
id: 1
}
}
},
/**
* Properties of a google.protobuf.FloatValue message.
* @interface IFloatValue
* @type {Object}
* @property {number} [value]
* @memberof common
*/
FloatValue: {
fields: {
value: {
type: "float",
id: 1
}
}
},
/**
* Properties of a google.protobuf.Int64Value message.
* @interface IInt64Value
* @type {Object}
* @property {number|Long} [value]
* @memberof common
*/
Int64Value: {
fields: {
value: {
type: "int64",
id: 1
}
}
},
/**
* Properties of a google.protobuf.UInt64Value message.
* @interface IUInt64Value
* @type {Object}
* @property {number|Long} [value]
* @memberof common
*/
UInt64Value: {
fields: {
value: {
type: "uint64",
id: 1
}
}
},
/**
* Properties of a google.protobuf.Int32Value message.
* @interface IInt32Value
* @type {Object}
* @property {number} [value]
* @memberof common
*/
Int32Value: {
fields: {
value: {
type: "int32",
id: 1
}
}
},
/**
* Properties of a google.protobuf.UInt32Value message.
* @interface IUInt32Value
* @type {Object}
* @property {number} [value]
* @memberof common
*/
UInt32Value: {
fields: {
value: {
type: "uint32",
id: 1
}
}
},
/**
* Properties of a google.protobuf.BoolValue message.
* @interface IBoolValue
* @type {Object}
* @property {boolean} [value]
* @memberof common
*/
BoolValue: {
fields: {
value: {
type: "bool",
id: 1
}
}
},
/**
* Properties of a google.protobuf.StringValue message.
* @interface IStringValue
* @type {Object}
* @property {string} [value]
* @memberof common
*/
StringValue: {
fields: {
value: {
type: "string",
id: 1
}
}
},
/**
* Properties of a google.protobuf.BytesValue message.
* @interface IBytesValue
* @type {Object}
* @property {Uint8Array} [value]
* @memberof common
*/
BytesValue: {
fields: {
value: {
type: "bytes",
id: 1
}
}
}
});
common("field_mask", {
/**
* Properties of a google.protobuf.FieldMask message.
* @interface IDoubleValue
* @type {Object}
* @property {number} [value]
* @memberof common
*/
FieldMask: {
fields: {
paths: {
rule: "repeated",
type: "string",
id: 1
}
}
}
});
/**
* Gets the root definition of the specified common proto file.
*
* Bundled definitions are:
* - google/protobuf/any.proto
* - google/protobuf/duration.proto
* - google/protobuf/empty.proto
* - google/protobuf/field_mask.proto
* - google/protobuf/struct.proto
* - google/protobuf/timestamp.proto
* - google/protobuf/wrappers.proto
*
* @param {string} file Proto file name
* @returns {INamespace|null} Root definition or `null` if not defined
*/
common.get = function get(file) {
return common[file] || null;
};
}, {}],
12: [function (require, module, exports) {
/**
* Runtime message from/to plain object converters.
* @namespace
*/
var converter = exports;
var Enum = require(15),
util = require(37);
/**
* Generates a partial value fromObject conveter.
* @param {Codegen} gen Codegen instance
* @param {Field} field Reflected field
* @param {number} fieldIndex Field index
* @param {string} prop Property reference
* @returns {Codegen} Codegen instance
* @ignore
*/
function genValuePartial_fromObject(gen, field, fieldIndex, prop) {
/* eslint-disable no-unexpected-multiline, block-scoped-var, no-redeclare */
if (field.resolvedType) {
if (field.resolvedType instanceof Enum) {
gen("switch(d%s){", prop);
for (var values = field.resolvedType.values, keys = Object.keys(values), i = 0; i < keys.length; ++i) {
if (field.repeated && values[keys[i]] === field.typeDefault) gen("default:");
gen("case%j:", keys[i])("case %i:", values[keys[i]])("m%s=%j", prop, values[keys[i]])("break");
}
gen("}");
} else gen("if(typeof d%s!==\"object\")", prop)("throw TypeError(%j)", field.fullName + ": object expected")("m%s=types[%i].fromObject(d%s)", prop, fieldIndex, prop);
} else {
var isUnsigned = false;
switch (field.type) {
case "double":
case "float":
gen("m%s=Number(d%s)", prop, prop); // also catches "NaN", "Infinity"
break;
case "uint32":
case "fixed32":
gen("m%s=d%s>>>0", prop, prop);
break;
case "int32":
case "sint32":
case "sfixed32":
gen("m%s=d%s|0", prop, prop);
break;
case "uint64":
isUnsigned = true;
// eslint-disable-line no-fallthrough
case "int64":
case "sint64":
case "fixed64":
case "sfixed64":
gen("if(util.Long)")("(m%s=util.Long.fromValue(d%s)).unsigned=%j", prop, prop, isUnsigned)("else if(typeof d%s===\"string\")", prop)("m%s=parseInt(d%s,10)", prop, prop)("else if(typeof d%s===\"number\")", prop)("m%s=d%s", prop, prop)("else if(typeof d%s===\"object\")", prop)("m%s=new util.LongBits(d%s.low>>>0,d%s.high>>>0).toNumber(%s)", prop, prop, prop, isUnsigned ? "true" : "");
break;
case "bytes":
gen("if(typeof d%s===\"string\")", prop)("util.base64.decode(d%s,m%s=util.newBuffer(util.base64.length(d%s)),0)", prop, prop, prop)("else if(d%s.length)", prop)("m%s=d%s", prop, prop);
break;
case "string":
gen("m%s=String(d%s)", prop, prop);
break;
case "bool":
gen("m%s=Boolean(d%s)", prop, prop);
break;
/* default: gen
("m%s=d%s", prop, prop);
break; */
}
}
return gen;
/* eslint-enable no-unexpected-multiline, block-scoped-var, no-redeclare */
}
/**
* Generates a plain object to runtime message converter specific to the specified message type.
* @param {Type} mtype Message type
* @returns {Codegen} Codegen instance
*/
converter.fromObject = function fromObject(mtype) {
/* eslint-disable no-unexpected-multiline, block-scoped-var, no-redeclare */
var fields = mtype.fieldsArray;
var gen = util.codegen(["d"], mtype.name + "$fromObject")("if(d instanceof this.ctor)")("return d");
if (!fields.length) return gen("return new this.ctor");
gen("var m=new this.ctor");
for (var i = 0; i < fields.length; ++i) {
var field = fields[i].resolve(),
prop = util.safeProp(field.name);
// Map fields
if (field.map) {
gen("if(d%s){", prop)("if(typeof d%s!==\"object\")", prop)("throw TypeError(%j)", field.fullName + ": object expected")("m%s={}", prop)("for(var ks=Object.keys(d%s),i=0;i<ks.length;++i){", prop);
genValuePartial_fromObject(gen, field, /* not sorted */i, prop + "[ks[i]]")("}")("}");
// Repeated fields
} else if (field.repeated) {
gen("if(d%s){", prop)("if(!Array.isArray(d%s))", prop)("throw TypeError(%j)", field.fullName + ": array expected")("m%s=[]", prop)("for(var i=0;i<d%s.length;++i){", prop);
genValuePartial_fromObject(gen, field, /* not sorted */i, prop + "[i]")("}")("}");
// Non-repeated fields
} else {
if (!(field.resolvedType instanceof Enum)) gen // no need to test for null/undefined if an enum (uses switch)
("if(d%s!=null){", prop); // !== undefined && !== null
genValuePartial_fromObject(gen, field, /* not sorted */i, prop);
if (!(field.resolvedType instanceof Enum)) gen("}");
}
}
return gen("return m");
/* eslint-enable no-unexpected-multiline, block-scoped-var, no-redeclare */
};
/**
* Generates a partial value toObject converter.
* @param {Codegen} gen Codegen instance
* @param {Field} field Reflected field
* @param {number} fieldIndex Field index
* @param {string} prop Property reference
* @returns {Codegen} Codegen instance
* @ignore
*/
function genValuePartial_toObject(gen, field, fieldIndex, prop) {
/* eslint-disable no-unexpected-multiline, block-scoped-var, no-redeclare */
if (field.resolvedType) {
if (field.resolvedType instanceof Enum) gen("d%s=o.enums===String?types[%i].values[m%s]:m%s", prop, fieldIndex, prop, prop);else gen("d%s=types[%i].toObject(m%s,o)", prop, fieldIndex, prop);
} else {
var isUnsigned = false;
switch (field.type) {
case "double":
case "float":
gen("d%s=o.json&&!isFinite(m%s)?String(m%s):m%s", prop, prop, prop, prop);
break;
case "uint64":
isUnsigned = true;
// eslint-disable-line no-fallthrough
case "int64":
case "sint64":
case "fixed64":
case "sfixed64":
gen("if(typeof m%s===\"number\")", prop)("d%s=o.longs===String?String(m%s):m%s", prop, prop, prop)("else") // Long-like
("d%s=o.longs===String?util.Long.prototype.toString.call(m%s):o.longs===Number?new util.LongBits(m%s.low>>>0,m%s.high>>>0).toNumber(%s):m%s", prop, prop, prop, prop, isUnsigned ? "true" : "", prop);
break;
case "bytes":
gen("d%s=o.bytes===String?util.base64.encode(m%s,0,m%s.length):o.bytes===Array?Array.prototype.slice.call(m%s):m%s", prop, prop, prop, prop, prop);
break;
default:
gen("d%s=m%s", prop, prop);
break;
}
}
return gen;
/* eslint-enable no-unexpected-multiline, block-scoped-var, no-redeclare */
}
/**
* Generates a runtime message to plain object converter specific to the specified message type.
* @param {Type} mtype Message type
* @returns {Codegen} Codegen instance
*/
converter.toObject = function toObject(mtype) {
/* eslint-disable no-unexpected-multiline, block-scoped-var, no-redeclare */
var fields = mtype.fieldsArray.slice().sort(util.compareFieldsById);
if (!fields.length) return util.codegen()("return {}");
var gen = util.codegen(["m", "o"], mtype.name + "$toObject")("if(!o)")("o={}")("var d={}");
var repeatedFields = [],
mapFields = [],
normalFields = [],
i = 0;
for (; i < fields.length; ++i) if (!fields[i].partOf) (fields[i].resolve().repeated ? repeatedFields : fields[i].map ? mapFields : normalFields).push(fields[i]);
if (repeatedFields.length) {
gen("if(o.arrays||o.defaults){");
for (i = 0; i < repeatedFields.length; ++i) gen("d%s=[]", util.safeProp(repeatedFields[i].name));
gen("}");
}
if (mapFields.length) {
gen("if(o.objects||o.defaults){");
for (i = 0; i < mapFields.length; ++i) gen("d%s={}", util.safeProp(mapFields[i].name));
gen("}");
}
if (normalFields.length) {
gen("if(o.defaults){");
for (i = 0; i < normalFields.length; ++i) {
var field = normalFields[i],
prop = util.safeProp(field.name);
if (field.resolvedType instanceof Enum) gen("d%s=o.enums===String?%j:%j", prop, field.resolvedType.valuesById[field.typeDefault], field.typeDefault);else if (field.long) gen("if(util.Long){")("var n=new util.Long(%i,%i,%j)", field.typeDefault.low, field.typeDefault.high, field.typeDefault.unsigned)("d%s=o.longs===String?n.toString():o.longs===Number?n.toNumber():n", prop)("}else")("d%s=o.longs===String?%j:%i", prop, field.typeDefault.toString(), field.typeDefault.toNumber());else if (field.bytes) gen("d%s=o.bytes===String?%j:%s", prop, String.fromCharCode.apply(String, field.typeDefault), "[" + Array.prototype.slice.call(field.typeDefault).join(",") + "]");else gen("d%s=%j", prop, field.typeDefault); // also messages (=null)
}
gen("}");
}
var hasKs2 = false;
for (i = 0; i < fields.length; ++i) {
var field = fields[i],
index = mtype._fieldsArray.indexOf(field),
prop = util.safeProp(field.name);
if (field.map) {
if (!hasKs2) {
hasKs2 = true;
gen("var ks2");
}
gen("if(m%s&&(ks2=Object.keys(m%s)).length){", prop, prop)("d%s={}", prop)("for(var j=0;j<ks2.length;++j){");
genValuePartial_toObject(gen, field, /* sorted */index, prop + "[ks2[j]]")("}");
} else if (field.repeated) {
gen("if(m%s&&m%s.length){", prop, prop)("d%s=[]", prop)("for(var j=0;j<m%s.length;++j){", prop);
genValuePartial_toObject(gen, field, /* sorted */index, prop + "[j]")("}");
} else {
gen("if(m%s!=null&&m.hasOwnProperty(%j)){", prop, field.name); // !== undefined && !== null
genValuePartial_toObject(gen, field, /* sorted */index, prop);
if (field.partOf) gen("if(o.oneofs)")("d%s=%j", util.safeProp(field.partOf.name), field.name);
}
gen("}");
}
return gen("return d");
/* eslint-enable no-unexpected-multiline, block-scoped-var, no-redeclare */
};
}, {
"15": 15,
"37": 37
}],
13: [function (require, module, exports) {
module.exports = decoder;
var Enum = require(15),
types = require(36),
util = require(37);
function missing(field) {
return "missing required '" + field.name + "'";
}
/**
* Generates a decoder specific to the specified message type.
* @param {Type} mtype Message type
* @returns {Codegen} Codegen instance
*/
function decoder(mtype) {
/* eslint-disable no-unexpected-multiline */
var gen = util.codegen(["r", "l"], mtype.name + "$decode")("if(!(r instanceof Reader))")("r=Reader.create(r)")("var c=l===undefined?r.len:r.pos+l,m=new this.ctor" + (mtype.fieldsArray.filter(function (field) {
return field.map;
}).length ? ",k" : ""))("while(r.pos<c){")("var t=r.uint32()");
if (mtype.group) gen("if((t&7)===4)")("break");
gen("switch(t>>>3){");
var i = 0;
for (; i < /* initializes */mtype.fieldsArray.length; ++i) {
var field = mtype._fieldsArray[i].resolve(),
type = field.resolvedType instanceof Enum ? "int32" : field.type,
ref = "m" + util.safeProp(field.name);
gen("case %i:", field.id);
// Map fields
if (field.map) {
gen("r.skip().pos++") // assumes id 1 + key wireType
("if(%s===util.emptyObject)", ref)("%s={}", ref)("k=r.%s()", field.keyType)("r.pos++"); // assumes id 2 + value wireType
if (types.long[field.keyType] !== undefined) {
if (types.basic[type] === undefined) gen("%s[typeof k===\"object\"?util.longToHash(k):k]=types[%i].decode(r,r.uint32())", ref, i); // can't be groups
else gen("%s[typeof k===\"object\"?util.longToHash(k):k]=r.%s()", ref, type);
} else {
if (types.basic[type] === undefined) gen("%s[k]=types[%i].decode(r,r.uint32())", ref, i); // can't be groups
else gen("%s[k]=r.%s()", ref, type);
}
// Repeated fields
} else if (field.repeated) {
gen("if(!(%s&&%s.length))", ref, ref)("%s=[]", ref);
// Packable (always check for forward and backward compatiblity)
if (types.packed[type] !== undefined) gen("if((t&7)===2){")("var c2=r.uint32()+r.pos")("while(r.pos<c2)")("%s.push(r.%s())", ref, type)("}else");
// Non-packed
if (types.basic[type] === undefined) gen(field.resolvedType.group ? "%s.push(types[%i].decode(r))" : "%s.push(types[%i].decode(r,r.uint32()))", ref, i);else gen("%s.push(r.%s())", ref, type);
// Non-repeated
} else if (types.basic[type] === undefined) gen(field.resolvedType.group ? "%s=types[%i].decode(r)" : "%s=types[%i].decode(r,r.uint32())", ref, i);else gen("%s=r.%s()", ref, type);
gen("break");
// Unknown fields
}
gen("default:")("r.skipType(t&7)")("break")("}")("}");
// Field presence
for (i = 0; i < mtype._fieldsArray.length; ++i) {
var rfield = mtype._fieldsArray[i];
if (rfield.required) gen("if(!m.hasOwnProperty(%j))", rfield.name)("throw util.ProtocolError(%j,{instance:m})", missing(rfield));
}
return gen("return m");
/* eslint-enable no-unexpected-multiline */
}
}, {
"15": 15,
"36": 36,
"37": 37
}],
14: [function (require, module, exports) {
module.exports = encoder;
var Enum = require(15),
types = require(36),
util = require(37);
/**
* Generates a partial message type encoder.
* @param {Codegen} gen Codegen instance
* @param {Field} field Reflected field
* @param {number} fieldIndex Field index
* @param {string} ref Variable reference
* @returns {Codegen} Codegen instance
* @ignore
*/
function genTypePartial(gen, field, fieldIndex, ref) {
return field.resolvedType.group ? gen("types[%i].encode(%s,w.uint32(%i)).uint32(%i)", fieldIndex, ref, (field.id << 3 | 3) >>> 0, (field.id << 3 | 4) >>> 0) : gen("types[%i].encode(%s,w.uint32(%i).fork()).ldelim()", fieldIndex, ref, (field.id << 3 | 2) >>> 0);
}
/**
* Generates an encoder specific to the specified message type.
* @param {Type} mtype Message type
* @returns {Codegen} Codegen instance
*/
function encoder(mtype) {
/* eslint-disable no-unexpected-multiline, block-scoped-var, no-redeclare */
var gen = util.codegen(["m", "w"], mtype.name + "$encode")("if(!w)")("w=Writer.create()");
var i, ref;
// "when a message is serialized its known fields should be written sequentially by field number"
var fields = /* initializes */mtype.fieldsArray.slice().sort(util.compareFieldsById);
for (var i = 0; i < fields.length; ++i) {
var field = fields[i].resolve(),
index = mtype._fieldsArray.indexOf(field),
type = field.resolvedType instanceof Enum ? "int32" : field.type,
wireType = types.basic[type];
ref = "m" + util.safeProp(field.name);
// Map fields
if (field.map) {
gen("if(%s!=null&&m.hasOwnProperty(%j)){", ref, field.name) // !== undefined && !== null
("for(var ks=Object.keys(%s),i=0;i<ks.length;++i){", ref)("w.uint32(%i).fork().uint32(%i).%s(ks[i])", (field.id << 3 | 2) >>> 0, 8 | types.mapKey[field.keyType], field.keyType);
if (wireType === undefined) gen("types[%i].encode(%s[ks[i]],w.uint32(18).fork()).ldelim().ldelim()", index, ref); // can't be groups
else gen(".uint32(%i).%s(%s[ks[i]]).ldelim()", 16 | wireType, type, ref);
gen("}")("}");
// Repeated fields
} else if (field.repeated) {
gen("if(%s!=null&&%s.length){", ref, ref); // !== undefined && !== null
// Packed repeated
if (field.packed && types.packed[type] !== undefined) {
gen("w.uint32(%i).fork()", (field.id << 3 | 2) >>> 0)("for(var i=0;i<%s.length;++i)", ref)("w.%s(%s[i])", type, ref)("w.ldelim()");
// Non-packed
} else {
gen("for(var i=0;i<%s.length;++i)", ref);
if (wireType === undefined) genTypePartial(gen, field, index, ref + "[i]");else gen("w.uint32(%i).%s(%s[i])", (field.id << 3 | wireType) >>> 0, type, ref);
}
gen("}");
// Non-repeated
} else {
if (field.optional) gen("if(%s!=null&&m.hasOwnProperty(%j))", ref, field.name); // !== undefined && !== null
if (wireType === undefined) genTypePartial(gen, field, index, ref);else gen("w.uint32(%i).%s(%s)", (field.id << 3 | wireType) >>> 0, type, ref);
}
}
return gen("return w");
/* eslint-enable no-unexpected-multiline, block-scoped-var, no-redeclare */
}
}, {
"15": 15,
"36": 36,
"37": 37
}],
15: [function (require, module, exports) {
module.exports = Enum;
// extends ReflectionObject
var ReflectionObject = require(24);
((Enum.prototype = Object.create(ReflectionObject.prototype)).constructor = Enum).className = "Enum";
var Namespace = require(23),
util = require(37);
/**
* Constructs a new enum instance.
* @classdesc Reflected enum.
* @extends ReflectionObject
* @constructor
* @param {string} name Unique name within its namespace
* @param {Object.<string,number>} [values] Enum values as an object, by name
* @param {Object.<string,*>} [options] Declared options
* @param {string} [comment] The comment for this enum
* @param {Object.<string,string>} [comments] The value comments for this enum
*/
function Enum(name, values, options, comment, comments) {
ReflectionObject.call(this, name, options);
if (values && typeof values !== "object") throw TypeError("values must be an object");
/**
* Enum values by id.
* @type {Object.<number,string>}
*/
this.valuesById = {};
/**
* Enum values by name.
* @type {Object.<string,number>}
*/
this.values = Object.create(this.valuesById); // toJSON, marker
/**
* Enum comment text.
* @type {string|null}
*/
this.comment = comment;
/**
* Value comment texts, if any.
* @type {Object.<string,string>}
*/
this.comments = comments || {};
/**
* Reserved ranges, if any.
* @type {Array.<number[]|string>}
*/
this.reserved = undefined; // toJSON
// Note that values inherit valuesById on their prototype which makes them a TypeScript-
// compatible enum. This is used by pbts to write actual enum definitions that work for
// static and reflection code alike instead of emitting generic object definitions.
if (values) for (var keys = Object.keys(values), i = 0; i < keys.length; ++i) if (typeof values[keys[i]] === "number")
// use forward entries only
this.valuesById[this.values[keys[i]] = values[keys[i]]] = keys[i];
}
/**
* Enum descriptor.
* @interface IEnum
* @property {Object.<string,number>} values Enum values
* @property {Object.<string,*>} [options] Enum options
*/
/**
* Constructs an enum from an enum descriptor.
* @param {string} name Enum name
* @param {IEnum} json Enum descriptor
* @returns {Enum} Created enum
* @throws {TypeError} If arguments are invalid
*/
Enum.fromJSON = function fromJSON(name, json) {
var enm = new Enum(name, json.values, json.options, json.comment, json.comments);
enm.reserved = json.reserved;
return enm;
};
/**
* Converts this enum to an enum descriptor.
* @param {IToJSONOptions} [toJSONOptions] JSON conversion options
* @returns {IEnum} Enum descriptor
*/
Enum.prototype.toJSON = function toJSON(toJSONOptions) {
var keepComments = toJSONOptions ? Boolean(toJSONOptions.keepComments) : false;
return util.toObject(["options", this.options, "values", this.values, "reserved", this.reserved && this.reserved.length ? this.reserved : undefined, "comment", keepComments ? this.comment : undefined, "comments", keepComments ? this.comments : undefined]);
};
/**
* Adds a value to this enum.
* @param {string} name Value name
* @param {number} id Value id
* @param {string} [comment] Comment, if any
* @returns {Enum} `this`
* @throws {TypeError} If arguments are invalid
* @throws {Error} If there is already a value with this name or id
*/
Enum.prototype.add = function add(name, id, comment) {
// utilized by the parser but not by .fromJSON
if (!util.isString(name)) throw TypeError("name must be a string");
if (!util.isInteger(id)) throw TypeError("id must be an integer");
if (this.values[name] !== undefined) throw Error("duplicate name '" + name + "' in " + this);
if (this.isReservedId(id)) throw Error("id " + id + " is reserved in " + this);
if (this.isReservedName(name)) throw Error("name '" + name + "' is reserved in " + this);
if (this.valuesById[id] !== undefined) {
if (!(this.options && this.options.allow_alias)) throw Error("duplicate id " + id + " in " + this);
this.values[name] = id;
} else this.valuesById[this.values[name] = id] = name;
this.comments[name] = comment || null;
return this;
};
/**
* Removes a value from this enum
* @param {string} name Value name
* @returns {Enum} `this`
* @throws {TypeError} If arguments are invalid
* @throws {Error} If `name` is not a name of this enum
*/
Enum.prototype.remove = function remove(name) {
if (!util.isString(name)) throw TypeError("name must be a string");
var val = this.values[name];
if (val == null) throw Error("name '" + name + "' does not exist in " + this);
delete this.valuesById[val];
delete this.values[name];
delete this.comments[name];
return this;
};
/**
* Tests if the specified id is reserved.
* @param {number} id Id to test
* @returns {boolean} `true` if reserved, otherwise `false`
*/
Enum.prototype.isReservedId = function isReservedId(id) {
return Namespace.isReservedId(this.reserved, id);
};
/**
* Tests if the specified name is reserved.
* @param {string} name Name to test
* @returns {boolean} `true` if reserved, otherwise `false`
*/
Enum.prototype.isReservedName = function isReservedName(name) {
return Namespace.isReservedName(this.reserved, name);
};
}, {
"23": 23,
"24": 24,
"37": 37
}],
16: [function (require, module, exports) {
module.exports = Field;
// extends ReflectionObject
var ReflectionObject = require(24);
((Field.prototype = Object.create(ReflectionObject.prototype)).constructor = Field).className = "Field";
var Enum = require(15),
types = require(36),
util = require(37);
var Type; // cyclic
var ruleRe = /^required|optional|repeated$/;
/**
* Constructs a new message field instance. Note that {@link MapField|map fields} have their own class.
* @name Field
* @classdesc Reflected message field.
* @extends FieldBase
* @constructor
* @param {string} name Unique name within its namespace
* @param {number} id Unique id within its namespace
* @param {string} type Value type
* @param {string|Object.<string,*>} [rule="optional"] Field rule
* @param {string|Object.<string,*>} [extend] Extended type if different from parent
* @param {Object.<string,*>} [options] Declared options
*/
/**
* Constructs a field from a field descriptor.
* @param {string} name Field name
* @param {IField} json Field descriptor
* @returns {Field} Created field
* @throws {TypeError} If arguments are invalid
*/
Field.fromJSON = function fromJSON(name, json) {
return new Field(name, json.id, json.type, json.rule, json.extend, json.options, json.comment);
};
/**
* Not an actual constructor. Use {@link Field} instead.
* @classdesc Base class of all reflected message fields. This is not an actual class but here for the sake of having consistent type definitions.
* @exports FieldBase
* @extends ReflectionObject
* @constructor
* @param {string} name Unique name within its namespace
* @param {number} id Unique id within its namespace
* @param {string} type Value type
* @param {string|Object.<string,*>} [rule="optional"] Field rule
* @param {string|Object.<string,*>} [extend] Extended type if different from parent
* @param {Object.<string,*>} [options] Declared options
* @param {string} [comment] Comment associated with this field
*/
function Field(name, id, type, rule, extend, options, comment) {
if (util.isObject(rule)) {
comment = extend;
options = rule;
rule = extend = undefined;
} else if (util.isObject(extend)) {
comment = options;
options = extend;
extend = undefined;
}
ReflectionObject.call(this, name, options);
if (!util.isInteger(id) || id < 0) throw TypeError("id must be a non-negative integer");
if (!util.isString(type)) throw TypeError("type must be a string");
if (rule !== undefined && !ruleRe.test(rule = rule.toString().toLowerCase())) throw TypeError("rule must be a string rule");
if (extend !== undefined && !util.isString(extend)) throw TypeError("extend must be a string");
/**
* Field rule, if any.
* @type {string|undefined}
*/
this.rule = rule && rule !== "optional" ? rule : undefined; // toJSON
/**
* Field type.
* @type {string}
*/
this.type = type; // toJSON
/**
* Unique field id.
* @type {number}
*/
this.id = id; // toJSON, marker
/**
* Extended type if different from parent.
* @type {string|undefined}
*/
this.extend = extend || undefined; // toJSON
/**
* Whether this field is required.
* @type {boolean}
*/
this.required = rule === "required";
/**
* Whether this field is optional.
* @type {boolean}
*/
this.optional = !this.required;
/**
* Whether this field is repeated.
* @type {boolean}
*/
this.repeated = rule === "repeated";
/**
* Whether this field is a map or not.
* @type {boolean}
*/
this.map = false;
/**
* Message this field belongs to.
* @type {Type|null}
*/
this.message = null;
/**
* OneOf this field belongs to, if any,
* @type {OneOf|null}
*/
this.partOf = null;
/**
* The field type's default value.
* @type {*}
*/
this.typeDefault = null;
/**
* The field's default value on prototypes.
* @type {*}
*/
this.defaultValue = null;
/**
* Whether this field's value should be treated as a long.
* @type {boolean}
*/
this.long = util.Long ? types.long[type] !== undefined : /* istanbul ignore next */false;
/**
* Whether this field's value is a buffer.
* @type {boolean}
*/
this.bytes = type === "bytes";
/**
* Resolved type if not a basic type.
* @type {Type|Enum|null}
*/
this.resolvedType = null;
/**
* Sister-field within the extended type if a declaring extension field.
* @type {Field|null}
*/
this.extensionField = null;
/**
* Sister-field within the declaring namespace if an extended field.
* @type {Field|null}
*/
this.declaringField = null;
/**
* Internally remembers whether this field is packed.
* @type {boolean|null}
* @private
*/
this._packed = null;
/**
* Comment for this field.
* @type {string|null}
*/
this.comment = comment;
}
/**
* Determines whether this field is packed. Only relevant when repeated and working with proto2.
* @name Field#packed
* @type {boolean}
* @readonly
*/
Object.defineProperty(Field.prototype, "packed", {
get: function () {
// defaults to packed=true if not explicity set to false
if (this._packed === null) this._packed = this.getOption("packed") !== false;
return this._packed;
}
});
/**
* @override
*/
Field.prototype.setOption = function setOption(name, value, ifNotSet) {
if (name === "packed")
// clear cached before setting
this._packed = null;
return ReflectionObject.prototype.setOption.call(this, name, value, ifNotSet);
};
/**
* Field descriptor.
* @interface IField
* @property {string} [rule="optional"] Field rule
* @property {string} type Field type
* @property {number} id Field id
* @property {Object.<string,*>} [options] Field options
*/
/**
* Extension field descriptor.
* @interface IExtensionField
* @extends IField
* @property {string} extend Extended type
*/
/**
* Converts this field to a field descriptor.
* @param {IToJSONOptions} [toJSONOptions] JSON conversion options
* @returns {IField} Field descriptor
*/
Field.prototype.toJSON = function toJSON(toJSONOptions) {
var keepComments = toJSONOptions ? Boolean(toJSONOptions.keepComments) : false;
return util.toObject(["rule", this.rule !== "optional" && this.rule || undefined, "type", this.type, "id", this.id, "extend", this.extend, "options", this.options, "comment", keepComments ? this.comment : undefined]);
};
/**
* Resolves this field's type references.
* @returns {Field} `this`
* @throws {Error} If any reference cannot be resolved
*/
Field.prototype.resolve = function resolve() {
if (this.resolved) return this;
if ((this.typeDefault = types.defaults[this.type]) === undefined) {
// if not a basic type, resolve it
this.resolvedType = (this.declaringField ? this.declaringField.parent : this.parent).lookupTypeOrEnum(this.type);
if (this.resolvedType instanceof Type) this.typeDefault = null;else
// instanceof Enum
this.typeDefault = this.resolvedType.values[Object.keys(this.resolvedType.values)[0]]; // first defined
}
// use explicitly set default value if present
if (this.options && this.options["default"] != null) {
this.typeDefault = this.options["default"];
if (this.resolvedType instanceof Enum && typeof this.typeDefault === "string") this.typeDefault = this.resolvedType.values[this.typeDefault];
}
// remove unnecessary options
if (this.options) {
if (this.options.packed === true || this.options.packed !== undefined && this.resolvedType && !(this.resolvedType instanceof Enum)) delete this.options.packed;
if (!Object.keys(this.options).length) this.options = undefined;
}
// convert to internal data type if necesssary
if (this.long) {
this.typeDefault = util.Long.fromNumber(this.typeDefault, this.type.charAt(0) === "u");
/* istanbul ignore else */
if (Object.freeze) Object.freeze(this.typeDefault); // long instances are meant to be immutable anyway (i.e. use small int cache that even requires it)
} else if (this.bytes && typeof this.typeDefault === "string") {
var buf;
if (util.base64.test(this.typeDefault)) util.base64.decode(this.typeDefault, buf = util.newBuffer(util.base64.length(this.typeDefault)), 0);else util.utf8.write(this.typeDefault, buf = util.newBuffer(util.utf8.length(this.typeDefault)), 0);
this.typeDefault = buf;
}
// take special care of maps and repeated fields
if (this.map) this.defaultValue = util.emptyObject;else if (this.repeated) this.defaultValue = util.emptyArray;else this.defaultValue = this.typeDefault;
// ensure proper value on prototype
if (this.parent instanceof Type) this.parent.ctor.prototype[this.name] = this.defaultValue;
return ReflectionObject.prototype.resolve.call(this);
};
/**
* Decorator function as returned by {@link Field.d} and {@link MapField.d} (TypeScript).
* @typedef FieldDecorator
* @type {function}
* @param {Object} prototype Target prototype
* @param {string} fieldName Field name
* @returns {undefined}
*/
/**
* Field decorator (TypeScript).
* @name Field.d
* @function
* @param {number} fieldId Field id
* @param {"double"|"float"|"int32"|"uint32"|"sint32"|"fixed32"|"sfixed32"|"int64"|"uint64"|"sint64"|"fixed64"|"sfixed64"|"string"|"bool"|"bytes"|Object} fieldType Field type
* @param {"optional"|"required"|"repeated"} [fieldRule="optional"] Field rule
* @param {T} [defaultValue] Default value
* @returns {FieldDecorator} Decorator function
* @template T extends number | number[] | Long | Long[] | string | string[] | boolean | boolean[] | Uint8Array | Uint8Array[] | Buffer | Buffer[]
*/
Field.d = function decorateField(fieldId, fieldType, fieldRule, defaultValue) {
// submessage: decorate the submessage and use its name as the type
if (typeof fieldType === "function") fieldType = util.decorateType(fieldType).name;
// enum reference: create a reflected copy of the enum and keep reuseing it
else if (fieldType && typeof fieldType === "object") fieldType = util.decorateEnum(fieldType).name;
return function fieldDecorator(prototype, fieldName) {
util.decorateType(prototype.constructor).add(new Field(fieldName, fieldId, fieldType, fieldRule, {
"default": defaultValue
}));
};
};
/**
* Field decorator (TypeScript).
* @name Field.d
* @function
* @param {number} fieldId Field id
* @param {Constructor<T>|string} fieldType Field type
* @param {"optional"|"required"|"repeated"} [fieldRule="optional"] Field rule
* @returns {FieldDecorator} Decorator function
* @template T extends Message<T>
* @variation 2
*/
// like Field.d but without a default value
Field._configure = function configure(Type_) {
Type = Type_;
};
}, {
"15": 15,
"24": 24,
"36": 36,
"37": 37
}],
17: [function (require, module, exports) {
var protobuf = module.exports = require(18);
protobuf.build = "light";
/**
* A node-style callback as used by {@link load} and {@link Root#load}.
* @typedef LoadCallback
* @type {function}
* @param {Error|null} error Error, if any, otherwise `null`
* @param {Root} [root] Root, if there hasn't been an error
* @returns {undefined}
*/
/**
* Loads one or multiple .proto or preprocessed .json files into a common root namespace and calls the callback.
* @param {string|string[]} filename One or multiple files to load
* @param {Root} root Root namespace, defaults to create a new one if omitted.
* @param {LoadCallback} callback Callback function
* @returns {undefined}
* @see {@link Root#load}
*/
function load(filename, root, callback) {
if (typeof root === "function") {
callback = root;
root = new protobuf.Root();
} else if (!root) root = new protobuf.Root();
return root.load(filename, callback);
}
/**
* Loads one or multiple .proto or preprocessed .json files into a common root namespace and calls the callback.
* @name load
* @function
* @param {string|string[]} filename One or multiple files to load
* @param {LoadCallback} callback Callback function
* @returns {undefined}
* @see {@link Root#load}
* @variation 2
*/
// function load(filename:string, callback:LoadCallback):undefined
/**
* Loads one or multiple .proto or preprocessed .json files into a common root namespace and returns a promise.
* @name load
* @function
* @param {string|string[]} filename One or multiple files to load
* @param {Root} [root] Root namespace, defaults to create a new one if omitted.
* @returns {Promise<Root>} Promise
* @see {@link Root#load}
* @variation 3
*/
// function load(filename:string, [root:Root]):Promise<Root>
protobuf.load = load;
/**
* Synchronously loads one or multiple .proto or preprocessed .json files into a common root namespace (node only).
* @param {string|string[]} filename One or multiple files to load
* @param {Root} [root] Root namespace, defaults to create a new one if omitted.
* @returns {Root} Root namespace
* @throws {Error} If synchronous fetching is not supported (i.e. in browsers) or if a file's syntax is invalid
* @see {@link Root#loadSync}
*/
function loadSync(filename, root) {
if (!root) root = new protobuf.Root();
return root.loadSync(filename);
}
protobuf.loadSync = loadSync;
// Serialization
protobuf.encoder = require(14);
protobuf.decoder = require(13);
protobuf.verifier = require(40);
protobuf.converter = require(12);
// Reflection
protobuf.ReflectionObject = require(24);
protobuf.Namespace = require(23);
protobuf.Root = require(29);
protobuf.Enum = require(15);
protobuf.Type = require(35);
protobuf.Field = require(16);
protobuf.OneOf = require(25);
protobuf.MapField = require(20);
protobuf.Service = require(33);
protobuf.Method = require(22);
// Runtime
protobuf.Message = require(21);
protobuf.wrappers = require(41);
// Utility
protobuf.types = require(36);
protobuf.util = require(37);
// Configure reflection
protobuf.ReflectionObject._configure(protobuf.Root);
protobuf.Namespace._configure(protobuf.Type, protobuf.Service);
protobuf.Root._configure(protobuf.Type);
protobuf.Field._configure(protobuf.Type);
}, {
"12": 12,
"13": 13,
"14": 14,
"15": 15,
"16": 16,
"18": 18,
"20": 20,
"21": 21,
"22": 22,
"23": 23,
"24": 24,
"25": 25,
"29": 29,
"33": 33,
"35": 35,
"36": 36,
"37": 37,
"40": 40,
"41": 41
}],
18: [function (require, module, exports) {
var protobuf = exports;
/**
* Build type, one of `"full"`, `"light"` or `"minimal"`.
* @name build
* @type {string}
* @const
*/
protobuf.build = "minimal";
// Serialization
protobuf.Writer = require(42);
protobuf.BufferWriter = require(43);
protobuf.Reader = require(27);
protobuf.BufferReader = require(28);
// Utility
protobuf.util = require(39);
protobuf.rpc = require(31);
protobuf.roots = require(30);
protobuf.configure = configure;
/* istanbul ignore next */
/**
* Reconfigures the library according to the environment.
* @returns {undefined}
*/
function configure() {
protobuf.Reader._configure(protobuf.BufferReader);
protobuf.util._configure();
}
// Configure serialization
protobuf.Writer._configure(protobuf.BufferWriter);
configure();
}, {
"27": 27,
"28": 28,
"30": 30,
"31": 31,
"39": 39,
"42": 42,
"43": 43
}],
19: [function (require, module, exports) {
var protobuf = module.exports = require(17);
protobuf.build = "full";
// Parser
protobuf.tokenize = require(34);
protobuf.parse = require(26);
protobuf.common = require(11);
// Configure parser
protobuf.Root._configure(protobuf.Type, protobuf.parse, protobuf.common);
}, {
"11": 11,
"17": 17,
"26": 26,
"34": 34
}],
20: [function (require, module, exports) {
module.exports = MapField;
// extends Field
var Field = require(16);
((MapField.prototype = Object.create(Field.prototype)).constructor = MapField).className = "MapField";
var types = require(36),
util = require(37);
/**
* Constructs a new map field instance.
* @classdesc Reflected map field.
* @extends FieldBase
* @constructor
* @param {string} name Unique name within its namespace
* @param {number} id Unique id within its namespace
* @param {string} keyType Key type
* @param {string} type Value type
* @param {Object.<string,*>} [options] Declared options
* @param {string} [comment] Comment associated with this field
*/
function MapField(name, id, keyType, type, options, comment) {
Field.call(this, name, id, type, undefined, undefined, options, comment);
/* istanbul ignore if */
if (!util.isString(keyType)) throw TypeError("keyType must be a string");
/**
* Key type.
* @type {string}
*/
this.keyType = keyType; // toJSON, marker
/**
* Resolved key type if not a basic type.
* @type {ReflectionObject|null}
*/
this.resolvedKeyType = null;
// Overrides Field#map
this.map = true;
}
/**
* Map field descriptor.
* @interface IMapField
* @extends {IField}
* @property {string} keyType Key type
*/
/**
* Extension map field descriptor.
* @interface IExtensionMapField
* @extends IMapField
* @property {string} extend Extended type
*/
/**
* Constructs a map field from a map field descriptor.
* @param {string} name Field name
* @param {IMapField} json Map field descriptor
* @returns {MapField} Created map field
* @throws {TypeError} If arguments are invalid
*/
MapField.fromJSON = function fromJSON(name, json) {
return new MapField(name, json.id, json.keyType, json.type, json.options, json.comment);
};
/**
* Converts this map field to a map field descriptor.
* @param {IToJSONOptions} [toJSONOptions] JSON conversion options
* @returns {IMapField} Map field descriptor
*/
MapField.prototype.toJSON = function toJSON(toJSONOptions) {
var keepComments = toJSONOptions ? Boolean(toJSONOptions.keepComments) : false;
return util.toObject(["keyType", this.keyType, "type", this.type, "id", this.id, "extend", this.extend, "options", this.options, "comment", keepComments ? this.comment : undefined]);
};
/**
* @override
*/
MapField.prototype.resolve = function resolve() {
if (this.resolved) return this;
// Besides a value type, map fields have a key type that may be "any scalar type except for floating point types and bytes"
if (types.mapKey[this.keyType] === undefined) throw Error("invalid key type: " + this.keyType);
return Field.prototype.resolve.call(this);
};
/**
* Map field decorator (TypeScript).
* @name MapField.d
* @function
* @param {number} fieldId Field id
* @param {"int32"|"uint32"|"sint32"|"fixed32"|"sfixed32"|"int64"|"uint64"|"sint64"|"fixed64"|"sfixed64"|"bool"|"string"} fieldKeyType Field key type
* @param {"double"|"float"|"int32"|"uint32"|"sint32"|"fixed32"|"sfixed32"|"int64"|"uint64"|"sint64"|"fixed64"|"sfixed64"|"bool"|"string"|"bytes"|Object|Constructor<{}>} fieldValueType Field value type
* @returns {FieldDecorator} Decorator function
* @template T extends { [key: string]: number | Long | string | boolean | Uint8Array | Buffer | number[] | Message<{}> }
*/
MapField.d = function decorateMapField(fieldId, fieldKeyType, fieldValueType) {
// submessage value: decorate the submessage and use its name as the type
if (typeof fieldValueType === "function") fieldValueType = util.decorateType(fieldValueType).name;
// enum reference value: create a reflected copy of the enum and keep reuseing it
else if (fieldValueType && typeof fieldValueType === "object") fieldValueType = util.decorateEnum(fieldValueType).name;
return function mapFieldDecorator(prototype, fieldName) {
util.decorateType(prototype.constructor).add(new MapField(fieldName, fieldId, fieldKeyType, fieldValueType));
};
};
}, {
"16": 16,
"36": 36,
"37": 37
}],
21: [function (require, module, exports) {
module.exports = Message;
var util = require(39);
/**
* Constructs a new message instance.
* @classdesc Abstract runtime message.
* @constructor
* @param {Properties<T>} [properties] Properties to set
* @template T extends object
*/
function Message(properties) {
// not used internally
if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) this[keys[i]] = properties[keys[i]];
}
/**
* Reference to the reflected type.
* @name Message.$type
* @type {Type}
* @readonly
*/
/**
* Reference to the reflected type.
* @name Message#$type
* @type {Type}
* @readonly
*/
/*eslint-disable valid-jsdoc*/
/**
* Creates a new message of this type using the specified properties.
* @param {Object.<string,*>} [properties] Properties to set
* @returns {Message<T>} Message instance
* @template T extends Message<T>
* @this Constructor<T>
*/
Message.create = function create(properties) {
return this.$type.create(properties);
};
/**
* Encodes a message of this type.
* @param {T|Object.<string,*>} message Message to encode
* @param {Writer} [writer] Writer to use
* @returns {Writer} Writer
* @template T extends Message<T>
* @this Constructor<T>
*/
Message.encode = function encode(message, writer) {
return this.$type.encode(message, writer);
};
/**
* Encodes a message of this type preceeded by its length as a varint.
* @param {T|Object.<string,*>} message Message to encode
* @param {Writer} [writer] Writer to use
* @returns {Writer} Writer
* @template T extends Message<T>
* @this Constructor<T>
*/
Message.encodeDelimited = function encodeDelimited(message, writer) {
return this.$type.encodeDelimited(message, writer);
};
/**
* Decodes a message of this type.
* @name Message.decode
* @function
* @param {Reader|Uint8Array} reader Reader or buffer to decode
* @returns {T} Decoded message
* @template T extends Message<T>
* @this Constructor<T>
*/
Message.decode = function decode(reader) {
return this.$type.decode(reader);
};
/**
* Decodes a message of this type preceeded by its length as a varint.
* @name Message.decodeDelimited
* @function
* @param {Reader|Uint8Array} reader Reader or buffer to decode
* @returns {T} Decoded message
* @template T extends Message<T>
* @this Constructor<T>
*/
Message.decodeDelimited = function decodeDelimited(reader) {
return this.$type.decodeDelimited(reader);
};
/**
* Verifies a message of this type.
* @name Message.verify
* @function
* @param {Object.<string,*>} message Plain object to verify
* @returns {string|null} `null` if valid, otherwise the reason why it is not
*/
Message.verify = function verify(message) {
return this.$type.verify(message);
};
/**
* Creates a new message of this type from a plain object. Also converts values to their respective internal types.
* @param {Object.<string,*>} object Plain object
* @returns {T} Message instance
* @template T extends Message<T>
* @this Constructor<T>
*/
Message.fromObject = function fromObject(object) {
return this.$type.fromObject(object);
};
/**
* Creates a plain object from a message of this type. Also converts values to other types if specified.
* @param {T} message Message instance
* @param {IConversionOptions} [options] Conversion options
* @returns {Object.<string,*>} Plain object
* @template T extends Message<T>
* @this Constructor<T>
*/
Message.toObject = function toObject(message, options) {
return this.$type.toObject(message, options);
};
/**
* Converts this message to JSON.
* @returns {Object.<string,*>} JSON object
*/
Message.prototype.toJSON = function toJSON() {
return this.$type.toObject(this, util.toJSONOptions);
};
/*eslint-enable valid-jsdoc*/
}, {
"39": 39
}],
22: [function (require, module, exports) {
module.exports = Method;
// extends ReflectionObject
var ReflectionObject = require(24);
((Method.prototype = Object.create(ReflectionObject.prototype)).constructor = Method).className = "Method";
var util = require(37);
/**
* Constructs a new service method instance.
* @classdesc Reflected service method.
* @extends ReflectionObject
* @constructor
* @param {string} name Method name
* @param {string|undefined} type Method type, usually `"rpc"`
* @param {string} requestType Request message type
* @param {string} responseType Response message type
* @param {boolean|Object.<string,*>} [requestStream] Whether the request is streamed
* @param {boolean|Object.<string,*>} [responseStream] Whether the response is streamed
* @param {Object.<string,*>} [options] Declared options
* @param {string} [comment] The comment for this method
*/
function Method(name, type, requestType, responseType, requestStream, responseStream, options, comment) {
/* istanbul ignore next */
if (util.isObject(requestStream)) {
options = requestStream;
requestStream = responseStream = undefined;
} else if (util.isObject(responseStream)) {
options = responseStream;
responseStream = undefined;
}
/* istanbul ignore if */
if (!(type === undefined || util.isString(type))) throw TypeError("type must be a string");
/* istanbul ignore if */
if (!util.isString(requestType)) throw TypeError("requestType must be a string");
/* istanbul ignore if */
if (!util.isString(responseType)) throw TypeError("responseType must be a string");
ReflectionObject.call(this, name, options);
/**
* Method type.
* @type {string}
*/
this.type = type || "rpc"; // toJSON
/**
* Request type.
* @type {string}
*/
this.requestType = requestType; // toJSON, marker
/**
* Whether requests are streamed or not.
* @type {boolean|undefined}
*/
this.requestStream = requestStream ? true : undefined; // toJSON
/**
* Response type.
* @type {string}
*/
this.responseType = responseType; // toJSON
/**
* Whether responses are streamed or not.
* @type {boolean|undefined}
*/
this.responseStream = responseStream ? true : undefined; // toJSON
/**
* Resolved request type.
* @type {Type|null}
*/
this.resolvedRequestType = null;
/**
* Resolved response type.
* @type {Type|null}
*/
this.resolvedResponseType = null;
/**
* Comment for this method
* @type {string|null}
*/
this.comment = comment;
}
/**
* Method descriptor.
* @interface IMethod
* @property {string} [type="rpc"] Method type
* @property {string} requestType Request type
* @property {string} responseType Response type
* @property {boolean} [requestStream=false] Whether requests are streamed
* @property {boolean} [responseStream=false] Whether responses are streamed
* @property {Object.<string,*>} [options] Method options
*/
/**
* Constructs a method from a method descriptor.
* @param {string} name Method name
* @param {IMethod} json Method descriptor
* @returns {Method} Created method
* @throws {TypeError} If arguments are invalid
*/
Method.fromJSON = function fromJSON(name, json) {
return new Method(name, json.type, json.requestType, json.responseType, json.requestStream, json.responseStream, json.options, json.comment);
};
/**
* Converts this method to a method descriptor.
* @param {IToJSONOptions} [toJSONOptions] JSON conversion options
* @returns {IMethod} Method descriptor
*/
Method.prototype.toJSON = function toJSON(toJSONOptions) {
var keepComments = toJSONOptions ? Boolean(toJSONOptions.keepComments) : false;
return util.toObject(["type", this.type !== "rpc" && /* istanbul ignore next */this.type || undefined, "requestType", this.requestType, "requestStream", this.requestStream, "responseType", this.responseType, "responseStream", this.responseStream, "options", this.options, "comment", keepComments ? this.comment : undefined]);
};
/**
* @override
*/
Method.prototype.resolve = function resolve() {
/* istanbul ignore if */
if (this.resolved) return this;
this.resolvedRequestType = this.parent.lookupType(this.requestType);
this.resolvedResponseType = this.parent.lookupType(this.responseType);
return ReflectionObject.prototype.resolve.call(this);
};
}, {
"24": 24,
"37": 37
}],
23: [function (require, module, exports) {
module.exports = Namespace;
// extends ReflectionObject
var ReflectionObject = require(24);
((Namespace.prototype = Object.create(ReflectionObject.prototype)).constructor = Namespace).className = "Namespace";
var Enum = require(15),
Field = require(16),
util = require(37);
var Type,
// cyclic
Service; // "
/**
* Constructs a new namespace instance.
* @name Namespace
* @classdesc Reflected namespace.
* @extends NamespaceBase
* @constructor
* @param {string} name Namespace name
* @param {Object.<string,*>} [options] Declared options
*/
/**
* Constructs a namespace from JSON.
* @memberof Namespace
* @function
* @param {string} name Namespace name
* @param {Object.<string,*>} json JSON object
* @returns {Namespace} Created namespace
* @throws {TypeError} If arguments are invalid
*/
Namespace.fromJSON = function fromJSON(name, json) {
return new Namespace(name, json.options).addJSON(json.nested);
};
/**
* Converts an array of reflection objects to JSON.
* @memberof Namespace
* @param {ReflectionObject[]} array Object array
* @param {IToJSONOptions} [toJSONOptions] JSON conversion options
* @returns {Object.<string,*>|undefined} JSON object or `undefined` when array is empty
*/
function arrayToJSON(array, toJSONOptions) {
if (!(array && array.length)) return undefined;
var obj = {};
for (var i = 0; i < array.length; ++i) obj[array[i].name] = array[i].toJSON(toJSONOptions);
return obj;
}
Namespace.arrayToJSON = arrayToJSON;
/**
* Tests if the specified id is reserved.
* @param {Array.<number[]|string>|undefined} reserved Array of reserved ranges and names
* @param {number} id Id to test
* @returns {boolean} `true` if reserved, otherwise `false`
*/
Namespace.isReservedId = function isReservedId(reserved, id) {
if (reserved) for (var i = 0; i < reserved.length; ++i) if (typeof reserved[i] !== "string" && reserved[i][0] <= id && reserved[i][1] >= id) return true;
return false;
};
/**
* Tests if the specified name is reserved.
* @param {Array.<number[]|string>|undefined} reserved Array of reserved ranges and names
* @param {string} name Name to test
* @returns {boolean} `true` if reserved, otherwise `false`
*/
Namespace.isReservedName = function isReservedName(reserved, name) {
if (reserved) for (var i = 0; i < reserved.length; ++i) if (reserved[i] === name) return true;
return false;
};
/**
* Not an actual constructor. Use {@link Namespace} instead.
* @classdesc Base class of all reflection objects containing nested objects. This is not an actual class but here for the sake of having consistent type definitions.
* @exports NamespaceBase
* @extends ReflectionObject
* @abstract
* @constructor
* @param {string} name Namespace name
* @param {Object.<string,*>} [options] Declared options
* @see {@link Namespace}
*/
function Namespace(name, options) {
ReflectionObject.call(this, name, options);
/**
* Nested objects by name.
* @type {Object.<string,ReflectionObject>|undefined}
*/
this.nested = undefined; // toJSON
/**
* Cached nested objects as an array.
* @type {ReflectionObject[]|null}
* @private
*/
this._nestedArray = null;
}
function clearCache(namespace) {
namespace._nestedArray = null;
return namespace;
}
/**
* Nested objects of this namespace as an array for iteration.
* @name NamespaceBase#nestedArray
* @type {ReflectionObject[]}
* @readonly
*/
Object.defineProperty(Namespace.prototype, "nestedArray", {
get: function () {
return this._nestedArray || (this._nestedArray = util.toArray(this.nested));
}
});
/**
* Namespace descriptor.
* @interface INamespace
* @property {Object.<string,*>} [options] Namespace options
* @property {Object.<string,AnyNestedObject>} [nested] Nested object descriptors
*/
/**
* Any extension field descriptor.
* @typedef AnyExtensionField
* @type {IExtensionField|IExtensionMapField}
*/
/**
* Any nested object descriptor.
* @typedef AnyNestedObject
* @type {IEnum|IType|IService|AnyExtensionField|INamespace}
*/
// ^ BEWARE: VSCode hangs forever when using more than 5 types (that's why AnyExtensionField exists in the first place)
/**
* Converts this namespace to a namespace descriptor.
* @param {IToJSONOptions} [toJSONOptions] JSON conversion options
* @returns {INamespace} Namespace descriptor
*/
Namespace.prototype.toJSON = function toJSON(toJSONOptions) {
return util.toObject(["options", this.options, "nested", arrayToJSON(this.nestedArray, toJSONOptions)]);
};
/**
* Adds nested objects to this namespace from nested object descriptors.
* @param {Object.<string,AnyNestedObject>} nestedJson Any nested object descriptors
* @returns {Namespace} `this`
*/
Namespace.prototype.addJSON = function addJSON(nestedJson) {
var ns = this;
/* istanbul ignore else */
if (nestedJson) {
for (var names = Object.keys(nestedJson), i = 0, nested; i < names.length; ++i) {
nested = nestedJson[names[i]];
ns.add(
// most to least likely
(nested.fields !== undefined ? Type.fromJSON : nested.values !== undefined ? Enum.fromJSON : nested.methods !== undefined ? Service.fromJSON : nested.id !== undefined ? Field.fromJSON : Namespace.fromJSON)(names[i], nested));
}
}
return this;
};
/**
* Gets the nested object of the specified name.
* @param {string} name Nested object name
* @returns {ReflectionObject|null} The reflection object or `null` if it doesn't exist
*/
Namespace.prototype.get = function get(name) {
return this.nested && this.nested[name] || null;
};
/**
* Gets the values of the nested {@link Enum|enum} of the specified name.
* This methods differs from {@link Namespace#get|get} in that it returns an enum's values directly and throws instead of returning `null`.
* @param {string} name Nested enum name
* @returns {Object.<string,number>} Enum values
* @throws {Error} If there is no such enum
*/
Namespace.prototype.getEnum = function getEnum(name) {
if (this.nested && this.nested[name] instanceof Enum) return this.nested[name].values;
throw Error("no such enum: " + name);
};
/**
* Adds a nested object to this namespace.
* @param {ReflectionObject} object Nested object to add
* @returns {Namespace} `this`
* @throws {TypeError} If arguments are invalid
* @throws {Error} If there is already a nested object with this name
*/
Namespace.prototype.add = function add(object) {
if (!(object instanceof Field && object.extend !== undefined || object instanceof Type || object instanceof Enum || object instanceof Service || object instanceof Namespace)) throw TypeError("object must be a valid nested object");
if (!this.nested) this.nested = {};else {
var prev = this.get(object.name);
if (prev) {
if (prev instanceof Namespace && object instanceof Namespace && !(prev instanceof Type || prev instanceof Service)) {
// replace plain namespace but keep existing nested elements and options
var nested = prev.nestedArray;
for (var i = 0; i < nested.length; ++i) object.add(nested[i]);
this.remove(prev);
if (!this.nested) this.nested = {};
object.setOptions(prev.options, true);
} else throw Error("duplicate name '" + object.name + "' in " + this);
}
}
this.nested[object.name] = object;
object.onAdd(this);
return clearCache(this);
};
/**
* Removes a nested object from this namespace.
* @param {ReflectionObject} object Nested object to remove
* @returns {Namespace} `this`
* @throws {TypeError} If arguments are invalid
* @throws {Error} If `object` is not a member of this namespace
*/
Namespace.prototype.remove = function remove(object) {
if (!(object instanceof ReflectionObject)) throw TypeError("object must be a ReflectionObject");
if (object.parent !== this) throw Error(object + " is not a member of " + this);
delete this.nested[object.name];
if (!Object.keys(this.nested).length) this.nested = undefined;
object.onRemove(this);
return clearCache(this);
};
/**
* Defines additial namespaces within this one if not yet existing.
* @param {string|string[]} path Path to create
* @param {*} [json] Nested types to create from JSON
* @returns {Namespace} Pointer to the last namespace created or `this` if path is empty
*/
Namespace.prototype.define = function define(path, json) {
if (util.isString(path)) path = path.split(".");else if (!Array.isArray(path)) throw TypeError("illegal path");
if (path && path.length && path[0] === "") throw Error("path must be relative");
var ptr = this;
while (path.length > 0) {
var part = path.shift();
if (ptr.nested && ptr.nested[part]) {
ptr = ptr.nested[part];
if (!(ptr instanceof Namespace)) throw Error("path conflicts with non-namespace objects");
} else ptr.add(ptr = new Namespace(part));
}
if (json) ptr.addJSON(json);
return ptr;
};
/**
* Resolves this namespace's and all its nested objects' type references. Useful to validate a reflection tree, but comes at a cost.
* @returns {Namespace} `this`
*/
Namespace.prototype.resolveAll = function resolveAll() {
var nested = this.nestedArray,
i = 0;
while (i < nested.length) if (nested[i] instanceof Namespace) nested[i++].resolveAll();else nested[i++].resolve();
return this.resolve();
};
/**
* Recursively looks up the reflection object matching the specified path in the scope of this namespace.
* @param {string|string[]} path Path to look up
* @param {*|Array.<*>} filterTypes Filter types, any combination of the constructors of `protobuf.Type`, `protobuf.Enum`, `protobuf.Service` etc.
* @param {boolean} [parentAlreadyChecked=false] If known, whether the parent has already been checked
* @returns {ReflectionObject|null} Looked up object or `null` if none could be found
*/
Namespace.prototype.lookup = function lookup(path, filterTypes, parentAlreadyChecked) {
/* istanbul ignore next */
if (typeof filterTypes === "boolean") {
parentAlreadyChecked = filterTypes;
filterTypes = undefined;
} else if (filterTypes && !Array.isArray(filterTypes)) filterTypes = [filterTypes];
if (util.isString(path) && path.length) {
if (path === ".") return this.root;
path = path.split(".");
} else if (!path.length) return this;
// Start at root if path is absolute
if (path[0] === "") return this.root.lookup(path.slice(1), filterTypes);
// Test if the first part matches any nested object, and if so, traverse if path contains more
var found = this.get(path[0]);
if (found) {
if (path.length === 1) {
if (!filterTypes || filterTypes.indexOf(found.constructor) > -1) return found;
} else if (found instanceof Namespace && (found = found.lookup(path.slice(1), filterTypes, true))) return found;
// Otherwise try each nested namespace
} else for (var i = 0; i < this.nestedArray.length; ++i) if (this._nestedArray[i] instanceof Namespace && (found = this._nestedArray[i].lookup(path, filterTypes, true))) return found;
// If there hasn't been a match, try again at the parent
if (this.parent === null || parentAlreadyChecked) return null;
return this.parent.lookup(path, filterTypes);
};
/**
* Looks up the reflection object at the specified path, relative to this namespace.
* @name NamespaceBase#lookup
* @function
* @param {string|string[]} path Path to look up
* @param {boolean} [parentAlreadyChecked=false] Whether the parent has already been checked
* @returns {ReflectionObject|null} Looked up object or `null` if none could be found
* @variation 2
*/
// lookup(path: string, [parentAlreadyChecked: boolean])
/**
* Looks up the {@link Type|type} at the specified path, relative to this namespace.
* Besides its signature, this methods differs from {@link Namespace#lookup|lookup} in that it throws instead of returning `null`.
* @param {string|string[]} path Path to look up
* @returns {Type} Looked up type
* @throws {Error} If `path` does not point to a type
*/
Namespace.prototype.lookupType = function lookupType(path) {
var found = this.lookup(path, [Type]);
if (!found) throw Error("no such type: " + path);
return found;
};
/**
* Looks up the values of the {@link Enum|enum} at the specified path, relative to this namespace.
* Besides its signature, this methods differs from {@link Namespace#lookup|lookup} in that it throws instead of returning `null`.
* @param {string|string[]} path Path to look up
* @returns {Enum} Looked up enum
* @throws {Error} If `path` does not point to an enum
*/
Namespace.prototype.lookupEnum = function lookupEnum(path) {
var found = this.lookup(path, [Enum]);
if (!found) throw Error("no such Enum '" + path + "' in " + this);
return found;
};
/**
* Looks up the {@link Type|type} or {@link Enum|enum} at the specified path, relative to this namespace.
* Besides its signature, this methods differs from {@link Namespace#lookup|lookup} in that it throws instead of returning `null`.
* @param {string|string[]} path Path to look up
* @returns {Type} Looked up type or enum
* @throws {Error} If `path` does not point to a type or enum
*/
Namespace.prototype.lookupTypeOrEnum = function lookupTypeOrEnum(path) {
var found = this.lookup(path, [Type, Enum]);
if (!found) throw Error("no such Type or Enum '" + path + "' in " + this);
return found;
};
/**
* Looks up the {@link Service|service} at the specified path, relative to this namespace.
* Besides its signature, this methods differs from {@link Namespace#lookup|lookup} in that it throws instead of returning `null`.
* @param {string|string[]} path Path to look up
* @returns {Service} Looked up service
* @throws {Error} If `path` does not point to a service
*/
Namespace.prototype.lookupService = function lookupService(path) {
var found = this.lookup(path, [Service]);
if (!found) throw Error("no such Service '" + path + "' in " + this);
return found;
};
Namespace._configure = function (Type_, Service_) {
Type = Type_;
Service = Service_;
};
}, {
"15": 15,
"16": 16,
"24": 24,
"37": 37
}],
24: [function (require, module, exports) {
module.exports = ReflectionObject;
ReflectionObject.className = "ReflectionObject";
var util = require(37);
var Root; // cyclic
/**
* Constructs a new reflection object instance.
* @classdesc Base class of all reflection objects.
* @constructor
* @param {string} name Object name
* @param {Object.<string,*>} [options] Declared options
* @abstract
*/
function ReflectionObject(name, options) {
if (!util.isString(name)) throw TypeError("name must be a string");
if (options && !util.isObject(options)) throw TypeError("options must be an object");
/**
* Options.
* @type {Object.<string,*>|undefined}
*/
this.options = options; // toJSON
/**
* Unique name within its namespace.
* @type {string}
*/
this.name = name;
/**
* Parent namespace.
* @type {Namespace|null}
*/
this.parent = null;
/**
* Whether already resolved or not.
* @type {boolean}
*/
this.resolved = false;
/**
* Comment text, if any.
* @type {string|null}
*/
this.comment = null;
/**
* Defining file name.
* @type {string|null}
*/
this.filename = null;
}
Object.defineProperties(ReflectionObject.prototype, {
/**
* Reference to the root namespace.
* @name ReflectionObject#root
* @type {Root}
* @readonly
*/
root: {
get: function () {
var ptr = this;
while (ptr.parent !== null) ptr = ptr.parent;
return ptr;
}
},
/**
* Full name including leading dot.
* @name ReflectionObject#fullName
* @type {string}
* @readonly
*/
fullName: {
get: function () {
var path = [this.name],
ptr = this.parent;
while (ptr) {
path.unshift(ptr.name);
ptr = ptr.parent;
}
return path.join(".");
}
}
});
/**
* Converts this reflection object to its descriptor representation.
* @returns {Object.<string,*>} Descriptor
* @abstract
*/
ReflectionObject.prototype.toJSON = /* istanbul ignore next */function toJSON() {
throw Error(); // not implemented, shouldn't happen
};
/**
* Called when this object is added to a parent.
* @param {ReflectionObject} parent Parent added to
* @returns {undefined}
*/
ReflectionObject.prototype.onAdd = function onAdd(parent) {
if (this.parent && this.parent !== parent) this.parent.remove(this);
this.parent = parent;
this.resolved = false;
var root = parent.root;
if (root instanceof Root) root._handleAdd(this);
};
/**
* Called when this object is removed from a parent.
* @param {ReflectionObject} parent Parent removed from
* @returns {undefined}
*/
ReflectionObject.prototype.onRemove = function onRemove(parent) {
var root = parent.root;
if (root instanceof Root) root._handleRemove(this);
this.parent = null;
this.resolved = false;
};
/**
* Resolves this objects type references.
* @returns {ReflectionObject} `this`
*/
ReflectionObject.prototype.resolve = function resolve() {
if (this.resolved) return this;
if (this.root instanceof Root) this.resolved = true; // only if part of a root
return this;
};
/**
* Gets an option value.
* @param {string} name Option name
* @returns {*} Option value or `undefined` if not set
*/
ReflectionObject.prototype.getOption = function getOption(name) {
if (this.options) return this.options[name];
return undefined;
};
/**
* Sets an option.
* @param {string} name Option name
* @param {*} value Option value
* @param {boolean} [ifNotSet] Sets the option only if it isn't currently set
* @returns {ReflectionObject} `this`
*/
ReflectionObject.prototype.setOption = function setOption(name, value, ifNotSet) {
if (!ifNotSet || !this.options || this.options[name] === undefined) (this.options || (this.options = {}))[name] = value;
return this;
};
/**
* Sets multiple options.
* @param {Object.<string,*>} options Options to set
* @param {boolean} [ifNotSet] Sets an option only if it isn't currently set
* @returns {ReflectionObject} `this`
*/
ReflectionObject.prototype.setOptions = function setOptions(options, ifNotSet) {
if (options) for (var keys = Object.keys(options), i = 0; i < keys.length; ++i) this.setOption(keys[i], options[keys[i]], ifNotSet);
return this;
};
/**
* Converts this instance to its string representation.
* @returns {string} Class name[, space, full name]
*/
ReflectionObject.prototype.toString = function toString() {
var className = this.constructor.className,
fullName = this.fullName;
if (fullName.length) return className + " " + fullName;
return className;
};
ReflectionObject._configure = function (Root_) {
Root = Root_;
};
}, {
"37": 37
}],
25: [function (require, module, exports) {
module.exports = OneOf;
// extends ReflectionObject
var ReflectionObject = require(24);
((OneOf.prototype = Object.create(ReflectionObject.prototype)).constructor = OneOf).className = "OneOf";
var Field = require(16),
util = require(37);
/**
* Constructs a new oneof instance.
* @classdesc Reflected oneof.
* @extends ReflectionObject
* @constructor
* @param {string} name Oneof name
* @param {string[]|Object.<string,*>} [fieldNames] Field names
* @param {Object.<string,*>} [options] Declared options
* @param {string} [comment] Comment associated with this field
*/
function OneOf(name, fieldNames, options, comment) {
if (!Array.isArray(fieldNames)) {
options = fieldNames;
fieldNames = undefined;
}
ReflectionObject.call(this, name, options);
/* istanbul ignore if */
if (!(fieldNames === undefined || Array.isArray(fieldNames))) throw TypeError("fieldNames must be an Array");
/**
* Field names that belong to this oneof.
* @type {string[]}
*/
this.oneof = fieldNames || []; // toJSON, marker
/**
* Fields that belong to this oneof as an array for iteration.
* @type {Field[]}
* @readonly
*/
this.fieldsArray = []; // declared readonly for conformance, possibly not yet added to parent
/**
* Comment for this field.
* @type {string|null}
*/
this.comment = comment;
}
/**
* Oneof descriptor.
* @interface IOneOf
* @property {Array.<string>} oneof Oneof field names
* @property {Object.<string,*>} [options] Oneof options
*/
/**
* Constructs a oneof from a oneof descriptor.
* @param {string} name Oneof name
* @param {IOneOf} json Oneof descriptor
* @returns {OneOf} Created oneof
* @throws {TypeError} If arguments are invalid
*/
OneOf.fromJSON = function fromJSON(name, json) {
return new OneOf(name, json.oneof, json.options, json.comment);
};
/**
* Converts this oneof to a oneof descriptor.
* @param {IToJSONOptions} [toJSONOptions] JSON conversion options
* @returns {IOneOf} Oneof descriptor
*/
OneOf.prototype.toJSON = function toJSON(toJSONOptions) {
var keepComments = toJSONOptions ? Boolean(toJSONOptions.keepComments) : false;
return util.toObject(["options", this.options, "oneof", this.oneof, "comment", keepComments ? this.comment : undefined]);
};
/**
* Adds the fields of the specified oneof to the parent if not already done so.
* @param {OneOf} oneof The oneof
* @returns {undefined}
* @inner
* @ignore
*/
function addFieldsToParent(oneof) {
if (oneof.parent) for (var i = 0; i < oneof.fieldsArray.length; ++i) if (!oneof.fieldsArray[i].parent) oneof.parent.add(oneof.fieldsArray[i]);
}
/**
* Adds a field to this oneof and removes it from its current parent, if any.
* @param {Field} field Field to add
* @returns {OneOf} `this`
*/
OneOf.prototype.add = function add(field) {
/* istanbul ignore if */
if (!(field instanceof Field)) throw TypeError("field must be a Field");
if (field.parent && field.parent !== this.parent) field.parent.remove(field);
this.oneof.push(field.name);
this.fieldsArray.push(field);
field.partOf = this; // field.parent remains null
addFieldsToParent(this);
return this;
};
/**
* Removes a field from this oneof and puts it back to the oneof's parent.
* @param {Field} field Field to remove
* @returns {OneOf} `this`
*/
OneOf.prototype.remove = function remove(field) {
/* istanbul ignore if */
if (!(field instanceof Field)) throw TypeError("field must be a Field");
var index = this.fieldsArray.indexOf(field);
/* istanbul ignore if */
if (index < 0) throw Error(field + " is not a member of " + this);
this.fieldsArray.splice(index, 1);
index = this.oneof.indexOf(field.name);
/* istanbul ignore else */
if (index > -1)
// theoretical
this.oneof.splice(index, 1);
field.partOf = null;
return this;
};
/**
* @override
*/
OneOf.prototype.onAdd = function onAdd(parent) {
ReflectionObject.prototype.onAdd.call(this, parent);
var self = this;
// Collect present fields
for (var i = 0; i < this.oneof.length; ++i) {
var field = parent.get(this.oneof[i]);
if (field && !field.partOf) {
field.partOf = self;
self.fieldsArray.push(field);
}
}
// Add not yet present fields
addFieldsToParent(this);
};
/**
* @override
*/
OneOf.prototype.onRemove = function onRemove(parent) {
for (var i = 0, field; i < this.fieldsArray.length; ++i) if ((field = this.fieldsArray[i]).parent) field.parent.remove(field);
ReflectionObject.prototype.onRemove.call(this, parent);
};
/**
* Decorator function as returned by {@link OneOf.d} (TypeScript).
* @typedef OneOfDecorator
* @type {function}
* @param {Object} prototype Target prototype
* @param {string} oneofName OneOf name
* @returns {undefined}
*/
/**
* OneOf decorator (TypeScript).
* @function
* @param {...string} fieldNames Field names
* @returns {OneOfDecorator} Decorator function
* @template T extends string
*/
OneOf.d = function decorateOneOf() {
var fieldNames = new Array(arguments.length),
index = 0;
while (index < arguments.length) fieldNames[index] = arguments[index++];
return function oneOfDecorator(prototype, oneofName) {
util.decorateType(prototype.constructor).add(new OneOf(oneofName, fieldNames));
Object.defineProperty(prototype, oneofName, {
get: util.oneOfGetter(fieldNames),
set: util.oneOfSetter(fieldNames)
});
};
};
}, {
"16": 16,
"24": 24,
"37": 37
}],
26: [function (require, module, exports) {
module.exports = parse;
parse.filename = null;
parse.defaults = {
keepCase: false
};
var tokenize = require(34),
Root = require(29),
Type = require(35),
Field = require(16),
MapField = require(20),
OneOf = require(25),
Enum = require(15),
Service = require(33),
Method = require(22),
types = require(36),
util = require(37);
var base10Re = /^[1-9][0-9]*$/,
base10NegRe = /^-?[1-9][0-9]*$/,
base16Re = /^0[x][0-9a-fA-F]+$/,
base16NegRe = /^-?0[x][0-9a-fA-F]+$/,
base8Re = /^0[0-7]+$/,
base8NegRe = /^-?0[0-7]+$/,
numberRe = /^(?![eE])[0-9]*(?:\.[0-9]*)?(?:[eE][+-]?[0-9]+)?$/,
nameRe = /^[a-zA-Z_][a-zA-Z_0-9]*$/,
typeRefRe = /^(?:\.?[a-zA-Z_][a-zA-Z_0-9]*)(?:\.[a-zA-Z_][a-zA-Z_0-9]*)*$/,
fqTypeRefRe = /^(?:\.[a-zA-Z_][a-zA-Z_0-9]*)+$/;
/**
* Result object returned from {@link parse}.
* @interface IParserResult
* @property {string|undefined} package Package name, if declared
* @property {string[]|undefined} imports Imports, if any
* @property {string[]|undefined} weakImports Weak imports, if any
* @property {string|undefined} syntax Syntax, if specified (either `"proto2"` or `"proto3"`)
* @property {Root} root Populated root instance
*/
/**
* Options modifying the behavior of {@link parse}.
* @interface IParseOptions
* @property {boolean} [keepCase=false] Keeps field casing instead of converting to camel case
* @property {boolean} [alternateCommentMode=false] Recognize double-slash comments in addition to doc-block comments.
*/
/**
* Options modifying the behavior of JSON serialization.
* @interface IToJSONOptions
* @property {boolean} [keepComments=false] Serializes comments.
*/
/**
* Parses the given .proto source and returns an object with the parsed contents.
* @param {string} source Source contents
* @param {Root} root Root to populate
* @param {IParseOptions} [options] Parse options. Defaults to {@link parse.defaults} when omitted.
* @returns {IParserResult} Parser result
* @property {string} filename=null Currently processing file name for error reporting, if known
* @property {IParseOptions} defaults Default {@link IParseOptions}
*/
function parse(source, root, options) {
/* eslint-disable callback-return */
if (!(root instanceof Root)) {
options = root;
root = new Root();
}
if (!options) options = parse.defaults;
var tn = tokenize(source, options.alternateCommentMode || false),
next = tn.next,
push = tn.push,
peek = tn.peek,
skip = tn.skip,
cmnt = tn.cmnt;
var head = true,
pkg,
imports,
weakImports,
syntax,
isProto3 = false;
var ptr = root;
var applyCase = options.keepCase ? function (name) {
return name;
} : util.camelCase;
/* istanbul ignore next */
function illegal(token, name, insideTryCatch) {
var filename = parse.filename;
if (!insideTryCatch) parse.filename = null;
return Error("illegal " + (name || "token") + " '" + token + "' (" + (filename ? filename + ", " : "") + "line " + tn.line + ")");
}
function readString() {
var values = [],
token;
do {
/* istanbul ignore if */
if ((token = next()) !== "\"" && token !== "'") throw illegal(token);
values.push(next());
skip(token);
token = peek();
} while (token === "\"" || token === "'");
return values.join("");
}
function readValue(acceptTypeRef) {
var token = next();
switch (token) {
case "'":
case "\"":
push(token);
return readString();
case "true":
case "TRUE":
return true;
case "false":
case "FALSE":
return false;
}
try {
return parseNumber(token, /* insideTryCatch */true);
} catch (e) {
/* istanbul ignore else */
if (acceptTypeRef && typeRefRe.test(token)) return token;
/* istanbul ignore next */
throw illegal(token, "value");
}
}
function readRanges(target, acceptStrings) {
var token, start;
do {
if (acceptStrings && ((token = peek()) === "\"" || token === "'")) target.push(readString());else target.push([start = parseId(next()), skip("to", true) ? parseId(next()) : start]);
} while (skip(",", true));
skip(";");
}
function parseNumber(token, insideTryCatch) {
var sign = 1;
if (token.charAt(0) === "-") {
sign = -1;
token = token.substring(1);
}
switch (token) {
case "inf":
case "INF":
case "Inf":
return sign * Infinity;
case "nan":
case "NAN":
case "Nan":
case "NaN":
return NaN;
case "0":
return 0;
}
if (base10Re.test(token)) return sign * parseInt(token, 10);
if (base16Re.test(token)) return sign * parseInt(token, 16);
if (base8Re.test(token)) return sign * parseInt(token, 8);
/* istanbul ignore else */
if (numberRe.test(token)) return sign * parseFloat(token);
/* istanbul ignore next */
throw illegal(token, "number", insideTryCatch);
}
function parseId(token, acceptNegative) {
switch (token) {
case "max":
case "MAX":
case "Max":
return 536870911;
case "0":
return 0;
}
/* istanbul ignore if */
if (!acceptNegative && token.charAt(0) === "-") throw illegal(token, "id");
if (base10NegRe.test(token)) return parseInt(token, 10);
if (base16NegRe.test(token)) return parseInt(token, 16);
/* istanbul ignore else */
if (base8NegRe.test(token)) return parseInt(token, 8);
/* istanbul ignore next */
throw illegal(token, "id");
}
function parsePackage() {
/* istanbul ignore if */
if (pkg !== undefined) throw illegal("package");
pkg = next();
/* istanbul ignore if */
if (!typeRefRe.test(pkg)) throw illegal(pkg, "name");
ptr = ptr.define(pkg);
skip(";");
}
function parseImport() {
var token = peek();
var whichImports;
switch (token) {
case "weak":
whichImports = weakImports || (weakImports = []);
next();
break;
case "public":
next();
// eslint-disable-line no-fallthrough
default:
whichImports = imports || (imports = []);
break;
}
token = readString();
skip(";");
whichImports.push(token);
}
function parseSyntax() {
skip("=");
syntax = readString();
isProto3 = syntax === "proto3";
/* istanbul ignore if */
if (!isProto3 && syntax !== "proto2") throw illegal(syntax, "syntax");
skip(";");
}
function parseCommon(parent, token) {
switch (token) {
case "option":
parseOption(parent, token);
skip(";");
return true;
case "message":
parseType(parent, token);
return true;
case "enum":
parseEnum(parent, token);
return true;
case "service":
parseService(parent, token);
return true;
case "extend":
parseExtension(parent, token);
return true;
}
return false;
}
function ifBlock(obj, fnIf, fnElse) {
var trailingLine = tn.line;
if (obj) {
obj.comment = cmnt(); // try block-type comment
obj.filename = parse.filename;
}
if (skip("{", true)) {
var token;
while ((token = next()) !== "}") fnIf(token);
skip(";", true);
} else {
if (fnElse) fnElse();
skip(";");
if (obj && typeof obj.comment !== "string") obj.comment = cmnt(trailingLine); // try line-type comment if no block
}
}
function parseType(parent, token) {
/* istanbul ignore if */
if (!nameRe.test(token = next())) throw illegal(token, "type name");
var type = new Type(token);
ifBlock(type, function parseType_block(token) {
if (parseCommon(type, token)) return;
switch (token) {
case "map":
parseMapField(type, token);
break;
case "required":
case "optional":
case "repeated":
parseField(type, token);
break;
case "oneof":
parseOneOf(type, token);
break;
case "extensions":
readRanges(type.extensions || (type.extensions = []));
break;
case "reserved":
readRanges(type.reserved || (type.reserved = []), true);
break;
default:
/* istanbul ignore if */
if (!isProto3 || !typeRefRe.test(token)) throw illegal(token);
push(token);
parseField(type, "optional");
break;
}
});
parent.add(type);
}
function parseField(parent, rule, extend) {
var type = next();
if (type === "group") {
parseGroup(parent, rule);
return;
}
/* istanbul ignore if */
if (!typeRefRe.test(type)) throw illegal(type, "type");
var name = next();
/* istanbul ignore if */
if (!nameRe.test(name)) throw illegal(name, "name");
name = applyCase(name);
skip("=");
var field = new Field(name, parseId(next()), type, rule, extend);
ifBlock(field, function parseField_block(token) {
/* istanbul ignore else */
if (token === "option") {
parseOption(field, token);
skip(";");
} else throw illegal(token);
}, function parseField_line() {
parseInlineOptions(field);
});
parent.add(field);
// JSON defaults to packed=true if not set so we have to set packed=false explicity when
// parsing proto2 descriptors without the option, where applicable. This must be done for
// all known packable types and anything that could be an enum (= is not a basic type).
if (!isProto3 && field.repeated && (types.packed[type] !== undefined || types.basic[type] === undefined)) field.setOption("packed", false, /* ifNotSet */true);
}
function parseGroup(parent, rule) {
var name = next();
/* istanbul ignore if */
if (!nameRe.test(name)) throw illegal(name, "name");
var fieldName = util.lcFirst(name);
if (name === fieldName) name = util.ucFirst(name);
skip("=");
var id = parseId(next());
var type = new Type(name);
type.group = true;
var field = new Field(fieldName, id, name, rule);
field.filename = parse.filename;
ifBlock(type, function parseGroup_block(token) {
switch (token) {
case "option":
parseOption(type, token);
skip(";");
break;
case "required":
case "optional":
case "repeated":
parseField(type, token);
break;
/* istanbul ignore next */
default:
throw illegal(token);
// there are no groups with proto3 semantics
}
});
parent.add(type).add(field);
}
function parseMapField(parent) {
skip("<");
var keyType = next();
/* istanbul ignore if */
if (types.mapKey[keyType] === undefined) throw illegal(keyType, "type");
skip(",");
var valueType = next();
/* istanbul ignore if */
if (!typeRefRe.test(valueType)) throw illegal(valueType, "type");
skip(">");
var name = next();
/* istanbul ignore if */
if (!nameRe.test(name)) throw illegal(name, "name");
skip("=");
var field = new MapField(applyCase(name), parseId(next()), keyType, valueType);
ifBlock(field, function parseMapField_block(token) {
/* istanbul ignore else */
if (token === "option") {
parseOption(field, token);
skip(";");
} else throw illegal(token);
}, function parseMapField_line() {
parseInlineOptions(field);
});
parent.add(field);
}
function parseOneOf(parent, token) {
/* istanbul ignore if */
if (!nameRe.test(token = next())) throw illegal(token, "name");
var oneof = new OneOf(applyCase(token));
ifBlock(oneof, function parseOneOf_block(token) {
if (token === "option") {
parseOption(oneof, token);
skip(";");
} else {
push(token);
parseField(oneof, "optional");
}
});
parent.add(oneof);
}
function parseEnum(parent, token) {
/* istanbul ignore if */
if (!nameRe.test(token = next())) throw illegal(token, "name");
var enm = new Enum(token);
ifBlock(enm, function parseEnum_block(token) {
switch (token) {
case "option":
parseOption(enm, token);
skip(";");
break;
case "reserved":
readRanges(enm.reserved || (enm.reserved = []), true);
break;
default:
parseEnumValue(enm, token);
}
});
parent.add(enm);
}
function parseEnumValue(parent, token) {
/* istanbul ignore if */
if (!nameRe.test(token)) throw illegal(token, "name");
skip("=");
var value = parseId(next(), true),
dummy = {};
ifBlock(dummy, function parseEnumValue_block(token) {
/* istanbul ignore else */
if (token === "option") {
parseOption(dummy, token); // skip
skip(";");
} else throw illegal(token);
}, function parseEnumValue_line() {
parseInlineOptions(dummy); // skip
});
parent.add(token, value, dummy.comment);
}
function parseOption(parent, token) {
var isCustom = skip("(", true);
/* istanbul ignore if */
if (!typeRefRe.test(token = next())) throw illegal(token, "name");
var name = token;
if (isCustom) {
skip(")");
name = "(" + name + ")";
token = peek();
if (fqTypeRefRe.test(token)) {
name += token;
next();
}
}
skip("=");
parseOptionValue(parent, name);
}
function parseOptionValue(parent, name) {
if (skip("{", true)) {
// { a: "foo" b { c: "bar" } }
do {
/* istanbul ignore if */
if (!nameRe.test(token = next())) throw illegal(token, "name");
if (peek() === "{") parseOptionValue(parent, name + "." + token);else {
skip(":");
if (peek() === "{") parseOptionValue(parent, name + "." + token);else setOption(parent, name + "." + token, readValue(true));
}
} while (!skip("}", true));
} else setOption(parent, name, readValue(true));
// Does not enforce a delimiter to be universal
}
function setOption(parent, name, value) {
if (parent.setOption) parent.setOption(name, value);
}
function parseInlineOptions(parent) {
if (skip("[", true)) {
do {
parseOption(parent, "option");
} while (skip(",", true));
skip("]");
}
return parent;
}
function parseService(parent, token) {
/* istanbul ignore if */
if (!nameRe.test(token = next())) throw illegal(token, "service name");
var service = new Service(token);
ifBlock(service, function parseService_block(token) {
if (parseCommon(service, token)) return;
/* istanbul ignore else */
if (token === "rpc") parseMethod(service, token);else throw illegal(token);
});
parent.add(service);
}
function parseMethod(parent, token) {
var type = token;
/* istanbul ignore if */
if (!nameRe.test(token = next())) throw illegal(token, "name");
var name = token,
requestType,
requestStream,
responseType,
responseStream;
skip("(");
if (skip("stream", true)) requestStream = true;
/* istanbul ignore if */
if (!typeRefRe.test(token = next())) throw illegal(token);
requestType = token;
skip(")");
skip("returns");
skip("(");
if (skip("stream", true)) responseStream = true;
/* istanbul ignore if */
if (!typeRefRe.test(token = next())) throw illegal(token);
responseType = token;
skip(")");
var method = new Method(name, type, requestType, responseType, requestStream, responseStream);
ifBlock(method, function parseMethod_block(token) {
/* istanbul ignore else */
if (token === "option") {
parseOption(method, token);
skip(";");
} else throw illegal(token);
});
parent.add(method);
}
function parseExtension(parent, token) {
/* istanbul ignore if */
if (!typeRefRe.test(token = next())) throw illegal(token, "reference");
var reference = token;
ifBlock(null, function parseExtension_block(token) {
switch (token) {
case "required":
case "repeated":
case "optional":
parseField(parent, token, reference);
break;
default:
/* istanbul ignore if */
if (!isProto3 || !typeRefRe.test(token)) throw illegal(token);
push(token);
parseField(parent, "optional", reference);
break;
}
});
}
var token;
while ((token = next()) !== null) {
switch (token) {
case "package":
/* istanbul ignore if */
if (!head) throw illegal(token);
parsePackage();
break;
case "import":
/* istanbul ignore if */
if (!head) throw illegal(token);
parseImport();
break;
case "syntax":
/* istanbul ignore if */
if (!head) throw illegal(token);
parseSyntax();
break;
case "option":
/* istanbul ignore if */
if (!head) throw illegal(token);
parseOption(ptr, token);
skip(";");
break;
default:
/* istanbul ignore else */
if (parseCommon(ptr, token)) {
head = false;
continue;
}
/* istanbul ignore next */
throw illegal(token);
}
}
parse.filename = null;
return {
"package": pkg,
"imports": imports,
weakImports: weakImports,
syntax: syntax,
root: root
};
}
/**
* Parses the given .proto source and returns an object with the parsed contents.
* @name parse
* @function
* @param {string} source Source contents
* @param {IParseOptions} [options] Parse options. Defaults to {@link parse.defaults} when omitted.
* @returns {IParserResult} Parser result
* @property {string} filename=null Currently processing file name for error reporting, if known
* @property {IParseOptions} defaults Default {@link IParseOptions}
* @variation 2
*/
}, {
"15": 15,
"16": 16,
"20": 20,
"22": 22,
"25": 25,
"29": 29,
"33": 33,
"34": 34,
"35": 35,
"36": 36,
"37": 37
}],
27: [function (require, module, exports) {
module.exports = Reader;
var util = require(39);
var BufferReader; // cyclic
var LongBits = util.LongBits,
utf8 = util.utf8;
/* istanbul ignore next */
function indexOutOfRange(reader, writeLength) {
return RangeError("index out of range: " + reader.pos + " + " + (writeLength || 1) + " > " + reader.len);
}
/**
* Constructs a new reader instance using the specified buffer.
* @classdesc Wire format reader using `Uint8Array` if available, otherwise `Array`.
* @constructor
* @param {Uint8Array} buffer Buffer to read from
*/
function Reader(buffer) {
/**
* Read buffer.
* @type {Uint8Array}
*/
this.buf = buffer;
/**
* Read buffer position.
* @type {number}
*/
this.pos = 0;
/**
* Read buffer length.
* @type {number}
*/
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");
}
/* istanbul ignore next */ : function create_array(buffer) {
if (Array.isArray(buffer)) return new Reader(buffer);
throw Error("illegal buffer");
};
/**
* Creates a new reader using the specified buffer.
* @function
* @param {Uint8Array|Buffer} buffer Buffer to read from
* @returns {Reader|BufferReader} A {@link BufferReader} if `buffer` is a Buffer, otherwise a {@link Reader}
* @throws {Error} If `buffer` is not a valid buffer
*/
Reader.create = util.Buffer ? function create_buffer_setup(buffer) {
return (Reader.create = function create_buffer(buffer) {
return util.Buffer.isBuffer(buffer) ? new BufferReader(buffer)
/* istanbul ignore next */ : create_array(buffer);
})(buffer);
}
/* istanbul ignore next */ : create_array;
Reader.prototype._slice = util.Array.prototype.subarray || /* istanbul ignore next */util.Array.prototype.slice;
/**
* Reads a varint as an unsigned 32 bit value.
* @function
* @returns {number} Value read
*/
Reader.prototype.uint32 = function read_uint32_setup() {
var value = 4294967295; // optimizer type-hint, tends to deopt otherwise (?!)
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;
/* istanbul ignore if */
if ((this.pos += 5) > this.len) {
this.pos = this.len;
throw indexOutOfRange(this, 10);
}
return value;
};
}();
/**
* Reads a varint as a signed 32 bit value.
* @returns {number} Value read
*/
Reader.prototype.int32 = function read_int32() {
return this.uint32() | 0;
};
/**
* Reads a zig-zag encoded varint as a signed 32 bit value.
* @returns {number} Value read
*/
Reader.prototype.sint32 = function read_sint32() {
var value = this.uint32();
return value >>> 1 ^ -(value & 1) | 0;
};
/* eslint-disable no-invalid-this */
function readLongVarint() {
// tends to deopt with local vars for octet etc.
var bits = new LongBits(0, 0);
var i = 0;
if (this.len - this.pos > 4) {
// fast route (lo)
for (; i < 4; ++i) {
// 1st..4th
bits.lo = (bits.lo | (this.buf[this.pos] & 127) << i * 7) >>> 0;
if (this.buf[this.pos++] < 128) return bits;
}
// 5th
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) {
/* istanbul ignore if */
if (this.pos >= this.len) throw indexOutOfRange(this);
// 1st..3th
bits.lo = (bits.lo | (this.buf[this.pos] & 127) << i * 7) >>> 0;
if (this.buf[this.pos++] < 128) return bits;
}
// 4th
bits.lo = (bits.lo | (this.buf[this.pos++] & 127) << i * 7) >>> 0;
return bits;
}
if (this.len - this.pos > 4) {
// fast route (hi)
for (; i < 5; ++i) {
// 6th..10th
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) {
/* istanbul ignore if */
if (this.pos >= this.len) throw indexOutOfRange(this);
// 6th..10th
bits.hi = (bits.hi | (this.buf[this.pos] & 127) << i * 7 + 3) >>> 0;
if (this.buf[this.pos++] < 128) return bits;
}
}
/* istanbul ignore next */
throw Error("invalid varint encoding");
}
/* eslint-enable no-invalid-this */
/**
* Reads a varint as a signed 64 bit value.
* @name Reader#int64
* @function
* @returns {Long} Value read
*/
/**
* Reads a varint as an unsigned 64 bit value.
* @name Reader#uint64
* @function
* @returns {Long} Value read
*/
/**
* Reads a zig-zag encoded varint as a signed 64 bit value.
* @name Reader#sint64
* @function
* @returns {Long} Value read
*/
/**
* Reads a varint as a boolean.
* @returns {boolean} Value read
*/
Reader.prototype.bool = function read_bool() {
return this.uint32() !== 0;
};
function readFixed32_end(buf, end) {
// note that this uses `end`, not `pos`
return (buf[end - 4] | buf[end - 3] << 8 | buf[end - 2] << 16 | buf[end - 1] << 24) >>> 0;
}
/**
* Reads fixed 32 bits as an unsigned 32 bit integer.
* @returns {number} Value read
*/
Reader.prototype.fixed32 = function read_fixed32() {
/* istanbul ignore if */
if (this.pos + 4 > this.len) throw indexOutOfRange(this, 4);
return readFixed32_end(this.buf, this.pos += 4);
};
/**
* Reads fixed 32 bits as a signed 32 bit integer.
* @returns {number} Value read
*/
Reader.prototype.sfixed32 = function read_sfixed32() {
/* istanbul ignore if */
if (this.pos + 4 > this.len) throw indexOutOfRange(this, 4);
return readFixed32_end(this.buf, this.pos += 4) | 0;
};
/* eslint-disable no-invalid-this */
function readFixed64( /* this: Reader */
) {
/* istanbul ignore if */
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));
}
/* eslint-enable no-invalid-this */
/**
* Reads fixed 64 bits.
* @name Reader#fixed64
* @function
* @returns {Long} Value read
*/
/**
* Reads zig-zag encoded fixed 64 bits.
* @name Reader#sfixed64
* @function
* @returns {Long} Value read
*/
/**
* Reads a float (32 bit) as a number.
* @function
* @returns {number} Value read
*/
Reader.prototype.float = function read_float() {
/* istanbul ignore if */
if (this.pos + 4 > this.len) throw indexOutOfRange(this, 4);
var value = util.float.readFloatLE(this.buf, this.pos);
this.pos += 4;
return value;
};
/**
* Reads a double (64 bit float) as a number.
* @function
* @returns {number} Value read
*/
Reader.prototype.double = function read_double() {
/* istanbul ignore if */
if (this.pos + 8 > this.len) throw indexOutOfRange(this, 4);
var value = util.float.readDoubleLE(this.buf, this.pos);
this.pos += 8;
return value;
};
/**
* Reads a sequence of bytes preceeded by its length as a varint.
* @returns {Uint8Array} Value read
*/
Reader.prototype.bytes = function read_bytes() {
var length = this.uint32(),
start = this.pos,
end = this.pos + length;
/* istanbul ignore if */
if (end > this.len) throw indexOutOfRange(this, length);
this.pos += length;
if (Array.isArray(this.buf))
// plain array
return this.buf.slice(start, end);
return start === end // fix for IE 10/Win8 and others' subarray returning array of size 1
? new this.buf.constructor(0) : this._slice.call(this.buf, start, end);
};
/**
* Reads a string preceeded by its byte length as a varint.
* @returns {string} Value read
*/
Reader.prototype.string = function read_string() {
var bytes = this.bytes();
return utf8.read(bytes, 0, bytes.length);
};
/**
* Skips the specified number of bytes if specified, otherwise skips a varint.
* @param {number} [length] Length if known, otherwise a varint is assumed
* @returns {Reader} `this`
*/
Reader.prototype.skip = function skip(length) {
if (typeof length === "number") {
/* istanbul ignore if */
if (this.pos + length > this.len) throw indexOutOfRange(this, length);
this.pos += length;
} else {
do {
/* istanbul ignore if */
if (this.pos >= this.len) throw indexOutOfRange(this);
} while (this.buf[this.pos++] & 128);
}
return this;
};
/**
* Skips the next element of the specified wire type.
* @param {number} wireType Wire type received
* @returns {Reader} `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:
do {
// eslint-disable-line no-constant-condition
if ((wireType = this.uint32() & 7) === 4) break;
this.skipType(wireType);
} while (true);
break;
case 5:
this.skip(4);
break;
/* istanbul ignore next */
default:
throw Error("invalid wire type " + wireType + " at offset " + this.pos);
}
return this;
};
Reader._configure = function (BufferReader_) {
BufferReader = BufferReader_;
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);
}
});
};
}, {
"39": 39
}],
28: [function (require, module, exports) {
module.exports = BufferReader;
// extends Reader
var Reader = require(27);
(BufferReader.prototype = Object.create(Reader.prototype)).constructor = BufferReader;
var util = require(39);
/**
* Constructs a new buffer reader instance.
* @classdesc Wire format reader using node buffers.
* @extends Reader
* @constructor
* @param {Buffer} buffer Buffer to read from
*/
function BufferReader(buffer) {
Reader.call(this, buffer);
/**
* Read buffer.
* @name BufferReader#buf
* @type {Buffer}
*/
}
/* istanbul ignore else */
if (util.Buffer) BufferReader.prototype._slice = util.Buffer.prototype.slice;
/**
* @override
*/
BufferReader.prototype.string = function read_string_buffer() {
var len = this.uint32(); // modifies pos
return this.buf.utf8Slice(this.pos, this.pos = Math.min(this.pos + len, this.len));
};
/**
* Reads a sequence of bytes preceeded by its length as a varint.
* @name BufferReader#bytes
* @function
* @returns {Buffer} Value read
*/
}, {
"27": 27,
"39": 39
}],
29: [function (require, module, exports) {
module.exports = Root;
// extends Namespace
var Namespace = require(23);
((Root.prototype = Object.create(Namespace.prototype)).constructor = Root).className = "Root";
var Field = require(16),
Enum = require(15),
OneOf = require(25),
util = require(37);
var Type,
// cyclic
parse,
// might be excluded
common; // "
/**
* Constructs a new root namespace instance.
* @classdesc Root namespace wrapping all types, enums, services, sub-namespaces etc. that belong together.
* @extends NamespaceBase
* @constructor
* @param {Object.<string,*>} [options] Top level options
*/
function Root(options) {
Namespace.call(this, "", options);
/**
* Deferred extension fields.
* @type {Field[]}
*/
this.deferred = [];
/**
* Resolved file names of loaded files.
* @type {string[]}
*/
this.files = [];
}
/**
* Loads a namespace descriptor into a root namespace.
* @param {INamespace} json Nameespace descriptor
* @param {Root} [root] Root namespace, defaults to create a new one if omitted
* @returns {Root} Root namespace
*/
Root.fromJSON = function fromJSON(json, root) {
if (!root) root = new Root();
if (json.options) root.setOptions(json.options);
return root.addJSON(json.nested);
};
/**
* Resolves the path of an imported file, relative to the importing origin.
* This method exists so you can override it with your own logic in case your imports are scattered over multiple directories.
* @function
* @param {string} origin The file name of the importing file
* @param {string} target The file name being imported
* @returns {string|null} Resolved path to `target` or `null` to skip the file
*/
Root.prototype.resolvePath = util.path.resolve;
// A symbol-like function to safely signal synchronous loading
/* istanbul ignore next */
function SYNC() {} // eslint-disable-line no-empty-function
/**
* Loads one or multiple .proto or preprocessed .json files into this root namespace and calls the callback.
* @param {string|string[]} filename Names of one or multiple files to load
* @param {IParseOptions} options Parse options
* @param {LoadCallback} callback Callback function
* @returns {undefined}
*/
Root.prototype.load = function load(filename, options, callback) {
if (typeof options === "function") {
callback = options;
options = undefined;
}
var self = this;
if (!callback) return util.asPromise(load, self, filename, options);
var sync = callback === SYNC; // undocumented
// Finishes loading by calling the callback (exactly once)
function finish(err, root) {
/* istanbul ignore if */
if (!callback) return;
var cb = callback;
callback = null;
if (sync) throw err;
cb(err, root);
}
// Processes a single file
function process(filename, source) {
try {
if (util.isString(source) && source.charAt(0) === "{") source = JSON.parse(source);
if (!util.isString(source)) self.setOptions(source.options).addJSON(source.nested);else {
parse.filename = filename;
var parsed = parse(source, self, options),
resolved,
i = 0;
if (parsed.imports) for (; i < parsed.imports.length; ++i) if (resolved = self.resolvePath(filename, parsed.imports[i])) fetch(resolved);
if (parsed.weakImports) for (i = 0; i < parsed.weakImports.length; ++i) if (resolved = self.resolvePath(filename, parsed.weakImports[i])) fetch(resolved, true);
}
} catch (err) {
finish(err);
}
if (!sync && !queued) finish(null, self); // only once anyway
}
// Fetches a single file
function fetch(filename, weak) {
// Strip path if this file references a bundled definition
var idx = filename.lastIndexOf("google/protobuf/");
if (idx > -1) {
var altname = filename.substring(idx);
if (altname in common) filename = altname;
}
// Skip if already loaded / attempted
if (self.files.indexOf(filename) > -1) return;
self.files.push(filename);
// Shortcut bundled definitions
if (filename in common) {
if (sync) process(filename, common[filename]);else {
++queued;
setTimeout(function () {
--queued;
process(filename, common[filename]);
});
}
return;
}
// Otherwise fetch from disk or network
if (sync) {
var source;
try {
source = util.fs.readFileSync(filename).toString("utf8");
} catch (err) {
if (!weak) finish(err);
return;
}
process(filename, source);
} else {
++queued;
util.fetch(filename, function (err, source) {
--queued;
/* istanbul ignore if */
if (!callback) return; // terminated meanwhile
if (err) {
/* istanbul ignore else */
if (!weak) finish(err);else if (!queued)
// can't be covered reliably
finish(null, self);
return;
}
process(filename, source);
});
}
}
var queued = 0;
// Assembling the root namespace doesn't require working type
// references anymore, so we can load everything in parallel
if (util.isString(filename)) filename = [filename];
for (var i = 0, resolved; i < filename.length; ++i) if (resolved = self.resolvePath("", filename[i])) fetch(resolved);
if (sync) return self;
if (!queued) finish(null, self);
return undefined;
};
// function load(filename:string, options:IParseOptions, callback:LoadCallback):undefined
/**
* Loads one or multiple .proto or preprocessed .json files into this root namespace and calls the callback.
* @function Root#load
* @param {string|string[]} filename Names of one or multiple files to load
* @param {LoadCallback} callback Callback function
* @returns {undefined}
* @variation 2
*/
// function load(filename:string, callback:LoadCallback):undefined
/**
* Loads one or multiple .proto or preprocessed .json files into this root namespace and returns a promise.
* @function Root#load
* @param {string|string[]} filename Names of one or multiple files to load
* @param {IParseOptions} [options] Parse options. Defaults to {@link parse.defaults} when omitted.
* @returns {Promise<Root>} Promise
* @variation 3
*/
// function load(filename:string, [options:IParseOptions]):Promise<Root>
/**
* Synchronously loads one or multiple .proto or preprocessed .json files into this root namespace (node only).
* @function Root#loadSync
* @param {string|string[]} filename Names of one or multiple files to load
* @param {IParseOptions} [options] Parse options. Defaults to {@link parse.defaults} when omitted.
* @returns {Root} Root namespace
* @throws {Error} If synchronous fetching is not supported (i.e. in browsers) or if a file's syntax is invalid
*/
Root.prototype.loadSync = function loadSync(filename, options) {
if (!util.isNode) throw Error("not supported");
return this.load(filename, options, SYNC);
};
/**
* @override
*/
Root.prototype.resolveAll = function resolveAll() {
if (this.deferred.length) throw Error("unresolvable extensions: " + this.deferred.map(function (field) {
return "'extend " + field.extend + "' in " + field.parent.fullName;
}).join(", "));
return Namespace.prototype.resolveAll.call(this);
};
// only uppercased (and thus conflict-free) children are exposed, see below
var exposeRe = /^[A-Z]/;
/**
* Handles a deferred declaring extension field by creating a sister field to represent it within its extended type.
* @param {Root} root Root instance
* @param {Field} field Declaring extension field witin the declaring type
* @returns {boolean} `true` if successfully added to the extended type, `false` otherwise
* @inner
* @ignore
*/
function tryHandleExtension(root, field) {
var extendedType = field.parent.lookup(field.extend);
if (extendedType) {
var sisterField = new Field(field.fullName, field.id, field.type, field.rule, undefined, field.options);
sisterField.declaringField = field;
field.extensionField = sisterField;
extendedType.add(sisterField);
return true;
}
return false;
}
/**
* Called when any object is added to this root or its sub-namespaces.
* @param {ReflectionObject} object Object added
* @returns {undefined}
* @private
*/
Root.prototype._handleAdd = function _handleAdd(object) {
if (object instanceof Field) {
if ( /* an extension field (implies not part of a oneof) */object.extend !== undefined && /* not already handled */!object.extensionField) if (!tryHandleExtension(this, object)) this.deferred.push(object);
} else if (object instanceof Enum) {
if (exposeRe.test(object.name)) object.parent[object.name] = object.values; // expose enum values as property of its parent
} else if (!(object instanceof OneOf)) /* everything else is a namespace */{
if (object instanceof Type)
// Try to handle any deferred extensions
for (var i = 0; i < this.deferred.length;) if (tryHandleExtension(this, this.deferred[i])) this.deferred.splice(i, 1);else ++i;
for (var j = 0; j < /* initializes */object.nestedArray.length; ++j)
// recurse into the namespace
this._handleAdd(object._nestedArray[j]);
if (exposeRe.test(object.name)) object.parent[object.name] = object; // expose namespace as property of its parent
}
// The above also adds uppercased (and thus conflict-free) nested types, services and enums as
// properties of namespaces just like static code does. This allows using a .d.ts generated for
// a static module with reflection-based solutions where the condition is met.
};
/**
* Called when any object is removed from this root or its sub-namespaces.
* @param {ReflectionObject} object Object removed
* @returns {undefined}
* @private
*/
Root.prototype._handleRemove = function _handleRemove(object) {
if (object instanceof Field) {
if ( /* an extension field */object.extend !== undefined) {
if ( /* already handled */object.extensionField) {
// remove its sister field
object.extensionField.parent.remove(object.extensionField);
object.extensionField = null;
} else {
// cancel the extension
var index = this.deferred.indexOf(object);
/* istanbul ignore else */
if (index > -1) this.deferred.splice(index, 1);
}
}
} else if (object instanceof Enum) {
if (exposeRe.test(object.name)) delete object.parent[object.name]; // unexpose enum values
} else if (object instanceof Namespace) {
for (var i = 0; i < /* initializes */object.nestedArray.length; ++i)
// recurse into the namespace
this._handleRemove(object._nestedArray[i]);
if (exposeRe.test(object.name)) delete object.parent[object.name]; // unexpose namespaces
}
};
Root._configure = function (Type_, parse_, common_) {
Type = Type_;
parse = parse_;
common = common_;
};
}, {
"15": 15,
"16": 16,
"23": 23,
"25": 25,
"37": 37
}],
30: [function (require, module, exports) {
module.exports = {};
/**
* Named roots.
* This is where pbjs stores generated structures (the option `-r, --root` specifies a name).
* Can also be used manually to make roots available accross modules.
* @name roots
* @type {Object.<string,Root>}
* @example
* // pbjs -r myroot -o compiled.js ...
*
* // in another module:
* require("./compiled.js");
*
* // in any subsequent module:
* var root = protobuf.roots["myroot"];
*/
}, {}],
31: [function (require, module, exports) {
/**
* Streaming RPC helpers.
* @namespace
*/
var rpc = exports;
/**
* RPC implementation passed to {@link Service#create} performing a service request on network level, i.e. by utilizing http requests or websockets.
* @typedef RPCImpl
* @type {function}
* @param {Method|rpc.ServiceMethod<Message<{}>,Message<{}>>} method Reflected or static method being called
* @param {Uint8Array} requestData Request data
* @param {RPCImplCallback} callback Callback function
* @returns {undefined}
* @example
* function rpcImpl(method, requestData, callback) {
* if (protobuf.util.lcFirst(method.name) !== "myMethod") // compatible with static code
* throw Error("no such method");
* asynchronouslyObtainAResponse(requestData, function(err, responseData) {
* callback(err, responseData);
* });
* }
*/
/**
* Node-style callback as used by {@link RPCImpl}.
* @typedef RPCImplCallback
* @type {function}
* @param {Error|null} error Error, if any, otherwise `null`
* @param {Uint8Array|null} [response] Response data or `null` to signal end of stream, if there hasn't been an error
* @returns {undefined}
*/
rpc.Service = require(32);
}, {
"32": 32
}],
32: [function (require, module, exports) {
module.exports = Service;
var util = require(39);
// Extends EventEmitter
(Service.prototype = Object.create(util.EventEmitter.prototype)).constructor = Service;
/**
* A service method callback as used by {@link rpc.ServiceMethod|ServiceMethod}.
*
* Differs from {@link RPCImplCallback} in that it is an actual callback of a service method which may not return `response = null`.
* @typedef rpc.ServiceMethodCallback
* @template TRes extends Message<TRes>
* @type {function}
* @param {Error|null} error Error, if any
* @param {TRes} [response] Response message
* @returns {undefined}
*/
/**
* A service method part of a {@link rpc.Service} as created by {@link Service.create}.
* @typedef rpc.ServiceMethod
* @template TReq extends Message<TReq>
* @template TRes extends Message<TRes>
* @type {function}
* @param {TReq|Properties<TReq>} request Request message or plain object
* @param {rpc.ServiceMethodCallback<TRes>} [callback] Node-style callback called with the error, if any, and the response message
* @returns {Promise<Message<TRes>>} Promise if `callback` has been omitted, otherwise `undefined`
*/
/**
* Constructs a new RPC service instance.
* @classdesc An RPC service as returned by {@link Service#create}.
* @exports rpc.Service
* @extends util.EventEmitter
* @constructor
* @param {RPCImpl} rpcImpl RPC implementation
* @param {boolean} [requestDelimited=false] Whether requests are length-delimited
* @param {boolean} [responseDelimited=false] Whether responses are length-delimited
*/
function Service(rpcImpl, requestDelimited, responseDelimited) {
if (typeof rpcImpl !== "function") throw TypeError("rpcImpl must be a function");
util.EventEmitter.call(this);
/**
* RPC implementation. Becomes `null` once the service is ended.
* @type {RPCImpl|null}
*/
this.rpcImpl = rpcImpl;
/**
* Whether requests are length-delimited.
* @type {boolean}
*/
this.requestDelimited = Boolean(requestDelimited);
/**
* Whether responses are length-delimited.
* @type {boolean}
*/
this.responseDelimited = Boolean(responseDelimited);
}
/**
* Calls a service method through {@link rpc.Service#rpcImpl|rpcImpl}.
* @param {Method|rpc.ServiceMethod<TReq,TRes>} method Reflected or static method
* @param {Constructor<TReq>} requestCtor Request constructor
* @param {Constructor<TRes>} responseCtor Response constructor
* @param {TReq|Properties<TReq>} request Request message or plain object
* @param {rpc.ServiceMethodCallback<TRes>} callback Service callback
* @returns {undefined}
* @template TReq extends Message<TReq>
* @template TRes extends Message<TRes>
*/
Service.prototype.rpcCall = function rpcCall(method, requestCtor, responseCtor, request, callback) {
if (!request) throw TypeError("request must be specified");
var self = this;
if (!callback) return util.asPromise(rpcCall, self, method, requestCtor, responseCtor, request);
if (!self.rpcImpl) {
setTimeout(function () {
callback(Error("already ended"));
}, 0);
return undefined;
}
try {
return self.rpcImpl(method, requestCtor[self.requestDelimited ? "encodeDelimited" : "encode"](request).finish(), function rpcCallback(err, response) {
if (err) {
self.emit("error", err, method);
return callback(err);
}
if (response === null) {
self.end( /* endedByRPC */true);
return undefined;
}
if (!(response instanceof responseCtor)) {
try {
response = responseCtor[self.responseDelimited ? "decodeDelimited" : "decode"](response);
} catch (err) {
self.emit("error", err, method);
return callback(err);
}
}
self.emit("data", response, method);
return callback(null, response);
});
} catch (err) {
self.emit("error", err, method);
setTimeout(function () {
callback(err);
}, 0);
return undefined;
}
};
/**
* Ends this service and emits the `end` event.
* @param {boolean} [endedByRPC=false] Whether the service has been ended by the RPC implementation.
* @returns {rpc.Service} `this`
*/
Service.prototype.end = function end(endedByRPC) {
if (this.rpcImpl) {
if (!endedByRPC)
// signal end to rpcImpl
this.rpcImpl(null, null, null);
this.rpcImpl = null;
this.emit("end").off();
}
return this;
};
}, {
"39": 39
}],
33: [function (require, module, exports) {
module.exports = Service;
// extends Namespace
var Namespace = require(23);
((Service.prototype = Object.create(Namespace.prototype)).constructor = Service).className = "Service";
var Method = require(22),
util = require(37),
rpc = require(31);
/**
* Constructs a new service instance.
* @classdesc Reflected service.
* @extends NamespaceBase
* @constructor
* @param {string} name Service name
* @param {Object.<string,*>} [options] Service options
* @throws {TypeError} If arguments are invalid
*/
function Service(name, options) {
Namespace.call(this, name, options);
/**
* Service methods.
* @type {Object.<string,Method>}
*/
this.methods = {}; // toJSON, marker
/**
* Cached methods as an array.
* @type {Method[]|null}
* @private
*/
this._methodsArray = null;
}
/**
* Service descriptor.
* @interface IService
* @extends INamespace
* @property {Object.<string,IMethod>} methods Method descriptors
*/
/**
* Constructs a service from a service descriptor.
* @param {string} name Service name
* @param {IService} json Service descriptor
* @returns {Service} Created service
* @throws {TypeError} If arguments are invalid
*/
Service.fromJSON = function fromJSON(name, json) {
var service = new Service(name, json.options);
/* istanbul ignore else */
if (json.methods) for (var names = Object.keys(json.methods), i = 0; i < names.length; ++i) service.add(Method.fromJSON(names[i], json.methods[names[i]]));
if (json.nested) service.addJSON(json.nested);
service.comment = json.comment;
return service;
};
/**
* Converts this service to a service descriptor.
* @param {IToJSONOptions} [toJSONOptions] JSON conversion options
* @returns {IService} Service descriptor
*/
Service.prototype.toJSON = function toJSON(toJSONOptions) {
var inherited = Namespace.prototype.toJSON.call(this, toJSONOptions);
var keepComments = toJSONOptions ? Boolean(toJSONOptions.keepComments) : false;
return util.toObject(["options", inherited && inherited.options || undefined, "methods", Namespace.arrayToJSON(this.methodsArray, toJSONOptions) || /* istanbul ignore next */{}, "nested", inherited && inherited.nested || undefined, "comment", keepComments ? this.comment : undefined]);
};
/**
* Methods of this service as an array for iteration.
* @name Service#methodsArray
* @type {Method[]}
* @readonly
*/
Object.defineProperty(Service.prototype, "methodsArray", {
get: function () {
return this._methodsArray || (this._methodsArray = util.toArray(this.methods));
}
});
function clearCache(service) {
service._methodsArray = null;
return service;
}
/**
* @override
*/
Service.prototype.get = function get(name) {
return this.methods[name] || Namespace.prototype.get.call(this, name);
};
/**
* @override
*/
Service.prototype.resolveAll = function resolveAll() {
var methods = this.methodsArray;
for (var i = 0; i < methods.length; ++i) methods[i].resolve();
return Namespace.prototype.resolve.call(this);
};
/**
* @override
*/
Service.prototype.add = function add(object) {
/* istanbul ignore if */
if (this.get(object.name)) throw Error("duplicate name '" + object.name + "' in " + this);
if (object instanceof Method) {
this.methods[object.name] = object;
object.parent = this;
return clearCache(this);
}
return Namespace.prototype.add.call(this, object);
};
/**
* @override
*/
Service.prototype.remove = function remove(object) {
if (object instanceof Method) {
/* istanbul ignore if */
if (this.methods[object.name] !== object) throw Error(object + " is not a member of " + this);
delete this.methods[object.name];
object.parent = null;
return clearCache(this);
}
return Namespace.prototype.remove.call(this, object);
};
/**
* Creates a runtime service using the specified rpc implementation.
* @param {RPCImpl} rpcImpl RPC implementation
* @param {boolean} [requestDelimited=false] Whether requests are length-delimited
* @param {boolean} [responseDelimited=false] Whether responses are length-delimited
* @returns {rpc.Service} RPC service. Useful where requests and/or responses are streamed.
*/
Service.prototype.create = function create(rpcImpl, requestDelimited, responseDelimited) {
var rpcService = new rpc.Service(rpcImpl, requestDelimited, responseDelimited);
for (var i = 0, method; i < /* initializes */this.methodsArray.length; ++i) {
var methodName = util.lcFirst((method = this._methodsArray[i]).resolve().name).replace(/[^$\w_]/g, "");
rpcService[methodName] = util.codegen(["r", "c"], util.isReserved(methodName) ? methodName + "_" : methodName)("return this.rpcCall(m,q,s,r,c)")({
m: method,
q: method.resolvedRequestType.ctor,
s: method.resolvedResponseType.ctor
});
}
return rpcService;
};
}, {
"22": 22,
"23": 23,
"31": 31,
"37": 37
}],
34: [function (require, module, exports) {
module.exports = tokenize;
var delimRe = /[\s{}=;:[\],'"()<>]/g,
stringDoubleRe = /(?:"([^"\\]*(?:\\.[^"\\]*)*)")/g,
stringSingleRe = /(?:'([^'\\]*(?:\\.[^'\\]*)*)')/g;
var setCommentRe = /^ *[*/]+ */,
setCommentAltRe = /^\s*\*?\/*/,
setCommentSplitRe = /\n/g,
whitespaceRe = /\s/,
unescapeRe = /\\(.?)/g;
var unescapeMap = {
"0": "\0",
"r": "\r",
"n": "\n",
"t": "\t"
};
/**
* Unescapes a string.
* @param {string} str String to unescape
* @returns {string} Unescaped string
* @property {Object.<string,string>} map Special characters map
* @memberof tokenize
*/
function unescape(str) {
return str.replace(unescapeRe, function ($0, $1) {
switch ($1) {
case "\\":
case "":
return $1;
default:
return unescapeMap[$1] || "";
}
});
}
tokenize.unescape = unescape;
/**
* Gets the next token and advances.
* @typedef TokenizerHandleNext
* @type {function}
* @returns {string|null} Next token or `null` on eof
*/
/**
* Peeks for the next token.
* @typedef TokenizerHandlePeek
* @type {function}
* @returns {string|null} Next token or `null` on eof
*/
/**
* Pushes a token back to the stack.
* @typedef TokenizerHandlePush
* @type {function}
* @param {string} token Token
* @returns {undefined}
*/
/**
* Skips the next token.
* @typedef TokenizerHandleSkip
* @type {function}
* @param {string} expected Expected token
* @param {boolean} [optional=false] If optional
* @returns {boolean} Whether the token matched
* @throws {Error} If the token didn't match and is not optional
*/
/**
* Gets the comment on the previous line or, alternatively, the line comment on the specified line.
* @typedef TokenizerHandleCmnt
* @type {function}
* @param {number} [line] Line number
* @returns {string|null} Comment text or `null` if none
*/
/**
* Handle object returned from {@link tokenize}.
* @interface ITokenizerHandle
* @property {TokenizerHandleNext} next Gets the next token and advances (`null` on eof)
* @property {TokenizerHandlePeek} peek Peeks for the next token (`null` on eof)
* @property {TokenizerHandlePush} push Pushes a token back to the stack
* @property {TokenizerHandleSkip} skip Skips a token, returns its presence and advances or, if non-optional and not present, throws
* @property {TokenizerHandleCmnt} cmnt Gets the comment on the previous line or the line comment on the specified line, if any
* @property {number} line Current line number
*/
/**
* Tokenizes the given .proto source and returns an object with useful utility functions.
* @param {string} source Source contents
* @param {boolean} alternateCommentMode Whether we should activate alternate comment parsing mode.
* @returns {ITokenizerHandle} Tokenizer handle
*/
function tokenize(source, alternateCommentMode) {
/* eslint-disable callback-return */
source = source.toString();
var offset = 0,
length = source.length,
line = 1,
commentType = null,
commentText = null,
commentLine = 0,
commentLineEmpty = false;
var stack = [];
var stringDelim = null;
/* istanbul ignore next */
/**
* Creates an error for illegal syntax.
* @param {string} subject Subject
* @returns {Error} Error created
* @inner
*/
function illegal(subject) {
return Error("illegal " + subject + " (line " + line + ")");
}
/**
* Reads a string till its end.
* @returns {string} String read
* @inner
*/
function readString() {
var re = stringDelim === "'" ? stringSingleRe : stringDoubleRe;
re.lastIndex = offset - 1;
var match = re.exec(source);
if (!match) throw illegal("string");
offset = re.lastIndex;
push(stringDelim);
stringDelim = null;
return unescape(match[1]);
}
/**
* Gets the character at `pos` within the source.
* @param {number} pos Position
* @returns {string} Character
* @inner
*/
function charAt(pos) {
return source.charAt(pos);
}
/**
* Sets the current comment text.
* @param {number} start Start offset
* @param {number} end End offset
* @returns {undefined}
* @inner
*/
function setComment(start, end) {
commentType = source.charAt(start++);
commentLine = line;
commentLineEmpty = false;
var lookback;
if (alternateCommentMode) {
lookback = 2; // alternate comment parsing: "//" or "/*"
} else {
lookback = 3; // "///" or "/**"
}
var commentOffset = start - lookback,
c;
do {
if (--commentOffset < 0 || (c = source.charAt(commentOffset)) === "\n") {
commentLineEmpty = true;
break;
}
} while (c === " " || c === "\t");
var lines = source.substring(start, end).split(setCommentSplitRe);
for (var i = 0; i < lines.length; ++i) lines[i] = lines[i].replace(alternateCommentMode ? setCommentAltRe : setCommentRe, "").trim();
commentText = lines.join("\n").trim();
}
function isDoubleSlashCommentLine(startOffset) {
var endOffset = findEndOfLine(startOffset);
// see if remaining line matches comment pattern
var lineText = source.substring(startOffset, endOffset);
// look for 1 or 2 slashes since startOffset would already point past
// the first slash that started the comment.
var isComment = /^\s*\/{1,2}/.test(lineText);
return isComment;
}
function findEndOfLine(cursor) {
// find end of cursor's line
var endOffset = cursor;
while (endOffset < length && charAt(endOffset) !== "\n") {
endOffset++;
}
return endOffset;
}
/**
* Obtains the next token.
* @returns {string|null} Next token or `null` on eof
* @inner
*/
function next() {
if (stack.length > 0) return stack.shift();
if (stringDelim) return readString();
var repeat, prev, curr, start, isDoc;
do {
if (offset === length) return null;
repeat = false;
while (whitespaceRe.test(curr = charAt(offset))) {
if (curr === "\n") ++line;
if (++offset === length) return null;
}
if (charAt(offset) === "/") {
if (++offset === length) {
throw illegal("comment");
}
if (charAt(offset) === "/") {
// Line
if (!alternateCommentMode) {
// check for triple-slash comment
isDoc = charAt(start = offset + 1) === "/";
while (charAt(++offset) !== "\n") {
if (offset === length) {
return null;
}
}
++offset;
if (isDoc) {
setComment(start, offset - 1);
}
++line;
repeat = true;
} else {
// check for double-slash comments, consolidating consecutive lines
start = offset;
isDoc = false;
if (isDoubleSlashCommentLine(offset)) {
isDoc = true;
do {
offset = findEndOfLine(offset);
if (offset === length) {
break;
}
offset++;
} while (isDoubleSlashCommentLine(offset));
} else {
offset = Math.min(length, findEndOfLine(offset) + 1);
}
if (isDoc) {
setComment(start, offset);
}
line++;
repeat = true;
}
} else if ((curr = charAt(offset)) === "*") {
/* Block */
// check for /** (regular comment mode) or /* (alternate comment mode)
start = offset + 1;
isDoc = alternateCommentMode || charAt(start) === "*";
do {
if (curr === "\n") {
++line;
}
if (++offset === length) {
throw illegal("comment");
}
prev = curr;
curr = charAt(offset);
} while (prev !== "*" || curr !== "/");
++offset;
if (isDoc) {
setComment(start, offset - 2);
}
repeat = true;
} else {
return "/";
}
}
} while (repeat);
// offset !== length if we got here
var end = offset;
delimRe.lastIndex = 0;
var delim = delimRe.test(charAt(end++));
if (!delim) while (end < length && !delimRe.test(charAt(end))) ++end;
var token = source.substring(offset, offset = end);
if (token === "\"" || token === "'") stringDelim = token;
return token;
}
/**
* Pushes a token back to the stack.
* @param {string} token Token
* @returns {undefined}
* @inner
*/
function push(token) {
stack.push(token);
}
/**
* Peeks for the next token.
* @returns {string|null} Token or `null` on eof
* @inner
*/
function peek() {
if (!stack.length) {
var token = next();
if (token === null) return null;
push(token);
}
return stack[0];
}
/**
* Skips a token.
* @param {string} expected Expected token
* @param {boolean} [optional=false] Whether the token is optional
* @returns {boolean} `true` when skipped, `false` if not
* @throws {Error} When a required token is not present
* @inner
*/
function skip(expected, optional) {
var actual = peek(),
equals = actual === expected;
if (equals) {
next();
return true;
}
if (!optional) throw illegal("token '" + actual + "', '" + expected + "' expected");
return false;
}
/**
* Gets a comment.
* @param {number} [trailingLine] Line number if looking for a trailing comment
* @returns {string|null} Comment text
* @inner
*/
function cmnt(trailingLine) {
var ret = null;
if (trailingLine === undefined) {
if (commentLine === line - 1 && (alternateCommentMode || commentType === "*" || commentLineEmpty)) {
ret = commentText;
}
} else {
/* istanbul ignore else */
if (commentLine < trailingLine) {
peek();
}
if (commentLine === trailingLine && !commentLineEmpty && (alternateCommentMode || commentType === "/")) {
ret = commentText;
}
}
return ret;
}
return Object.defineProperty({
next: next,
peek: peek,
push: push,
skip: skip,
cmnt: cmnt
}, "line", {
get: function () {
return line;
}
});
/* eslint-enable callback-return */
}
}, {}],
35: [function (require, module, exports) {
module.exports = Type;
// extends Namespace
var Namespace = require(23);
((Type.prototype = Object.create(Namespace.prototype)).constructor = Type).className = "Type";
var Enum = require(15),
OneOf = require(25),
Field = require(16),
MapField = require(20),
Service = require(33),
Message = require(21),
Reader = require(27),
Writer = require(42),
util = require(37),
encoder = require(14),
decoder = require(13),
verifier = require(40),
converter = require(12),
wrappers = require(41);
/**
* Constructs a new reflected message type instance.
* @classdesc Reflected message type.
* @extends NamespaceBase
* @constructor
* @param {string} name Message name
* @param {Object.<string,*>} [options] Declared options
*/
function Type(name, options) {
Namespace.call(this, name, options);
/**
* Message fields.
* @type {Object.<string,Field>}
*/
this.fields = {}; // toJSON, marker
/**
* Oneofs declared within this namespace, if any.
* @type {Object.<string,OneOf>}
*/
this.oneofs = undefined; // toJSON
/**
* Extension ranges, if any.
* @type {number[][]}
*/
this.extensions = undefined; // toJSON
/**
* Reserved ranges, if any.
* @type {Array.<number[]|string>}
*/
this.reserved = undefined; // toJSON
/*?
* Whether this type is a legacy group.
* @type {boolean|undefined}
*/
this.group = undefined; // toJSON
/**
* Cached fields by id.
* @type {Object.<number,Field>|null}
* @private
*/
this._fieldsById = null;
/**
* Cached fields as an array.
* @type {Field[]|null}
* @private
*/
this._fieldsArray = null;
/**
* Cached oneofs as an array.
* @type {OneOf[]|null}
* @private
*/
this._oneofsArray = null;
/**
* Cached constructor.
* @type {Constructor<{}>}
* @private
*/
this._ctor = null;
}
Object.defineProperties(Type.prototype, {
/**
* Message fields by id.
* @name Type#fieldsById
* @type {Object.<number,Field>}
* @readonly
*/
fieldsById: {
get: function () {
/* istanbul ignore if */
if (this._fieldsById) return this._fieldsById;
this._fieldsById = {};
for (var names = Object.keys(this.fields), i = 0; i < names.length; ++i) {
var field = this.fields[names[i]],
id = field.id;
/* istanbul ignore if */
if (this._fieldsById[id]) throw Error("duplicate id " + id + " in " + this);
this._fieldsById[id] = field;
}
return this._fieldsById;
}
},
/**
* Fields of this message as an array for iteration.
* @name Type#fieldsArray
* @type {Field[]}
* @readonly
*/
fieldsArray: {
get: function () {
return this._fieldsArray || (this._fieldsArray = util.toArray(this.fields));
}
},
/**
* Oneofs of this message as an array for iteration.
* @name Type#oneofsArray
* @type {OneOf[]}
* @readonly
*/
oneofsArray: {
get: function () {
return this._oneofsArray || (this._oneofsArray = util.toArray(this.oneofs));
}
},
/**
* The registered constructor, if any registered, otherwise a generic constructor.
* Assigning a function replaces the internal constructor. If the function does not extend {@link Message} yet, its prototype will be setup accordingly and static methods will be populated. If it already extends {@link Message}, it will just replace the internal constructor.
* @name Type#ctor
* @type {Constructor<{}>}
*/
ctor: {
get: function () {
return this._ctor || (this.ctor = Type.generateConstructor(this)());
},
set: function (ctor) {
// Ensure proper prototype
var prototype = ctor.prototype;
if (!(prototype instanceof Message)) {
(ctor.prototype = new Message()).constructor = ctor;
util.merge(ctor.prototype, prototype);
}
// Classes and messages reference their reflected type
ctor.$type = ctor.prototype.$type = this;
// Mix in static methods
util.merge(ctor, Message, true);
this._ctor = ctor;
// Messages have non-enumerable default values on their prototype
var i = 0;
for (; i < /* initializes */this.fieldsArray.length; ++i) this._fieldsArray[i].resolve(); // ensures a proper value
// Messages have non-enumerable getters and setters for each virtual oneof field
var ctorProperties = {};
for (i = 0; i < /* initializes */this.oneofsArray.length; ++i) ctorProperties[this._oneofsArray[i].resolve().name] = {
get: util.oneOfGetter(this._oneofsArray[i].oneof),
set: util.oneOfSetter(this._oneofsArray[i].oneof)
};
if (i) Object.defineProperties(ctor.prototype, ctorProperties);
}
}
});
/**
* Generates a constructor function for the specified type.
* @param {Type} mtype Message type
* @returns {Codegen} Codegen instance
*/
Type.generateConstructor = function generateConstructor(mtype) {
/* eslint-disable no-unexpected-multiline */
var gen = util.codegen(["p"], mtype.name);
// explicitly initialize mutable object/array fields so that these aren't just inherited from the prototype
for (var i = 0, field; i < mtype.fieldsArray.length; ++i) if ((field = mtype._fieldsArray[i]).map) gen("this%s={}", util.safeProp(field.name));else if (field.repeated) gen("this%s=[]", util.safeProp(field.name));
return gen("if(p)for(var ks=Object.keys(p),i=0;i<ks.length;++i)if(p[ks[i]]!=null)") // omit undefined or null
("this[ks[i]]=p[ks[i]]");
/* eslint-enable no-unexpected-multiline */
};
function clearCache(type) {
type._fieldsById = type._fieldsArray = type._oneofsArray = null;
delete type.encode;
delete type.decode;
delete type.verify;
return type;
}
/**
* Message type descriptor.
* @interface IType
* @extends INamespace
* @property {Object.<string,IOneOf>} [oneofs] Oneof descriptors
* @property {Object.<string,IField>} fields Field descriptors
* @property {number[][]} [extensions] Extension ranges
* @property {number[][]} [reserved] Reserved ranges
* @property {boolean} [group=false] Whether a legacy group or not
*/
/**
* Creates a message type from a message type descriptor.
* @param {string} name Message name
* @param {IType} json Message type descriptor
* @returns {Type} Created message type
*/
Type.fromJSON = function fromJSON(name, json) {
var type = new Type(name, json.options);
type.extensions = json.extensions;
type.reserved = json.reserved;
var names = Object.keys(json.fields),
i = 0;
for (; i < names.length; ++i) type.add((typeof json.fields[names[i]].keyType !== "undefined" ? MapField.fromJSON : Field.fromJSON)(names[i], json.fields[names[i]]));
if (json.oneofs) for (names = Object.keys(json.oneofs), i = 0; i < names.length; ++i) type.add(OneOf.fromJSON(names[i], json.oneofs[names[i]]));
if (json.nested) for (names = Object.keys(json.nested), i = 0; i < names.length; ++i) {
var nested = json.nested[names[i]];
type.add(
// most to least likely
(nested.id !== undefined ? Field.fromJSON : nested.fields !== undefined ? Type.fromJSON : nested.values !== undefined ? Enum.fromJSON : nested.methods !== undefined ? Service.fromJSON : Namespace.fromJSON)(names[i], nested));
}
if (json.extensions && json.extensions.length) type.extensions = json.extensions;
if (json.reserved && json.reserved.length) type.reserved = json.reserved;
if (json.group) type.group = true;
if (json.comment) type.comment = json.comment;
return type;
};
/**
* Converts this message type to a message type descriptor.
* @param {IToJSONOptions} [toJSONOptions] JSON conversion options
* @returns {IType} Message type descriptor
*/
Type.prototype.toJSON = function toJSON(toJSONOptions) {
var inherited = Namespace.prototype.toJSON.call(this, toJSONOptions);
var keepComments = toJSONOptions ? Boolean(toJSONOptions.keepComments) : false;
return util.toObject(["options", inherited && inherited.options || undefined, "oneofs", Namespace.arrayToJSON(this.oneofsArray, toJSONOptions), "fields", Namespace.arrayToJSON(this.fieldsArray.filter(function (obj) {
return !obj.declaringField;
}), toJSONOptions) || {}, "extensions", this.extensions && this.extensions.length ? this.extensions : undefined, "reserved", this.reserved && this.reserved.length ? this.reserved : undefined, "group", this.group || undefined, "nested", inherited && inherited.nested || undefined, "comment", keepComments ? this.comment : undefined]);
};
/**
* @override
*/
Type.prototype.resolveAll = function resolveAll() {
var fields = this.fieldsArray,
i = 0;
while (i < fields.length) fields[i++].resolve();
var oneofs = this.oneofsArray;
i = 0;
while (i < oneofs.length) oneofs[i++].resolve();
return Namespace.prototype.resolveAll.call(this);
};
/**
* @override
*/
Type.prototype.get = function get(name) {
return this.fields[name] || this.oneofs && this.oneofs[name] || this.nested && this.nested[name] || null;
};
/**
* Adds a nested object to this type.
* @param {ReflectionObject} object Nested object to add
* @returns {Type} `this`
* @throws {TypeError} If arguments are invalid
* @throws {Error} If there is already a nested object with this name or, if a field, when there is already a field with this id
*/
Type.prototype.add = function add(object) {
if (this.get(object.name)) throw Error("duplicate name '" + object.name + "' in " + this);
if (object instanceof Field && object.extend === undefined) {
// NOTE: Extension fields aren't actual fields on the declaring type, but nested objects.
// The root object takes care of adding distinct sister-fields to the respective extended
// type instead.
// avoids calling the getter if not absolutely necessary because it's called quite frequently
if (this._fieldsById ? /* istanbul ignore next */this._fieldsById[object.id] : this.fieldsById[object.id]) throw Error("duplicate id " + object.id + " in " + this);
if (this.isReservedId(object.id)) throw Error("id " + object.id + " is reserved in " + this);
if (this.isReservedName(object.name)) throw Error("name '" + object.name + "' is reserved in " + this);
if (object.parent) object.parent.remove(object);
this.fields[object.name] = object;
object.message = this;
object.onAdd(this);
return clearCache(this);
}
if (object instanceof OneOf) {
if (!this.oneofs) this.oneofs = {};
this.oneofs[object.name] = object;
object.onAdd(this);
return clearCache(this);
}
return Namespace.prototype.add.call(this, object);
};
/**
* Removes a nested object from this type.
* @param {ReflectionObject} object Nested object to remove
* @returns {Type} `this`
* @throws {TypeError} If arguments are invalid
* @throws {Error} If `object` is not a member of this type
*/
Type.prototype.remove = function remove(object) {
if (object instanceof Field && object.extend === undefined) {
// See Type#add for the reason why extension fields are excluded here.
/* istanbul ignore if */
if (!this.fields || this.fields[object.name] !== object) throw Error(object + " is not a member of " + this);
delete this.fields[object.name];
object.parent = null;
object.onRemove(this);
return clearCache(this);
}
if (object instanceof OneOf) {
/* istanbul ignore if */
if (!this.oneofs || this.oneofs[object.name] !== object) throw Error(object + " is not a member of " + this);
delete this.oneofs[object.name];
object.parent = null;
object.onRemove(this);
return clearCache(this);
}
return Namespace.prototype.remove.call(this, object);
};
/**
* Tests if the specified id is reserved.
* @param {number} id Id to test
* @returns {boolean} `true` if reserved, otherwise `false`
*/
Type.prototype.isReservedId = function isReservedId(id) {
return Namespace.isReservedId(this.reserved, id);
};
/**
* Tests if the specified name is reserved.
* @param {string} name Name to test
* @returns {boolean} `true` if reserved, otherwise `false`
*/
Type.prototype.isReservedName = function isReservedName(name) {
return Namespace.isReservedName(this.reserved, name);
};
/**
* Creates a new message of this type using the specified properties.
* @param {Object.<string,*>} [properties] Properties to set
* @returns {Message<{}>} Message instance
*/
Type.prototype.create = function create(properties) {
return new this.ctor(properties);
};
/**
* Sets up {@link Type#encode|encode}, {@link Type#decode|decode} and {@link Type#verify|verify}.
* @returns {Type} `this`
*/
Type.prototype.setup = function setup() {
// Sets up everything at once so that the prototype chain does not have to be re-evaluated
// multiple times (V8, soft-deopt prototype-check).
var fullName = this.fullName,
types = [];
for (var i = 0; i < /* initializes */this.fieldsArray.length; ++i) types.push(this._fieldsArray[i].resolve().resolvedType);
// Replace setup methods with type-specific generated functions
this.encode = encoder(this)({
Writer: Writer,
types: types,
util: util
});
this.decode = decoder(this)({
Reader: Reader,
types: types,
util: util
});
this.verify = verifier(this)({
types: types,
util: util
});
this.fromObject = converter.fromObject(this)({
types: types,
util: util
});
this.toObject = converter.toObject(this)({
types: types,
util: util
});
// Inject custom wrappers for common types
var wrapper = wrappers[fullName];
if (wrapper) {
var originalThis = Object.create(this);
// if (wrapper.fromObject) {
originalThis.fromObject = this.fromObject;
this.fromObject = wrapper.fromObject.bind(originalThis);
// }
// if (wrapper.toObject) {
originalThis.toObject = this.toObject;
this.toObject = wrapper.toObject.bind(originalThis);
// }
}
return this;
};
/**
* Encodes a message of this type. Does not implicitly {@link Type#verify|verify} messages.
* @param {Message<{}>|Object.<string,*>} message Message instance or plain object
* @param {Writer} [writer] Writer to encode to
* @returns {Writer} writer
*/
Type.prototype.encode = function encode_setup(message, writer) {
return this.setup().encode(message, writer); // overrides this method
};
/**
* Encodes a message of this type preceeded by its byte length as a varint. Does not implicitly {@link Type#verify|verify} messages.
* @param {Message<{}>|Object.<string,*>} message Message instance or plain object
* @param {Writer} [writer] Writer to encode to
* @returns {Writer} writer
*/
Type.prototype.encodeDelimited = function encodeDelimited(message, writer) {
return this.encode(message, writer && writer.len ? writer.fork() : writer).ldelim();
};
/**
* Decodes a message of this type.
* @param {Reader|Uint8Array} reader Reader or buffer to decode from
* @param {number} [length] Length of the message, if known beforehand
* @returns {Message<{}>} Decoded message
* @throws {Error} If the payload is not a reader or valid buffer
* @throws {util.ProtocolError<{}>} If required fields are missing
*/
Type.prototype.decode = function decode_setup(reader, length) {
return this.setup().decode(reader, length); // overrides this method
};
/**
* Decodes a message of this type preceeded by its byte length as a varint.
* @param {Reader|Uint8Array} reader Reader or buffer to decode from
* @returns {Message<{}>} Decoded message
* @throws {Error} If the payload is not a reader or valid buffer
* @throws {util.ProtocolError} If required fields are missing
*/
Type.prototype.decodeDelimited = function decodeDelimited(reader) {
if (!(reader instanceof Reader)) reader = Reader.create(reader);
return this.decode(reader, reader.uint32());
};
/**
* Verifies that field values are valid and that required fields are present.
* @param {Object.<string,*>} message Plain object to verify
* @returns {null|string} `null` if valid, otherwise the reason why it is not
*/
Type.prototype.verify = function verify_setup(message) {
return this.setup().verify(message); // overrides this method
};
/**
* Creates a new message of this type from a plain object. Also converts values to their respective internal types.
* @param {Object.<string,*>} object Plain object to convert
* @returns {Message<{}>} Message instance
*/
Type.prototype.fromObject = function fromObject(object) {
return this.setup().fromObject(object);
};
/**
* Conversion options as used by {@link Type#toObject} and {@link Message.toObject}.
* @interface IConversionOptions
* @property {Function} [longs] Long conversion type.
* Valid values are `String` and `Number` (the global types).
* Defaults to copy the present value, which is a possibly unsafe number without and a {@link Long} with a long library.
* @property {Function} [enums] Enum value conversion type.
* Only valid value is `String` (the global type).
* Defaults to copy the present value, which is the numeric id.
* @property {Function} [bytes] Bytes value conversion type.
* Valid values are `Array` and (a base64 encoded) `String` (the global types).
* Defaults to copy the present value, which usually is a Buffer under node and an Uint8Array in the browser.
* @property {boolean} [defaults=false] Also sets default values on the resulting object
* @property {boolean} [arrays=false] Sets empty arrays for missing repeated fields even if `defaults=false`
* @property {boolean} [objects=false] Sets empty objects for missing map fields even if `defaults=false`
* @property {boolean} [oneofs=false] Includes virtual oneof properties set to the present field's name, if any
* @property {boolean} [json=false] Performs additional JSON compatibility conversions, i.e. NaN and Infinity to strings
*/
/**
* Creates a plain object from a message of this type. Also converts values to other types if specified.
* @param {Message<{}>} message Message instance
* @param {IConversionOptions} [options] Conversion options
* @returns {Object.<string,*>} Plain object
*/
Type.prototype.toObject = function toObject(message, options) {
return this.setup().toObject(message, options);
};
/**
* Decorator function as returned by {@link Type.d} (TypeScript).
* @typedef TypeDecorator
* @type {function}
* @param {Constructor<T>} target Target constructor
* @returns {undefined}
* @template T extends Message<T>
*/
/**
* Type decorator (TypeScript).
* @param {string} [typeName] Type name, defaults to the constructor's name
* @returns {TypeDecorator<T>} Decorator function
* @template T extends Message<T>
*/
Type.d = function decorateType(typeName) {
return function typeDecorator(target) {
util.decorateType(target, typeName);
};
};
}, {
"12": 12,
"13": 13,
"14": 14,
"15": 15,
"16": 16,
"20": 20,
"21": 21,
"23": 23,
"25": 25,
"27": 27,
"33": 33,
"37": 37,
"40": 40,
"41": 41,
"42": 42
}],
36: [function (require, module, exports) {
/**
* Common type constants.
* @namespace
*/
var types = exports;
var util = require(37);
var s = ["double",
// 0
"float",
// 1
"int32",
// 2
"uint32",
// 3
"sint32",
// 4
"fixed32",
// 5
"sfixed32",
// 6
"int64",
// 7
"uint64",
// 8
"sint64",
// 9
"fixed64",
// 10
"sfixed64",
// 11
"bool",
// 12
"string",
// 13
"bytes" // 14
];
function bake(values, offset) {
var i = 0,
o = {};
offset |= 0;
while (i < values.length) o[s[i + offset]] = values[i++];
return o;
}
/**
* Basic type wire types.
* @type {Object.<string,number>}
* @const
* @property {number} double=1 Fixed64 wire type
* @property {number} float=5 Fixed32 wire type
* @property {number} int32=0 Varint wire type
* @property {number} uint32=0 Varint wire type
* @property {number} sint32=0 Varint wire type
* @property {number} fixed32=5 Fixed32 wire type
* @property {number} sfixed32=5 Fixed32 wire type
* @property {number} int64=0 Varint wire type
* @property {number} uint64=0 Varint wire type
* @property {number} sint64=0 Varint wire type
* @property {number} fixed64=1 Fixed64 wire type
* @property {number} sfixed64=1 Fixed64 wire type
* @property {number} bool=0 Varint wire type
* @property {number} string=2 Ldelim wire type
* @property {number} bytes=2 Ldelim wire type
*/
types.basic = bake([/* double */1, /* float */5, /* int32 */0, /* uint32 */0, /* sint32 */0, /* fixed32 */5, /* sfixed32 */5, /* int64 */0, /* uint64 */0, /* sint64 */0, /* fixed64 */1, /* sfixed64 */1, /* bool */0, /* string */2, /* bytes */2]);
/**
* Basic type defaults.
* @type {Object.<string,*>}
* @const
* @property {number} double=0 Double default
* @property {number} float=0 Float default
* @property {number} int32=0 Int32 default
* @property {number} uint32=0 Uint32 default
* @property {number} sint32=0 Sint32 default
* @property {number} fixed32=0 Fixed32 default
* @property {number} sfixed32=0 Sfixed32 default
* @property {number} int64=0 Int64 default
* @property {number} uint64=0 Uint64 default
* @property {number} sint64=0 Sint32 default
* @property {number} fixed64=0 Fixed64 default
* @property {number} sfixed64=0 Sfixed64 default
* @property {boolean} bool=false Bool default
* @property {string} string="" String default
* @property {Array.<number>} bytes=Array(0) Bytes default
* @property {null} message=null Message default
*/
types.defaults = bake([/* double */0, /* float */0, /* int32 */0, /* uint32 */0, /* sint32 */0, /* fixed32 */0, /* sfixed32 */0, /* int64 */0, /* uint64 */0, /* sint64 */0, /* fixed64 */0, /* sfixed64 */0, /* bool */false, /* string */"", /* bytes */util.emptyArray, /* message */null]);
/**
* Basic long type wire types.
* @type {Object.<string,number>}
* @const
* @property {number} int64=0 Varint wire type
* @property {number} uint64=0 Varint wire type
* @property {number} sint64=0 Varint wire type
* @property {number} fixed64=1 Fixed64 wire type
* @property {number} sfixed64=1 Fixed64 wire type
*/
types.long = bake([/* int64 */0, /* uint64 */0, /* sint64 */0, /* fixed64 */1, /* sfixed64 */1], 7);
/**
* Allowed types for map keys with their associated wire type.
* @type {Object.<string,number>}
* @const
* @property {number} int32=0 Varint wire type
* @property {number} uint32=0 Varint wire type
* @property {number} sint32=0 Varint wire type
* @property {number} fixed32=5 Fixed32 wire type
* @property {number} sfixed32=5 Fixed32 wire type
* @property {number} int64=0 Varint wire type
* @property {number} uint64=0 Varint wire type
* @property {number} sint64=0 Varint wire type
* @property {number} fixed64=1 Fixed64 wire type
* @property {number} sfixed64=1 Fixed64 wire type
* @property {number} bool=0 Varint wire type
* @property {number} string=2 Ldelim wire type
*/
types.mapKey = bake([/* int32 */0, /* uint32 */0, /* sint32 */0, /* fixed32 */5, /* sfixed32 */5, /* int64 */0, /* uint64 */0, /* sint64 */0, /* fixed64 */1, /* sfixed64 */1, /* bool */0, /* string */2], 2);
/**
* Allowed types for packed repeated fields with their associated wire type.
* @type {Object.<string,number>}
* @const
* @property {number} double=1 Fixed64 wire type
* @property {number} float=5 Fixed32 wire type
* @property {number} int32=0 Varint wire type
* @property {number} uint32=0 Varint wire type
* @property {number} sint32=0 Varint wire type
* @property {number} fixed32=5 Fixed32 wire type
* @property {number} sfixed32=5 Fixed32 wire type
* @property {number} int64=0 Varint wire type
* @property {number} uint64=0 Varint wire type
* @property {number} sint64=0 Varint wire type
* @property {number} fixed64=1 Fixed64 wire type
* @property {number} sfixed64=1 Fixed64 wire type
* @property {number} bool=0 Varint wire type
*/
types.packed = bake([/* double */1, /* float */5, /* int32 */0, /* uint32 */0, /* sint32 */0, /* fixed32 */5, /* sfixed32 */5, /* int64 */0, /* uint64 */0, /* sint64 */0, /* fixed64 */1, /* sfixed64 */1, /* bool */0]);
}, {
"37": 37
}],
37: [function (require, module, exports) {
/**
* Various utility functions.
* @namespace
*/
var util = module.exports = require(39);
var roots = require(30);
var Type,
// cyclic
Enum;
util.codegen = require(3);
util.fetch = require(5);
util.path = require(8);
/**
* Node's fs module if available.
* @type {Object.<string,*>}
*/
util.fs = util.inquire("fs");
/**
* Converts an object's values to an array.
* @param {Object.<string,*>} object Object to convert
* @returns {Array.<*>} Converted array
*/
util.toArray = function toArray(object) {
if (object) {
var keys = Object.keys(object),
array = new Array(keys.length),
index = 0;
while (index < keys.length) array[index] = object[keys[index++]];
return array;
}
return [];
};
/**
* Converts an array of keys immediately followed by their respective value to an object, omitting undefined values.
* @param {Array.<*>} array Array to convert
* @returns {Object.<string,*>} Converted object
*/
util.toObject = function toObject(array) {
var object = {},
index = 0;
while (index < array.length) {
var key = array[index++],
val = array[index++];
if (val !== undefined) object[key] = val;
}
return object;
};
var safePropBackslashRe = /\\/g,
safePropQuoteRe = /"/g;
/**
* Tests whether the specified name is a reserved word in JS.
* @param {string} name Name to test
* @returns {boolean} `true` if reserved, otherwise `false`
*/
util.isReserved = function isReserved(name) {
return /^(?:do|if|in|for|let|new|try|var|case|else|enum|eval|false|null|this|true|void|with|break|catch|class|const|super|throw|while|yield|delete|export|import|public|return|static|switch|typeof|default|extends|finally|package|private|continue|debugger|function|arguments|interface|protected|implements|instanceof)$/.test(name);
};
/**
* Returns a safe property accessor for the specified property name.
* @param {string} prop Property name
* @returns {string} Safe accessor
*/
util.safeProp = function safeProp(prop) {
if (!/^[$\w_]+$/.test(prop) || util.isReserved(prop)) return "[\"" + prop.replace(safePropBackslashRe, "\\\\").replace(safePropQuoteRe, "\\\"") + "\"]";
return "." + prop;
};
/**
* Converts the first character of a string to upper case.
* @param {string} str String to convert
* @returns {string} Converted string
*/
util.ucFirst = function ucFirst(str) {
return str.charAt(0).toUpperCase() + str.substring(1);
};
var camelCaseRe = /_([a-z])/g;
/**
* Converts a string to camel case.
* @param {string} str String to convert
* @returns {string} Converted string
*/
util.camelCase = function camelCase(str) {
return str.substring(0, 1) + str.substring(1).replace(camelCaseRe, function ($0, $1) {
return $1.toUpperCase();
});
};
/**
* Compares reflected fields by id.
* @param {Field} a First field
* @param {Field} b Second field
* @returns {number} Comparison value
*/
util.compareFieldsById = function compareFieldsById(a, b) {
return a.id - b.id;
};
/**
* Decorator helper for types (TypeScript).
* @param {Constructor<T>} ctor Constructor function
* @param {string} [typeName] Type name, defaults to the constructor's name
* @returns {Type} Reflected type
* @template T extends Message<T>
* @property {Root} root Decorators root
*/
util.decorateType = function decorateType(ctor, typeName) {
/* istanbul ignore if */
if (ctor.$type) {
if (typeName && ctor.$type.name !== typeName) {
util.decorateRoot.remove(ctor.$type);
ctor.$type.name = typeName;
util.decorateRoot.add(ctor.$type);
}
return ctor.$type;
}
/* istanbul ignore next */
if (!Type) Type = require(35);
var type = new Type(typeName || ctor.name);
util.decorateRoot.add(type);
type.ctor = ctor; // sets up .encode, .decode etc.
Object.defineProperty(ctor, "$type", {
value: type,
enumerable: false
});
Object.defineProperty(ctor.prototype, "$type", {
value: type,
enumerable: false
});
return type;
};
var decorateEnumIndex = 0;
/**
* Decorator helper for enums (TypeScript).
* @param {Object} object Enum object
* @returns {Enum} Reflected enum
*/
util.decorateEnum = function decorateEnum(object) {
/* istanbul ignore if */
if (object.$type) return object.$type;
/* istanbul ignore next */
if (!Enum) Enum = require(15);
var enm = new Enum("Enum" + decorateEnumIndex++, object);
util.decorateRoot.add(enm);
Object.defineProperty(object, "$type", {
value: enm,
enumerable: false
});
return enm;
};
/**
* Decorator root (TypeScript).
* @name util.decorateRoot
* @type {Root}
* @readonly
*/
Object.defineProperty(util, "decorateRoot", {
get: function () {
return roots["decorated"] || (roots["decorated"] = new (require(29))());
}
});
}, {
"15": 15,
"29": 29,
"3": 3,
"30": 30,
"35": 35,
"39": 39,
"5": 5,
"8": 8
}],
38: [function (require, module, exports) {
module.exports = LongBits;
var util = require(39);
/**
* Constructs new long bits.
* @classdesc Helper class for working with the low and high bits of a 64 bit value.
* @memberof util
* @constructor
* @param {number} lo Low 32 bits, unsigned
* @param {number} hi High 32 bits, unsigned
*/
function LongBits(lo, hi) {
// note that the casts below are theoretically unnecessary as of today, but older statically
// generated converter code might still call the ctor with signed 32bits. kept for compat.
/**
* Low bits.
* @type {number}
*/
this.lo = lo >>> 0;
/**
* High bits.
* @type {number}
*/
this.hi = hi >>> 0;
}
/**
* Zero bits.
* @memberof util.LongBits
* @type {util.LongBits}
*/
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;
};
/**
* Zero hash.
* @memberof util.LongBits
* @type {string}
*/
var zeroHash = LongBits.zeroHash = "\0\0\0\0\0\0\0\0";
/**
* Constructs new long bits from the specified number.
* @param {number} value Value
* @returns {util.LongBits} Instance
*/
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);
};
/**
* Constructs new long bits from a number, long or string.
* @param {Long|number|string} value Value
* @returns {util.LongBits} Instance
*/
LongBits.from = function from(value) {
if (typeof value === "number") return LongBits.fromNumber(value);
if (util.isString(value)) {
/* istanbul ignore else */
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;
};
/**
* Converts this long bits to a possibly unsafe JavaScript number.
* @param {boolean} [unsigned=false] Whether unsigned or not
* @returns {number} Possibly unsafe number
*/
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;
};
/**
* Converts this long bits to a long.
* @param {boolean} [unsigned=false] Whether unsigned or not
* @returns {Long} Long
*/
LongBits.prototype.toLong = function toLong(unsigned) {
return util.Long ? new util.Long(this.lo | 0, this.hi | 0, Boolean(unsigned))
/* istanbul ignore next */ : {
low: this.lo | 0,
high: this.hi | 0,
unsigned: Boolean(unsigned)
};
};
var charCodeAt = String.prototype.charCodeAt;
/**
* Constructs new long bits from the specified 8 characters long hash.
* @param {string} hash Hash
* @returns {util.LongBits} Bits
*/
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);
};
/**
* Converts this long bits to a 8 characters long hash.
* @returns {string} Hash
*/
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);
};
/**
* Zig-zag encodes this long bits.
* @returns {util.LongBits} `this`
*/
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;
};
/**
* Zig-zag decodes this long bits.
* @returns {util.LongBits} `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;
};
/**
* Calculates the length of this longbits when encoded as a varint.
* @returns {number} Length
*/
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;
};
}, {
"39": 39
}],
39: [function (require, module, exports) {
var util = exports;
// used to return a Promise where callback is omitted
util.asPromise = require(1);
// converts to / from base64 encoded strings
util.base64 = require(2);
// base class of rpc.Service
util.EventEmitter = require(4);
// float handling accross browsers
util.float = require(6);
// requires modules optionally and hides the call from bundlers
util.inquire = require(7);
// converts to / from utf8 encoded strings
util.utf8 = require(10);
// provides a node-like buffer pool in the browser
util.pool = require(9);
// utility to work with the low and high bits of a 64 bit value
util.LongBits = require(38);
/**
* An immuable empty array.
* @memberof util
* @type {Array.<*>}
* @const
*/
util.emptyArray = Object.freeze ? Object.freeze([]) : /* istanbul ignore next */[]; // used on prototypes
/**
* An immutable empty object.
* @type {Object}
* @const
*/
util.emptyObject = Object.freeze ? Object.freeze({}) : /* istanbul ignore next */{}; // used on prototypes
/**
* Whether running within node or not.
* @memberof util
* @type {boolean}
* @const
*/
util.isNode = Boolean(global.process && global.process.versions && global.process.versions.node);
/**
* Tests if the specified value is an integer.
* @function
* @param {*} value Value to test
* @returns {boolean} `true` if the value is an integer
*/
util.isInteger = Number.isInteger || /* istanbul ignore next */function isInteger(value) {
return typeof value === "number" && isFinite(value) && Math.floor(value) === value;
};
/**
* Tests if the specified value is a string.
* @param {*} value Value to test
* @returns {boolean} `true` if the value is a string
*/
util.isString = function isString(value) {
return typeof value === "string" || value instanceof String;
};
/**
* Tests if the specified value is a non-null object.
* @param {*} value Value to test
* @returns {boolean} `true` if the value is a non-null object
*/
util.isObject = function isObject(value) {
return value && typeof value === "object";
};
/**
* Checks if a property on a message is considered to be present.
* This is an alias of {@link util.isSet}.
* @function
* @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 =
/**
* 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 isSet(obj, prop) {
var value = obj[prop];
if (value != null && obj.hasOwnProperty(prop))
// eslint-disable-line eqeqeq, no-prototype-builtins
return typeof value !== "object" || (Array.isArray(value) ? value.length : Object.keys(value).length) > 0;
return false;
};
/**
* Any compatible Buffer instance.
* This is a minimal stand-alone definition of a Buffer instance. The actual type is that exported by node's typings.
* @interface Buffer
* @extends Uint8Array
*/
/**
* Node's Buffer class if available.
* @type {Constructor<Buffer>}
*/
util.Buffer = function () {
try {
var Buffer = util.inquire("buffer").Buffer;
// refuse to use non-node buffers if not explicitly assigned (perf reasons):
return Buffer.prototype.utf8Write ? Buffer : /* istanbul ignore next */null;
} catch (e) {
/* istanbul ignore next */
return null;
}
}();
// Internal alias of or polyfull for Buffer.from.
util._Buffer_from = null;
// Internal alias of or polyfill for Buffer.allocUnsafe.
util._Buffer_allocUnsafe = null;
/**
* Creates a new buffer of whatever type supported by the environment.
* @param {number|number[]} [sizeOrArray=0] Buffer size or number array
* @returns {Uint8Array|Buffer} Buffer
*/
util.newBuffer = function newBuffer(sizeOrArray) {
/* istanbul ignore next */
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);
};
/**
* Array implementation used in the browser. `Uint8Array` if supported, otherwise `Array`.
* @type {Constructor<Uint8Array>}
*/
util.Array = typeof Uint8Array !== "undefined" ? Uint8Array /* istanbul ignore next */ : Array;
/**
* Any compatible Long instance.
* This is a minimal stand-alone definition of a Long instance. The actual type is that exported by long.js.
* @interface Long
* @property {number} low Low bits
* @property {number} high High bits
* @property {boolean} unsigned Whether unsigned or not
*/
/**
* Long.js's Long class if available.
* @type {Constructor<Long>}
*/
util.Long = /* istanbul ignore next */global.dcodeIO && /* istanbul ignore next */global.dcodeIO.Long || util.inquire("long");
/**
* Regular expression used to verify 2 bit (`bool`) map keys.
* @type {RegExp}
* @const
*/
util.key2Re = /^true|false|0|1$/;
/**
* Regular expression used to verify 32 bit (`int32` etc.) map keys.
* @type {RegExp}
* @const
*/
util.key32Re = /^-?(?:0|[1-9][0-9]*)$/;
/**
* Regular expression used to verify 64 bit (`int64` etc.) map keys.
* @type {RegExp}
* @const
*/
util.key64Re = /^(?:[\\x00-\\xff]{8}|-?(?:0|[1-9][0-9]*))$/;
/**
* Converts a number or long to an 8 characters long hash string.
* @param {Long|number} value Value to convert
* @returns {string} Hash
*/
util.longToHash = function longToHash(value) {
return value ? util.LongBits.from(value).toHash() : util.LongBits.zeroHash;
};
/**
* Converts an 8 characters long hash string to a long or number.
* @param {string} hash Hash
* @param {boolean} [unsigned=false] Whether unsigned or not
* @returns {Long|number} Original value
*/
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));
};
/**
* Merges the properties of the source object into the destination object.
* @memberof util
* @param {Object.<string,*>} dst Destination object
* @param {Object.<string,*>} src Source object
* @param {boolean} [ifNotSet=false] Merges only if the key is not already set
* @returns {Object.<string,*>} Destination object
*/
function merge(dst, src, ifNotSet) {
// used by converters
for (var keys = Object.keys(src), i = 0; i < keys.length; ++i) if (dst[keys[i]] === undefined || !ifNotSet) dst[keys[i]] = src[keys[i]];
return dst;
}
util.merge = merge;
/**
* Converts the first character of a string to lower case.
* @param {string} str String to convert
* @returns {string} Converted string
*/
util.lcFirst = function lcFirst(str) {
return str.charAt(0).toLowerCase() + str.substring(1);
};
/**
* Creates a custom error constructor.
* @memberof util
* @param {string} name Error name
* @returns {Constructor<Error>} Custom error constructor
*/
function newError(name) {
function CustomError(message, properties) {
if (!(this instanceof CustomError)) return new CustomError(message, properties);
// Error.call(this, message);
// ^ just returns a new error instance because the ctor can be called as a function
Object.defineProperty(this, "message", {
get: function () {
return message;
}
});
/* istanbul ignore next */
if (Error.captureStackTrace)
// node
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;
/**
* Constructs a new protocol error.
* @classdesc Error subclass indicating a protocol specifc error.
* @memberof util
* @extends Error
* @template T extends Message<T>
* @constructor
* @param {string} message Error message
* @param {Object.<string,*>} [properties] Additional properties
* @example
* try {
* MyMessage.decode(someBuffer); // throws if required fields are missing
* } catch (e) {
* if (e instanceof ProtocolError && e.instance)
* console.log("decoded so far: " + JSON.stringify(e.instance));
* }
*/
util.ProtocolError = newError("ProtocolError");
/**
* So far decoded message instance.
* @name util.ProtocolError#instance
* @type {Message<T>}
*/
/**
* A OneOf getter as returned by {@link util.oneOfGetter}.
* @typedef OneOfGetter
* @type {function}
* @returns {string|undefined} Set field name, if any
*/
/**
* Builds a getter for a oneof's present field name.
* @param {string[]} fieldNames Field names
* @returns {OneOfGetter} Unbound getter
*/
util.oneOfGetter = function getOneOf(fieldNames) {
var fieldMap = {};
for (var i = 0; i < fieldNames.length; ++i) fieldMap[fieldNames[i]] = 1;
/**
* @returns {string|undefined} Set field name, if any
* @this Object
* @ignore
*/
return function () {
// eslint-disable-line consistent-return
for (var keys = Object.keys(this), i = keys.length - 1; i > -1; --i) if (fieldMap[keys[i]] === 1 && this[keys[i]] !== undefined && this[keys[i]] !== null) return keys[i];
};
};
/**
* A OneOf setter as returned by {@link util.oneOfSetter}.
* @typedef OneOfSetter
* @type {function}
* @param {string|undefined} value Field name
* @returns {undefined}
*/
/**
* Builds a setter for a oneof's present field name.
* @param {string[]} fieldNames Field names
* @returns {OneOfSetter} Unbound setter
*/
util.oneOfSetter = function setOneOf(fieldNames) {
/**
* @param {string} name Field name
* @returns {undefined}
* @this Object
* @ignore
*/
return function (name) {
for (var i = 0; i < fieldNames.length; ++i) if (fieldNames[i] !== name) delete this[fieldNames[i]];
};
};
/**
* Default conversion options used for {@link Message#toJSON} implementations.
*
* These options are close to proto3's JSON mapping with the exception that internal types like Any are handled just like messages. More precisely:
*
* - Longs become strings
* - Enums become string keys
* - Bytes become base64 encoded strings
* - (Sub-)Messages become plain objects
* - Maps become plain objects with all string keys
* - Repeated fields become arrays
* - NaN and Infinity for float and double fields become strings
*
* @type {IConversionOptions}
* @see https://developers.google.com/protocol-buffers/docs/proto3?hl=en#json
*/
util.toJSONOptions = {
longs: String,
enums: String,
bytes: String,
json: true
};
util._configure = function () {
var Buffer = util.Buffer;
/* istanbul ignore if */
if (!Buffer) {
util._Buffer_from = util._Buffer_allocUnsafe = null;
return;
}
// because node 4.x buffers are incompatible & immutable
// see: https://github.com/dcodeIO/protobuf.js/pull/665
util._Buffer_from = Buffer.from !== Uint8Array.from && Buffer.from || /* istanbul ignore next */
function Buffer_from(value, encoding) {
return new Buffer(value, encoding);
};
util._Buffer_allocUnsafe = Buffer.allocUnsafe || /* istanbul ignore next */
function Buffer_allocUnsafe(size) {
return new Buffer(size);
};
};
}, {
"1": 1,
"10": 10,
"2": 2,
"38": 38,
"4": 4,
"6": 6,
"7": 7,
"9": 9
}],
40: [function (require, module, exports) {
module.exports = verifier;
var Enum = require(15),
util = require(37);
function invalid(field, expected) {
return field.name + ": " + expected + (field.repeated && expected !== "array" ? "[]" : field.map && expected !== "object" ? "{k:" + field.keyType + "}" : "") + " expected";
}
/**
* Generates a partial value verifier.
* @param {Codegen} gen Codegen instance
* @param {Field} field Reflected field
* @param {number} fieldIndex Field index
* @param {string} ref Variable reference
* @returns {Codegen} Codegen instance
* @ignore
*/
function genVerifyValue(gen, field, fieldIndex, ref) {
/* eslint-disable no-unexpected-multiline */
if (field.resolvedType) {
if (field.resolvedType instanceof Enum) {
gen("switch(%s){", ref)("default:")("return%j", invalid(field, "enum value"));
for (var keys = Object.keys(field.resolvedType.values), j = 0; j < keys.length; ++j) gen("case %i:", field.resolvedType.values[keys[j]]);
gen("break")("}");
} else {
gen("{")("var e=types[%i].verify(%s);", fieldIndex, ref)("if(e)")("return%j+e", field.name + ".")("}");
}
} else {
switch (field.type) {
case "int32":
case "uint32":
case "sint32":
case "fixed32":
case "sfixed32":
gen("if(!util.isInteger(%s))", ref)("return%j", invalid(field, "integer"));
break;
case "int64":
case "uint64":
case "sint64":
case "fixed64":
case "sfixed64":
gen("if(!util.isInteger(%s)&&!(%s&&util.isInteger(%s.low)&&util.isInteger(%s.high)))", ref, ref, ref, ref)("return%j", invalid(field, "integer|Long"));
break;
case "float":
case "double":
gen("if(typeof %s!==\"number\")", ref)("return%j", invalid(field, "number"));
break;
case "bool":
gen("if(typeof %s!==\"boolean\")", ref)("return%j", invalid(field, "boolean"));
break;
case "string":
gen("if(!util.isString(%s))", ref)("return%j", invalid(field, "string"));
break;
case "bytes":
gen("if(!(%s&&typeof %s.length===\"number\"||util.isString(%s)))", ref, ref, ref)("return%j", invalid(field, "buffer"));
break;
}
}
return gen;
/* eslint-enable no-unexpected-multiline */
}
/**
* Generates a partial key verifier.
* @param {Codegen} gen Codegen instance
* @param {Field} field Reflected field
* @param {string} ref Variable reference
* @returns {Codegen} Codegen instance
* @ignore
*/
function genVerifyKey(gen, field, ref) {
/* eslint-disable no-unexpected-multiline */
switch (field.keyType) {
case "int32":
case "uint32":
case "sint32":
case "fixed32":
case "sfixed32":
gen("if(!util.key32Re.test(%s))", ref)("return%j", invalid(field, "integer key"));
break;
case "int64":
case "uint64":
case "sint64":
case "fixed64":
case "sfixed64":
gen("if(!util.key64Re.test(%s))", ref) // see comment above: x is ok, d is not
("return%j", invalid(field, "integer|Long key"));
break;
case "bool":
gen("if(!util.key2Re.test(%s))", ref)("return%j", invalid(field, "boolean key"));
break;
}
return gen;
/* eslint-enable no-unexpected-multiline */
}
/**
* Generates a verifier specific to the specified message type.
* @param {Type} mtype Message type
* @returns {Codegen} Codegen instance
*/
function verifier(mtype) {
/* eslint-disable no-unexpected-multiline */
var gen = util.codegen(["m"], mtype.name + "$verify")("if(typeof m!==\"object\"||m===null)")("return%j", "object expected");
var oneofs = mtype.oneofsArray,
seenFirstField = {};
if (oneofs.length) gen("var p={}");
for (var i = 0; i < /* initializes */mtype.fieldsArray.length; ++i) {
var field = mtype._fieldsArray[i].resolve(),
ref = "m" + util.safeProp(field.name);
if (field.optional) gen("if(%s!=null&&m.hasOwnProperty(%j)){", ref, field.name); // !== undefined && !== null
// map fields
if (field.map) {
gen("if(!util.isObject(%s))", ref)("return%j", invalid(field, "object"))("var k=Object.keys(%s)", ref)("for(var i=0;i<k.length;++i){");
genVerifyKey(gen, field, "k[i]");
genVerifyValue(gen, field, i, ref + "[k[i]]")("}");
// repeated fields
} else if (field.repeated) {
gen("if(!Array.isArray(%s))", ref)("return%j", invalid(field, "array"))("for(var i=0;i<%s.length;++i){", ref);
genVerifyValue(gen, field, i, ref + "[i]")("}");
// required or present fields
} else {
if (field.partOf) {
var oneofProp = util.safeProp(field.partOf.name);
if (seenFirstField[field.partOf.name] === 1) gen("if(p%s===1)", oneofProp)("return%j", field.partOf.name + ": multiple values");
seenFirstField[field.partOf.name] = 1;
gen("p%s=1", oneofProp);
}
genVerifyValue(gen, field, i, ref);
}
if (field.optional) gen("}");
}
return gen("return null");
/* eslint-enable no-unexpected-multiline */
}
}, {
"15": 15,
"37": 37
}],
41: [function (require, module, exports) {
/**
* Wrappers for common types.
* @type {Object.<string,IWrapper>}
* @const
*/
var wrappers = exports;
var Message = require(21);
/**
* From object converter part of an {@link IWrapper}.
* @typedef WrapperFromObjectConverter
* @type {function}
* @param {Object.<string,*>} object Plain object
* @returns {Message<{}>} Message instance
* @this Type
*/
/**
* To object converter part of an {@link IWrapper}.
* @typedef WrapperToObjectConverter
* @type {function}
* @param {Message<{}>} message Message instance
* @param {IConversionOptions} [options] Conversion options
* @returns {Object.<string,*>} Plain object
* @this Type
*/
/**
* Common type wrapper part of {@link wrappers}.
* @interface IWrapper
* @property {WrapperFromObjectConverter} [fromObject] From object converter
* @property {WrapperToObjectConverter} [toObject] To object converter
*/
// Custom wrapper for Any
wrappers[".google.protobuf.Any"] = {
fromObject: function (object) {
// unwrap value type if mapped
if (object && object["@type"]) {
var type = this.lookup(object["@type"]);
/* istanbul ignore else */
if (type) {
// type_url does not accept leading "."
var type_url = object["@type"].charAt(0) === "." ? object["@type"].substr(1) : object["@type"];
// type_url prefix is optional, but path seperator is required
return this.create({
type_url: "/" + type_url,
value: type.encode(type.fromObject(object)).finish()
});
}
}
return this.fromObject(object);
},
toObject: function (message, options) {
// decode value if requested and unmapped
if (options && options.json && message.type_url && message.value) {
// Only use fully qualified type name after the last '/'
var name = message.type_url.substring(message.type_url.lastIndexOf("/") + 1);
var type = this.lookup(name);
/* istanbul ignore else */
if (type) message = type.decode(message.value);
}
// wrap value if unmapped
if (!(message instanceof this.ctor) && message instanceof Message) {
var object = message.$type.toObject(message, options);
object["@type"] = message.$type.fullName;
return object;
}
return this.toObject(message, options);
}
};
}, {
"21": 21
}],
42: [function (require, module, exports) {
module.exports = Writer;
var util = require(39);
var BufferWriter; // cyclic
var LongBits = util.LongBits,
base64 = util.base64,
utf8 = util.utf8;
/**
* Constructs a new writer operation instance.
* @classdesc Scheduled writer operation.
* @constructor
* @param {function(*, Uint8Array, number)} fn Function to call
* @param {number} len Value byte length
* @param {*} val Value to write
* @ignore
*/
function Op(fn, len, val) {
/**
* Function to call.
* @type {function(Uint8Array, number, *)}
*/
this.fn = fn;
/**
* Value byte length.
* @type {number}
*/
this.len = len;
/**
* Next operation.
* @type {Writer.Op|undefined}
*/
this.next = undefined;
/**
* Value to write.
* @type {*}
*/
this.val = val; // type varies
}
/* istanbul ignore next */
function noop() {} // eslint-disable-line no-empty-function
/**
* Constructs a new writer state instance.
* @classdesc Copied writer state.
* @memberof Writer
* @constructor
* @param {Writer} writer Writer to copy state from
* @ignore
*/
function State(writer) {
/**
* Current head.
* @type {Writer.Op}
*/
this.head = writer.head;
/**
* Current tail.
* @type {Writer.Op}
*/
this.tail = writer.tail;
/**
* Current buffer length.
* @type {number}
*/
this.len = writer.len;
/**
* Next state.
* @type {State|null}
*/
this.next = writer.states;
}
/**
* Constructs a new writer instance.
* @classdesc Wire format writer using `Uint8Array` if available, otherwise `Array`.
* @constructor
*/
function Writer() {
/**
* Current length.
* @type {number}
*/
this.len = 0;
/**
* Operations head.
* @type {Object}
*/
this.head = new Op(noop, 0, 0);
/**
* Operations tail
* @type {Object}
*/
this.tail = this.head;
/**
* Linked forked states.
* @type {Object|null}
*/
this.states = null;
// When a value is written, the writer calculates its byte length and puts it into a linked
// list of operations to perform when finish() is called. This both allows us to allocate
// buffers of the exact required size and reduces the amount of work we have to do compared
// to first calculating over objects and then encoding over objects. In our case, the encoding
// part is just a linked list walk calling operations with already prepared values.
}
/**
* Creates a new writer.
* @function
* @returns {BufferWriter|Writer} A {@link BufferWriter} when Buffers are supported, otherwise a {@link Writer}
*/
Writer.create = util.Buffer ? function create_buffer_setup() {
return (Writer.create = function create_buffer() {
return new BufferWriter();
})();
}
/* istanbul ignore next */ : function create_array() {
return new Writer();
};
/**
* Allocates a buffer of the specified size.
* @param {number} size Buffer size
* @returns {Uint8Array} Buffer
*/
Writer.alloc = function alloc(size) {
return new util.Array(size);
};
// Use Uint8Array buffer pool in the browser, just like node does with buffers
/* istanbul ignore else */
if (util.Array !== Array) Writer.alloc = util.pool(Writer.alloc, util.Array.prototype.subarray);
/**
* Pushes a new operation to the queue.
* @param {function(Uint8Array, number, *)} fn Function to call
* @param {number} len Value byte length
* @param {number} val Value to write
* @returns {Writer} `this`
* @private
*/
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;
}
/**
* Constructs a new varint writer operation instance.
* @classdesc Scheduled varint writer operation.
* @extends Op
* @constructor
* @param {number} len Value byte length
* @param {number} val Value to write
* @ignore
*/
function VarintOp(len, val) {
this.len = len;
this.next = undefined;
this.val = val;
}
VarintOp.prototype = Object.create(Op.prototype);
VarintOp.prototype.fn = writeVarint32;
/**
* Writes an unsigned 32 bit value as a varint.
* @param {number} value Value to write
* @returns {Writer} `this`
*/
Writer.prototype.uint32 = function write_uint32(value) {
// here, the call to this.push has been inlined and a varint specific Op subclass is used.
// uint32 is by far the most frequently used operation and benefits significantly from this.
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;
};
/**
* Writes a signed 32 bit value as a varint.
* @function
* @param {number} value Value to write
* @returns {Writer} `this`
*/
Writer.prototype.int32 = function write_int32(value) {
return value < 0 ? this._push(writeVarint64, 10, LongBits.fromNumber(value)) // 10 bytes per spec
: this.uint32(value);
};
/**
* Writes a 32 bit value as a varint, zig-zag encoded.
* @param {number} value Value to write
* @returns {Writer} `this`
*/
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;
}
/**
* Writes an unsigned 64 bit value as a varint.
* @param {Long|number|string} value Value to write
* @returns {Writer} `this`
* @throws {TypeError} If `value` is a string and no long library is present.
*/
Writer.prototype.uint64 = function write_uint64(value) {
var bits = LongBits.from(value);
return this._push(writeVarint64, bits.length(), bits);
};
/**
* Writes a signed 64 bit value as a varint.
* @function
* @param {Long|number|string} value Value to write
* @returns {Writer} `this`
* @throws {TypeError} If `value` is a string and no long library is present.
*/
Writer.prototype.int64 = Writer.prototype.uint64;
/**
* Writes a signed 64 bit value as a varint, zig-zag encoded.
* @param {Long|number|string} value Value to write
* @returns {Writer} `this`
* @throws {TypeError} If `value` is a string and no long library is present.
*/
Writer.prototype.sint64 = function write_sint64(value) {
var bits = LongBits.from(value).zzEncode();
return this._push(writeVarint64, bits.length(), bits);
};
/**
* Writes a boolish value as a varint.
* @param {boolean} value Value to write
* @returns {Writer} `this`
*/
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;
}
/**
* Writes an unsigned 32 bit value as fixed 32 bits.
* @param {number} value Value to write
* @returns {Writer} `this`
*/
Writer.prototype.fixed32 = function write_fixed32(value) {
return this._push(writeFixed32, 4, value >>> 0);
};
/**
* Writes a signed 32 bit value as fixed 32 bits.
* @function
* @param {number} value Value to write
* @returns {Writer} `this`
*/
Writer.prototype.sfixed32 = Writer.prototype.fixed32;
/**
* Writes an unsigned 64 bit value as fixed 64 bits.
* @param {Long|number|string} value Value to write
* @returns {Writer} `this`
* @throws {TypeError} If `value` is a string and no long library is present.
*/
Writer.prototype.fixed64 = function write_fixed64(value) {
var bits = LongBits.from(value);
return this._push(writeFixed32, 4, bits.lo)._push(writeFixed32, 4, bits.hi);
};
/**
* Writes a signed 64 bit value as fixed 64 bits.
* @function
* @param {Long|number|string} value Value to write
* @returns {Writer} `this`
* @throws {TypeError} If `value` is a string and no long library is present.
*/
Writer.prototype.sfixed64 = Writer.prototype.fixed64;
/**
* Writes a float (32 bit).
* @function
* @param {number} value Value to write
* @returns {Writer} `this`
*/
Writer.prototype.float = function write_float(value) {
return this._push(util.float.writeFloatLE, 4, value);
};
/**
* Writes a double (64 bit float).
* @function
* @param {number} value Value to write
* @returns {Writer} `this`
*/
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); // also works for plain array values
}
/* istanbul ignore next */ : function writeBytes_for(val, buf, pos) {
for (var i = 0; i < val.length; ++i) buf[pos + i] = val[i];
};
/**
* Writes a sequence of bytes.
* @param {Uint8Array|string} value Buffer or base64 encoded string to write
* @returns {Writer} `this`
*/
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);
};
/**
* Writes a string.
* @param {string} value Value to write
* @returns {Writer} `this`
*/
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);
};
/**
* Forks this writer's state by pushing it to a stack.
* Calling {@link Writer#reset|reset} or {@link Writer#ldelim|ldelim} resets the writer to the previous state.
* @returns {Writer} `this`
*/
Writer.prototype.fork = function fork() {
this.states = new State(this);
this.head = this.tail = new Op(noop, 0, 0);
this.len = 0;
return this;
};
/**
* Resets this instance to the last state.
* @returns {Writer} `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;
};
/**
* Resets to the last state and appends the fork state's current write length as a varint followed by its operations.
* @returns {Writer} `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; // skip noop
this.tail = tail;
this.len += len;
}
return this;
};
/**
* Finishes the write operation.
* @returns {Uint8Array} Finished buffer
*/
Writer.prototype.finish = function finish() {
var head = this.head.next,
// skip noop
buf = this.constructor.alloc(this.len),
pos = 0;
while (head) {
head.fn(head.val, buf, pos);
pos += head.len;
head = head.next;
}
// this.head = this.tail = null;
return buf;
};
Writer._configure = function (BufferWriter_) {
BufferWriter = BufferWriter_;
};
}, {
"39": 39
}],
43: [function (require, module, exports) {
module.exports = BufferWriter;
// extends Writer
var Writer = require(42);
(BufferWriter.prototype = Object.create(Writer.prototype)).constructor = BufferWriter;
var util = require(39);
var Buffer = util.Buffer;
/**
* Constructs a new buffer writer instance.
* @classdesc Wire format writer using node buffers.
* @extends Writer
* @constructor
*/
function BufferWriter() {
Writer.call(this);
}
/**
* Allocates a buffer of the specified size.
* @param {number} size Buffer size
* @returns {Buffer} Buffer
*/
BufferWriter.alloc = function alloc_buffer(size) {
return (BufferWriter.alloc = util._Buffer_allocUnsafe)(size);
};
var writeBytesBuffer = Buffer && Buffer.prototype instanceof Uint8Array && Buffer.prototype.set.name === "set" ? function writeBytesBuffer_set(val, buf, pos) {
buf.set(val, pos); // faster than copy (requires node >= 4 where Buffers extend Uint8Array and set is properly inherited)
// also works for plain array values
}
/* istanbul ignore next */ : function writeBytesBuffer_copy(val, buf, pos) {
if (val.copy)
// Buffer values
val.copy(buf, pos, 0, val.length);else for (var i = 0; i < val.length;)
// plain array values
buf[pos++] = val[i++];
};
/**
* @override
*/
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(writeBytesBuffer, len, value);
return this;
};
function writeStringBuffer(val, buf, pos) {
if (val.length < 40)
// plain js is faster for short strings (probably due to redundant assertions)
util.utf8.write(val, buf, pos);else buf.utf8Write(val, pos);
}
/**
* @override
*/
BufferWriter.prototype.string = function write_string_buffer(value) {
var len = Buffer.byteLength(value);
this.uint32(len);
if (len) this._push(writeStringBuffer, len, value);
return this;
};
/**
* Finishes the write operation.
* @name BufferWriter#finish
* @function
* @returns {Buffer} Finished buffer
*/
}, {
"39": 39,
"42": 42
}]
}, {}, [19]);
})(typeof window === "object" && window || typeof self === "object" && self || undefined);
/*eslint-disable block-scoped-var, no-redeclare, no-control-regex, no-prototype-builtins*/
(function ($protobuf) {
// Common aliases
var $Reader = $protobuf.Reader,
$Writer = $protobuf.Writer,
$util = $protobuf.util;
// Exported root namespace
var $root = $protobuf.roots["push-server"] || ($protobuf.roots["push-server"] = {});
$root.RequestBatch = function () {
/**
* Properties of a RequestBatch.
* @exports IRequestBatch
* @interface IRequestBatch
* @property {Array.<Request>|null} [requests] RequestBatch requests
*/
/**
* Constructs a new RequestBatch.
* @exports RequestBatch
* @classdesc Represents a RequestBatch.
* @implements IRequestBatch
* @constructor
* @param {IRequestBatch=} [properties] Properties to set
*/
function RequestBatch(properties) {
this.requests = [];
if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
}
/**
* RequestBatch requests.
* @member {Array.<Request>} requests
* @memberof RequestBatch
* @instance
*/
RequestBatch.prototype.requests = $util.emptyArray;
/**
* Creates a new RequestBatch instance using the specified properties.
* @function create
* @memberof RequestBatch
* @static
* @param {IRequestBatch=} [properties] Properties to set
* @returns {RequestBatch} RequestBatch instance
*/
RequestBatch.create = function create(properties) {
return new RequestBatch(properties);
};
/**
* Encodes the specified RequestBatch message. Does not implicitly {@link RequestBatch.verify|verify} messages.
* @function encode
* @memberof RequestBatch
* @static
* @param {RequestBatch} message RequestBatch message or plain object to encode
* @param {$protobuf.Writer} [writer] Writer to encode to
* @returns {$protobuf.Writer} Writer
*/
RequestBatch.encode = function encode(message, writer) {
if (!writer) writer = $Writer.create();
if (message.requests != null && message.requests.length) for (var i = 0; i < message.requests.length; ++i) $root.Request.encode(message.requests[i], writer.uint32( /* id 1, wireType 2 =*/10).fork()).ldelim();
return writer;
};
/**
* Decodes a RequestBatch message from the specified reader or buffer.
* @function decode
* @memberof RequestBatch
* @static
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
* @param {number} [length] Message length if known beforehand
* @returns {RequestBatch} RequestBatch
* @throws {Error} If the payload is not a reader or valid buffer
* @throws {$protobuf.util.ProtocolError} If required fields are missing
*/
RequestBatch.decode = function decode(reader, length) {
if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
var end = length === undefined ? reader.len : reader.pos + length,
message = new $root.RequestBatch();
while (reader.pos < end) {
var tag = reader.uint32();
switch (tag >>> 3) {
case 1:
if (!(message.requests && message.requests.length)) message.requests = [];
message.requests.push($root.Request.decode(reader, reader.uint32()));
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
};
return RequestBatch;
}();
$root.Request = function () {
/**
* Properties of a Request.
* @exports IRequest
* @interface IRequest
* @property {IncomingMessagesRequest|null} [incomingMessages] Request incomingMessages
* @property {ChannelStatsRequest|null} [channelStats] Request channelStats
* @property {ServerStatsRequest|null} [serverStats] Request serverStats
*/
/**
* Constructs a new Request.
* @exports Request
* @classdesc Represents a Request.
* @implements IRequest
* @constructor
* @param {IRequest=} [properties] Properties to set
*/
function Request(properties) {
if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
}
/**
* Request incomingMessages.
* @member {IncomingMessagesRequest|null|undefined} incomingMessages
* @memberof Request
* @instance
*/
Request.prototype.incomingMessages = null;
/**
* Request channelStats.
* @member {ChannelStatsRequest|null|undefined} channelStats
* @memberof Request
* @instance
*/
Request.prototype.channelStats = null;
/**
* Request serverStats.
* @member {ServerStatsRequest|null|undefined} serverStats
* @memberof Request
* @instance
*/
Request.prototype.serverStats = null;
// OneOf field names bound to virtual getters and setters
var $oneOfFields;
/**
* Request command.
* @member {"incomingMessages"|"channelStats"|"serverStats"|undefined} command
* @memberof Request
* @instance
*/
Object.defineProperty(Request.prototype, "command", {
get: $util.oneOfGetter($oneOfFields = ["incomingMessages", "channelStats", "serverStats"]),
set: $util.oneOfSetter($oneOfFields)
});
/**
* Creates a new Request instance using the specified properties.
* @function create
* @memberof Request
* @static
* @param {IRequest=} [properties] Properties to set
* @returns {Request} Request instance
*/
Request.create = function create(properties) {
return new Request(properties);
};
/**
* Encodes the specified Request message. Does not implicitly {@link Request.verify|verify} messages.
* @function encode
* @memberof Request
* @static
* @param {Request} message Request message or plain object to encode
* @param {$protobuf.Writer} [writer] Writer to encode to
* @returns {$protobuf.Writer} Writer
*/
Request.encode = function encode(message, writer) {
if (!writer) writer = $Writer.create();
if (message.incomingMessages != null && message.hasOwnProperty("incomingMessages")) $root.IncomingMessagesRequest.encode(message.incomingMessages, writer.uint32( /* id 1, wireType 2 =*/10).fork()).ldelim();
if (message.channelStats != null && message.hasOwnProperty("channelStats")) $root.ChannelStatsRequest.encode(message.channelStats, writer.uint32( /* id 2, wireType 2 =*/18).fork()).ldelim();
if (message.serverStats != null && message.hasOwnProperty("serverStats")) $root.ServerStatsRequest.encode(message.serverStats, writer.uint32( /* id 3, wireType 2 =*/26).fork()).ldelim();
return writer;
};
/**
* Decodes a Request message from the specified reader or buffer.
* @function decode
* @memberof Request
* @static
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
* @param {number} [length] Message length if known beforehand
* @returns {Request} Request
* @throws {Error} If the payload is not a reader or valid buffer
* @throws {$protobuf.util.ProtocolError} If required fields are missing
*/
Request.decode = function decode(reader, length) {
if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
var end = length === undefined ? reader.len : reader.pos + length,
message = new $root.Request();
while (reader.pos < end) {
var tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.incomingMessages = $root.IncomingMessagesRequest.decode(reader, reader.uint32());
break;
case 2:
message.channelStats = $root.ChannelStatsRequest.decode(reader, reader.uint32());
break;
case 3:
message.serverStats = $root.ServerStatsRequest.decode(reader, reader.uint32());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
};
return Request;
}();
$root.IncomingMessagesRequest = function () {
/**
* Properties of an IncomingMessagesRequest.
* @exports IIncomingMessagesRequest
* @interface IIncomingMessagesRequest
* @property {Array.<IncomingMessage>|null} [messages] IncomingMessagesRequest messages
*/
/**
* Constructs a new IncomingMessagesRequest.
* @exports IncomingMessagesRequest
* @classdesc Represents an IncomingMessagesRequest.
* @implements IIncomingMessagesRequest
* @constructor
* @param {IIncomingMessagesRequest=} [properties] Properties to set
*/
function IncomingMessagesRequest(properties) {
this.messages = [];
if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
}
/**
* IncomingMessagesRequest messages.
* @member {Array.<IncomingMessage>} messages
* @memberof IncomingMessagesRequest
* @instance
*/
IncomingMessagesRequest.prototype.messages = $util.emptyArray;
/**
* Creates a new IncomingMessagesRequest instance using the specified properties.
* @function create
* @memberof IncomingMessagesRequest
* @static
* @param {IIncomingMessagesRequest=} [properties] Properties to set
* @returns {IncomingMessagesRequest} IncomingMessagesRequest instance
*/
IncomingMessagesRequest.create = function create(properties) {
return new IncomingMessagesRequest(properties);
};
/**
* Encodes the specified IncomingMessagesRequest message. Does not implicitly {@link IncomingMessagesRequest.verify|verify} messages.
* @function encode
* @memberof IncomingMessagesRequest
* @static
* @param {IncomingMessagesRequest} message IncomingMessagesRequest message or plain object to encode
* @param {$protobuf.Writer} [writer] Writer to encode to
* @returns {$protobuf.Writer} Writer
*/
IncomingMessagesRequest.encode = function encode(message, writer) {
if (!writer) writer = $Writer.create();
if (message.messages != null && message.messages.length) for (var i = 0; i < message.messages.length; ++i) $root.IncomingMessage.encode(message.messages[i], writer.uint32( /* id 1, wireType 2 =*/10).fork()).ldelim();
return writer;
};
/**
* Decodes an IncomingMessagesRequest message from the specified reader or buffer.
* @function decode
* @memberof IncomingMessagesRequest
* @static
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
* @param {number} [length] Message length if known beforehand
* @returns {IncomingMessagesRequest} IncomingMessagesRequest
* @throws {Error} If the payload is not a reader or valid buffer
* @throws {$protobuf.util.ProtocolError} If required fields are missing
*/
IncomingMessagesRequest.decode = function decode(reader, length) {
if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
var end = length === undefined ? reader.len : reader.pos + length,
message = new $root.IncomingMessagesRequest();
while (reader.pos < end) {
var tag = reader.uint32();
switch (tag >>> 3) {
case 1:
if (!(message.messages && message.messages.length)) message.messages = [];
message.messages.push($root.IncomingMessage.decode(reader, reader.uint32()));
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
};
return IncomingMessagesRequest;
}();
$root.IncomingMessage = function () {
/**
* Properties of an IncomingMessage.
* @exports IIncomingMessage
* @interface IIncomingMessage
* @property {Array.<Receiver>|null} [receivers] IncomingMessage receivers
* @property {Sender|null} [sender] IncomingMessage sender
* @property {string|null} [body] IncomingMessage body
* @property {number|null} [expiry] IncomingMessage expiry
* @property {string|null} [type] IncomingMessage type
*/
/**
* Constructs a new IncomingMessage.
* @exports IncomingMessage
* @classdesc Represents an IncomingMessage.
* @implements IIncomingMessage
* @constructor
* @param {IIncomingMessage=} [properties] Properties to set
*/
function IncomingMessage(properties) {
this.receivers = [];
if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
}
/**
* IncomingMessage receivers.
* @member {Array.<Receiver>} receivers
* @memberof IncomingMessage
* @instance
*/
IncomingMessage.prototype.receivers = $util.emptyArray;
/**
* IncomingMessage sender.
* @member {Sender|null|undefined} sender
* @memberof IncomingMessage
* @instance
*/
IncomingMessage.prototype.sender = null;
/**
* IncomingMessage body.
* @member {string} body
* @memberof IncomingMessage
* @instance
*/
IncomingMessage.prototype.body = "";
/**
* IncomingMessage expiry.
* @member {number} expiry
* @memberof IncomingMessage
* @instance
*/
IncomingMessage.prototype.expiry = 0;
/**
* IncomingMessage type.
* @member {string} type
* @memberof IncomingMessage
* @instance
*/
IncomingMessage.prototype.type = "";
/**
* Creates a new IncomingMessage instance using the specified properties.
* @function create
* @memberof IncomingMessage
* @static
* @param {IIncomingMessage=} [properties] Properties to set
* @returns {IncomingMessage} IncomingMessage instance
*/
IncomingMessage.create = function create(properties) {
return new IncomingMessage(properties);
};
/**
* Encodes the specified IncomingMessage message. Does not implicitly {@link IncomingMessage.verify|verify} messages.
* @function encode
* @memberof IncomingMessage
* @static
* @param {IncomingMessage} message IncomingMessage message or plain object to encode
* @param {$protobuf.Writer} [writer] Writer to encode to
* @returns {$protobuf.Writer} Writer
*/
IncomingMessage.encode = function encode(message, writer) {
if (!writer) writer = $Writer.create();
if (message.receivers != null && message.receivers.length) for (var i = 0; i < message.receivers.length; ++i) $root.Receiver.encode(message.receivers[i], writer.uint32( /* id 1, wireType 2 =*/10).fork()).ldelim();
if (message.sender != null && message.hasOwnProperty("sender")) $root.Sender.encode(message.sender, writer.uint32( /* id 2, wireType 2 =*/18).fork()).ldelim();
if (message.body != null && message.hasOwnProperty("body")) writer.uint32( /* id 3, wireType 2 =*/26).string(message.body);
if (message.expiry != null && message.hasOwnProperty("expiry")) writer.uint32( /* id 4, wireType 0 =*/32).uint32(message.expiry);
if (message.type != null && message.hasOwnProperty("type")) writer.uint32( /* id 5, wireType 2 =*/42).string(message.type);
return writer;
};
/**
* Decodes an IncomingMessage message from the specified reader or buffer.
* @function decode
* @memberof IncomingMessage
* @static
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
* @param {number} [length] Message length if known beforehand
* @returns {IncomingMessage} IncomingMessage
* @throws {Error} If the payload is not a reader or valid buffer
* @throws {$protobuf.util.ProtocolError} If required fields are missing
*/
IncomingMessage.decode = function decode(reader, length) {
if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
var end = length === undefined ? reader.len : reader.pos + length,
message = new $root.IncomingMessage();
while (reader.pos < end) {
var tag = reader.uint32();
switch (tag >>> 3) {
case 1:
if (!(message.receivers && message.receivers.length)) message.receivers = [];
message.receivers.push($root.Receiver.decode(reader, reader.uint32()));
break;
case 2:
message.sender = $root.Sender.decode(reader, reader.uint32());
break;
case 3:
message.body = reader.string();
break;
case 4:
message.expiry = reader.uint32();
break;
case 5:
message.type = reader.string();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
};
return IncomingMessage;
}();
$root.ChannelStatsRequest = function () {
/**
* Properties of a ChannelStatsRequest.
* @exports IChannelStatsRequest
* @interface IChannelStatsRequest
* @property {Array.<ChannelId>|null} [channels] ChannelStatsRequest channels
*/
/**
* Constructs a new ChannelStatsRequest.
* @exports ChannelStatsRequest
* @classdesc Represents a ChannelStatsRequest.
* @implements IChannelStatsRequest
* @constructor
* @param {IChannelStatsRequest=} [properties] Properties to set
*/
function ChannelStatsRequest(properties) {
this.channels = [];
if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
}
/**
* ChannelStatsRequest channels.
* @member {Array.<ChannelId>} channels
* @memberof ChannelStatsRequest
* @instance
*/
ChannelStatsRequest.prototype.channels = $util.emptyArray;
/**
* Creates a new ChannelStatsRequest instance using the specified properties.
* @function create
* @memberof ChannelStatsRequest
* @static
* @param {IChannelStatsRequest=} [properties] Properties to set
* @returns {ChannelStatsRequest} ChannelStatsRequest instance
*/
ChannelStatsRequest.create = function create(properties) {
return new ChannelStatsRequest(properties);
};
/**
* Encodes the specified ChannelStatsRequest message. Does not implicitly {@link ChannelStatsRequest.verify|verify} messages.
* @function encode
* @memberof ChannelStatsRequest
* @static
* @param {ChannelStatsRequest} message ChannelStatsRequest message or plain object to encode
* @param {$protobuf.Writer} [writer] Writer to encode to
* @returns {$protobuf.Writer} Writer
*/
ChannelStatsRequest.encode = function encode(message, writer) {
if (!writer) writer = $Writer.create();
if (message.channels != null && message.channels.length) for (var i = 0; i < message.channels.length; ++i) $root.ChannelId.encode(message.channels[i], writer.uint32( /* id 1, wireType 2 =*/10).fork()).ldelim();
return writer;
};
/**
* Decodes a ChannelStatsRequest message from the specified reader or buffer.
* @function decode
* @memberof ChannelStatsRequest
* @static
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
* @param {number} [length] Message length if known beforehand
* @returns {ChannelStatsRequest} ChannelStatsRequest
* @throws {Error} If the payload is not a reader or valid buffer
* @throws {$protobuf.util.ProtocolError} If required fields are missing
*/
ChannelStatsRequest.decode = function decode(reader, length) {
if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
var end = length === undefined ? reader.len : reader.pos + length,
message = new $root.ChannelStatsRequest();
while (reader.pos < end) {
var tag = reader.uint32();
switch (tag >>> 3) {
case 1:
if (!(message.channels && message.channels.length)) message.channels = [];
message.channels.push($root.ChannelId.decode(reader, reader.uint32()));
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
};
return ChannelStatsRequest;
}();
$root.ChannelId = function () {
/**
* Properties of a ChannelId.
* @exports IChannelId
* @interface IChannelId
* @property {Uint8Array|null} [id] ChannelId id
* @property {boolean|null} [isPrivate] ChannelId isPrivate
* @property {Uint8Array|null} [signature] ChannelId signature
*/
/**
* Constructs a new ChannelId.
* @exports ChannelId
* @classdesc Represents a ChannelId.
* @implements IChannelId
* @constructor
* @param {IChannelId=} [properties] Properties to set
*/
function ChannelId(properties) {
if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
}
/**
* ChannelId id.
* @member {Uint8Array} id
* @memberof ChannelId
* @instance
*/
ChannelId.prototype.id = $util.newBuffer([]);
/**
* ChannelId isPrivate.
* @member {boolean} isPrivate
* @memberof ChannelId
* @instance
*/
ChannelId.prototype.isPrivate = false;
/**
* ChannelId signature.
* @member {Uint8Array} signature
* @memberof ChannelId
* @instance
*/
ChannelId.prototype.signature = $util.newBuffer([]);
/**
* Creates a new ChannelId instance using the specified properties.
* @function create
* @memberof ChannelId
* @static
* @param {IChannelId=} [properties] Properties to set
* @returns {ChannelId} ChannelId instance
*/
ChannelId.create = function create(properties) {
return new ChannelId(properties);
};
/**
* Encodes the specified ChannelId message. Does not implicitly {@link ChannelId.verify|verify} messages.
* @function encode
* @memberof ChannelId
* @static
* @param {ChannelId} message ChannelId message or plain object to encode
* @param {$protobuf.Writer} [writer] Writer to encode to
* @returns {$protobuf.Writer} Writer
*/
ChannelId.encode = function encode(message, writer) {
if (!writer) writer = $Writer.create();
if (message.id != null && message.hasOwnProperty("id")) writer.uint32( /* id 1, wireType 2 =*/10).bytes(message.id);
if (message.isPrivate != null && message.hasOwnProperty("isPrivate")) writer.uint32( /* id 2, wireType 0 =*/16).bool(message.isPrivate);
if (message.signature != null && message.hasOwnProperty("signature")) writer.uint32( /* id 3, wireType 2 =*/26).bytes(message.signature);
return writer;
};
/**
* Decodes a ChannelId message from the specified reader or buffer.
* @function decode
* @memberof ChannelId
* @static
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
* @param {number} [length] Message length if known beforehand
* @returns {ChannelId} ChannelId
* @throws {Error} If the payload is not a reader or valid buffer
* @throws {$protobuf.util.ProtocolError} If required fields are missing
*/
ChannelId.decode = function decode(reader, length) {
if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
var end = length === undefined ? reader.len : reader.pos + length,
message = new $root.ChannelId();
while (reader.pos < end) {
var tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.id = reader.bytes();
break;
case 2:
message.isPrivate = reader.bool();
break;
case 3:
message.signature = reader.bytes();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
};
return ChannelId;
}();
$root.ServerStatsRequest = function () {
/**
* Properties of a ServerStatsRequest.
* @exports IServerStatsRequest
* @interface IServerStatsRequest
*/
/**
* Constructs a new ServerStatsRequest.
* @exports ServerStatsRequest
* @classdesc Represents a ServerStatsRequest.
* @implements IServerStatsRequest
* @constructor
* @param {IServerStatsRequest=} [properties] Properties to set
*/
function ServerStatsRequest(properties) {
if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
}
/**
* Creates a new ServerStatsRequest instance using the specified properties.
* @function create
* @memberof ServerStatsRequest
* @static
* @param {IServerStatsRequest=} [properties] Properties to set
* @returns {ServerStatsRequest} ServerStatsRequest instance
*/
ServerStatsRequest.create = function create(properties) {
return new ServerStatsRequest(properties);
};
/**
* Encodes the specified ServerStatsRequest message. Does not implicitly {@link ServerStatsRequest.verify|verify} messages.
* @function encode
* @memberof ServerStatsRequest
* @static
* @param {ServerStatsRequest} message ServerStatsRequest message or plain object to encode
* @param {$protobuf.Writer} [writer] Writer to encode to
* @returns {$protobuf.Writer} Writer
*/
ServerStatsRequest.encode = function encode(message, writer) {
if (!writer) writer = $Writer.create();
return writer;
};
/**
* Decodes a ServerStatsRequest message from the specified reader or buffer.
* @function decode
* @memberof ServerStatsRequest
* @static
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
* @param {number} [length] Message length if known beforehand
* @returns {ServerStatsRequest} ServerStatsRequest
* @throws {Error} If the payload is not a reader or valid buffer
* @throws {$protobuf.util.ProtocolError} If required fields are missing
*/
ServerStatsRequest.decode = function decode(reader, length) {
if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
var end = length === undefined ? reader.len : reader.pos + length,
message = new $root.ServerStatsRequest();
while (reader.pos < end) {
var tag = reader.uint32();
switch (tag >>> 3) {
default:
reader.skipType(tag & 7);
break;
}
}
return message;
};
return ServerStatsRequest;
}();
$root.Sender = function () {
/**
* Properties of a Sender.
* @exports ISender
* @interface ISender
* @property {SenderType|null} [type] Sender type
* @property {Uint8Array|null} [id] Sender id
*/
/**
* Constructs a new Sender.
* @exports Sender
* @classdesc Represents a Sender.
* @implements ISender
* @constructor
* @param {ISender=} [properties] Properties to set
*/
function Sender(properties) {
if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
}
/**
* Sender type.
* @member {SenderType} type
* @memberof Sender
* @instance
*/
Sender.prototype.type = 0;
/**
* Sender id.
* @member {Uint8Array} id
* @memberof Sender
* @instance
*/
Sender.prototype.id = $util.newBuffer([]);
/**
* Creates a new Sender instance using the specified properties.
* @function create
* @memberof Sender
* @static
* @param {ISender=} [properties] Properties to set
* @returns {Sender} Sender instance
*/
Sender.create = function create(properties) {
return new Sender(properties);
};
/**
* Encodes the specified Sender message. Does not implicitly {@link Sender.verify|verify} messages.
* @function encode
* @memberof Sender
* @static
* @param {Sender} message Sender message or plain object to encode
* @param {$protobuf.Writer} [writer] Writer to encode to
* @returns {$protobuf.Writer} Writer
*/
Sender.encode = function encode(message, writer) {
if (!writer) writer = $Writer.create();
if (message.type != null && message.hasOwnProperty("type")) writer.uint32( /* id 1, wireType 0 =*/8).int32(message.type);
if (message.id != null && message.hasOwnProperty("id")) writer.uint32( /* id 2, wireType 2 =*/18).bytes(message.id);
return writer;
};
/**
* Decodes a Sender message from the specified reader or buffer.
* @function decode
* @memberof Sender
* @static
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
* @param {number} [length] Message length if known beforehand
* @returns {Sender} Sender
* @throws {Error} If the payload is not a reader or valid buffer
* @throws {$protobuf.util.ProtocolError} If required fields are missing
*/
Sender.decode = function decode(reader, length) {
if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
var end = length === undefined ? reader.len : reader.pos + length,
message = new $root.Sender();
while (reader.pos < end) {
var tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.type = reader.int32();
break;
case 2:
message.id = reader.bytes();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
};
return Sender;
}();
/**
* SenderType enum.
* @exports SenderType
* @enum {string}
* @property {number} UNKNOWN=0 UNKNOWN value
* @property {number} CLIENT=1 CLIENT value
* @property {number} BACKEND=2 BACKEND value
*/
$root.SenderType = function () {
var valuesById = {},
values = Object.create(valuesById);
values[valuesById[0] = "UNKNOWN"] = 0;
values[valuesById[1] = "CLIENT"] = 1;
values[valuesById[2] = "BACKEND"] = 2;
return values;
}();
$root.Receiver = function () {
/**
* Properties of a Receiver.
* @exports IReceiver
* @interface IReceiver
* @property {Uint8Array|null} [id] Receiver id
* @property {boolean|null} [isPrivate] Receiver isPrivate
* @property {Uint8Array|null} [signature] Receiver signature
*/
/**
* Constructs a new Receiver.
* @exports Receiver
* @classdesc Represents a Receiver.
* @implements IReceiver
* @constructor
* @param {IReceiver=} [properties] Properties to set
*/
function Receiver(properties) {
if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
}
/**
* Receiver id.
* @member {Uint8Array} id
* @memberof Receiver
* @instance
*/
Receiver.prototype.id = $util.newBuffer([]);
/**
* Receiver isPrivate.
* @member {boolean} isPrivate
* @memberof Receiver
* @instance
*/
Receiver.prototype.isPrivate = false;
/**
* Receiver signature.
* @member {Uint8Array} signature
* @memberof Receiver
* @instance
*/
Receiver.prototype.signature = $util.newBuffer([]);
/**
* Creates a new Receiver instance using the specified properties.
* @function create
* @memberof Receiver
* @static
* @param {IReceiver=} [properties] Properties to set
* @returns {Receiver} Receiver instance
*/
Receiver.create = function create(properties) {
return new Receiver(properties);
};
/**
* Encodes the specified Receiver message. Does not implicitly {@link Receiver.verify|verify} messages.
* @function encode
* @memberof Receiver
* @static
* @param {Receiver} message Receiver message or plain object to encode
* @param {$protobuf.Writer} [writer] Writer to encode to
* @returns {$protobuf.Writer} Writer
*/
Receiver.encode = function encode(message, writer) {
if (!writer) writer = $Writer.create();
if (message.id != null && message.hasOwnProperty("id")) writer.uint32( /* id 1, wireType 2 =*/10).bytes(message.id);
if (message.isPrivate != null && message.hasOwnProperty("isPrivate")) writer.uint32( /* id 2, wireType 0 =*/16).bool(message.isPrivate);
if (message.signature != null && message.hasOwnProperty("signature")) writer.uint32( /* id 3, wireType 2 =*/26).bytes(message.signature);
return writer;
};
/**
* Decodes a Receiver message from the specified reader or buffer.
* @function decode
* @memberof Receiver
* @static
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
* @param {number} [length] Message length if known beforehand
* @returns {Receiver} Receiver
* @throws {Error} If the payload is not a reader or valid buffer
* @throws {$protobuf.util.ProtocolError} If required fields are missing
*/
Receiver.decode = function decode(reader, length) {
if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
var end = length === undefined ? reader.len : reader.pos + length,
message = new $root.Receiver();
while (reader.pos < end) {
var tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.id = reader.bytes();
break;
case 2:
message.isPrivate = reader.bool();
break;
case 3:
message.signature = reader.bytes();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
};
return Receiver;
}();
$root.ResponseBatch = function () {
/**
* Properties of a ResponseBatch.
* @exports IResponseBatch
* @interface IResponseBatch
* @property {Array.<Response>|null} [responses] ResponseBatch responses
*/
/**
* Constructs a new ResponseBatch.
* @exports ResponseBatch
* @classdesc Represents a ResponseBatch.
* @implements IResponseBatch
* @constructor
* @param {IResponseBatch=} [properties] Properties to set
*/
function ResponseBatch(properties) {
this.responses = [];
if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
}
/**
* ResponseBatch responses.
* @member {Array.<Response>} responses
* @memberof ResponseBatch
* @instance
*/
ResponseBatch.prototype.responses = $util.emptyArray;
/**
* Creates a new ResponseBatch instance using the specified properties.
* @function create
* @memberof ResponseBatch
* @static
* @param {IResponseBatch=} [properties] Properties to set
* @returns {ResponseBatch} ResponseBatch instance
*/
ResponseBatch.create = function create(properties) {
return new ResponseBatch(properties);
};
/**
* Encodes the specified ResponseBatch message. Does not implicitly {@link ResponseBatch.verify|verify} messages.
* @function encode
* @memberof ResponseBatch
* @static
* @param {ResponseBatch} message ResponseBatch message or plain object to encode
* @param {$protobuf.Writer} [writer] Writer to encode to
* @returns {$protobuf.Writer} Writer
*/
ResponseBatch.encode = function encode(message, writer) {
if (!writer) writer = $Writer.create();
if (message.responses != null && message.responses.length) for (var i = 0; i < message.responses.length; ++i) $root.Response.encode(message.responses[i], writer.uint32( /* id 1, wireType 2 =*/10).fork()).ldelim();
return writer;
};
/**
* Decodes a ResponseBatch message from the specified reader or buffer.
* @function decode
* @memberof ResponseBatch
* @static
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
* @param {number} [length] Message length if known beforehand
* @returns {ResponseBatch} ResponseBatch
* @throws {Error} If the payload is not a reader or valid buffer
* @throws {$protobuf.util.ProtocolError} If required fields are missing
*/
ResponseBatch.decode = function decode(reader, length) {
if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
var end = length === undefined ? reader.len : reader.pos + length,
message = new $root.ResponseBatch();
while (reader.pos < end) {
var tag = reader.uint32();
switch (tag >>> 3) {
case 1:
if (!(message.responses && message.responses.length)) message.responses = [];
message.responses.push($root.Response.decode(reader, reader.uint32()));
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
};
return ResponseBatch;
}();
$root.Response = function () {
/**
* Properties of a Response.
* @exports IResponse
* @interface IResponse
* @property {OutgoingMessagesResponse|null} [outgoingMessages] Response outgoingMessages
* @property {ChannelStatsResponse|null} [channelStats] Response channelStats
* @property {JsonResponse|null} [serverStats] Response serverStats
*/
/**
* Constructs a new Response.
* @exports Response
* @classdesc Represents a Response.
* @implements IResponse
* @constructor
* @param {IResponse=} [properties] Properties to set
*/
function Response(properties) {
if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
}
/**
* Response outgoingMessages.
* @member {OutgoingMessagesResponse|null|undefined} outgoingMessages
* @memberof Response
* @instance
*/
Response.prototype.outgoingMessages = null;
/**
* Response channelStats.
* @member {ChannelStatsResponse|null|undefined} channelStats
* @memberof Response
* @instance
*/
Response.prototype.channelStats = null;
/**
* Response serverStats.
* @member {JsonResponse|null|undefined} serverStats
* @memberof Response
* @instance
*/
Response.prototype.serverStats = null;
// OneOf field names bound to virtual getters and setters
var $oneOfFields;
/**
* Response command.
* @member {"outgoingMessages"|"channelStats"|"serverStats"|undefined} command
* @memberof Response
* @instance
*/
Object.defineProperty(Response.prototype, "command", {
get: $util.oneOfGetter($oneOfFields = ["outgoingMessages", "channelStats", "serverStats"]),
set: $util.oneOfSetter($oneOfFields)
});
/**
* Creates a new Response instance using the specified properties.
* @function create
* @memberof Response
* @static
* @param {IResponse=} [properties] Properties to set
* @returns {Response} Response instance
*/
Response.create = function create(properties) {
return new Response(properties);
};
/**
* Encodes the specified Response message. Does not implicitly {@link Response.verify|verify} messages.
* @function encode
* @memberof Response
* @static
* @param {Response} message Response message or plain object to encode
* @param {$protobuf.Writer} [writer] Writer to encode to
* @returns {$protobuf.Writer} Writer
*/
Response.encode = function encode(message, writer) {
if (!writer) writer = $Writer.create();
if (message.outgoingMessages != null && message.hasOwnProperty("outgoingMessages")) $root.OutgoingMessagesResponse.encode(message.outgoingMessages, writer.uint32( /* id 1, wireType 2 =*/10).fork()).ldelim();
if (message.channelStats != null && message.hasOwnProperty("channelStats")) $root.ChannelStatsResponse.encode(message.channelStats, writer.uint32( /* id 2, wireType 2 =*/18).fork()).ldelim();
if (message.serverStats != null && message.hasOwnProperty("serverStats")) $root.JsonResponse.encode(message.serverStats, writer.uint32( /* id 3, wireType 2 =*/26).fork()).ldelim();
return writer;
};
/**
* Decodes a Response message from the specified reader or buffer.
* @function decode
* @memberof Response
* @static
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
* @param {number} [length] Message length if known beforehand
* @returns {Response} Response
* @throws {Error} If the payload is not a reader or valid buffer
* @throws {$protobuf.util.ProtocolError} If required fields are missing
*/
Response.decode = function decode(reader, length) {
if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
var end = length === undefined ? reader.len : reader.pos + length,
message = new $root.Response();
while (reader.pos < end) {
var tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.outgoingMessages = $root.OutgoingMessagesResponse.decode(reader, reader.uint32());
break;
case 2:
message.channelStats = $root.ChannelStatsResponse.decode(reader, reader.uint32());
break;
case 3:
message.serverStats = $root.JsonResponse.decode(reader, reader.uint32());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
};
return Response;
}();
$root.OutgoingMessagesResponse = function () {
/**
* Properties of an OutgoingMessagesResponse.
* @exports IOutgoingMessagesResponse
* @interface IOutgoingMessagesResponse
* @property {Array.<OutgoingMessage>|null} [messages] OutgoingMessagesResponse messages
*/
/**
* Constructs a new OutgoingMessagesResponse.
* @exports OutgoingMessagesResponse
* @classdesc Represents an OutgoingMessagesResponse.
* @implements IOutgoingMessagesResponse
* @constructor
* @param {IOutgoingMessagesResponse=} [properties] Properties to set
*/
function OutgoingMessagesResponse(properties) {
this.messages = [];
if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
}
/**
* OutgoingMessagesResponse messages.
* @member {Array.<OutgoingMessage>} messages
* @memberof OutgoingMessagesResponse
* @instance
*/
OutgoingMessagesResponse.prototype.messages = $util.emptyArray;
/**
* Creates a new OutgoingMessagesResponse instance using the specified properties.
* @function create
* @memberof OutgoingMessagesResponse
* @static
* @param {IOutgoingMessagesResponse=} [properties] Properties to set
* @returns {OutgoingMessagesResponse} OutgoingMessagesResponse instance
*/
OutgoingMessagesResponse.create = function create(properties) {
return new OutgoingMessagesResponse(properties);
};
/**
* Encodes the specified OutgoingMessagesResponse message. Does not implicitly {@link OutgoingMessagesResponse.verify|verify} messages.
* @function encode
* @memberof OutgoingMessagesResponse
* @static
* @param {OutgoingMessagesResponse} message OutgoingMessagesResponse message or plain object to encode
* @param {$protobuf.Writer} [writer] Writer to encode to
* @returns {$protobuf.Writer} Writer
*/
OutgoingMessagesResponse.encode = function encode(message, writer) {
if (!writer) writer = $Writer.create();
if (message.messages != null && message.messages.length) for (var i = 0; i < message.messages.length; ++i) $root.OutgoingMessage.encode(message.messages[i], writer.uint32( /* id 1, wireType 2 =*/10).fork()).ldelim();
return writer;
};
/**
* Decodes an OutgoingMessagesResponse message from the specified reader or buffer.
* @function decode
* @memberof OutgoingMessagesResponse
* @static
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
* @param {number} [length] Message length if known beforehand
* @returns {OutgoingMessagesResponse} OutgoingMessagesResponse
* @throws {Error} If the payload is not a reader or valid buffer
* @throws {$protobuf.util.ProtocolError} If required fields are missing
*/
OutgoingMessagesResponse.decode = function decode(reader, length) {
if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
var end = length === undefined ? reader.len : reader.pos + length,
message = new $root.OutgoingMessagesResponse();
while (reader.pos < end) {
var tag = reader.uint32();
switch (tag >>> 3) {
case 1:
if (!(message.messages && message.messages.length)) message.messages = [];
message.messages.push($root.OutgoingMessage.decode(reader, reader.uint32()));
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
};
return OutgoingMessagesResponse;
}();
$root.OutgoingMessage = function () {
/**
* Properties of an OutgoingMessage.
* @exports IOutgoingMessage
* @interface IOutgoingMessage
* @property {Uint8Array|null} [id] OutgoingMessage id
* @property {string|null} [body] OutgoingMessage body
* @property {number|null} [expiry] OutgoingMessage expiry
* @property {number|null} [created] OutgoingMessage created
* @property {Sender|null} [sender] OutgoingMessage sender
*/
/**
* Constructs a new OutgoingMessage.
* @exports OutgoingMessage
* @classdesc Represents an OutgoingMessage.
* @implements IOutgoingMessage
* @constructor
* @param {IOutgoingMessage=} [properties] Properties to set
*/
function OutgoingMessage(properties) {
if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
}
/**
* OutgoingMessage id.
* @member {Uint8Array} id
* @memberof OutgoingMessage
* @instance
*/
OutgoingMessage.prototype.id = $util.newBuffer([]);
/**
* OutgoingMessage body.
* @member {string} body
* @memberof OutgoingMessage
* @instance
*/
OutgoingMessage.prototype.body = "";
/**
* OutgoingMessage expiry.
* @member {number} expiry
* @memberof OutgoingMessage
* @instance
*/
OutgoingMessage.prototype.expiry = 0;
/**
* OutgoingMessage created.
* @member {number} created
* @memberof OutgoingMessage
* @instance
*/
OutgoingMessage.prototype.created = 0;
/**
* OutgoingMessage sender.
* @member {Sender|null|undefined} sender
* @memberof OutgoingMessage
* @instance
*/
OutgoingMessage.prototype.sender = null;
/**
* Creates a new OutgoingMessage instance using the specified properties.
* @function create
* @memberof OutgoingMessage
* @static
* @param {IOutgoingMessage=} [properties] Properties to set
* @returns {OutgoingMessage} OutgoingMessage instance
*/
OutgoingMessage.create = function create(properties) {
return new OutgoingMessage(properties);
};
/**
* Encodes the specified OutgoingMessage message. Does not implicitly {@link OutgoingMessage.verify|verify} messages.
* @function encode
* @memberof OutgoingMessage
* @static
* @param {OutgoingMessage} message OutgoingMessage message or plain object to encode
* @param {$protobuf.Writer} [writer] Writer to encode to
* @returns {$protobuf.Writer} Writer
*/
OutgoingMessage.encode = function encode(message, writer) {
if (!writer) writer = $Writer.create();
if (message.id != null && message.hasOwnProperty("id")) writer.uint32( /* id 1, wireType 2 =*/10).bytes(message.id);
if (message.body != null && message.hasOwnProperty("body")) writer.uint32( /* id 2, wireType 2 =*/18).string(message.body);
if (message.expiry != null && message.hasOwnProperty("expiry")) writer.uint32( /* id 3, wireType 0 =*/24).uint32(message.expiry);
if (message.created != null && message.hasOwnProperty("created")) writer.uint32( /* id 4, wireType 5 =*/37).fixed32(message.created);
if (message.sender != null && message.hasOwnProperty("sender")) $root.Sender.encode(message.sender, writer.uint32( /* id 5, wireType 2 =*/42).fork()).ldelim();
return writer;
};
/**
* Decodes an OutgoingMessage message from the specified reader or buffer.
* @function decode
* @memberof OutgoingMessage
* @static
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
* @param {number} [length] Message length if known beforehand
* @returns {OutgoingMessage} OutgoingMessage
* @throws {Error} If the payload is not a reader or valid buffer
* @throws {$protobuf.util.ProtocolError} If required fields are missing
*/
OutgoingMessage.decode = function decode(reader, length) {
if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
var end = length === undefined ? reader.len : reader.pos + length,
message = new $root.OutgoingMessage();
while (reader.pos < end) {
var tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.id = reader.bytes();
break;
case 2:
message.body = reader.string();
break;
case 3:
message.expiry = reader.uint32();
break;
case 4:
message.created = reader.fixed32();
break;
case 5:
message.sender = $root.Sender.decode(reader, reader.uint32());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
};
return OutgoingMessage;
}();
$root.ChannelStatsResponse = function () {
/**
* Properties of a ChannelStatsResponse.
* @exports IChannelStatsResponse
* @interface IChannelStatsResponse
* @property {Array.<ChannelStats>|null} [channels] ChannelStatsResponse channels
*/
/**
* Constructs a new ChannelStatsResponse.
* @exports ChannelStatsResponse
* @classdesc Represents a ChannelStatsResponse.
* @implements IChannelStatsResponse
* @constructor
* @param {IChannelStatsResponse=} [properties] Properties to set
*/
function ChannelStatsResponse(properties) {
this.channels = [];
if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
}
/**
* ChannelStatsResponse channels.
* @member {Array.<ChannelStats>} channels
* @memberof ChannelStatsResponse
* @instance
*/
ChannelStatsResponse.prototype.channels = $util.emptyArray;
/**
* Creates a new ChannelStatsResponse instance using the specified properties.
* @function create
* @memberof ChannelStatsResponse
* @static
* @param {IChannelStatsResponse=} [properties] Properties to set
* @returns {ChannelStatsResponse} ChannelStatsResponse instance
*/
ChannelStatsResponse.create = function create(properties) {
return new ChannelStatsResponse(properties);
};
/**
* Encodes the specified ChannelStatsResponse message. Does not implicitly {@link ChannelStatsResponse.verify|verify} messages.
* @function encode
* @memberof ChannelStatsResponse
* @static
* @param {ChannelStatsResponse} message ChannelStatsResponse message or plain object to encode
* @param {$protobuf.Writer} [writer] Writer to encode to
* @returns {$protobuf.Writer} Writer
*/
ChannelStatsResponse.encode = function encode(message, writer) {
if (!writer) writer = $Writer.create();
if (message.channels != null && message.channels.length) for (var i = 0; i < message.channels.length; ++i) $root.ChannelStats.encode(message.channels[i], writer.uint32( /* id 1, wireType 2 =*/10).fork()).ldelim();
return writer;
};
/**
* Decodes a ChannelStatsResponse message from the specified reader or buffer.
* @function decode
* @memberof ChannelStatsResponse
* @static
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
* @param {number} [length] Message length if known beforehand
* @returns {ChannelStatsResponse} ChannelStatsResponse
* @throws {Error} If the payload is not a reader or valid buffer
* @throws {$protobuf.util.ProtocolError} If required fields are missing
*/
ChannelStatsResponse.decode = function decode(reader, length) {
if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
var end = length === undefined ? reader.len : reader.pos + length,
message = new $root.ChannelStatsResponse();
while (reader.pos < end) {
var tag = reader.uint32();
switch (tag >>> 3) {
case 1:
if (!(message.channels && message.channels.length)) message.channels = [];
message.channels.push($root.ChannelStats.decode(reader, reader.uint32()));
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
};
return ChannelStatsResponse;
}();
$root.ChannelStats = function () {
/**
* Properties of a ChannelStats.
* @exports IChannelStats
* @interface IChannelStats
* @property {Uint8Array|null} [id] ChannelStats id
* @property {boolean|null} [isPrivate] ChannelStats isPrivate
* @property {boolean|null} [isOnline] ChannelStats isOnline
*/
/**
* Constructs a new ChannelStats.
* @exports ChannelStats
* @classdesc Represents a ChannelStats.
* @implements IChannelStats
* @constructor
* @param {IChannelStats=} [properties] Properties to set
*/
function ChannelStats(properties) {
if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
}
/**
* ChannelStats id.
* @member {Uint8Array} id
* @memberof ChannelStats
* @instance
*/
ChannelStats.prototype.id = $util.newBuffer([]);
/**
* ChannelStats isPrivate.
* @member {boolean} isPrivate
* @memberof ChannelStats
* @instance
*/
ChannelStats.prototype.isPrivate = false;
/**
* ChannelStats isOnline.
* @member {boolean} isOnline
* @memberof ChannelStats
* @instance
*/
ChannelStats.prototype.isOnline = false;
/**
* Creates a new ChannelStats instance using the specified properties.
* @function create
* @memberof ChannelStats
* @static
* @param {IChannelStats=} [properties] Properties to set
* @returns {ChannelStats} ChannelStats instance
*/
ChannelStats.create = function create(properties) {
return new ChannelStats(properties);
};
/**
* Encodes the specified ChannelStats message. Does not implicitly {@link ChannelStats.verify|verify} messages.
* @function encode
* @memberof ChannelStats
* @static
* @param {ChannelStats} message ChannelStats message or plain object to encode
* @param {$protobuf.Writer} [writer] Writer to encode to
* @returns {$protobuf.Writer} Writer
*/
ChannelStats.encode = function encode(message, writer) {
if (!writer) writer = $Writer.create();
if (message.id != null && message.hasOwnProperty("id")) writer.uint32( /* id 1, wireType 2 =*/10).bytes(message.id);
if (message.isPrivate != null && message.hasOwnProperty("isPrivate")) writer.uint32( /* id 2, wireType 0 =*/16).bool(message.isPrivate);
if (message.isOnline != null && message.hasOwnProperty("isOnline")) writer.uint32( /* id 3, wireType 0 =*/24).bool(message.isOnline);
return writer;
};
/**
* Decodes a ChannelStats message from the specified reader or buffer.
* @function decode
* @memberof ChannelStats
* @static
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
* @param {number} [length] Message length if known beforehand
* @returns {ChannelStats} ChannelStats
* @throws {Error} If the payload is not a reader or valid buffer
* @throws {$protobuf.util.ProtocolError} If required fields are missing
*/
ChannelStats.decode = function decode(reader, length) {
if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
var end = length === undefined ? reader.len : reader.pos + length,
message = new $root.ChannelStats();
while (reader.pos < end) {
var tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.id = reader.bytes();
break;
case 2:
message.isPrivate = reader.bool();
break;
case 3:
message.isOnline = reader.bool();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
};
return ChannelStats;
}();
$root.JsonResponse = function () {
/**
* Properties of a JsonResponse.
* @exports IJsonResponse
* @interface IJsonResponse
* @property {string|null} [json] JsonResponse json
*/
/**
* Constructs a new JsonResponse.
* @exports JsonResponse
* @classdesc Represents a JsonResponse.
* @implements IJsonResponse
* @constructor
* @param {IJsonResponse=} [properties] Properties to set
*/
function JsonResponse(properties) {
if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
}
/**
* JsonResponse json.
* @member {string} json
* @memberof JsonResponse
* @instance
*/
JsonResponse.prototype.json = "";
/**
* Creates a new JsonResponse instance using the specified properties.
* @function create
* @memberof JsonResponse
* @static
* @param {IJsonResponse=} [properties] Properties to set
* @returns {JsonResponse} JsonResponse instance
*/
JsonResponse.create = function create(properties) {
return new JsonResponse(properties);
};
/**
* Encodes the specified JsonResponse message. Does not implicitly {@link JsonResponse.verify|verify} messages.
* @function encode
* @memberof JsonResponse
* @static
* @param {JsonResponse} message JsonResponse message or plain object to encode
* @param {$protobuf.Writer} [writer] Writer to encode to
* @returns {$protobuf.Writer} Writer
*/
JsonResponse.encode = function encode(message, writer) {
if (!writer) writer = $Writer.create();
if (message.json != null && message.hasOwnProperty("json")) writer.uint32( /* id 1, wireType 2 =*/10).string(message.json);
return writer;
};
/**
* Decodes a JsonResponse message from the specified reader or buffer.
* @function decode
* @memberof JsonResponse
* @static
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
* @param {number} [length] Message length if known beforehand
* @returns {JsonResponse} JsonResponse
* @throws {Error} If the payload is not a reader or valid buffer
* @throws {$protobuf.util.ProtocolError} If required fields are missing
*/
JsonResponse.decode = function decode(reader, length) {
if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
var end = length === undefined ? reader.len : reader.pos + length,
message = new $root.JsonResponse();
while (reader.pos < end) {
var tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.json = reader.string();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
};
return JsonResponse;
}();
return $root;
})(typeof window === "object" && typeof window.protobuf === 'object' && window.protobuf || typeof self === "object" && typeof self.protobuf === 'object' && self.protobuf || typeof protobuf === 'object' && protobuf);
// Protobuf message models
const Response = protobuf.roots['push-server'].Response;
const ResponseBatch = protobuf.roots['push-server'].ResponseBatch;
const Request = protobuf.roots['push-server'].Request;
const RequestBatch = protobuf.roots['push-server'].RequestBatch;
const IncomingMessagesRequest = protobuf.roots['push-server'].IncomingMessagesRequest;
const IncomingMessage = protobuf.roots['push-server'].IncomingMessage;
const Receiver = protobuf.roots['push-server'].Receiver;
class ProtobufCodec {
constructor(options) {
this.channelManager = options.channelManager;
}
extractMessages(pullEvent) {
const result = [];
try {
const responseBatch = ResponseBatch.decode(new Uint8Array(pullEvent));
for (let i = 0; i < responseBatch.responses.length; i++) {
const response = responseBatch.responses[i];
if (response.command !== 'outgoingMessages') {
continue;
}
const messages = response.outgoingMessages.messages;
for (const message of messages) {
let messageFields = {};
try {
messageFields = JSON.parse(message.body);
} catch (e) {
console.error(`${getDateForLog()}: Pull: Could not parse message body`, e);
continue;
}
if (!messageFields.extra) {
messageFields.extra = {};
}
messageFields.extra.sender = {
type: message.sender.type
};
if (message.sender.id instanceof Uint8Array) {
messageFields.extra.sender.id = decodeId(message.sender.id);
}
const compatibleMessage = {
mid: decodeId(message.id),
text: messageFields
};
result.push(compatibleMessage);
}
}
} catch (e) {
console.error(`${getDateForLog()}: Pull: Could not parse message`, e);
}
return result;
}
async encodeMessageBatch(messageBatch) {
const userIds = {};
for (const element of messageBatch) {
if (element.userList) {
for (let j = 0; j < element.userList.length; j++) {
userIds[element.userList[j]] = true;
}
}
}
const publicIds = await this.channelManager.getPublicIds(Object.keys(userIds));
return this.encodeMessageBatchInternal(messageBatch, publicIds);
}
encodeMessageBatchInternal(messageBatch, publicIds) {
const messages = [];
messageBatch.forEach(messageFields => {
const messageBody = messageFields.body;
let receivers = [];
if (messageFields.userList) {
receivers = this.createMessageReceivers(messageFields.userList, publicIds);
}
if (messageFields.channelList) {
if (!isArray(messageFields.channelList)) {
throw new TypeError('messageFields.publicChannels must be an array');
}
messageFields.channelList.forEach(publicChannel => {
let publicId = '';
let signature = '';
if (typeof publicChannel === 'string' && publicChannel.includes('.')) {
const fields = publicChannel.toString().split('.');
publicId = fields[0];
signature = fields[1];
} else if (typeof publicChannel === 'object' && 'publicId' in publicChannel && 'signature' in publicChannel) {
publicId = publicChannel.publicId;
signature = publicChannel.signature;
} else {
throw new Error('Public channel MUST be either a string, formatted like "{publicId}.{signature}" or an object with fields \'publicId\' and \'signature\'');
}
receivers.push(Receiver.create({
id: this.encodeId(publicId),
signature: this.encodeId(signature)
}));
});
}
const message = IncomingMessage.create({
receivers,
body: JSON.stringify(messageBody),
expiry: messageFields.expiry || 0
});
messages.push(message);
});
const requestBatch = RequestBatch.create({
requests: [{
incomingMessages: {
messages
}
}]
});
return RequestBatch.encode(requestBatch).finish();
}
createMessageReceivers(users, publicIds) {
const result = [];
for (const userId of users) {
if (!publicIds[userId] || !publicIds[userId].publicId) {
throw new Error(`Could not determine public id for user ${userId}`);
}
result.push(Receiver.create({
id: this.encodeId(publicIds[userId].publicId),
signature: this.encodeId(publicIds[userId].signature)
}));
}
return result;
}
/**
* Converts message id from hex-encoded string to byte[]
* @param {string} id Hex-encoded string.
* @return {Uint8Array}
*/
encodeId(id) {
if (!id) {
return new Uint8Array();
}
const result = [];
for (let i = 0; i < id.length; i += 2) {
result.push(parseInt(id.slice(i, i + 2), 16));
}
return new Uint8Array(result);
}
}
/**
* Converts message id from byte[] to string
*/
function decodeId(encodedId) {
if (!(encodedId instanceof Uint8Array)) {
throw new TypeError('encodedId should be an instance of Uint8Array');
}
let result = '';
for (const element of encodedId) {
const hexByte = element.toString(16);
if (hexByte.length === 1) {
result += '0';
}
result += hexByte;
}
return result;
}
class LegacyCodec {
async encodeMessageBatch(messageBatch) {
return null;
}
extractMessages(pullEvent) {
const result = [];
const dataArray = pullEvent.match(/#!NGINXNMS!#(.*?)#!NGINXNME!#/gm);
if (dataArray === null) {
const text = '\n========= PULL ERROR ===========\n' + 'Error type: parseResponse error parsing message\n' + '\n' + `Data string: ${pullEvent}\n` + '================================\n\n';
console.error(text);
return result;
}
for (let i = 0; i < dataArray.length; i++) {
dataArray[i] = dataArray[i].slice(12, -12);
if (dataArray[i].length <= 0) {
continue;
}
let data = {};
try {
data = JSON.parse(dataArray[i]);
} catch {
continue;
}
result.push(data);
}
return result;
}
}
/* eslint-disable no-param-reassign */
const RESTORE_WEBSOCKET_TIMEOUT = 30 * 60;
const MAX_IDS_TO_STORE = 10;
const PING_TIMEOUT = 10;
const JSON_RPC_PING = 'ping';
const JSON_RPC_PONG = 'pong';
const LS_SESSION = 'bx-pull-session';
// const LS_SESSION_CACHE_TIME = 20;
const ConnectorEvents = {
Message: 'message',
RevisionChanged: 'revisionChanged',
ChannelReplaced: 'channelReplaced',
ConfigExpired: 'configExpired',
ConnectionStatus: 'connectionStatus',
ConnectionError: 'connectionError'
};
class Connector extends EventTarget {
constructor(options = {}) {
super();
this.connectors = {
webSocket: null,
longPolling: null
};
this.connectPromises = [];
this.pingWaitTimeout = null;
this.reconnectTimeout = null;
this.isWebsocketBlocked = false;
this.isLongPollingBlocked = false;
this.isManualDisconnect = false;
this._status = PullStatus.Offline;
this.connectionAttempt = 0;
this.config = options.config;
this.logger = options.logger;
this.storage = options.storage;
this.restClient = options.restClient;
this.isSecure = globalThis.location.protocol === 'https:';
this.connectors.webSocket = new WebSocketConnector({
pathGetter: () => this.getConnectionPathByType(ConnectionType.WebSocket),
onOpen: this.onWebSocketOpen.bind(this),
onMessage: this.onIncomingMessage.bind(this),
onDisconnect: this.onWebSocketDisconnect.bind(this),
onError: this.onWebSocketError.bind(this)
});
this.connectors.longPolling = new LongPollingConnector({
pathGetter: () => this.getConnectionPathByType(ConnectionType.LongPolling),
isBinary: this.isProtobufSupported() && !this.isJsonRpc(),
onOpen: this.onLongPollingOpen.bind(this),
onMessage: this.onIncomingMessage.bind(this),
onDisconnect: this.onLongPollingDisconnect.bind(this),
onError: this.onLongPollingError.bind(this)
});
this.connectionType = this.isWebSocketAllowed() ? ConnectionType.WebSocket : ConnectionType.LongPolling;
for (const eventName of Object.keys(options.events || {})) {
this.addEventListener(eventName, options.events[eventName]);
}
this.channelManager = new ChannelManager({
restClient: options.restClient,
getPublicListMethod: options.getPublicListMethod
});
this.jsonRpcAdapter = this.createRpcAdapter();
this.codec = this.createCodec();
this.session = {
mid: null,
tag: null,
time: null,
history: {},
lastMessageIds: [],
messageCount: 0
};
if (options.restoreSession && this.storage) {
const oldSession = this.storage.get(LS_SESSION);
const now = new Date();
if (isPlainObject(oldSession) && 'ttl' in oldSession && oldSession.ttl >= now) {
this.session.mid = oldSession.mid;
}
}
}
get status() {
return this._status;
}
set status(status) {
if (this._status === status) {
return;
}
this._status = status;
this.dispatchEvent(new CustomEvent(ConnectorEvents.ConnectionStatus, {
detail: {
status,
connectionType: this.connector.connectionType
}
}));
}
createRpcAdapter() {
return new JsonRpc({
sender: this.connectors.webSocket,
handlers: {
'incoming.message': this.handleRpcIncomingMessage.bind(this)
},
events: {
error: this.onRpcError.bind(this)
}
});
}
createCodec() {
if (this.isProtobufSupported()) {
return new ProtobufCodec({
channelManager: this.channelManager
});
}
return new LegacyCodec();
}
get connector() {
return this.connectors[this.connectionType];
}
disconnect(disconnectCode, disconnectReason) {
if (this.connector) {
this.isManualDisconnect = true;
this.connector.disconnect(disconnectCode, disconnectReason);
}
}
stop(disconnectCode, disconnectReason) {
this.disconnect(disconnectCode, disconnectReason);
this.stopCheckConfig();
}
resetSession() {
this.session.mid = null;
this.session.tag = null;
this.session.time = null;
}
setConfig(config) {
const wasConnected = this.isConnected();
if (wasConnected) {
this.disconnect(CloseReasons.CONFIG_REPLACED, 'config was replaced');
}
this.config = config;
if (config.publicChannels) {
this.channelManager.setPublicIds(Object.values(config.publicChannels));
}
if (wasConnected) {
this.connect();
}
}
connect() {
if (this.connector.connected) {
return Promise.resolve();
}
if (this.reconnectTimeout) {
clearTimeout(this.reconnectTimeout);
}
this.isManualDisconnect = false;
this.status = PullStatus.Connecting;
this.connectionAttempt++;
return new Promise((resolve, reject) => {
this.connectPromises.push({
resolve,
reject
});
this.connector.connect();
});
}
reconnect(disconnectCode, disconnectReason, delay = 1) {
this.disconnect(disconnectCode, disconnectReason);
this.scheduleReconnect(delay);
}
restoreWebSocketConnection() {
if (this.connectionType === ConnectionType.WebSocket) {
return;
}
this.connectors.webSocket.connect();
}
scheduleReconnect(connectionDelay) {
var _this$logger;
const delay = connectionDelay != null ? connectionDelay : this.getConnectionAttemptDelay(this.connectionAttempt);
if (this.reconnectTimeout) {
clearTimeout(this.reconnectTimeout);
}
(_this$logger = this.logger) == null ? void 0 : _this$logger.log(`Pull: scheduling reconnection in ${delay} seconds; attempt # ${this.connectionAttempt}`);
this.reconnectTimeout = setTimeout(() => {
this.connect().catch(error => {
console.error(error);
});
}, delay * 1000);
}
scheduleRestoreWebSocketConnection() {
var _this$logger2;
(_this$logger2 = this.logger) == null ? void 0 : _this$logger2.log(`Pull: scheduling restoration of websocket connection in ${RESTORE_WEBSOCKET_TIMEOUT} seconds`);
if (this.restoreWebSocketTimeout) {
return;
}
this.restoreWebSocketTimeout = setTimeout(() => {
this.restoreWebSocketTimeout = 0;
this.restoreWebSocketConnection();
}, RESTORE_WEBSOCKET_TIMEOUT * 1000);
}
handleInternalPullEvent(command, message) {
switch (command.toUpperCase()) {
case SystemCommands.CHANNEL_EXPIRE:
{
if (message.params.action === 'reconnect' && 'new_channel' in message.params) {
this.dispatchEvent(new CustomEvent(ConnectorEvents.ChannelReplaced), {
detail: {
type: message.params.channel.type,
newChannel: message.params.new_channel
}
});
} else {
this.dispatchEvent(new CustomEvent(ConnectorEvents.ConfigExpired));
}
break;
}
case SystemCommands.CONFIG_EXPIRE:
{
this.dispatchEvent(new CustomEvent(ConnectorEvents.ConfigExpired));
break;
}
case SystemCommands.SERVER_RESTART:
{
this.reconnect(CloseReasons.SERVER_RESTARTED, 'server was restarted', 15);
break;
}
default: //
}
}
getConnectionBasePath(connectionType) {
switch (connectionType) {
case ConnectionType.WebSocket:
return this.isSecure ? this.config.server.websocket_secure : this.config.server.websocket;
case ConnectionType.LongPolling:
return this.isSecure ? this.config.server.long_pooling_secure : this.config.server.long_polling;
default:
throw new Error(`Unknown connection type ${connectionType}`);
}
}
getConnectionChannels() {
const channels = [];
for (const channelType of ['private', 'shared']) {
if (channelType in this.config.channels) {
channels.push(this.config.channels[channelType].id);
}
}
if (channels.length === 0) {
throw new Error('Empty channel list');
}
return channels.join('/');
}
getConnectionPath() {
return this.getConnectionPathByType(this.connectionType);
}
getConnectionPathByType(connectionType) {
const params = {};
const path = this.getConnectionBasePath(connectionType);
if (isNotEmptyString(this.config.jwt)) {
params.token = this.config.jwt;
} else {
params.CHANNEL_ID = this.getConnectionChannels();
}
if (this.isJsonRpc()) {
params.jsonRpc = 'true';
} else if (this.isProtobufSupported()) {
params.binaryMode = 'true';
}
if (this.isSharedMode()) {
if (!this.config.clientId) {
throw new Error('Push-server is in shared mode, but clientId is not set');
}
params.clientId = this.config.clientId;
}
if (this.config.server && this.config.server.hostname) {
params.hostname = this.config.server.hostname;
}
if (this.session.mid) {
params.mid = this.session.mid;
}
if (this.session.tag) {
params.tag = this.session.tag;
}
if (this.session.time) {
params.time = this.session.time;
}
params.revision = REVISION;
return `${path}?${buildQueryString(params)}`;
}
getPublicationPath() {
const path = this.isSecure ? this.config.server.publish_secure : this.config.server.publish;
if (!path) {
return '';
}
const channels = [];
for (const type of Object.keys(this.config.channels)) {
channels.push(this.config.channels[type].id);
}
const params = {
CHANNEL_ID: channels.join('/')
};
return `${path}?${buildQueryString(params)}`;
}
emitMessage(message) {
if (!isPlainObject(message.extra)) {
message.extra = {};
}
if (message.extra.server_time_unix) {
var _this$config$server$t;
const timeShift = (_this$config$server$t = this.config.server.timeShift) != null ? _this$config$server$t : 0;
const timeAgo = (getTimestamp() - message.extra.server_time_unix * 1000) / 1000 - timeShift;
message.extra.server_time_ago = timeAgo > 0 ? timeAgo : 0;
}
this.dispatchEvent(new CustomEvent(ConnectorEvents.Message, {
detail: message
}));
}
/**
* Returns reconnect delay in seconds
* @param attemptNumber
* @return {number}
*/
getConnectionAttemptDelay(attemptNumber) {
let result = 60;
if (attemptNumber < 1) {
result = 0.5;
} else if (attemptNumber < 3) {
result = 5;
} else if (attemptNumber < 5) {
result = 25;
} else if (attemptNumber < 10) {
result = 45;
}
return result + result * Math.random() * 0.2;
}
onLongPollingOpen() {
var _this$logger3;
this.unloading = false;
this.starting = false;
this.connectionAttempt = 0;
this.isManualDisconnect = false;
this.status = PullStatus.Online;
(_this$logger3 = this.logger) == null ? void 0 : _this$logger3.log('Pull: Long polling connection with push-server opened');
if (this.isWebSocketEnabled()) {
this.scheduleRestoreWebSocketConnection();
}
this.connectPromises.forEach(resolver => {
resolver.resolve();
});
this.connectPromises = [];
}
onWebSocketOpen() {
var _this$logger4;
this.status = PullStatus.Online;
this.isWebsocketBlocked = false;
this.connectionAttempt = 0;
// to prevent fallback to long polling in case of networking problems
this.isLongPollingBlocked = true;
if (this.connectionType === ConnectionType.LongPolling) {
this.connectionType = ConnectionType.WebSocket;
this.connectors.longPolling.disconnect();
}
if (this.restoreWebSocketTimeout) {
clearTimeout(this.restoreWebSocketTimeout);
this.restoreWebSocketTimeout = null;
}
(_this$logger4 = this.logger) == null ? void 0 : _this$logger4.log('Pull: Websocket connection with push-server opened');
this.connectPromises.forEach(resolver => {
resolver.resolve();
});
this.connectPromises = [];
}
onWebSocketDisconnect(e = {}) {
if (this.connectionType === ConnectionType.WebSocket) {
this.status = PullStatus.Offline;
}
if (this.isManualDisconnect) {
var _this$logger5;
(_this$logger5 = this.logger) == null ? void 0 : _this$logger5.logForce('Pull: Websocket connection with push-server manually closed');
} else {
var _this$logger6;
(_this$logger6 = this.logger) == null ? void 0 : _this$logger6.logForce(`Pull: Websocket connection with push-server closed. Code: ${e.code}, reason: ${e.reason}`);
if (e.code === CloseReasons.WRONG_CHANNEL_ID) {
this.dispatchEvent(new CustomEvent(ConnectorEvents.ConnectionError, {
detail: {
code: e.code,
reason: 'wrong channel signature'
}
}));
} else {
this.scheduleReconnect();
}
}
// to prevent fallback to long polling in case of networking problems
this.isLongPollingBlocked = true;
this.isManualDisconnect = false;
this.clearPingWaitTimeout();
}
onWebSocketError(e) {
this.starting = false;
if (this.connectionType === ConnectionType.WebSocket) {
this.status = PullStatus.Offline;
}
console.error(`${getDateForLog()}: Pull: WebSocket connection error`, e);
this.scheduleReconnect();
this.connectPromises.forEach(resolver => {
resolver.reject();
});
this.connectPromises = [];
this.clearPingWaitTimeout();
}
onWebSocketBlockChanged(e) {
const isWebSocketBlocked = e.isWebSocketBlocked;
if (isWebSocketBlocked && this.connectionType === ConnectionType.WebSocket && !this.isConnected()) {
clearTimeout(this.reconnectTimeout);
this.connectionAttempt = 0;
this.connectionType = ConnectionType.LongPolling;
this.scheduleReconnect(1);
} else if (!isWebSocketBlocked && this.connectionType === ConnectionType.LongPolling) {
clearTimeout(this.reconnectTimeout);
clearTimeout(this.restoreWebSocketTimeout);
this.connectionAttempt = 0;
this.connectionType = ConnectionType.WebSocket;
this.scheduleReconnect(1);
}
}
onLongPollingDisconnect(e = {}) {
var _this$logger7;
if (this.connectionType === ConnectionType.LongPolling) {
this.status = PullStatus.Offline;
}
(_this$logger7 = this.logger) == null ? void 0 : _this$logger7.log(`Pull: Long polling connection with push-server closed. Code: ${e.code}, reason: ${e.reason}`);
if (!this.isManualDisconnect) {
this.scheduleReconnect();
}
this.isManualDisconnect = false;
this.clearPingWaitTimeout();
}
onLongPollingError(e) {
this.starting = false;
if (this.connectionType === ConnectionType.LongPolling) {
this.status = PullStatus.Offline;
}
console.error(`${getDateForLog()}: Pull: Long polling connection error`, e);
this.scheduleReconnect();
this.connectPromises.forEach(resolver => {
resolver.reject();
});
this.connectPromises = [];
this.clearPingWaitTimeout();
}
onIncomingMessage(message) {
if (this.isJsonRpc()) {
if (message === JSON_RPC_PING) {
this.onJsonRpcPing();
} else {
this.jsonRpcAdapter.handleIncomingMessage(message);
}
} else {
const events = this.codec.extractMessages(message);
this.handleIncomingEvents(events);
}
}
handleRpcIncomingMessage(messageFields) {
this.session.mid = messageFields.mid;
const body = messageFields.body;
if (!messageFields.body.extra) {
body.extra = {};
}
body.extra.sender = messageFields.sender;
if ('user_params' in messageFields && isPlainObject(messageFields.user_params)) {
Object.assign(body.params, messageFields.user_params);
}
if ('dictionary' in messageFields && isPlainObject(messageFields.dictionary)) {
Object.assign(body.params, messageFields.dictionary);
}
if (this.checkDuplicate(messageFields.mid)) {
this.addMessageToStat(body);
this.trimDuplicates();
if (body.module_id === 'pull') {
this.handleInternalPullEvent(body.command, body);
} else {
this.emitMessage(body);
}
if (body.extra && body.extra.revision_web) {
this.checkRevision(body.extra.revision_web);
}
}
this.connector.send(`mack:${messageFields.mid}`);
return {};
}
onRpcError(event) {
// probably, fire event
}
onJsonRpcPing() {
this.updatePingWaitTimeout();
this.connector.send(JSON_RPC_PONG);
}
handleIncomingEvents(events) {
const messages = [];
if (events.length === 0) {
this.session.mid = null;
return;
}
for (const event of events) {
this.updateSessionFromEvent(event);
if (event.mid && !this.checkDuplicate(event.mid)) {
continue;
}
this.addMessageToStat(event.text);
messages.push(event.text);
}
this.trimDuplicates();
messages.forEach(message => {
if (message.module_id === 'pull') {
this.handleInternalPullEvent(message.command, message);
} else {
this.emitMessage(message);
}
if (message.extra && message.extra.revision_web) {
this.checkRevision(message.extra.revision_web);
}
});
}
checkRevision(serverRevision) {
if (serverRevision > 0 && serverRevision !== REVISION) {
var _this$logger8;
(_this$logger8 = this.logger) == null ? void 0 : _this$logger8.log(`Pull revision changed from ${REVISION} to ${serverRevision}. Reload required`);
this.dispatchEvent(new CustomEvent(ConnectorEvents.RevisionChanged, {
detail: {
revision: serverRevision
}
}));
}
}
updateSessionFromEvent(event) {
this.session.mid = event.mid || null;
this.session.tag = event.tag || null;
this.session.time = event.time || null;
}
checkDuplicate(mid) {
if (this.session.lastMessageIds.includes(mid)) {
// eslint-disable-next-line no-console
console.warn(`Duplicate message ${mid} skipped`);
return false;
}
this.session.lastMessageIds.push(mid);
return true;
}
trimDuplicates() {
if (this.session.lastMessageIds.length > MAX_IDS_TO_STORE) {
this.session.lastMessageIds = this.session.lastMessageIds.slice(-MAX_IDS_TO_STORE);
}
}
addMessageToStat(message) {
if (!this.session.history[message.module_id]) {
this.session.history[message.module_id] = {};
}
if (!this.session.history[message.module_id][message.command]) {
this.session.history[message.module_id][message.command] = 0;
}
this.session.history[message.module_id][message.command]++;
this.session.messageCount++;
}
getRevision() {
return this.config && this.config.api ? this.config.api.revision_web : null;
}
getServerVersion() {
return this.config && this.config.server ? this.config.server.version : 0;
}
getServerMode() {
return this.config && this.config.server ? this.config.server.mode : null;
}
isConnected() {
return this.connector.connected;
}
isWebSocketConnected() {
return this.connector.connected && this.connector.connectionType === ConnectionType.WebSocket;
}
isWebSocketAllowed() {
return !this.isWebsocketBlocked && this.isWebSocketEnabled();
}
isWebSocketEnabled() {
return this.config && this.config.server && this.config.server.websocket_enabled === true;
}
isPublishingSupported() {
return this.getServerVersion() > 3;
}
isPublishingEnabled() {
if (!this.isPublishingSupported()) {
return false;
}
return this.config && this.config.server && this.config.server.publish_enabled === true;
}
isProtobufSupported() {
return this.getServerVersion() === 4 && !browser.IsIe();
}
isJsonRpc() {
return this.getServerVersion() >= 5;
}
isSharedMode() {
return this.getServerMode() === ServerMode.Shared;
}
setPublicIds(publicIds) {
this.channelManager.setPublicIds(publicIds);
}
/**
* Sends batch of messages to the multiple public channels.
*
* @param {object[]} messageBatch Array of messages to send.
* @param {int[]} messageBatch.userList User ids the message receivers.
* @param {string[]|object[]} messageBatch.channelList Public ids of the channels to send messages.
* @param {string} messageBatch.moduleId Name of the module to receive message,
* @param {string} messageBatch.command Command name.
* @param {object} messageBatch.params Command parameters.
* @param {integer} [messageBatch.expiry] Message expiry time in seconds.
* @return void
*/
async sendMessageBatch(messageBatch) {
if (!this.isPublishingEnabled()) {
throw new Error('Client publishing is not supported or is disabled');
}
try {
const packet = await this.codec.encodeMessageBatch(messageBatch);
this.connector.send(packet);
} catch (e) {
console.error('sendMessageBatch error:', e);
throw e;
}
}
/**
* Send single message to the specified users.
*
* @param {integer[]} users User ids of the message receivers.
* @param {string} moduleId Name of the module to receive message,
* @param {string} command Command name.
* @param {object} params Command parameters.
* @param {integer} [expiry] Message expiry time in seconds.
*/
async sendMessage(users, moduleId, command, params, expiry) {
const message = {
userList: users,
body: {
module_id: moduleId,
command,
params
},
expiry
};
if (this.isJsonRpc()) {
return this.jsonRpcAdapter.executeOutgoingRpcCommand(RpcMethod.Publish, message);
}
return this.sendMessageBatch([message]);
}
/**
* Send single message to the specified public channels.
*
* @param {string[]} publicChannels Public ids of the channels to receive message.
* @param {string} moduleId Name of the module to receive message,
* @param {string} command Command name.
* @param {object} params Command parameters.
* @param {integer} [expiry] Message expiry time in seconds.
* @return {Promise}
*/
sendMessageToChannels(publicChannels, moduleId, command, params, expiry) {
const message = {
channelList: publicChannels,
body: {
module_id: moduleId,
command,
params
},
expiry
};
if (this.isJsonRpc()) {
return this.jsonRpcAdapter.executeOutgoingRpcCommand(RpcMethod.Publish, message);
}
return this.sendMessageBatch([message]);
}
/**
* @param userId {number}
*/
async subscribeUserStatusChange(userId) {
if (typeof userId !== 'number') {
throw new TypeError('userId must be a number');
}
await this.jsonRpcAdapter.executeOutgoingRpcCommand(RpcMethod.SubscribeStatusChange, {
userId
});
}
/**
* @param userId {number}
* @returns {Promise}
*/
async unsubscribeUserStatusChange(userId) {
if (typeof userId !== 'number') {
throw new TypeError('userId must be a number');
}
await this.jsonRpcAdapter.executeOutgoingRpcCommand(RpcMethod.UnsubscribeStatusChange, {
userId
});
}
/**
* Returns "last seen" time in seconds for the users. Result format: Object{userId: int}
* If the user is currently connected - will return 0.
* If the user if offline - will return diff between current timestamp and last seen timestamp in seconds.
* If the user was never online - the record for user will be missing from the result object.
*
* @param {integer[]} userList List of user ids.
* @returns {Promise}
*/
async getUsersLastSeen(userList) {
if (!isArray(userList) || !userList.every(item => typeof item === 'number')) {
throw new Error('userList must be an array of numbers');
}
const result = {};
const response = await this.jsonRpcAdapter.executeOutgoingRpcCommand(RpcMethod.GetUsersLastSeen, {
userList
});
const unresolved = [];
for (const userId of userList) {
if (!(userId in response)) {
unresolved.push(userId);
}
result[userId] = response[userId];
}
if (unresolved.length === 0) {
return result;
}
const params = {
userIds: unresolved,
sendToQueueSever: true
};
const restResponse = await this.restClient.callMethod('pull.api.user.getLastSeen', params);
const restData = restResponse.data();
for (const userId of Object.keys(restData)) {
result[userId] = restData[userId];
}
return result;
}
/**
* Pings server. In case of success promise will be resolved, otherwise - rejected.
*
* @param {int} timeout Request timeout in seconds
* @returns {Promise}
*/
ping(timeout) {
return this.jsonRpcAdapter.executeOutgoingRpcCommand(RpcMethod.Ping, {}, timeout);
}
/**
* Returns list channels that the connection is subscribed to.
*
* @returns {Promise}
*/
listChannels() {
return this.jsonRpcAdapter.executeOutgoingRpcCommand(RpcMethod.ListChannels, {});
}
updatePingWaitTimeout() {
clearTimeout(this.pingWaitTimeout);
this.pingWaitTimeout = setTimeout(this.onPingTimeout.bind(this), PING_TIMEOUT * 2 * 1000);
}
clearPingWaitTimeout() {
clearTimeout(this.pingWaitTimeout);
this.pingWaitTimeout = null;
}
onPingTimeout() {
this.pingWaitTimeout = null;
if (!this.isConnected()) {
return;
}
// eslint-disable-next-line no-console
console.warn(`No pings are received in ${PING_TIMEOUT * 2} seconds. Reconnecting`);
this.disconnect(CloseReasons.STUCK, 'connection stuck');
this.scheduleReconnect();
}
}
exports.ConnectorEvents = ConnectorEvents;
exports.Connector = Connector;
}((this.BX.Pull = this.BX.Pull || {})));
//# sourceMappingURL=connector.bundle.js.map