@coast-team/mute-crypto
Version:
Algorithm generating a cryptographic key for MUTE collaborative session
1,375 lines (1,355 loc) • 82.4 kB
JavaScript
import { symmetricCrypto, keyAgreementCrypto, asymmetricCrypto } from '@coast-team/mute-crypto-helper';
export { asymmetricCrypto } from '@coast-team/mute-crypto-helper';
var env = {};
var KeyState;
(function (KeyState) {
KeyState[KeyState["UNDEFINED"] = 0] = "UNDEFINED";
KeyState[KeyState["CALCUL_IN_PROGRESS"] = 1] = "CALCUL_IN_PROGRESS";
KeyState[KeyState["READY"] = 2] = "READY";
})(KeyState || (KeyState = {}));
/*! *****************************************************************************
Copyright (c) Microsoft Corporation. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
this file except in compliance with the License. You may obtain a copy of the
License at http://www.apache.org/licenses/LICENSE-2.0
THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
MERCHANTABLITY OR NON-INFRINGEMENT.
See the Apache Version 2.0 License for specific language governing permissions
and limitations under the License.
***************************************************************************** */
/* global Reflect, Promise */
var extendStatics = function(d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
function __extends(d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
}
function __awaiter(thisArg, _arguments, P, generator) {
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
}
function __generator(thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
}
function __values(o) {
var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
if (m) return m.call(o);
return {
next: function () {
if (o && i >= o.length) o = void 0;
return { value: o && o[i++], done: !o };
}
};
}
function __read(o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m) return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
}
catch (error) { e = { error: error }; }
finally {
try {
if (r && !r.done && (m = i["return"])) m.call(i);
}
finally { if (e) throw e.error; }
}
return ar;
}
function __spread() {
for (var ar = [], i = 0; i < arguments.length; i++)
ar = ar.concat(__read(arguments[i]));
return ar;
}
var prefix = ['%cMUTE CRYPTO:%c ', 'background-color: #81C784; padding: 0 2px', ''];
var prefixError = ['%cMUTE CRYPTO ERROR:%c ', 'background-color: #81C784; padding: 0 2px', ''];
var perfPrefix = [
'%cMUTE CRYPTO:%c %cPERFORMANCE:%c ',
'background-color: #81C784; padding: 0 2px',
'',
'background-color: #FFCC80; padding: 0 2px',
'',
];
var logEnabled = {
debug: function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
return console.log.apply(console, __spread(prefix, args));
},
error: function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
return console.error.apply(console, __spread(prefixError, args));
},
};
var logDisabled = {
debug: function () { },
error: function () { },
};
var log = logDisabled;
var assertEnabled = function (condition, msg) {
var args = [];
for (var _i = 2; _i < arguments.length; _i++) {
args[_i - 2] = arguments[_i];
}
console.assert.apply(console, __spread([condition, "MUTE-CRYPTO: " + msg], args));
};
var assertDisabled = function () { };
var assert = assertDisabled;
var perfEnabled = {
mark: function (name) { return env.performance.mark(name); },
measure: function (name, startMark, endMark) {
env.performance.measure(name, startMark, endMark);
var measure = env.performance.getEntriesByName(name)[0];
console.log.apply(console, __spread(perfPrefix, [measure.name + " = " + measure.duration.toFixed(0) + "ms"]));
env.performance.clearMeasures();
},
};
var perfDisabled = {
mark: function () { },
measure: function () { },
};
var perf = perfDisabled;
function enableDebug(enable, performanceLog) {
if (enable === void 0) { enable = true; }
if (performanceLog === void 0) { performanceLog = true; }
if (enable) {
log = logEnabled;
assert = assertEnabled;
}
else {
log = logDisabled;
assert = assertDisabled;
}
perf = performanceLog ? perfEnabled : perfDisabled;
}
function bytesToString(bytes) {
var CHUNK_SIZE = 0x8000;
var index = 0;
var length = bytes.length;
var result = '';
var slice;
while (index < length) {
slice = bytes.subarray(index, Math.min(index + CHUNK_SIZE, length));
result += String.fromCharCode.apply(null, slice);
index += CHUNK_SIZE;
}
return btoa(result).substr(0, 20) + '...';
}
var MuteCrypto = (function () {
function MuteCrypto() {
this.onStateChange = function () { };
this.state = KeyState.UNDEFINED;
}
MuteCrypto.generateKey = function () {
return __awaiter(this, void 0, void 0, function () {
var key, jsonWebKey;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4, symmetricCrypto.generateEncryptionKey()];
case 1:
key = _a.sent();
return [4, symmetricCrypto.exportKey(key)];
case 2:
jsonWebKey = _a.sent();
return [2, symmetricCrypto.toB64(jsonWebKey)];
}
});
});
};
MuteCrypto.prototype.setState = function (state) {
if (this.state !== state) {
log.debug('key state = ' + KeyState[state]);
this.state = state;
this.onStateChange(this.state);
}
};
return MuteCrypto;
}());
var Symmetric = (function (_super) {
__extends(Symmetric, _super);
function Symmetric() {
var _this = _super.call(this) || this;
_this.key = undefined;
return _this;
}
Symmetric.prototype.importKey = function (key) {
return __awaiter(this, void 0, void 0, function () {
var _a;
return __generator(this, function (_b) {
switch (_b.label) {
case 0:
_a = this;
return [4, symmetricCrypto.importKey(symmetricCrypto.fromB64(key))];
case 1:
_a.key = _b.sent();
_super.prototype.setState.call(this, KeyState.READY);
return [2];
}
});
});
};
Symmetric.prototype.encrypt = function (msg) {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
if (this.key) {
return [2, symmetricCrypto.encrypt(msg, this.key)];
}
throw new Error('Cryptographic key is not ready yet.');
});
});
};
Symmetric.prototype.decrypt = function (ciphertext) {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
if (this.key) {
return [2, symmetricCrypto.decrypt(ciphertext, this.key)];
}
throw new Error('Cryptographic key is not ready yet.');
});
});
};
return Symmetric;
}(MuteCrypto));
var Streams;
(function (Streams) {
Streams[Streams["KEY_AGREEMENT_BD"] = 700] = "KEY_AGREEMENT_BD";
})(Streams || (Streams = {}));
var Key = (function () {
function Key(key, initiatorId, initiatorCounter) {
this.value = key;
this.initiatorId = initiatorId;
this.initiatorCounter = initiatorCounter;
}
Key.prototype.isEqual = function (initiatorId, initiatorCounter) {
return this.initiatorId === initiatorId && this.initiatorCounter === initiatorCounter;
};
return Key;
}());
var Cycle = (function () {
function Cycle(id, counter, members, myId, send, myMembers) {
perf.mark('start cycle');
this.id = id;
this.myId = myId;
this.myMembers = myMembers;
this.isZBroadcasted = false;
this.isXBroadcasted = false;
this.isFinished = false;
this.firstXadded = false;
this.counter = counter;
this.members = members;
this.send = send;
this._onKey = function () { };
this.r = keyAgreementCrypto.generateRi();
perf.mark('R ready');
this.z = keyAgreementCrypto.computeZi(this.r);
perf.mark('Z ready');
this.zArray = new Array(members.length);
this.zArray[members.indexOf(myId)] = this.z;
this.xArray = new Array(members.length);
}
Cycle.prototype.addX = function (index, x) {
this.xArray[index] = x;
if (!this.firstXadded) {
perf.mark('start X array');
}
this.firstXadded = true;
};
Object.defineProperty(Cycle.prototype, "onKey", {
set: function (handler) {
this._onKey = handler;
},
enumerable: false,
configurable: true
});
Cycle.prototype.isReadyToBroadcastZ = function (members) {
return this.members.every(function (m) { return members.includes(m); });
};
Cycle.prototype.checkZArray = function (myId, members) {
var e_1, _a;
if (this.isXBroadcasted) {
this.debug('checkZArray abort -> X broadcasted already');
return;
}
if (!this.members.every(function (m) { return members.includes(m); })) {
this.debug('checkZArray abort -> missing a member');
return;
}
try {
for (var _b = __values(this.zArray), _c = _b.next(); !_c.done; _c = _b.next()) {
var z = _c.value;
if (z === undefined) {
this.debug('checkZArray abort -> missing Z value');
return;
}
}
}
catch (e_1_1) { e_1 = { error: e_1_1 }; }
finally {
try {
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
}
finally { if (e_1) throw e_1.error; }
}
perf.mark('Z array ready');
this.debug('checkZArray OK');
var myIndex = this.members.indexOf(myId);
var zRight = (myIndex + 1) % this.members.length;
var zLeft = (this.members.length + myIndex - 1) % this.members.length;
var x = keyAgreementCrypto.computeXi(this.r, this.zArray[zRight], this.zArray[zLeft]);
perf.mark('X ready');
this.assert(this.xArray[myIndex] === undefined, 'Setting my X value twice');
this.addX(myIndex, x);
this.broadcastX(x);
this.checkXArray(myId, members);
};
Cycle.prototype.checkXArray = function (myId, members) {
return __awaiter(this, void 0, void 0, function () {
var _a, _b, x, myIndex, zLeft, sk, key, _c;
var e_2, _d;
return __generator(this, function (_e) {
switch (_e.label) {
case 0:
if (this.isFinished) {
this.debug('checkXArray abort -> key computed already');
return [2];
}
if (!this.members.every(function (m) { return members.includes(m); })) {
this.debug('checkXArray abort -> missing a member');
return [2];
}
try {
for (_a = __values(this.xArray), _b = _a.next(); !_b.done; _b = _a.next()) {
x = _b.value;
if (x === undefined) {
this.debug('checkXArray abort -> missing X value');
return [2];
}
}
}
catch (e_2_1) { e_2 = { error: e_2_1 }; }
finally {
try {
if (_b && !_b.done && (_d = _a.return)) _d.call(_a);
}
finally { if (e_2) throw e_2.error; }
}
perf.mark('X array ready');
this.isFinished = true;
this.debug('checkXArray OK');
myIndex = this.members.indexOf(myId);
zLeft = (this.members.length + myIndex - 1) % this.members.length;
sk = keyAgreementCrypto.computeSharedSecret(this.r, this.xArray[myIndex], this.zArray[zLeft], this.xArray);
_c = Key.bind;
return [4, keyAgreementCrypto.deriveKey(sk)];
case 1:
key = new (_c.apply(Key, [void 0, _e.sent(), this.id, this.counter]))();
perf.mark('end cycle');
perf.measure('R', 'start cycle', 'R ready');
perf.measure('Z', 'R ready', 'Z ready');
perf.measure('X', 'Z array ready', 'X ready');
perf.measure('Z array full', 'Z ready', 'Z array ready');
perf.measure('X array full', 'start X array', 'X array ready');
perf.measure("secret key", 'X array ready', 'end cycle');
perf.measure(this.id + "(" + this.counter + "): cycle", 'start cycle', 'end cycle');
this._onKey(key);
return [2];
}
});
});
};
Cycle.prototype.debug = function (msg) {
log.debug(this.id + "(" + this.counter + "): " + msg + ": ", this.formatCycle());
};
Cycle.prototype.assert = function (condition, msg) {
assert(condition, this.id + "(" + this.counter + "): " + msg, this.formatCycle());
};
Cycle.prototype.broadcastZ = function () {
this.send({
initiator: { id: this.id, counter: this.counter, members: this.members },
z: this.z,
});
this.isZBroadcasted = true;
log.debug('broadcast my Z value');
};
Cycle.prototype.broadcastX = function (x) {
this.send({
initiator: { id: this.id, counter: this.counter, members: this.members },
x: x,
});
this.isXBroadcasted = true;
this.debug('broadcast my X value');
};
Cycle.prototype.formatCycle = function () {
return {
initiatorId: this.id,
initiatorCounter: this.counter,
initiatorMembers: this.members.slice(),
myId: this.myId,
myMembers: this.myMembers.slice(),
zArray: this.zArray.map(function (z) {
var res = '';
z.forEach(function (v) { return (res += String.fromCharCode(v)); });
return btoa(res).substring(0, 7);
}),
xArray: this.xArray.map(function (x) {
var res = '';
x.forEach(function (v) { return (res += String.fromCharCode(v)); });
return btoa(res).substring(0, 7);
}),
};
};
return Cycle;
}());
var commonjsGlobal = typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
function createCommonjsModule(fn, module) {
return module = { exports: {} }, fn(module, module.exports), module.exports;
}
var aspromise = asPromise;
function asPromise(fn, ctx ) {
var params = new Array(arguments.length - 1),
offset = 0,
index = 2,
pending = true;
while (index < arguments.length)
params[offset++] = arguments[index++];
return new Promise(function executor(resolve, reject) {
params[offset] = function callback(err ) {
if (pending) {
pending = false;
if (err)
reject(err);
else {
var 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);
}
}
});
}
var base64_1 = createCommonjsModule(function (module, exports) {
var base64 = exports;
base64.length = function length(string) {
var p = string.length;
if (!p)
return 0;
var n = 0;
while (--p % 4 > 1 && string.charAt(p) === "=")
++n;
return Math.ceil(string.length * 3) / 4 - n;
};
var b64 = new Array(64);
var s64 = new Array(123);
for (var i = 0; i < 64;)
s64[b64[i] = i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i - 59 | 43] = i++;
base64.encode = function encode(buffer, start, end) {
var parts = null,
chunk = [];
var i = 0,
j = 0,
t;
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";
base64.decode = function decode(string, buffer, offset) {
var start = offset;
var j = 0,
t;
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;
};
base64.test = function test(string) {
return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(string);
};
});
var eventemitter = EventEmitter;
function EventEmitter() {
this._listeners = {};
}
EventEmitter.prototype.on = function on(evt, fn, ctx) {
(this._listeners[evt] || (this._listeners[evt] = [])).push({
fn : fn,
ctx : ctx || this
});
return 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;
};
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;
};
var float_1 = factory(factory);
function factory(exports) {
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];
}
exports.writeFloatLE = le ? writeFloat_f32_cpy : writeFloat_f32_rev;
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];
}
exports.readFloatLE = le ? readFloat_f32_cpy : readFloat_f32_rev;
exports.readFloatBE = le ? readFloat_f32_rev : readFloat_f32_cpy;
})(); else (function() {
function writeFloat_ieee754(writeUint, val, buf, pos) {
var sign = val < 0 ? 1 : 0;
if (sign)
val = -val;
if (val === 0)
writeUint(1 / val > 0 ? 0 : 2147483648, buf, pos);
else if (isNaN(val))
writeUint(2143289344, buf, pos);
else if (val > 3.4028234663852886e+38)
writeUint((sign << 31 | 2139095040) >>> 0, buf, pos);
else if (val < 1.1754943508222875e-38)
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
? 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);
})();
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];
}
exports.writeDoubleLE = le ? writeDouble_f64_cpy : writeDouble_f64_rev;
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];
}
exports.readDoubleLE = le ? readDouble_f64_cpy : readDouble_f64_rev;
exports.readDoubleBE = le ? readDouble_f64_rev : readDouble_f64_cpy;
})(); else (function() {
function writeDouble_ieee754(writeUint, off0, off1, val, buf, pos) {
var sign = val < 0 ? 1 : 0;
if (sign)
val = -val;
if (val === 0) {
writeUint(0, buf, pos + off0);
writeUint(1 / val > 0 ? 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) {
writeUint(0, buf, pos + off0);
writeUint((sign << 31 | 2146435072) >>> 0, buf, pos + off1);
} else {
var mantissa;
if (val < 2.2250738585072014e-308) {
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
? 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;
}
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;
}
var inquire_1 = inquire;
function inquire(moduleName) {
return null;
}
var utf8_1 = createCommonjsModule(function (module, exports) {
var utf8 = exports;
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;
};
utf8.read = function utf8_read(buffer, start, end) {
var len = end - start;
if (len < 1)
return "";
var parts = null,
chunk = [],
i = 0,
t;
while (start < end) {
t = buffer[start++];
if (t < 128)
chunk[i++] = t;
else if (t > 191 && t < 224)
chunk[i++] = (t & 31) << 6 | buffer[start++] & 63;
else if (t > 239 && t < 365) {
t = ((t & 7) << 18 | (buffer[start++] & 63) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63) - 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));
};
utf8.write = function utf8_write(string, buffer, offset) {
var start = offset,
c1,
c2;
for (var i = 0; i < string.length; ++i) {
c1 = string.charCodeAt(i);
if (c1 < 128) {
buffer[offset++] = c1;
} else if (c1 < 2048) {
buffer[offset++] = c1 >> 6 | 192;
buffer[offset++] = c1 & 63 | 128;
} else if ((c1 & 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;
};
});
var pool_1 = pool;
function pool(alloc, slice, size) {
var SIZE = size || 8192;
var MAX = SIZE >>> 1;
var slab = null;
var offset = SIZE;
return function pool_alloc(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)
offset = (offset | 7) + 1;
return buf;
};
}
var longbits = LongBits;
function LongBits(lo, hi) {
this.lo = lo >>> 0;
this.hi = hi >>> 0;
}
var zero = LongBits.zero = new LongBits(0, 0);
zero.toNumber = function() { return 0; };
zero.zzEncode = zero.zzDecode = function() { return this; };
zero.length = function() { return 1; };
var zeroHash = LongBits.zeroHash = "\0\0\0\0\0\0\0\0";
LongBits.fromNumber = function fromNumber(value) {
if (value === 0)
return zero;
var sign = value < 0;
if (sign)
value = -value;
var lo = value >>> 0,
hi = (value - lo) / 4294967296 >>> 0;
if (sign) {
hi = ~hi >>> 0;
lo = ~lo >>> 0;
if (++lo > 4294967295) {
lo = 0;
if (++hi > 4294967295)
hi = 0;
}
}
return new LongBits(lo, hi);
};
LongBits.from = function from(value) {
if (typeof value === "number")
return LongBits.fromNumber(value);
if (minimal.isString(value)) {
if (minimal.Long)
value = minimal.Long.fromString(value);
else
return LongBits.fromNumber(parseInt(value, 10));
}
return value.low || value.high ? new LongBits(value.low >>> 0, value.high >>> 0) : zero;
};
LongBits.prototype.toNumber = function toNumber(unsigned) {
if (!unsigned && this.hi >>> 31) {
var lo = ~this.lo + 1 >>> 0,
hi = ~this.hi >>> 0;
if (!lo)
hi = hi + 1 >>> 0;
return -(lo + hi * 4294967296);
}
return this.lo + this.hi * 4294967296;
};
LongBits.prototype.toLong = function toLong(unsigned) {
return minimal.Long
? new minimal.Long(this.lo | 0, this.hi | 0, Boolean(unsigned))
: { low: this.lo | 0, high: this.hi | 0, unsigned: Boolean(unsigned) };
};
var charCodeAt = String.prototype.charCodeAt;
LongBits.fromHash = function fromHash(hash) {
if (hash === zeroHash)
return zero;
return new LongBits(
( charCodeAt.call(hash, 0)
| charCodeAt.call(hash, 1) << 8
| charCodeAt.call(hash, 2) << 16
| charCodeAt.call(hash, 3) << 24) >>> 0
,
( charCodeAt.call(hash, 4)
| charCodeAt.call(hash, 5) << 8
| charCodeAt.call(hash, 6) << 16
| charCodeAt.call(hash, 7) << 24) >>> 0
);
};
LongBits.prototype.toHash = function toHash() {
return String.fromCharCode(
this.lo & 255,
this.lo >>> 8 & 255,
this.lo >>> 16 & 255,
this.lo >>> 24 ,
this.hi & 255,
this.hi >>> 8 & 255,
this.hi >>> 16 & 255,
this.hi >>> 24
);
};
LongBits.prototype.zzEncode = function zzEncode() {
var mask = this.hi >> 31;
this.hi = ((this.hi << 1 | this.lo >>> 31) ^ mask) >>> 0;
this.lo = ( this.lo << 1 ^ mask) >>> 0;
return this;
};
LongBits.prototype.zzDecode = function zzDecode() {
var mask = -(this.lo & 1);
this.lo = ((this.lo >>> 1 | this.hi << 31) ^ mask) >>> 0;
this.hi = ( this.hi >>> 1 ^ mask) >>> 0;
return this;
};
LongBits.prototype.length = function length() {
var part0 = this.lo,
part1 = (this.lo >>> 28 | this.hi << 4) >>> 0,
part2 = this.hi >>> 24;
return part2 === 0
? part1 === 0
? part0 < 16384
? part0 < 128 ? 1 : 2
: part0 < 2097152 ? 3 : 4
: part1 < 16384
? part1 < 128 ? 5 : 6
: part1 < 2097152 ? 7 : 8
: part2 < 128 ? 9 : 10;
};
var minimal = createCommonjsModule(function (module, exports) {
var util = exports;
util.asPromise = aspromise;
util.base64 = base64_1;
util.EventEmitter = eventemitter;
util.float = float_1;
util.inquire = inquire_1;
util.utf8 = utf8_1;
util.pool = pool_1;
util.LongBits = longbits;
util.global = typeof window !== "undefined" && window
|| typeof commonjsGlobal !== "undefined" && commonjsGlobal
|| typeof self !== "undefined" && self
|| commonjsGlobal;
util.emptyArray = Object.freeze ? Object.freeze([]) : [];
util.emptyObject = Object.freeze ? Object.freeze({}) : {};
util.isNode = Boolean(util.global.process && util.global.process.versions && util.global.process.versions.node);
util.isInteger = Number.isInteger || function isInteger(value) {
return typeof value === "number" && isFinite(value) && Math.floor(value) === value;
};
util.isString = function isString(value) {
return typeof value === "string" || value instanceof String;
};
util.isObject = function isObject(value) {
return value && typeof value === "object";
};
util.isset =
util.isSet = function isSet(obj, prop) {
var value = obj[prop];
if (value != null && obj.hasOwnProperty(prop))
return typeof value !== "object" || (Array.isArray(value) ? value.length : Object.keys(value).length) > 0;
return false;
};
util.Buffer = (function() {
try {
var Buffer = util.inquire("buffer").Buffer;
return Buffer.prototype.utf8Write ? Buffer : null;
} catch (e) {
return null;
}
})();
util._Buffer_from = null;
util._Buffer_allocUnsafe = null;
util.newBuffer = function newBuffer(sizeOrArray) {
return typeof sizeOrArray === "number"
? util.Buffer
? util._Buffer_allocUnsafe(sizeOrArray)
: new util.Array(sizeOrArray)
: util.Buffer
? util._Buffer_from(sizeOrArray)
: typeof Uint8Array === "undefined"
? sizeOrArray
: new Uint8Array(sizeOrArray);
};
util.Array = typeof Uint8Array !== "undefined" ? Uint8Array : Array;
util.Long = util.global.dcodeIO && util.global.dcodeIO.Long
|| util.global.Long
|| util.inquire("long");
util.key2Re = /^true|false|0|1$/;
util.key32Re = /^-?(?:0|[1-9][0-9]*)$/;
util.key64Re = /^(?:[\\x00-\\xff]{8}|-?(?:0|[1-9][0-9]*))$/;
util.longToHash = function longToHash(value) {
return value
? util.LongBits.from(value).toHash()
: util.LongBits.zeroHash;
};
util.longFromHash = function longFromHash(hash, unsigned) {
var bits = util.LongBits.fromHash(hash);
if (util.Long)
return util.Long.fromBits(bits.lo, bits.hi, unsigned);
return bits.toNumber(Boolean(unsigned));
};
function merge(dst, src, ifNotSet) {
for (var keys = Object.keys(src), i = 0; i < keys.length; ++i)
if (dst[keys[i]] === undefined || !ifNotSet)
dst[keys[i]] = src[keys[i]];
return dst;
}
util.merge = merge;
util.lcFirst = function lcFirst(str) {
return str.charAt(0).toLowerCase() + str.substring(1);
};
function newError(name) {
function CustomError(message, properties) {
if (!(this instanceof CustomError))
return new CustomError(message, properties);
Object.defineProperty(this, "message", { get: function() { return message; } });
if (Error.captureStackTrace)
Error.captureStackTrace(this, CustomError);
else
Object.defineProperty(this, "stack", { value: (new Error()).stack || "" });
if (properties)
merge(this, properties);
}
(CustomError.prototype = Object.create(Error.prototype)).constructor = CustomError;
Object.defineProperty(CustomError.prototype, "name", { get: function() { return name; } });
CustomError.prototype.toString = function toString() {
return this.name + ": " + this.message;
};
return CustomError;
}
util.newError = newError;
util.ProtocolError = newError("ProtocolError");
util.oneOfGetter = function getOneOf(fieldNames) {
var fieldMap = {};
for (var i = 0; i < fieldNames.length; ++i)
fieldMap[fieldNames[i]] = 1;
return function() {
for (var keys = Object.keys(this), i = keys.length - 1; i > -1; --i)
if (fieldMap[keys[i]] === 1 && this[keys[i]] !== undefined && this[keys[i]] !== null)
return keys[i];
};
};
util.oneOfSetter = function setOneOf(fieldNames) {
return function(name) {
for (var i = 0; i < fieldNames.length; ++i)
if (fieldNames[i] !== name)
delete this[fieldNames[i]];
};
};
util.toJSONOptions = {
longs: String,
enums: String,
bytes: String,
json: true
};
util._configure = function() {
var Buffer = util.Buffer;
if (!Buffer) {
util._Buffer_from = util._Buffer_allocUnsafe = null;
return;
}
util._Buffer_from = Buffer.from !== Uint8Array.from && Buffer.from ||
function Buffer_from(value, encoding) {
return new Buffer(value, encoding);
};
util._Buffer_allocUnsafe = Buffer.allocUnsafe ||
function Buffer_allocUnsafe(size) {
return new Buffer(size);
};
};
});
var writer = Writer;
var BufferWriter;
var LongBits$1 = minimal.LongBits,
base64 = minimal.base64,
utf8 = minimal.utf8;
function Op(fn, len, val) {
this.fn = fn;
this.len = len;
this.next = undefined;
this.val = val;
}
function noop() {}
function State(writer) {
this.head = writer.head;
this.tail = writer.tail;
this.len = writer.len;
this.next = writer.states;
}
function Writer() {
this.len = 0;
this.head = new Op(noop, 0, 0);
this.tail = this.head;
this.states = null;
}
Writer.create = minimal.Buffer
? function create_buffer_setup() {
return (Writer.create = function create_buffer() {
return new BufferWriter();
})();
}
: function create_array() {
return new Writer();
};
Writer.alloc = function alloc(size) {
return new minimal.Array(size);
};
if (minimal.Array !== Array)
Writer.alloc = minimal.pool(Writer.alloc, minimal.Array.prototype.subarray);
Writer.prototype._push = function push(fn, len, val) {
this.tail = this.tail.next = new Op(fn, len, val);
this.len += len;
return this;
};
function writeByte(val, buf, pos) {
buf[pos] = val & 255;
}
function writeVarint32(val, buf, pos) {
while (val > 127) {
buf[pos++] = val & 127 | 128;
val >>>= 7;
}
buf[pos] = val;
}
function VarintOp(len, val) {
this.len = len;
this.next = undefined;
this.val = val;
}
VarintOp.prototype = Object.create(Op.prototype);
VarintOp.prototype.fn = writeVarint32;
Writer.prototype.uint32 = function write_uint32(value) {
this.len += (this.tail = this.tail.next = new VarintOp(
(value = value >>> 0)
< 128 ? 1
: value < 16384 ? 2
: value < 2097152 ? 3
: value < 268435456 ? 4
: 5,
value)).len;
return this;
};
Writer.prototype.int32 = function write_int32(value) {
return value < 0
? this._push(writeVarint64, 10, LongBits$1.fromNumber(value))
: this.uint32(value);
};
Writer.prototype.sint32 = function write_sint32(value) {
return this.uint32((value << 1 ^ value >> 31) >>> 0);
};
function writeVarint64(val, buf, pos) {
while (val.hi) {
buf[pos++] = val.lo & 127 | 128;
val.lo = (val.lo >>> 7 | val.hi << 25) >>> 0;
val.hi >>>= 7;
}
while (val.lo > 127) {
buf[pos++] = val.lo & 127 | 128;
val.lo = val.lo >>> 7;
}
buf[pos++] = val.lo;
}
Writer.prototype.uint64 = function write_uint64(value) {
var bits = LongBits$1.from(value);
return this._push(writeVarint64, bits.length(), bits);
};
Writer.prototype.int64 = Writer.prototype.uint64;
Writer.prototype.sint64 = function write_sint64(value) {
var bits = LongBits$1.from(value).zzEncode();
return this._push(writeVarint64, bits.length(), bits);
};
Writer.prototype.bool = function write_bool(value) {
return this._push(writeByte, 1, value ? 1 : 0);
};
function writeFixed32(val, buf, pos) {
buf[pos ] = val & 255;
buf[pos + 1] = val >>> 8 & 255;
buf[pos + 2] = val >>> 16 & 255;
buf[pos + 3] = val >>> 24;
}
Writer.prototype.fixed32 = function write_fixed32(value) {
return this._push(writeFixed32, 4, value >>> 0);
};
Writer.prototype.sfixed32 = Writer.prototype.fixed32;
Writer.prototype.fixed64 = function write_fixed64(value) {
var bits = LongBits$1.from(value);
return this._push(writeFixed32, 4, bits.lo)._push(writeFixed32, 4, bits.hi);
};
Writer.prototype.sfixed64 = Writer.prototype.fixed64;
Writer.prototype.float = function write_float(value) {
return this._push(minimal.float.writeFloatLE, 4, value);
};
Writer.prototype.double = function write_double(value) {
return this._push(minimal.float.writeDoubleLE, 8, value);
};
var writeBytes = minimal.Array.prototype.set
? function writeBytes_set(val, buf, pos) {
buf.set(val, pos);
}
: function writeBytes_for(val, buf, pos) {
for (var i = 0; i < val.length; ++i)
buf[pos + i] = val[i];
};
Writer.prototype.bytes = function write_bytes(value) {
var len = value.length >>> 0;
if (!len)
return this._push(writeByte, 1, 0);
if (minimal.isString(value)) {
var buf = Writer.alloc(len = base64.length(value));
base64.decode(value, buf, 0);
value = buf;
}
return this.uint32(len)._push(writeBytes, len, value);
};
Writer.prototype.string = function write_string(value) {
var len = utf8.length(value);
return len
? this.uint32(len)._push(utf8.write, len, value)
: this._push(writeByte, 1, 0);
};
Writer.prototype.fork = function fork() {
this.states = new State(this);
this.head = this.tail = new Op(noop, 0, 0);
this.len = 0;
return this;
};
Writer.prototype.reset = function reset() {
if (this.states) {
this.head = this.states.head;
this.tail = this.states.tail;
this.len = this.states.len;
this.states = this.states.next;
} else {
this.head = this.tail = new Op(noop, 0, 0);
this.len = 0;
}
return this;
};
Writer.prototype.ldelim = function ldelim() {
var head = this.head,
tail = this.tail,
len = this.len;
this.reset().uint32(len);
if (len) {
this.tail.next = head.next;
this.tail = tail;
this.len += len;
}
return this;
};
Writer.prototype.finish = function finish() {
var head = this.head.next,
buf = this.constructor.alloc(this.len),
pos = 0;